From e39f97198a66b79e620320be87ac88823b888be3 Mon Sep 17 00:00:00 2001
From: sunnycase <sunnycase@live.cn>
Date: Wed, 24 May 2023 17:49:09 +0800
Subject: [PATCH 001/308] Add cpu module

---
 .../Nncase.Modules.CPU/CPUApplicationPart.cs  |  30 +++
 modules/Nncase.Modules.CPU/CPUModule.cs       |  19 ++
 .../Evaluator/CPU/CPUModule.cs                |  18 ++
 .../Evaluator/CPU/CPUUnary.cs                 | 141 ++++++++++
 modules/Nncase.Modules.CPU/IR/CPU/CPUUnary.cs |  23 ++
 .../Nncase.Modules.CPU/IR/CPU/Functional.cs   |  26 ++
 .../Nncase.Modules.CPU.csproj                 |  21 ++
 .../Passes/Rules/LowerUnary.cs                |  33 +++
 .../Targets/CPUTarget.cs                      |   5 +
 modules/Nncase.Modules.CPU/packages.lock.json | 243 ++++++++++++++++++
 .../Nncase.Modules.StackVM/StackVMModule.cs   |   1 -
 nncase.sln                                    |   7 +
 python/nncase/__init__.py                     |   2 +-
 src/Nncase.Cli/Nncase.Cli.csproj              |   4 +
 src/Nncase.Cli/packages.lock.json             |   9 +
 .../Hosting/CompilerHostBuilderExtensions.cs  |   3 +-
 src/Nncase.Compiler/Hosting/PluginLoader.cs   |   1 +
 src/Nncase.Compiler/Nncase.Compiler.csproj    |   1 +
 src/Nncase.Compiler/packages.lock.json        |   8 +
 .../Nncase.Tests.TestFixture.csproj           |   1 +
 .../packages.lock.json                        |   8 +
 src/Nncase.Tests/Targets/UnitTestCPUTarget.cs |  10 +
 src/Nncase.Tests/packages.lock.json           |  10 +
 23 files changed, 621 insertions(+), 3 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/CPUApplicationPart.cs
 create mode 100644 modules/Nncase.Modules.CPU/CPUModule.cs
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/CPU/CPUUnary.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/CPU/CPUUnary.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
 create mode 100644 modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs
 rename modules/{Nncase.Modules.StackVM => Nncase.Modules.CPU}/Targets/CPUTarget.cs (94%)
 create mode 100644 modules/Nncase.Modules.CPU/packages.lock.json

diff --git a/modules/Nncase.Modules.CPU/CPUApplicationPart.cs b/modules/Nncase.Modules.CPU/CPUApplicationPart.cs
new file mode 100644
index 0000000000..655138ddd4
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CPUApplicationPart.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using DryIoc;
+using Nncase.Hosting;
+
+namespace Nncase;
+
+/// <summary>
+/// CPU application part extensions.
+/// </summary>
+public static class CPUApplicationPart
+{
+    /// <summary>
+    /// Add CPU assembly.
+    /// </summary>
+    /// <param name="registrator">Service registrator.</param>
+    /// <returns>Configured service registrator.</returns>
+    public static IRegistrator AddCPU(this IRegistrator registrator)
+    {
+        return registrator.RegisterModule<CPUModule>()
+            .RegisterModule<Evaluator.CPU.CPUModule>();
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/CPUModule.cs b/modules/Nncase.Modules.CPU/CPUModule.cs
new file mode 100644
index 0000000000..5e91015cef
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CPUModule.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using DryIoc;
+using Nncase.Hosting;
+using Nncase.Targets;
+
+namespace Nncase;
+
+/// <summary>
+/// CPU module.
+/// </summary>
+internal class CPUModule : IApplicationPart
+{
+    public void ConfigureServices(IRegistrator registrator)
+    {
+        registrator.Register<ITarget, CPUTarget>(reuse: Reuse.Singleton);
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
new file mode 100644
index 0000000000..025c6e3b1b
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
@@ -0,0 +1,18 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using DryIoc;
+using Nncase.Hosting;
+
+namespace Nncase.Evaluator.CPU;
+
+/// <summary>
+/// CPU module.
+/// </summary>
+internal class CPUModule : IApplicationPart
+{
+    public void ConfigureServices(IRegistrator registrator)
+    {
+        registrator.RegisterManyInterface<CPUUnaryEvaluator>(reuse: Reuse.Singleton);
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUUnary.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUUnary.cs
new file mode 100644
index 0000000000..d48a45b8e0
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUUnary.cs
@@ -0,0 +1,141 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Linq;
+using Nncase.CostModel;
+using Nncase.IR;
+using Nncase.IR.CPU;
+using OrtKISharp;
+
+namespace Nncase.Evaluator.CPU;
+
+/// <summary>
+/// Evaluator for <see cref="CPUUnary"/>.
+/// </summary>
+public class CPUUnaryEvaluator : IEvaluator<CPUUnary>, ITypeInferencer<CPUUnary>, ICostEvaluator<CPUUnary>, IOpPrinter<CPUUnary>
+{
+    /// <inheritdoc/>
+    public IValue Visit(IEvaluateContext context, CPUUnary unary)
+    {
+        var input_tensor = context.GetArgumentValueAsTensor(unary, CPUUnary.Input);
+        if (input_tensor.Shape.IsScalar)
+        {
+            if (input_tensor.ElementType == DataTypes.Int32)
+            {
+                return Value.FromTensor(Tensor.FromScalar<int>(Compute_int(input_tensor.ToScalar<int>(), unary.UnaryOp)));
+            }
+            else if (input_tensor.ElementType == DataTypes.Float32)
+            {
+                return Value.FromTensor(Tensor.FromScalar<float>(Compute_float(input_tensor.ToScalar<float>(), unary.UnaryOp)));
+            }
+        }
+
+        var input = context.GetOrtArgumentValue(unary, CPUUnary.Input);
+        var result = unary.UnaryOp switch
+        {
+            UnaryOp.Abs => OrtKI.Abs(input),
+            UnaryOp.Acos => OrtKI.Acos(input),
+            UnaryOp.Acosh => OrtKI.Acosh(input),
+            UnaryOp.Asin => OrtKI.Asin(input),
+            UnaryOp.Asinh => OrtKI.Asinh(input),
+            UnaryOp.Ceil => OrtKI.Ceil(input),
+            UnaryOp.Cos => OrtKI.Cos(input),
+            UnaryOp.Cosh => OrtKI.Cosh(input),
+            UnaryOp.Exp => OrtKI.Exp(input),
+            UnaryOp.Floor => OrtKI.Floor(input),
+            UnaryOp.Log => OrtKI.Log(input),
+            UnaryOp.Neg => OrtKI.Neg(input),
+            UnaryOp.Round => OrtKI.Round(input),
+            UnaryOp.Rsqrt => OrtKI.Rsqrt(input),
+            UnaryOp.Sin => OrtKI.Sin(input),
+            UnaryOp.Sinh => OrtKI.Sinh(input),
+            UnaryOp.Sign => OrtKI.Sign(input),
+            UnaryOp.Sqrt => OrtKI.Sqrt(input),
+            UnaryOp.Square => OrtKI.Square(input),
+            UnaryOp.Tanh => OrtKI.Tanh(input),
+            UnaryOp.BitwiseNot => throw new NotSupportedException("NotSupported UnaryOp BitwiseNot"),
+            UnaryOp.LogicalNot => OrtKI.Not(input),
+            _ => throw new ArgumentOutOfRangeException(nameof(unary)),
+        };
+        return result.ToValue();
+    }
+
+    /// <inheritdoc/>
+    public IRType Visit(ITypeInferenceContext context, CPUUnary target)
+    {
+        var input = context.CheckArgumentType<TensorType>(target, CPUUnary.Input);
+        return Visit(input);
+    }
+
+    /// <inheritdoc/>
+    public Cost Visit(ICostEvaluateContext context, CPUUnary target)
+    {
+        var inputType = context.GetArgumentType<TensorType>(target, CPUUnary.Input);
+        var outputType = context.GetReturnType<TensorType>();
+
+        return new()
+        {
+            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType),
+            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(outputType),
+            [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(outputType, CostUtility.GetCPUCyclesOfUnary(target.UnaryOp)),
+        };
+    }
+
+    /// <inheritdoc/>
+    public string Visit(IIRPrinterContext context, CPUUnary target, bool iLmode)
+    {
+        var op_str = target.UnaryOp switch
+        {
+            UnaryOp.BitwiseNot => "!",
+            UnaryOp.LogicalNot => "!",
+            var op => op.ToString(),
+        };
+        if (!iLmode)
+        {
+            return $"{op_str}({string.Join(", ", target.Parameters.Select(p => p.Name + ": " + context.GetArgument(target, p).Serialize()))})";
+        }
+
+        throw new NotSupportedException("ILmode = true");
+    }
+
+    private int Compute_int(int input, UnaryOp op) => op switch
+    {
+        UnaryOp.Ceil => input,
+        UnaryOp.Floor => input,
+        UnaryOp.Neg => -input,
+        UnaryOp.Abs => System.Math.Abs(input),
+        UnaryOp.Square => input * input,
+        _ => throw new ArgumentOutOfRangeException(nameof(op), $"NotSupported {nameof(op)} For Int"),
+    };
+
+    private float Compute_float(float input, UnaryOp op) => op switch
+    {
+        UnaryOp.Abs => System.MathF.Abs(input),
+        UnaryOp.Acos => System.MathF.Acos(input),
+        UnaryOp.Acosh => System.MathF.Acosh(input),
+        UnaryOp.Asin => System.MathF.Asin(input),
+        UnaryOp.Asinh => System.MathF.Asinh(input),
+        UnaryOp.Ceil => System.MathF.Ceiling(input),
+        UnaryOp.Cos => System.MathF.Cos(input),
+        UnaryOp.Cosh => System.MathF.Cosh(input),
+        UnaryOp.Exp => System.MathF.Exp(input),
+        UnaryOp.Floor => System.MathF.Floor(input),
+        UnaryOp.Log => System.MathF.Log(input),
+        UnaryOp.Neg => -input,
+        UnaryOp.Round => System.MathF.Round(input),
+        UnaryOp.Rsqrt => 1.0f / System.MathF.Sqrt(input),
+        UnaryOp.Sin => System.MathF.Sin(input),
+        UnaryOp.Sinh => System.MathF.Sinh(input),
+        UnaryOp.Sign => System.MathF.Sign(input),
+        UnaryOp.Sqrt => System.MathF.Sqrt(input),
+        UnaryOp.Square => input * input,
+        UnaryOp.Tanh => System.MathF.Tanh(input),
+        _ => throw new ArgumentOutOfRangeException(nameof(op), $"NotSupported {nameof(op)} For Float"),
+    };
+
+    private IRType Visit(TensorType input)
+    {
+        return input;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/CPUUnary.cs b/modules/Nncase.Modules.CPU/IR/CPU/CPUUnary.cs
new file mode 100644
index 0000000000..44dbb59fd8
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/CPU/CPUUnary.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR.Math;
+using Nncase.PatternMatch;
+
+namespace Nncase.IR.CPU;
+
+[PatternFunctionalGenerator]
+public sealed partial class CPUUnary : Op
+{
+    /// <summary>
+    /// Gets input.
+    /// </summary>
+    public static readonly ParameterInfo Input = new(typeof(CPUUnary), 0, "input");
+
+    public UnaryOp UnaryOp { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
new file mode 100644
index 0000000000..9fd63b63a6
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR.CPU;
+using Nncase.IR.Math;
+
+namespace Nncase.IR.F;
+
+public partial class CPU
+{
+    /// <summary>
+    /// Call unary.
+    /// </summary>
+    /// <param name="unaryOp">Unary operator.</param>
+    /// <param name="expr">Source expression.</param>
+    /// <returns>Result expression.</returns>
+    public static Call CPUUnary(UnaryOp unaryOp, Expr expr)
+    {
+        return new Call(new CPUUnary(unaryOp), expr);
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj b/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj
new file mode 100644
index 0000000000..fb4674b51c
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj
@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>Nncase</RootNamespace>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Nncase.Passes\Nncase.Passes.csproj" />
+    <ProjectReference Include="..\..\src\Nncase.CodeGen\Nncase.CodeGen.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../../tools/Nncase.SourceGenerator/Nncase.SourceGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
+    <ProjectReference Include="..\Nncase.Modules.StackVM\Nncase.Modules.StackVM.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs b/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs
new file mode 100644
index 0000000000..bb77cc1354
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs
@@ -0,0 +1,33 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.Math;
+using Nncase.PatternMatch;
+
+using static Nncase.IR.F.CPU;
+using static Nncase.IR.TypePatternUtility;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.Utility;
+
+namespace Nncase.Passes.Rules;
+
+[RuleGenerator]
+public partial class LowerUnary : RewriteRule<Pattern>
+{
+    /// <inheritdoc/>
+    public override Pattern Pattern { get; } = IsUnary(
+      target_name: "unary",
+      _ => true,
+      IsWildcard("input"));
+
+    private Expr GetReplace(Unary unary, Expr input)
+    {
+        return CPUUnary(unary.UnaryOp, input);
+    }
+}
diff --git a/modules/Nncase.Modules.StackVM/Targets/CPUTarget.cs b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
similarity index 94%
rename from modules/Nncase.Modules.StackVM/Targets/CPUTarget.cs
rename to modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
index ba77ae58f5..27fb312bfd 100644
--- a/modules/Nncase.Modules.StackVM/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
@@ -12,6 +12,7 @@
 using Nncase.CodeGen.StackVM;
 using Nncase.IR;
 using Nncase.Passes;
+using Nncase.Passes.Rules;
 using Nncase.Quantization;
 
 namespace Nncase.Targets;
@@ -41,6 +42,10 @@ public void RegisterTargetInDependentPass(IPassManager passManager, CompileOptio
     /// <inheritdoc/>
     public void RegisterTargetDependentPass(IPassManager passManager, CompileOptions options)
     {
+        passManager.AddWithName<EGraphRulesPass>("LowerIR").Configure(p =>
+        {
+            p.Add<LowerUnary>();
+        });
     }
 
     /// <inheritdoc/>
diff --git a/modules/Nncase.Modules.CPU/packages.lock.json b/modules/Nncase.Modules.CPU/packages.lock.json
new file mode 100644
index 0000000000..444b371070
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/packages.lock.json
@@ -0,0 +1,243 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net7.0": {
+      "StyleCop.Analyzers": {
+        "type": "Direct",
+        "requested": "[1.2.0-beta.435, )",
+        "resolved": "1.2.0-beta.435",
+        "contentHash": "TADk7vdGXtfTnYCV7GyleaaRTQjfoSfZXprQrVMm7cSJtJbFc1QIbWPyLvrgrfGdfHbGmUPvaN4ODKNxg2jgPQ==",
+        "dependencies": {
+          "StyleCop.Analyzers.Unstable": "1.2.0.435"
+        }
+      },
+      "libortki": {
+        "type": "Transitive",
+        "resolved": "0.0.2",
+        "contentHash": "svfuG5mxGY/QC/5DVheHOCELmdSP90RtxQ73j23KarPXZ9ZXW+7v1l5J77hGDyQbEh1BGrnGgKBlyn76RauGHg==",
+        "dependencies": {
+          "libortki-linux": "0.0.2",
+          "libortki-osx": "0.0.2",
+          "libortki-osx-arm64": "0.0.2",
+          "libortki-win": "0.0.2"
+        }
+      },
+      "libortki-linux": {
+        "type": "Transitive",
+        "resolved": "0.0.2",
+        "contentHash": "b04LWD4lgGy60tys3hPFhnUpgWDM6dN5r1PI7GOcPj8VupXCaI70LKNQ5/5twbDE6rkowOGanVTw0S2wBGBqBQ=="
+      },
+      "libortki-osx": {
+        "type": "Transitive",
+        "resolved": "0.0.2",
+        "contentHash": "O6Q9GLULkDkZEPAZJVKLPH0ROXGVOE7BxuddgOcHNK2oiTEM7wIRnzp2OIlYgLpaOLyxJMisbGOhtWgdzt2Wng=="
+      },
+      "libortki-osx-arm64": {
+        "type": "Transitive",
+        "resolved": "0.0.2",
+        "contentHash": "4Qn2dirJmRicnUG945oWpq7HVGwgqCKKxYPMISv/MRvmpZBbXrZ1cVvRaF8WwTu4XXgfKTa1sLv+i8zLifUMeQ=="
+      },
+      "libortki-win": {
+        "type": "Transitive",
+        "resolved": "0.0.2",
+        "contentHash": "HAoROgAKn8XBun11X43HZuspKlo5JGy8/OYw5IUPo7FVh5TCaPrLjGmyGYYZ2dqLlv31yv/b6s254PIRGn95cA=="
+      },
+      "Microsoft.Extensions.Configuration.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "qWzV9o+ZRWq+pGm+1dF+R7qTgTYoXvbyowRoBxQJGfqTpqDun2eteerjRQhq5PQ/14S+lqto3Ft4gYaRyl4rdQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "6.0.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "xlzi2IYREJH3/m6+lUrQlujzX8wDitm4QGnUu6kUXTQAWPuZY8i+ticFJbzfqaetLA6KR/rO6Ew/HuYD+bxifg=="
+      },
+      "Microsoft.Extensions.FileProviders.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "0pd4/fho0gC12rQswaGQxbU34jOS1TPS8lZPpkFCH68ppQjHNHYle9iRuHeev1LhrJ94YPvzcRd8UmIuFk23Qw==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "6.0.0"
+        }
+      },
+      "Microsoft.Extensions.Primitives": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "9+PnzmQFfEFNR9J2aDTfJGGupShHjOuGw4VUv+JB044biSHrnmCIMD+mJHmb2H7YryrfBEXDurxQ47gJZdCKNQ==",
+        "dependencies": {
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
+        }
+      },
+      "NetFabric.Hyperlinq.Abstractions": {
+        "type": "Transitive",
+        "resolved": "1.3.0",
+        "contentHash": "WXnEcGwmXfa8gW9N2MlcaPNUzM3NLMwnAhacbtH554F8YcoXbIkTB+uGa1Aa+9gyb/9JZgYVHnmADgJUKP52nA=="
+      },
+      "StyleCop.Analyzers.Unstable": {
+        "type": "Transitive",
+        "resolved": "1.2.0.435",
+        "contentHash": "ouwPWZxbOV3SmCZxIRqHvljkSzkCyi1tDoMzQtDb/bRP8ctASV/iRJr+A2Gdj0QLaLmWnqTWDrH82/iP+X80Lg=="
+      },
+      "System.Buffers": {
+        "type": "Transitive",
+        "resolved": "4.5.1",
+        "contentHash": "Rw7ijyl1qqRS0YQD/WycNst8hUUMgrMH4FCn1nNm27M4VxchZ1js3fVjQaANHO5f3sN4isvP4a+Met9Y4YomAg=="
+      },
+      "System.Runtime.CompilerServices.Unsafe": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "/iUeP3tq1S0XdNNoMz5C9twLSrM/TH+qElHkXWaPvuNOt+99G75NrV0OS2EqHx5wMN7popYjpc8oTjC1y16DLg=="
+      },
+      "nncase.codegen": {
+        "type": "Project",
+        "dependencies": {
+          "Extension.Mathematics": "[1.2.12, )",
+          "Nncase.Core": "[1.0.0, )",
+          "Nncase.IO": "[1.0.0, )"
+        }
+      },
+      "nncase.core": {
+        "type": "Project",
+        "dependencies": {
+          "DryIoc.dll": "[5.3.1, )",
+          "GiGraph.Dot": "[2.0.0, )",
+          "Microsoft.Extensions.Hosting.Abstractions": "[6.0.0, )",
+          "Microsoft.Extensions.Logging.Abstractions": "[6.0.0, )",
+          "Microsoft.Extensions.Options": "[6.0.0, )",
+          "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
+          "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.Reactive": "[5.0.0, )"
+        }
+      },
+      "nncase.egraph": {
+        "type": "Project",
+        "dependencies": {
+          "GiGraph.Dot": "[2.0.0, )",
+          "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "Nncase.Core": "[1.0.0, )",
+          "Nncase.Evaluator": "[1.0.0, )",
+          "Singulink.Collections.Weak": "[1.0.2, )"
+        }
+      },
+      "nncase.evaluator": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.Core": "[1.0.0, )",
+          "OrtKISharp": "[0.0.2, )"
+        }
+      },
+      "nncase.graph": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.Core": "[1.0.0, )",
+          "Nncase.Evaluator": "[1.0.0, )"
+        }
+      },
+      "nncase.io": {
+        "type": "Project"
+      },
+      "nncase.modules.stackvm": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Passes": "[1.0.0, )"
+        }
+      },
+      "nncase.passes": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.Core": "[1.0.0, )",
+          "Nncase.EGraph": "[1.0.0, )",
+          "Nncase.Evaluator": "[1.0.0, )",
+          "Nncase.Graph": "[1.0.0, )"
+        }
+      },
+      "DryIoc.dll": {
+        "type": "CentralTransitive",
+        "requested": "[5.3.1, )",
+        "resolved": "5.3.1",
+        "contentHash": "E3zclUh2CIBks1t2uBD1k18pyGFJ1YSKCrbCDbB7qCdl2RAB+k68AyDpjeplhF1ot2XPV82AgyCWBXMf0ggL1g=="
+      },
+      "Extension.Mathematics": {
+        "type": "CentralTransitive",
+        "requested": "[1.2.12, )",
+        "resolved": "1.2.12",
+        "contentHash": "D4mn5Cab4ztPLJ0V8uMErDrO/Y61098nwrvyIOLZymVAYOQcwP1vomVWKbTagf1aPU3cX5Q7adZtQEQwOy6XEg=="
+      },
+      "GiGraph.Dot": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0, )",
+        "resolved": "2.0.0",
+        "contentHash": "ThvS2mQVveSkTMUm04tMbRYzu1XFPV8xBHISrUMp02APjhv9IRbLu3v3upTPCywORx2Ds/c6AqEUL1WU6kPfuQ=="
+      },
+      "Microsoft.Extensions.Hosting.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "GcT5l2CYXL6Sa27KCSh0TixsRfADUgth+ojQSD5EkzisZxmGFh7CwzkcYuGwvmXLjr27uWRNrJ2vuuEjMhU05Q==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0"
+        }
+      },
+      "Microsoft.Extensions.Logging.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "/HggWBbTwy8TgebGSX5DBZ24ndhzi93sHUBDvP1IxbZD7FDokYzdAr6+vbWGjw2XAfR2EJ1sfKUotpjHnFWPxA=="
+      },
+      "Microsoft.Extensions.Options": {
+        "type": "CentralTransitive",
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "dzXN0+V1AyjOe2xcJ86Qbo233KHuLEY0njf/P2Kw8SfJU+d45HNS2ctJdnEnrWbM9Ye2eFgaC5Mj9otRMU6IsQ==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Primitives": "6.0.0"
+        }
+      },
+      "Microsoft.Toolkit.HighPerformance": {
+        "type": "CentralTransitive",
+        "requested": "[7.1.1, )",
+        "resolved": "7.1.1",
+        "contentHash": "TRnvDpZPXO30hTOtjfLw6Y9BtTKtTpzk9lefeh4RMCaUihWrVKQR454nYH4/mMJAh+LXqfAPyk0kfkJs0Amopw=="
+      },
+      "NetFabric.Hyperlinq": {
+        "type": "CentralTransitive",
+        "requested": "[3.0.0-beta48, )",
+        "resolved": "3.0.0-beta48",
+        "contentHash": "oYUhXvxNS8bBJWqNkvx5g8y0P/0LtyqS2pN0w4OWjVDNWEpLbdbvPy9w/9z1n2PrqIjX3jxUsEnoCmxxGnI3gw==",
+        "dependencies": {
+          "NetFabric.Hyperlinq.Abstractions": "1.3.0",
+          "System.Buffers": "4.5.1",
+          "System.Runtime.CompilerServices.Unsafe": "5.0.0"
+        }
+      },
+      "OrtKISharp": {
+        "type": "CentralTransitive",
+        "requested": "[0.0.2, )",
+        "resolved": "0.0.2",
+        "contentHash": "q8j0yR5836Zhv9WB9BFkQt1UaEFyibq8bqJcTiULlILF6/sz8z7Wy2N8sgYdDKsdW25zncIz7j6IDbKM5ynePg==",
+        "dependencies": {
+          "libortki": "0.0.2"
+        }
+      },
+      "Singulink.Collections.Weak": {
+        "type": "CentralTransitive",
+        "requested": "[1.0.2, )",
+        "resolved": "1.0.2",
+        "contentHash": "giLAHrjJe0Bh7yhNexR6pmcv02+Fi+lEPxQVdB8zvkuJCmy6rnqu8CZLIpxrUfLcWDuTCSiK0IfGmMhig3UDhA=="
+      },
+      "System.Reactive": {
+        "type": "CentralTransitive",
+        "requested": "[5.0.0, )",
+        "resolved": "5.0.0",
+        "contentHash": "erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/modules/Nncase.Modules.StackVM/StackVMModule.cs b/modules/Nncase.Modules.StackVM/StackVMModule.cs
index 44d5c616e8..fcbeb7a0f5 100644
--- a/modules/Nncase.Modules.StackVM/StackVMModule.cs
+++ b/modules/Nncase.Modules.StackVM/StackVMModule.cs
@@ -14,6 +14,5 @@ internal class StackVMModule : IApplicationPart
 {
     public void ConfigureServices(IRegistrator registrator)
     {
-        registrator.Register<ITarget, CPUTarget>(reuse: Reuse.Singleton);
     }
 }
diff --git a/nncase.sln b/nncase.sln
index afde606dc0..e77c50726c 100644
--- a/nncase.sln
+++ b/nncase.sln
@@ -79,6 +79,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nncase.Tests.TestFixture",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nncase.Passes", "src\Nncase.Passes\Nncase.Passes.csproj", "{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nncase.Modules.CPU", "modules\Nncase.Modules.CPU\Nncase.Modules.CPU.csproj", "{97DA8EED-F382-4A2E-AE0E-F297A00DA19D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -173,6 +175,10 @@ Global
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}.Release|Any CPU.Build.0 = Release|Any CPU
+		{97DA8EED-F382-4A2E-AE0E-F297A00DA19D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{97DA8EED-F382-4A2E-AE0E-F297A00DA19D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{97DA8EED-F382-4A2E-AE0E-F297A00DA19D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{97DA8EED-F382-4A2E-AE0E-F297A00DA19D}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -203,6 +209,7 @@ Global
 		{E365B1B1-4D13-4839-9763-A7A7C5F32FD4} = {BCA74168-F015-4B5B-B4CD-C83AE06B9822}
 		{98A03405-CA53-4EC4-9B18-94D1C8DF9453} = {E5A4516C-4080-4346-991D-57A7AA76ADA6}
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42} = {BCA74168-F015-4B5B-B4CD-C83AE06B9822}
+		{97DA8EED-F382-4A2E-AE0E-F297A00DA19D} = {9859F5E8-5504-4AFE-B955-9497A0A0CD66}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {9492E141-292E-4D60-9C6E-3738AB234DB2}
diff --git a/python/nncase/__init__.py b/python/nncase/__init__.py
index f8bc443b06..7e186030e6 100644
--- a/python/nncase/__init__.py
+++ b/python/nncase/__init__.py
@@ -43,7 +43,7 @@ def _initialize():
 
 
 _initialize()
-# _nncase.launch_debugger()
+_nncase.launch_debugger()
 
 
 class ImportOptions:
diff --git a/src/Nncase.Cli/Nncase.Cli.csproj b/src/Nncase.Cli/Nncase.Cli.csproj
index 3070806ba5..17e370d4ca 100644
--- a/src/Nncase.Cli/Nncase.Cli.csproj
+++ b/src/Nncase.Cli/Nncase.Cli.csproj
@@ -26,4 +26,8 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Properties\" />
+  </ItemGroup>
 </Project>
diff --git a/src/Nncase.Cli/packages.lock.json b/src/Nncase.Cli/packages.lock.json
index 40fb79a75e..1677ce9a38 100644
--- a/src/Nncase.Cli/packages.lock.json
+++ b/src/Nncase.Cli/packages.lock.json
@@ -655,6 +655,7 @@
           "Nncase.Evaluator": "[1.0.0, )",
           "Nncase.Graph": "[1.0.0, )",
           "Nncase.Importer": "[1.0.0, )",
+          "Nncase.Modules.CPU": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )",
           "Nncase.Quantization": "[1.0.0, )",
@@ -716,6 +717,14 @@
       "nncase.io": {
         "type": "Project"
       },
+      "nncase.modules.cpu": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Modules.StackVM": "[1.0.0, )",
+          "Nncase.Passes": "[1.0.0, )"
+        }
+      },
       "nncase.modules.stackvm": {
         "type": "Project",
         "dependencies": {
diff --git a/src/Nncase.Compiler/Hosting/CompilerHostBuilderExtensions.cs b/src/Nncase.Compiler/Hosting/CompilerHostBuilderExtensions.cs
index 5fa0e4ba0f..70f110f2e5 100644
--- a/src/Nncase.Compiler/Hosting/CompilerHostBuilderExtensions.cs
+++ b/src/Nncase.Compiler/Hosting/CompilerHostBuilderExtensions.cs
@@ -53,7 +53,8 @@ private static void ConfigureBuiltinModules(Container builder)
                 .AddEGraph()
                 .AddCodeGen()
                 .AddPasses()
-                .AddStackVM();
+                .AddStackVM()
+                .AddCPU();
     }
 
     private static void ConfigureServices(HostBuilderContext context, IServiceCollection services)
diff --git a/src/Nncase.Compiler/Hosting/PluginLoader.cs b/src/Nncase.Compiler/Hosting/PluginLoader.cs
index 73f10f367a..0264ccc1b9 100644
--- a/src/Nncase.Compiler/Hosting/PluginLoader.cs
+++ b/src/Nncase.Compiler/Hosting/PluginLoader.cs
@@ -25,6 +25,7 @@ public sealed class PluginLoader
     private static readonly string[] _builtinModules = new[]
     {
         "Nncase.Modules.StackVM.dll",
+        "Nncase.Modules.CPU.dll",
         "Nncase.Modules.K210.dll",
     };
 
diff --git a/src/Nncase.Compiler/Nncase.Compiler.csproj b/src/Nncase.Compiler/Nncase.Compiler.csproj
index 8d02d21ec4..ab93c75220 100644
--- a/src/Nncase.Compiler/Nncase.Compiler.csproj
+++ b/src/Nncase.Compiler/Nncase.Compiler.csproj
@@ -14,6 +14,7 @@
     </ItemGroup>
 
     <ItemGroup>
+        <ProjectReference Include="..\..\modules\Nncase.Modules.CPU\Nncase.Modules.CPU.csproj" />
         <ProjectReference Include="..\Nncase.CodeGen\Nncase.CodeGen.csproj" />
         <ProjectReference Include="..\Nncase.Core\Nncase.Core.csproj" />
         <ProjectReference Include="..\Nncase.Diagnostics\Nncase.Diagnostics.csproj" />
diff --git a/src/Nncase.Compiler/packages.lock.json b/src/Nncase.Compiler/packages.lock.json
index c58fa234e0..a00db8ff64 100644
--- a/src/Nncase.Compiler/packages.lock.json
+++ b/src/Nncase.Compiler/packages.lock.json
@@ -694,6 +694,14 @@
       "nncase.io": {
         "type": "Project"
       },
+      "nncase.modules.cpu": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Modules.StackVM": "[1.0.0, )",
+          "Nncase.Passes": "[1.0.0, )"
+        }
+      },
       "nncase.modules.stackvm": {
         "type": "Project",
         "dependencies": {
diff --git a/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj b/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
index 3e1336e99c..d3b0b7e32b 100644
--- a/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
+++ b/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
@@ -22,6 +22,7 @@
     </ItemGroup>
     
     <ItemGroup>
+        <ProjectReference Include="..\..\modules\Nncase.Modules.CPU\Nncase.Modules.CPU.csproj" />
         <ProjectReference Include="..\..\modules\Nncase.Modules.StackVM\Nncase.Modules.StackVM.csproj" />
         <ProjectReference Include="..\Nncase.Core\Nncase.Core.csproj" />
         <ProjectReference Include="..\Nncase.CodeGen\Nncase.CodeGen.csproj" />
diff --git a/src/Nncase.Tests.TestFixture/packages.lock.json b/src/Nncase.Tests.TestFixture/packages.lock.json
index 02bfd47a3b..692f52a7fe 100644
--- a/src/Nncase.Tests.TestFixture/packages.lock.json
+++ b/src/Nncase.Tests.TestFixture/packages.lock.json
@@ -1094,6 +1094,14 @@
       "nncase.io": {
         "type": "Project"
       },
+      "nncase.modules.cpu": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Modules.StackVM": "[1.0.0, )",
+          "Nncase.Passes": "[1.0.0, )"
+        }
+      },
       "nncase.modules.stackvm": {
         "type": "Project",
         "dependencies": {
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTarget.cs b/src/Nncase.Tests/Targets/UnitTestCPUTarget.cs
index b3be7dff7e..89c6555e5c 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTarget.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTarget.cs
@@ -111,6 +111,16 @@ public void TestSimpleBinary()
         GenerateKModelAndRun(module, new[] { 1.0f }, new[] { 2.0f });
     }
 
+    [Fact]
+    public void TestSimpleUnary()
+    {
+        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
+        var y = IR.F.Math.Log(x);
+        var main = new Function("main", y, new[] { x });
+        var module = new IRModule(main);
+        GenerateKModelAndRun(module, new[] { 1.0f }, new[] { MathF.Log(1.0f) });
+    }
+
     [Fact]
     public void TestCodegenCallParamOrder()
     {
diff --git a/src/Nncase.Tests/packages.lock.json b/src/Nncase.Tests/packages.lock.json
index b2b9315b3b..0b497aebc2 100644
--- a/src/Nncase.Tests/packages.lock.json
+++ b/src/Nncase.Tests/packages.lock.json
@@ -1445,6 +1445,7 @@
           "Nncase.Evaluator": "[1.0.0, )",
           "Nncase.Graph": "[1.0.0, )",
           "Nncase.Importer": "[1.0.0, )",
+          "Nncase.Modules.CPU": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )",
           "Nncase.Quantization": "[1.0.0, )",
@@ -1506,6 +1507,14 @@
       "nncase.io": {
         "type": "Project"
       },
+      "nncase.modules.cpu": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Modules.StackVM": "[1.0.0, )",
+          "Nncase.Passes": "[1.0.0, )"
+        }
+      },
       "nncase.modules.stackvm": {
         "type": "Project",
         "dependencies": {
@@ -1544,6 +1553,7 @@
           "MethodBoundaryAspect.Fody": "[2.0.148, )",
           "Nncase.CodeGen": "[1.0.0, )",
           "Nncase.Core": "[1.0.0, )",
+          "Nncase.Modules.CPU": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )",
           "Nncase.Simulator": "[1.0.0, )",

From 296e70b6c71df1808b83435f27a4df8b8f3308a4 Mon Sep 17 00:00:00 2001
From: sunnycase <sunnycase@live.cn>
Date: Wed, 24 May 2023 18:46:23 +0800
Subject: [PATCH 002/308] Add make fusion

---
 .../Passes/Rules/MakeFusion.cs                | 43 +++++++++++++++++++
 .../Nncase.Modules.CPU/Targets/CPUTarget.cs   | 15 ++++---
 .../Rule/RuleGenerator.cs                     |  1 +
 3 files changed, 54 insertions(+), 5 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
new file mode 100644
index 0000000000..fb1bd25a22
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
@@ -0,0 +1,43 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.CPU;
+using Nncase.Passes.Rules.Neutral;
+using Nncase.PatternMatch;
+using Nncase.Targets;
+using static Nncase.PatternMatch.F.Tensors;
+using static Nncase.PatternMatch.Utility;
+using static Nncase.Utilities.ReplaceUtility;
+
+namespace Nncase.Passes.Rules;
+
+[RuleGenerator]
+internal partial class CPUSingleInputFusion<T> : FusionMaker
+    where T : Op
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern { get; } = IsCallWildcard(
+            "call",
+            IsOp<T>("op"),
+            IsWildcard("input"));
+
+    private Call? GetReplace(Call call, IReadOnlyList<Expr> callParams, Op op, Expr input)
+    {
+        var newInput = new Var(input.CheckedType!);
+        var newCall = ReplaceCallParams(op, callParams, (input, newInput));
+        var fusion = new Call(new Fusion(FullName, ModuleKind, newCall, new[] { newInput }), input);
+        return fusion;
+    }
+}
+
+internal sealed class CPUUnaryFusion : CPUSingleInputFusion<CPUUnary>
+{
+    public override string Name => "Unary";
+}
diff --git a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
index 27fb312bfd..c82f0d24d1 100644
--- a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Options;
+using Microsoft.VisualBasic;
 using Nncase.CodeGen;
 using Nncase.CodeGen.StackVM;
 using Nncase.IR;
@@ -63,11 +64,6 @@ public Task AdaRoundWeights(ICalibrationDatasetProvider calibrationDataset, List
 
     /// <inheritdoc/>
     public void RegisterQuantizePass(IPassManager passManager, CompileOptions options)
-    {
-    }
-
-    /// <inheritdoc/>
-    public void RegisterTargetDependentAfterQuantPass(IPassManager passManager, CompileOptions options)
     {
         if (options.QuantizeOptions.ModelQuantMode == ModelQuantMode.UsePTQ)
         {
@@ -78,6 +74,15 @@ public void RegisterTargetDependentAfterQuantPass(IPassManager passManager, Comp
         }
     }
 
+    /// <inheritdoc/>
+    public void RegisterTargetDependentAfterQuantPass(IPassManager passManager, CompileOptions options)
+    {
+        passManager.AddWithName<DataflowPass>("MakeFusion").Configure(p =>
+        {
+            p.Add<CPUUnaryFusion>();
+        });
+    }
+
     public void RegisterTargetDependentBeforeCodeGen(IPassManager passManager, CompileOptions options)
     {
     }
diff --git a/tools/Nncase.SourceGenerator/Rule/RuleGenerator.cs b/tools/Nncase.SourceGenerator/Rule/RuleGenerator.cs
index 57cf983aba..f2af3c5a2d 100644
--- a/tools/Nncase.SourceGenerator/Rule/RuleGenerator.cs
+++ b/tools/Nncase.SourceGenerator/Rule/RuleGenerator.cs
@@ -213,6 +213,7 @@ private void Execute(SourceProductionContext context, ImmutableArray<RuleCandida
             // 3. add classes
             grouped_classes[cand.ClassSymobl.ContainingNamespace].Add(
               cand.ClassDeclaration
+              .WithBaseList(null)
               .WithIdentifier(Identifier(cand.ClassSymobl.Name))
               .WithMembers(SingletonList<MemberDeclarationSyntax>(method))
               .WithAttributeLists(new SyntaxList<AttributeListSyntax>() { })

From a36cd0845d0a66f22b189e2c879cacd3b41f3852 Mon Sep 17 00:00:00 2001
From: sunnycase <sunnycase@live.cn>
Date: Thu, 6 Jul 2023 12:23:59 +0800
Subject: [PATCH 003/308] GNNE-1881 Add tiling basics

---
 .../Passes/CPUFusionToTirPass.cs              |  117 ++
 .../Passes/Tile/CPUFusionGroupMutator.cs      |  187 +++
 .../Passes/Tile/IFusionChecker.cs             |   26 +
 .../Passes/Tile/LayerFusionConverter.cs       | 1262 +++++++++++++++++
 .../Passes/Tile/MultiFusionChecker.cs         |  251 ++++
 .../Passes/Tile/MultiLayerFusionConverter.cs  |  228 +++
 .../Passes/Tile/TileOptions.cs                |   21 +
 .../Passes/Tile/TwoFusionChecker.cs           |  131 ++
 .../Nncase.Modules.CPU/Targets/CPUTarget.cs   |    2 -
 modules/Nncase.Modules.CPU/packages.lock.json |   46 +
 .../Properties/launchSettings.json            |    2 +-
 11 files changed, 2270 insertions(+), 3 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/IFusionChecker.cs
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/TwoFusionChecker.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs b/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
new file mode 100644
index 0000000000..128ca15c91
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.Passes.Analysis;
+using Nncase.Passes.Mutators;
+using Nncase.Passes.Tile;
+using Nncase.TIR;
+
+namespace Nncase.Passes;
+
+internal sealed class CPUFusionToTirPass : ModulePass
+{
+    private readonly TileOptions _tileOptions;
+    private readonly Dictionary<Fusion, ulong> _fusionMacsMap;
+
+    public CPUFusionToTirPass(TileOptions tileOptions)
+    {
+        _tileOptions = tileOptions;
+        _fusionMacsMap = new(ReferenceEqualityComparer.Instance);
+    }
+
+    private IAnalyzerManager AnalyzerManager => CompileSession.GetRequiredService<IAnalyzerManager>();
+
+    /// <inheritdoc/>
+    protected override Task<IRModule> RunCoreAsync(IRModule module, RunPassContext options)
+    {
+        Dictionary<Fusion, BaseFunction> fusionConertedCache = new(ReferenceEqualityComparer.Instance);
+
+        // convert the fusion as entry.
+        for (int i = 0; i < module.Functions.Count; i++)
+        {
+            if (module.Functions[i] is Fusion { ModuleKind: "cpu" } fusion)
+            {
+                TIR.PrimFunction primFunction;
+                var visitor = new MultiLayerFusionConverter(_tileOptions);
+                primFunction = visitor.VisitToPrimFunc(fusion);
+
+                CompilerServices.InferenceType(primFunction);
+                fusionConertedCache[fusion] = primFunction;
+                module.Replace(i, primFunction);
+            }
+        }
+
+        // convert the stackvm function call k510 fusion
+        for (int i = 0; i < module.Functions.Count; i++)
+        {
+            if (module.Functions[i] is Function { ModuleKind: "stackvm" } func)
+            {
+                var analysis = new Dictionary<Type, IAnalysisResult>
+                {
+                    [typeof(IExprUserAnalysisResult)] = AnalyzerManager.GetAnaylsis<IExprUserAnalysisResult>(func),
+                };
+                var rewriter = new DataFlowMergeRewriter();
+                var fusionCheckCache = new Dictionary<Fusion, IFusionChecker>(ReferenceEqualityComparer.Instance);
+
+                var post = (Function)rewriter.Rewrite(func, new Mutators.IMergeRewriteRule[] { new GNNESameInputFusionMergeRule(), }, (rule, option) => new CPUFusionGroupMutator<MultiFusionChecker>(fusionCheckCache, _tileOptions, rule, option), new() { AnalysisResults = analysis, MatchOptions = new Mutators.FusionGroupMutator.GroupedMatchOptions() });
+
+                // if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
+                // {
+                //     DumpScope.Current.DumpDotIR(post, "MultiLayer");
+                // }
+                // post = (Function)rewriter.Rewrite(
+                //    post,
+                //    new Mutators.IMergeRewriteRule[] {
+                //    new GNNESameInputFusionMergeRule(),
+                //  },
+                //    (rule, option) => new CPUFusionGroupMutator<TwoFusionChecker>(fusionCheckCache, _tileOptions, rule, option),
+                //    new() { AnalysisResults = analysis, MatchOptions = new Mutators.FusionGroupMutator.GroupedMatchOptions() });
+
+                // if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
+                // {
+                //     DumpScope.Current.DumpDotIR(post, "TwoLayer");
+                // }
+                // var post = func;
+                var mutator = new CheckedConvertMutator(fusionConertedCache, _fusionMacsMap, fusionCheckCache, _tileOptions, options);
+                var new_func = (Function)mutator.Rewrite(post);
+                CompilerServices.InferenceType(new_func);
+                if (mutator.IsMutated)
+                {
+                    module.Replace(i, new_func);
+                }
+            }
+        }
+
+        // add all prim func.
+        foreach (var item in fusionConertedCache.Values)
+        {
+            if (item is PrimFunctionWrapper wrapper)
+            {
+                module.Add(wrapper);
+                module.Add(wrapper.Target);
+            }
+        }
+
+        return Task.FromResult(module);
+    }
+
+    protected override async Task OnPassEndAsync(IRModule post, RunPassContext context)
+    {
+        await base.OnPassEndAsync(post, context);
+        if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
+        {
+            using var writer = new StreamWriter(DumpScope.Current.OpenFile("mac.csv"));
+            foreach (var (fusion, mac) in _fusionMacsMap)
+            {
+                writer.WriteLine($"mac: {fusion.Name},{mac}");
+            }
+        }
+
+        _fusionMacsMap.Clear();
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
new file mode 100644
index 0000000000..4b206ca688
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
@@ -0,0 +1,187 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Runtime.CompilerServices;
+using Nncase.IR;
+using Nncase.PatternMatch;
+using Nncase.Targets;
+using static Nncase.PatternMatch.Utility;
+
+namespace Nncase.Passes.Tile;
+
+internal sealed class GNNESameInputFusionMergeRule : Mutators.SameInputFusionMergeRule
+{
+    public override string ModuleKind => CPUTarget.Kind;
+
+    // todo enable multi input fusion merge pattern.
+    public override Pattern CreatePattern(string target_module_kind)
+    {
+        var inputPat = IsWildcard("input");
+
+        var callerPattern = IsCall(
+            "caller",
+            IsFusion(
+                "caller_fusion",
+                target_module_kind,
+                IsWildcard(),
+                IsVArgs(IsWildcard())),
+            IsVArgs("caller_inputs", new[] {
+              IsCall(
+                  $"callee_{0}",
+                  IsFusion($"callee_fusion_{0}", target_module_kind, IsWildcard(), IsVArgs(IsWildcard())),
+                  inputPat),
+            }));
+        return callerPattern;
+    }
+}
+
+internal sealed class CPUFusionGroupMutator<T> : Mutators.FusionGroupMutator
+  where T : IFusionChecker
+{
+    private readonly TileOptions _tileOptions;
+
+    public CPUFusionGroupMutator(
+      Dictionary<Fusion, IFusionChecker> fusioncheckerCache,
+      TileOptions tileOptions,
+      Mutators.IMergeRewriteRule rule,
+      RunPassContext passOptions)
+        : base(rule, passOptions)
+    {
+        _tileOptions = tileOptions;
+        FusioncheckerCache = fusioncheckerCache;
+    }
+
+    public Dictionary<Fusion, IFusionChecker> FusioncheckerCache { get; }
+
+    /// <inheritdoc/>
+    public override bool MergedFusionCheckCallBack(Fusion mergedFusion, HashSet<Fusion> candidateFusions)
+    {
+        // note the gnne activate must be first layer.
+        if (mergedFusion.Body is Call { Target: IR.K510.GNNEStore } st_call &&
+          st_call[IR.K510.GNNEStore.Input] is Call { Target: IR.K510.GNNEActivation })
+        {
+            return false;
+        }
+
+        var checker = (IFusionChecker)Activator.CreateInstance(typeof(T), new object[] { _tileOptions })!;
+        var ret = checker.Check(mergedFusion, PassOptions);
+        if (ret)
+        {
+            FusioncheckerCache.Add(mergedFusion, checker);
+            foreach (var cand in candidateFusions)
+            { // release the merged fusion.
+                FusioncheckerCache.Remove(cand);
+            }
+        }
+
+        return ret;
+    }
+
+    public override Expr MergedFusionRewriteCallBack(Expr mergedFusionBody)
+    {
+        return CompilerServices.Rewrite(mergedFusionBody, new[] { new Rules.GNNE.Opt.FoldLoadStore() }, new());
+    }
+}
+
+internal sealed class CheckedConvertMutator : ExprRewriter
+{
+    private readonly Dictionary<Fusion, BaseFunction> _fusionConertedCache;
+    private readonly IDictionary<Fusion, ulong> _fusionMacsMap;
+    private readonly IReadOnlyDictionary<Fusion, IFusionChecker> _fusionCheckerCache;
+    private readonly TileOptions _tileOptions;
+    private readonly RunPassContext _passOptions;
+
+    public CheckedConvertMutator(Dictionary<Fusion, BaseFunction> fusion_converted_cache, Dictionary<Fusion, ulong> fusionMacsMap, IReadOnlyDictionary<Fusion, IFusionChecker> fusionchecker_cache, TileOptions tileOptions, RunPassContext passOptions)
+    {
+        _fusionConertedCache = fusion_converted_cache;
+        _fusionMacsMap = fusionMacsMap;
+        _fusionCheckerCache = fusionchecker_cache;
+        _tileOptions = tileOptions;
+        _passOptions = passOptions;
+    }
+
+    /// <inheritdoc/>
+    protected override Expr RewriteLeafFusion(Fusion expr)
+    {
+        if (expr is Fusion { ModuleKind: K510Target.Kind } fusion)
+        {
+            if (!_fusionConertedCache.TryGetValue(fusion, out _))
+            {
+                TIR.PrimFunction prim_func;
+                if (_fusionCheckerCache.TryGetValue(fusion, out var checker))
+                {
+                    prim_func = checker.Convert(_passOptions);
+                }
+                else
+                {
+                    if (CompilerServices.TryMatchRoot(fusion, Conv2DFusionConverter.Conv2DFusionPattern, out var matchResult))
+                    {
+                        prim_func = Conv2DFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
+                    }
+                    else if (CompilerServices.TryMatchRoot(fusion, Conv2DTransposeFusionConverter.Conv2DFusionPattern, out matchResult))
+                    {
+                        prim_func = Conv2DTransposeFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
+                    }
+                    else if (!_tileOptions.ForceMultiLayer && CompilerServices.TryMatchRoot(fusion, LSTMFusionConverter.FusionPattern, out matchResult))
+                    {
+                        prim_func = LSTMFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
+                    }
+                    else
+                    {
+                        var visitor = new MultiLayerFusionConverter(_tileOptions);
+                        prim_func = visitor.VisitToPrimFunc(fusion);
+                    }
+                }
+
+                BaseFunction? convert_func = prim_func;
+                _fusionConertedCache.Add(fusion, convert_func);
+                new DDrMacCalcVisitor(_fusionMacsMap).Visit(fusion);
+            }
+        }
+
+        return expr;
+    }
+
+    protected override Expr RewriteLeafCall(Call expr)
+    {
+        if (expr.Target is Fusion { ModuleKind: K510Target.Kind } fusion)
+        {
+            var convert_func = _fusionConertedCache[fusion];
+            PrimFunctionWrapper wrapper;
+            if (convert_func is TIR.PrimFunction prim_func)
+            {
+                bool is_input = true;
+                int param_count = 0;
+                foreach (var b in prim_func.Parameters)
+                {
+                    if (b.MemLocation == Schedule.MemoryLocation.Input)
+                    {
+                        if (is_input)
+                        {
+                            param_count += 1;
+                        }
+                        else
+                        {
+                            throw new InvalidOperationException("The output buffer must behind the input buffer");
+                        }
+                    }
+                    else
+                    {
+                        is_input = false;
+                    }
+                }
+
+                wrapper = new PrimFunctionWrapper(prim_func, param_count);
+                _fusionConertedCache[fusion] = wrapper;
+            }
+            else
+            {
+                wrapper = (PrimFunctionWrapper)convert_func;
+            }
+
+            return expr.With(target: wrapper);
+        }
+
+        return expr;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/IFusionChecker.cs b/modules/Nncase.Modules.CPU/Passes/Tile/IFusionChecker.cs
new file mode 100644
index 0000000000..84b2d37072
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/IFusionChecker.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+
+namespace Nncase.Passes.Tile;
+
+internal interface IFusionChecker
+{
+    /// <summary>
+    /// 检查fusion是否可以正常执行.
+    /// </summary>
+    /// <param name="fusion">fusion.</param>
+    /// <param name="passOptions">passOptions.</param>
+    /// <returns>.</returns>
+    public bool Check(Fusion fusion, RunPassContext passOptions);
+
+    /// <summary>
+    /// 通常当check过一个fusion之后, 可以cache部分的内容, 此时通过convert复用.
+    /// </summary>
+    /// <param name="passOptions">passOptions.</param>
+    /// <returns>.</returns>
+    public TIR.PrimFunction Convert(RunPassContext passOptions);
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs
new file mode 100644
index 0000000000..8cf139f3fc
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs
@@ -0,0 +1,1262 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Reactive;
+using System.Runtime.CompilerServices;
+using NetFabric.Hyperlinq;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.IR.Buffers;
+using Nncase.IR.F;
+using Nncase.IR.K510;
+using Nncase.IR.Math;
+using Nncase.Passes.BufferSchedule;
+using Nncase.Passes.Mutators;
+using Nncase.Runtime.K510;
+using Nncase.Schedule;
+using Nncase.TIR;
+using Nncase.TIR.Builders;
+using Nncase.TIR.K510;
+using Nncase.TIR.K510.Builders;
+using Nncase.TIR.K510.Instructions;
+using Buffer = Nncase.TIR.Buffer;
+using MathF = Nncase.IR.F.Math;
+using Range = Nncase.TIR.Range;
+using Tuple = Nncase.IR.Tuple;
+
+namespace Nncase.Passes.Tile;
+
+public sealed class BufferRegionView
+{
+    private Expr? _cache;
+
+    private Expr[]? _condtion_buffer_regions;
+
+    private Expr[]? _region_size;
+
+    public BufferRegionView(IEnumerable<Buffer> buffers, IEnumerable<Range> bounds, IEnumerable<Range> region, IndexMapKey key)
+        : this(buffers, bounds, region, key, 0, null)
+    {
+    }
+
+    public BufferRegionView(IEnumerable<Buffer> buffers, IEnumerable<Range> bounds, IEnumerable<Range> region, IndexMapKey key, Expr loopCount, int? promote)
+    {
+        Buffers = buffers.ToArray();
+        Region = region.ToArray();
+        LoopCount = loopCount;
+        Parent = null;
+        Key = key;
+        Promote = promote;
+        Bounds = bounds.ToArray();
+    }
+
+    public IndexMapKey Key { get; }
+
+    /// <summary>
+    /// Gets 记录他的loop count.
+    /// </summary>
+    public Expr LoopCount { get; }
+
+    public int? Promote { get; }
+
+    public IReadOnlyList<Range> Bounds { get; }
+
+    public IReadOnlyList<Buffer> Buffers { get; }
+
+    public IReadOnlyList<Range> Region { get; }
+
+    public BufferRegionView? Parent { get; set; }
+
+    public ReadOnlySpan<Expr> Dimensions => Buffers[0].Dimensions;
+
+    /// <summary>
+    /// Gets 返回带有condition的buffer region的表达式.
+    /// </summary>
+    public IReadOnlyList<Expr> BufferRegions
+    {
+        get
+        {
+            _condtion_buffer_regions ??= Buffers.Count == 0 ? Array.Empty<Expr>() : Buffers.Select(b => new BufferRegion(b, Region.ToArray())).ToArray();
+            return _condtion_buffer_regions;
+        }
+    }
+
+    public BufferRegionView this[params Range[] ranges]
+    {
+        get => new(Buffers, Bounds, Region.Zip(ranges).Select(tp => tp.Second.Equals(Range.All) ? tp.First : tp.Second.Stop switch { Call { Target: Unary { UnaryOp: UnaryOp.Neg } } => throw new NotSupportedException("Neg Region!"), _ => tp.Second, }), Key, LoopCount, Promote) { Parent = Parent is null ? this : Parent, }; // if stop is neg, add the shape, else return the origin range.
+    }
+
+    /// <summary>
+    /// convert the BufferRegionView to expr.
+    /// <remarks>
+    /// 当开启ping pong时,如果
+    /// </remarks>
+    /// </summary>
+    /// <param name="view">view.</param>
+    public static implicit operator Expr(BufferRegionView view)
+    {
+        if (view._cache is not null)
+        {
+            return view._cache;
+        }
+
+        Expr expr;
+        if (view.Buffers.Count == 0)
+        {
+            expr = IR.None.Default;
+        }
+        else if (view.Buffers.Count == 1)
+        {
+            expr = view.BufferRegions[0];
+        }
+        else if (view.Buffers.Count >= 2)
+        {
+            expr = new Tuple(view.BufferRegions.ToArray())[view.LoopCount % view.Buffers.Count];
+        }
+        else
+        {
+            throw new NotSupportedException();
+        }
+
+        view._cache = expr;
+        return view._cache;
+    }
+
+    public static BufferRegionView None(IndexMapKey key) => new(Array.Empty<Buffer>(), new IRArray<Range>(), new IRArray<Range>(), key);
+
+    public ReadOnlySpan<Expr> RegionSize()
+    {
+        _region_size ??= Region.AsValueEnumerable().Select(r => r.Stop - r.Start).ToArray();
+        return _region_size;
+    }
+
+    public Expr RegionSize(int i) => RegionSize()[i];
+}
+
+/// <summary>
+/// name 分配器.
+/// </summary>
+internal sealed class NameAllocator
+{
+    public Dictionary<string, int> NamePool { get; } = new();
+
+    public string Get(string name)
+    {
+        if (!NamePool.TryGetValue(name, out var count))
+        {
+            count = 0;
+        }
+
+        NamePool[name] = count + 1;
+        return count == 0 ? name : $"{name}_{count}";
+    }
+}
+
+/// <summary>
+/// buffer region view.
+/// </summary>
+internal sealed class LogiclPrimFuncCloner : ExprCloner<Unit>
+{
+    protected override Expr VisitLeafLogicalBuffer(LogicalBuffer buffer, Unit context)
+    {
+        return buffer;
+    }
+
+    protected override Expr VisitLeafPhysicalBuffer(PhysicalBuffer buffer, Unit context)
+    {
+        return buffer;
+    }
+
+    protected override Expr VisitVar(Var var, Unit context)
+    {
+        return var;
+    }
+}
+
+internal sealed record ReIndexCacheKey(IBoundsInferGraph BoundsInferGraph, IndexMapKey From, IndexMapKey To, IRArray<TIR.Range> FromRegion, int? Promote)
+{
+}
+
+internal abstract class LayerFusionConverter
+{
+    public NameAllocator NameAllocator { get; } = new();
+
+    /// <summary>
+    /// Gets map the graph expression and it's bufferRegion.
+    /// </summary>
+    public Dictionary<IndexMapKey, BufferRegionView> KeyToViewMap { get; } = new();
+
+    /// <summary>
+    /// Gets because of the index map can't create by var, so need other map save the relationship.
+    /// </summary>
+    public Dictionary<Var, IndexMapKey> VarToKeyMap { get; } = new(ReferenceEqualityComparer.Instance);
+
+    /// <summary>
+    /// Gets tile size 的变量.
+    /// </summary>
+    public List<Var> TileSizeVars { get; } = new();
+
+    /// <summary>
+    /// Gets loop 变量.
+    /// </summary>
+    public List<Var> LoopVars { get; } = new();
+
+    /// <summary>
+    /// Gets loop domains.
+    /// </summary>
+    public List<Range> LoopDomains { get; } = new();
+
+    /// <summary>
+    /// Gets 所有的blocks
+    /// 最终是:
+    /// mainBlock
+    ///   loop n
+    ///     block n
+    ///       loop c
+    ///         block c
+    ///          .
+    ///          .
+    /// </summary>
+    public List<ITileBlockBuilder> NestedBlocks { get; } = new();
+
+    /// <summary>
+    /// Gets nested loops.
+    /// </summary>
+    public List<ISequentialBuilder<For>> NestedLoops { get; } = new();
+
+    public TileOptions TileOptions { get; protected set; } = null!;
+
+    /// <summary>
+    /// Gets or sets 默认的bounds infer graph.
+    /// </summary>
+    public abstract IBoundsInferGraph BoundsInferGraph { get; protected set; }
+
+    /// <summary>
+    /// Gets or sets 总的loop count.
+    /// </summary>/
+    public abstract Expr LoopCount { get; protected set; }
+
+    /// <summary>
+    /// Gets or sets ping pong 外层的tiling.
+    /// </summary>
+    public abstract Expr LoopCountOuter { get; protected set; }
+
+    /// <summary>
+    /// Gets or sets ping pong 内侧的tiling.
+    /// </summary>
+    public abstract Expr LoopCountInner { get; protected set; }
+
+    /// <summary>
+    /// Gets or sets 当前的fusion.
+    /// </summary>
+    public abstract Fusion CurrentFusion { get; protected set; }
+
+    /// <summary>
+    /// Gets glb reindex cache.
+    /// </summary>
+    protected Dictionary<ReIndexCacheKey, (IRArray<TIR.Range> ToRegion, IReadOnlyList<(Expr Before, Expr After)> Paddings)> GlbReindexCache { get; } = new();
+
+    public abstract Expr Visit(Fusion fusion);
+
+    public virtual PrimFunction BuildLogicalPrimFunc(Expr bodySeq)
+    {
+        var inputs_buffer = CurrentFusion.Parameters.ToArray().Select(p => (PhysicalBuffer)KeyToViewMap[VarToKeyMap[p]].Buffers[0]);
+        var primFuncBuilder = T.PrimFunc(CurrentFusion.Name, K510RTModule.Kind, inputs_buffer.Concat(new[] { (PhysicalBuffer)KeyToViewMap[(Call)CurrentFusion.Body].Buffers[0] }).ToArray());
+
+        NestedBlocks[^1].Body(bodySeq);
+        primFuncBuilder.Body(
+          I.MmuConf(0, 0, MMU_CONF_WIDTH._8, 0, ExtCompilerServices.Env.GlbDepth), // 把整个glb当作连续内存使用.
+          NestedBlocks[0],
+          I.Fence());
+
+        var logicalPrimFunc = primFuncBuilder.Build();
+        logicalPrimFunc = (PrimFunction)new Mutators.SimplifyBounds().Rewrite(logicalPrimFunc);
+        logicalPrimFunc.InferenceType();
+        GlbReindexCache.Clear();
+        return logicalPrimFunc;
+    }
+
+    public abstract bool BalanceTileSize(int[] tile_size, Segment[] search_spaces);
+
+    public virtual PrimFunction BuildPhysicalPrimFunc(int[] final_tile_size, IReadOnlyDictionary<Buffer, PhysicalBuffer> sched_result, PrimFunction logicalPrimFunc)
+    {
+        var physicalizer = new BufferPhysicalizer(final_tile_size, sched_result, TileSizeVars);
+        var physicalPrimFunc = (PrimFunction)physicalizer.Rewrite(logicalPrimFunc);
+        return physicalPrimFunc;
+    }
+
+    public virtual int[] SearchTileSize(ISearchTileGenerator tile_generator, PrimFunction logicalPrimFunc, bool multi_workers, bool hasResult, out ScheduledResponse response)
+    {
+        AllocationCache<int[], ScheduledResponse> response_cache = new();
+        bool schedule_status = false;
+        int[] final_tile = Array.Empty<int>();
+
+        while (true)
+        {
+            var next_tile = tile_generator.GetNextTile(schedule_status).ToArray();
+            if (next_tile.Length == 0)
+            {
+                break;
+            }
+
+            schedule_status = TryScheduleNextTileSize(next_tile, logicalPrimFunc, response_cache, multi_workers, hasResult);
+            if (schedule_status)
+            {
+                final_tile = next_tile;
+                response_cache.CheckIn();
+            }
+        }
+
+        if (!final_tile.Any())
+        {
+            response = new(new Dictionary<TIR.Buffer, TIR.PhysicalBuffer>(), null!, null!, logicalPrimFunc, null!, 0, false);
+            return final_tile;
+        }
+
+        // take back last success allocation result
+        response = response_cache.GetLastSuccess(final_tile);
+        return final_tile;
+    }
+
+    public virtual Expr Visit(IndexMapKey mapKey, string prefix, int? promote = null)
+    {
+        prefix = prefix + mapKey.Prefix;
+        return mapKey.Expr switch
+        {
+            Call call => (call.Target switch
+            {
+                GNNELoad op => LowerGnneLoad(mapKey, call, op, NameAllocator.Get(nameof(GNNELoad)), prefix, promote, true),
+                GNNEStore op => LowerGnneStore(call, op, NameAllocator.Get(nameof(GNNEStore)), prefix),
+                GNNEConv2D op => LowerGnneConv2D(mapKey, call, op, NameAllocator.Get(nameof(GNNEConv2D)), prefix),
+                GNNEConv2DTranspose op => LowerGnneConv2DTranspose(mapKey, call, op, NameAllocator.Get(nameof(GNNEConv2D)), prefix),
+                GNNEReduce op => LowerGnneReduce(mapKey, call, op, NameAllocator.Get(nameof(GNNEReduce)), prefix),
+                GNNEMeshNet op => LowerGnneMeshNet(mapKey, call, op, NameAllocator.Get(nameof(GNNEMeshNet)), prefix),
+                GNNETranspose op => LowerGnneTranspose(mapKey, call, op, NameAllocator.Get(nameof(GNNETranspose)), prefix),
+                GNNEActivation op => LowerGnneActivation(mapKey, call, op, NameAllocator.Get(nameof(GNNEActivation)), prefix),
+                GNNEPdpReduce op => LowerGnnePdpReduce(mapKey, call, op, NameAllocator.Get(nameof(GNNEPdpReduce)), prefix),
+                GNNECrop op => LowerGnneCrop(mapKey, call, op, NameAllocator.Get(nameof(GNNECrop)), prefix),
+                Uninitialized => T.Sequential(),
+                _ => throw new NotSupportedException(),
+            }).Build(),
+            _ => T.Nop(),
+        };
+    }
+
+    /// <summary>
+    /// 子偏移输入到bounds infer后反推子偏移.
+    /// </summary>
+    /// <param name="from">from.</param>
+    /// <param name="to">to.</param>
+    /// <param name="sub_paddings">sub_paddings.</param>
+    /// <param name="partialFuncs">the partial compute funcs.</param>
+    /// <returns>.</returns>
+    public virtual BufferRegionView GlbReIndex(BufferRegionView from, BufferRegionView to, out IReadOnlyList<(Expr Before, Expr After)> sub_paddings, params (int Axis, Func<TIR.Range, TIR.Range> CallBack)[] partialFuncs)
+    {
+        var key = new ReIndexCacheKey(BoundsInferGraph, from.Key, to.Key, new(from.Region), to.Promote);
+        IReadOnlyList<Range> to_region;
+        if (partialFuncs.Length == 0 && GlbReindexCache.TryGetValue(key, out var result))
+        {
+            to_region = result.ToRegion;
+            sub_paddings = result.Paddings;
+        }
+        else
+        {
+            to_region = TileUtilities.GetRelativeNoPadBounds(BoundsInferGraph, from.Key, to.Key, from.Region, to.Promote, partialFuncs, out sub_paddings);
+            if (partialFuncs.Length == 0)
+            {
+                GlbReindexCache.Add(key, (new(to_region), sub_paddings));
+            }
+        }
+
+        return to[to_region.ToArray()];
+    }
+
+    protected virtual bool TryScheduleNextTileSize(int[] next_tile_size, PrimFunction logicalPrimFunc, AllocationCache<int[], ScheduledResponse> response_cache, bool multi_workers, bool hasResult)
+    {
+        // 1. make one tile feed dict
+        var feed_dict = next_tile_size.Select((s, i) =>
+                    new[] { (LoopVars[i], (IValue)Value.FromTensor(Tensor.FromScalar(0))),
+                     (TileSizeVars[i], (IValue)Value.FromTensor(Tensor.FromScalar(s))), }).
+                    SelectMany(i => i).
+                    ToDictionary(kv => kv.Item1, kv => kv.Item2);
+        var sched_candidate = new Dictionary<Buffer, PhysicalBuffer>(ReferenceEqualityComparer.Instance);
+
+        // 2. folding the tileblock op to the block
+        PrimFunction new_logical_primfunc;
+        using (var dumpScope = new DumpScope(NullDumpper.Instance))
+        {
+            var pass = new PrimFuncPass { Name = "FoldingTileBlock" };
+            pass.Add<RemoveFoldOfMakers>(feed_dict);
+            pass.Add<FoldCondition>();
+            pass.Add<FoldTileBlock>();
+            var task = pass.RunAsync(new LogiclPrimFuncCloner().Clone(logicalPrimFunc, default), new());
+            task.Wait();
+            new_logical_primfunc = task.Result;
+        }
+
+        BufferScheduler bufferScheduler = new(new_logical_primfunc);
+
+        // 3. clloction buffers
+        bufferScheduler.LifeTimeAnalysis();
+
+        // compute the size in bytes
+        foreach (var buffer in bufferScheduler.RecordBuffers)
+        {
+            var dimensions = buffer.Dimensions.ToArray().Select(d => d.Evaluate(feed_dict).AsTensor().ToScalar<int>()).ToArray();
+            var strides = TensorUtilities.GetStrides(dimensions);
+            var glb_strides = strides.Select(s => s * buffer.ElemType.SizeInBytes).ToArray();
+
+            if (bufferScheduler.InnerConstraints[buffer] == ConstraintsMode.Channel &&
+
+               // 当load psum的时候,如果shape过小, 那么不额外添加stride.
+               !(buffer.Name.Split(".").Last().StartsWith(GNNEConv2D.PSum.Name) &&
+                 dimensions[2] * dimensions[3] < 14 * 14))
+            {
+                glb_strides = TileUtilities.PaddingAvoidConflict(dimensions, glb_strides, 1);
+                strides = glb_strides.Select(s =>
+                {
+                    if (s % buffer.ElemType.SizeInBytes != 0)
+                    {
+                        throw new NotSupportedException();
+                    }
+
+                    return s / buffer.ElemType.SizeInBytes;
+                }).ToArray();
+            }
+
+            var size_n_byte = dimensions[0] * glb_strides[0];
+
+            // todo 可以不用align到一整行, 到一个bank即可.
+            var glb_size = TileUtilities.AlignBy(size_n_byte, ExtCompilerServices.Env.GlbBankWidth * ExtCompilerServices.Env.GlbWidth);
+            var physical_candidate = new PhysicalBuffer(buffer.Name, buffer.ElemType, buffer.MemLocation, dimensions, strides, start: 0, size: glb_size);
+            sched_candidate.Add(buffer, physical_candidate);
+        }
+
+        var respose = bufferScheduler.Schedule(sched_candidate, multi_workers, hasResult);
+        response_cache.Add(next_tile_size, respose);
+        return respose.Success;
+    }
+
+    /// <summary>
+    /// 申请 buffer.
+    /// NOTE 会自动添加到buffer map, 同时会记录他ddr 上的padding到字典中.
+    /// 如果给定 ddr buf region, 那么默认glb buffer region则是通过ddr buffer load 进来的,此时glb buffer的region是减去过padding的.
+    /// 如果promote到对应的循环后,那么申请buffer的时候在promote内部的循环都应该被调整到最大值.
+    /// </summary>
+    /// <param name="mapKey">mapKey.</param>
+    /// <param name="region">region.</param>
+    /// <param name="ping_pong">开启ping pong就会多开一块相同的buffer.</param>
+    /// <param name="promote"> 如果promote为int,那么就会提升buffer到指定循环, 为-1那么就是整个计算块, 会忽略ping pong. </param>
+    /// <param name="specificLoopBounds">specificLoopBounds.</param>
+    /// <param name="name">name.</param>
+    /// <returns>.</returns>
+    /// <exception cref="NotSupportedException">NotSupportedException.</exception>
+    /// <exception cref="System.ArgumentOutOfRangeException">System.ArgumentOutOfRangeException.</exception>
+    protected virtual Expr GetBufferRegion(IndexMapKey mapKey, out BufferRegionView region, bool ping_pong = false, int? promote = null, Dictionary<IndexMapKey, List<Range>>? specificLoopBounds = null, [CallerArgumentExpression("region")] string name = "region")
+    {
+        if (name.StartsWith("var "))
+        {
+            name = name[4..];
+        }
+
+        if (KeyToViewMap.ContainsKey(mapKey))
+        {
+            region = KeyToViewMap[mapKey];
+            return T.Nop();
+        }
+
+        name = NameAllocator.Get(name);
+        switch (mapKey.Expr)
+        {
+            case TensorConst con:
+                {
+                    IEnumerable<Range> bounds;
+                    IEnumerable<Range> clampedBounds;
+                    if (promote is int promoteInt)
+                    {
+                        if (promoteInt == -1)
+                        {
+                            clampedBounds = mapKey.Expr.CheckedShape.Select(s => new Range(0, s.FixedValue, 1));
+                            bounds = BoundsInferGraph[mapKey].Bounds;
+                        }
+                        else
+                        {
+                            if (specificLoopBounds is null || !specificLoopBounds.TryGetValue(mapKey, out var newBounds))
+                            {
+                                newBounds = K510TIRExtensions.PromotedBounds(promoteInt, BoundsInferGraph, mapKey, LoopVars, LoopDomains).ToList();
+                            }
+
+                            bounds = newBounds;
+                            clampedBounds = TIRUtilities.ClampBounds(newBounds, mapKey.Expr.CheckedShape);
+                        }
+                    }
+                    else
+                    {
+                        bounds = BoundsInferGraph[mapKey].Bounds;
+                        clampedBounds = BoundsInferGraph[mapKey].ClampedBounds;
+                    }
+
+                    T.ConstBuffer(con, out var ddr_buffer, name);
+                    if (ping_pong)
+                    {
+                        throw new NotSupportedException();
+                    }
+
+                    region = new BufferRegionView(new[] { ddr_buffer }, bounds, clampedBounds, mapKey);
+                    break;
+                }
+
+            case Call call:
+                {
+                    // 1. 对于glb buffer来说, 他的总大小要跟着申请buffer维度来变化.
+                    // note 实际上对于
+                    List<Range> bounds;
+                    Expr loopCount;
+                    if (promote is int promoteInt)
+                    {
+                        if (promoteInt == -1)
+                        {
+                            bounds = mapKey.Expr.CheckedShape.Select(s => new Range(0, s.FixedValue, 1)).ToList();
+                            loopCount = 0;
+                        }
+                        else
+                        {
+                            if (specificLoopBounds is null || !specificLoopBounds.TryGetValue(mapKey, out var newBounds))
+                            {
+                                newBounds = K510TIRExtensions.PromotedBounds(promoteInt, BoundsInferGraph, mapKey, LoopVars, LoopDomains).ToList();
+                            }
+
+                            bounds = newBounds;
+                            loopCount = K510TIRExtensions.PromotedLoopCount(promoteInt, LoopVars, LoopDomains);
+                        }
+                    }
+                    else
+                    {
+                        bounds = BoundsInferGraph[mapKey].Bounds.ToList();
+                        loopCount = LoopCount;
+                    }
+
+                    // note 这里的bounds实际上会因为输入不同的var而被改变, 所以后面要获取dimension的地方需要注意.
+                    var dimensions = bounds.Select(r => r.Stop - r.Start).Select((b, i) => MathF.Min(b, call.CheckedShape[i].FixedValue)).ToArray();
+                    List<Buffer> glb_buffers = new();
+                    if (ping_pong)
+                    {
+                        for (int i = 0; i < TileOptions.PingPongNum; i++)
+                        {
+                            glb_buffers.Add(new LogicalBuffer(name + $"(p{i})", call.CheckedDataType, MemoryLocation.L2Data, dimensions));
+                        }
+                    }
+                    else
+                    {
+                        glb_buffers.Add(new LogicalBuffer(name, call.CheckedDataType, MemoryLocation.L2Data, dimensions));
+                    }
+
+                    // 对于glb_buffer来说, 默认region 从0 开始, 但是要减去输入ddr index 的padding.
+                    var noPadBounds = TIRUtilities.ComputeNoPadBounds(bounds, TIRUtilities.ComputePaddings(bounds, mapKey.Expr.CheckedShape));
+                    region = new BufferRegionView(glb_buffers, bounds, noPadBounds, mapKey, loopCount, promote);
+                    break;
+                }
+
+            case Var v:
+                {
+                    // the different mapkey will point to same var: add(v,conv(v))
+                    if (!VarToKeyMap.TryGetValue(v, out var old_map_key))
+                    {
+                        T.PhysicalBuffer(v.CheckedDataType, MemoryLocation.Input, v.CheckedShape.ToValueArray(), out var ddr_buffer, name);
+                        IEnumerable<Range> clampedBounds;
+                        IReadOnlyList<Range> bounds;
+                        if (promote is int promoteInt)
+                        {
+                            if (promoteInt != -1)
+                            {
+                                if (specificLoopBounds is null || !specificLoopBounds.TryGetValue(mapKey, out var newBounds))
+                                {
+                                    newBounds = K510TIRExtensions.PromotedBounds(promoteInt, BoundsInferGraph, mapKey, LoopVars, LoopDomains).ToList();
+                                }
+
+                                bounds = newBounds;
+                            }
+                            else
+                            {
+                                bounds = mapKey.Expr.CheckedShape.Select(s => new Range(0, s.FixedValue, 1)).ToList();
+                            }
+
+                            clampedBounds = TIRUtilities.ClampBounds(bounds, mapKey.Expr.CheckedShape);
+                        }
+                        else
+                        {
+                            bounds = BoundsInferGraph[mapKey].Bounds;
+                            clampedBounds = BoundsInferGraph[mapKey].ClampedBounds;
+                        }
+
+                        if (ping_pong)
+                        {
+                            throw new NotSupportedException();
+                        }
+
+                        region = new BufferRegionView(new[] { ddr_buffer }, bounds, clampedBounds, mapKey);
+                        VarToKeyMap.Add(v, mapKey);
+                    }
+                    else
+                    {
+                        region = KeyToViewMap[old_map_key];
+                    }
+
+                    break;
+                }
+
+            case None none:
+                region = BufferRegionView.None(mapKey);
+                break;
+            default:
+                throw new NotSupportedException();
+        }
+
+        KeyToViewMap.Add(mapKey, region);
+        return T.Nop();
+    }
+
+    /// <summary>
+    /// promote 的逻辑, 根据值选择移动当前的buffer开在哪个循环.
+    /// -1 表示在所有循环之外
+    /// 0 表示在N循环内
+    /// 3 表示在W循环内.
+    ///
+    /// </summary>
+    /// <param name="parentKey">上一级传入的key.</param>
+    /// <param name="call">call.</param>
+    /// <param name="op">op.</param>
+    /// <param name="block_name">block_name.</param>
+    /// <param name="prefix">prefix.</param>
+    /// <param name="promote">promote.</param>
+    /// <param name="softPipeLine">is enable soft pipe line.</param>
+    /// <returns>.</returns>
+    protected virtual ISequentialBuilder<Sequential> LowerGnneLoad(IndexMapKey parentKey, Call call, GNNELoad op, string block_name, string prefix, int? promote, bool softPipeLine)
+    {
+        var call_input = IndexMapKey.Create(call, GNNELoad.Input);
+        var call_deq = IndexMapKey.Create(call, GNNELoad.DeqParams);
+
+        var seq = T.Sequential().Body(
+          Visit(call_deq, prefix, promote),
+          GetBufferRegion(call_input, out var ddr_ld_input, name: prefix + "." + TileNames.DdrInput, promote: promote), // loadif 的输入可能来自于const或输入
+          GetBufferRegion(call_deq, out var glb_ld_qarg_input), // 只有promote到n循环外时,才不进行ping pong.
+          GetBufferRegion(parentKey, out var glb_ld_output, promote == -1 ? false : TileOptions.PingPong, name: prefix, promote: promote)); // load if 要用的glb buffer
+
+        var block = EAction.TileBlock(block_name).
+          Alloc(promote is null ? glb_ld_output.Buffers : None.Default).
+          Reads(ddr_ld_input.BufferRegions, glb_ld_qarg_input.BufferRegions).
+          Writes(glb_ld_output.BufferRegions).
+          Predicate(true).// todo 这里先不做局部加载, 后面再实现
+          Body(// promote这里load用的是full region, 但是在字典中存的还应该是partial的, 因为后面是每个glb的tile在使用.
+            softPipeLine ?
+              (TileOptions.PingPong & (promote != -1) ? K510.PingPongSlot(block_name, glb_ld_output.LoopCount / TileOptions.PingPongNum, glb_ld_output.LoopCount % TileOptions.PingPongNum) : T.Nop()) :
+              T.Nop(),
+            EAction.LoadT(ddr_ld_input, glb_ld_output, glb_ld_qarg_input, op.DeqAxis));
+
+        if (promote is int promoteIndex)
+        {
+            // 如果promote, 那么在这个循环的所有block外执行
+            NestedBlocks[promoteIndex + 1].Init(block);
+            NestedBlocks[promoteIndex + 1].Alloc(glb_ld_output.Buffers);
+        }
+        else
+        {
+            seq.Body(block);
+        }
+
+        return seq;
+    }
+
+    protected virtual ISequentialBuilder<Sequential> LowerGnneMeshNet(IndexMapKey parentKey, Call call, GNNEMeshNet target, string block_name, string prefix)
+    {
+        prefix = NameAllocator.Get(nameof(GNNEMeshNet));
+        var call_in_a = IndexMapKey.Create(call, GNNEMeshNet.InputA);
+        var call_in_b = IndexMapKey.Create(call, GNNEMeshNet.InputB);
+        var call_in_seg0 = IndexMapKey.Create(call, GNNEMeshNet.SegFittingParam0);
+        var call_in_seg1 = IndexMapKey.Create(call, GNNEMeshNet.SegFittingParam1);
+        var seq = T.Sequential().Body(
+          Visit(call_in_a, prefix),
+          Visit(call_in_b, prefix),
+          GetBufferRegion(call_in_a, out var meshnet_input_a),
+          GetBufferRegion(call_in_b, out var meshnet_input_b),
+          GetBufferRegion(call_in_seg0, out var meshnet_input_seg0),
+          GetBufferRegion(call_in_seg1, out var meshnet_input_seg1),
+          GetBufferRegion(parentKey, out var meshnet_output, TileOptions.PingPong, name: prefix),
+          EAction.TileBlock(block_name).
+            Alloc(meshnet_output.Buffers).
+            Reads(
+                meshnet_input_a.BufferRegions,
+                meshnet_input_b.BufferRegions,
+                meshnet_input_seg0.BufferRegions,
+                meshnet_input_seg1.BufferRegions).
+            Body(
+              EAction.MeshNetCompute(
+                  (Fusion)call[GNNEMeshNet.MeshFunc],
+                  meshnet_input_a,
+                  meshnet_input_b,
+                  meshnet_input_seg0,
+                  meshnet_input_seg1,
+                  meshnet_output)));
+
+        if (!(call[GNNEMeshNet.InputB] is None && call[GNNEMeshNet.NewShape] is None && call[GNNEMeshNet.SegFittingParam0] is None && call[GNNEMeshNet.SegFittingParam1] is None && !TileUtilities.MeshFuncHasConstants((Fusion)call[GNNEMeshNet.MeshFunc])))
+        {
+            foreach (var item in meshnet_output.Buffers)
+            {
+                item.Metadata = new TileMetadata() { StrideByShape = true };
+            }
+        }
+
+        return seq;
+    }
+
+    protected virtual ISequentialBuilder<Sequential> LowerGnneStore(Call call, GNNEStore op, string block_name, string prefix, bool promoteQarg = true)
+    {
+        prefix = NameAllocator.Get(nameof(GNNEStore));
+        var cropPadding = ((TensorConst)call[GNNEStore.CropPadding]).Value.Cast<int>();
+        var channel = call.CheckedShape[1].FixedValue;
+        bool is_quant_by_channel = false;
+        if (call[GNNEStore.QuantParams] is Call { Target: GNNELoad } l_qarg && l_qarg[GNNELoad.Input] is TensorConst qarg)
+        {
+            _ = qarg.Value.Cast<QuantizeParam>();
+            if (qarg[0] != qarg[channel - 1])
+            {
+                is_quant_by_channel = true;
+            }
+        }
+
+        var outputShape = call.CheckedShape.ToValueArray();
+        T.PhysicalBuffer(call.CheckedDataType, MemoryLocation.Output, outputShape, out var ddr_st_buffer, name: prefix + ".ddr_buffer");
+        var bounds = BoundsInferGraph[call].Bounds;
+
+        var (paddingHBefore, paddingHafter) = TileUtilities.ComputePadding(bounds[2] - cropPadding[0, 0], outputShape[2]);
+        var (paddingWBefore, paddingWafter) = TileUtilities.ComputePadding(bounds[3] - cropPadding[1, 0], outputShape[3]);
+
+        var newBounds = bounds.ToArray();
+        newBounds[2] = newBounds[2] - cropPadding[0, 0];
+        newBounds[3] = newBounds[3] - cropPadding[1, 0];
+        var ddrRegion = TIRUtilities.ClampBounds(newBounds, outputShape);
+        var ddr_st_output = new BufferRegionView(new[] { ddr_st_buffer }, BoundsInferGraph[call].Bounds, ddrRegion, call);
+        KeyToViewMap.Add(call, ddr_st_output);
+
+        var call_in = IndexMapKey.Create(call, GNNEStore.Input);
+        var call_qarg = IndexMapKey.Create(call, GNNEStore.QuantParams);
+        return T.Sequential().Body(
+          Visit(call_in, prefix),
+          Visit(call_qarg, prefix, promoteQarg ? -1 : null), // 多层是只按h切, 此时oc满的,默认promote.
+          GetBufferRegion(call_in, out var glb_st_input),
+          GetBufferRegion(call_qarg, out var glb_st_qarg_input),
+          EAction.TileBlock(block_name).Reads(glb_st_input.BufferRegions, glb_st_qarg_input.BufferRegions).Body(
+            EAction.StoreT(ddr_st_output, glb_st_input[.., .., (glb_st_input.Region[2].Start + paddingHBefore, glb_st_input.Region[2].Stop - paddingHafter), (glb_st_input.Region[3].Start + paddingWBefore, glb_st_input.Region[3].Stop - paddingWafter)], glb_st_qarg_input, null, is_quant_by_channel)));
+    }
+
+    protected virtual ISequentialBuilder<Sequential> LowerGnneReduce(IndexMapKey parentKey, Call call, GNNEReduce op, string block_name, string prefix)
+    {
+        prefix = NameAllocator.Get(nameof(GNNEReduce));
+        var reduce_in = IndexMapKey.Create(call, GNNEReduce.Input);
+        var seq = T.Sequential().Body(
+          Visit(reduce_in, prefix),
+          GetBufferRegion(reduce_in, out var gnne_reduce_input),
+          GetBufferRegion(parentKey, out var gnne_reduce_output, TileOptions.PingPong, name: prefix),
+          EAction.TileBlock(block_name).
+            Alloc(gnne_reduce_output.Buffers).
+            Reads(gnne_reduce_input.BufferRegions).Body(
+              EAction.Reduce(
+                gnne_reduce_input,
+                gnne_reduce_output,
+                call[GNNEReduce.InitValue],
+                op.ReduceOp,
+                op.ReduceDim)));
+
+        return seq;
+    }
+
+    /// <summary>
+    /// 对于dw卷积来说,每个ic对应一个oc, 因此让每个tcu计算一半的if.
+    /// </summary>
+    protected ITileBlockBuilder GNNEConv2DSharedNone(Call call, string block_name, BufferRegionView glb_w, BufferRegionView glb_if, BufferRegionView glb_act, BufferRegionView glb_psum, BufferRegionView glb_of, bool is_init_psum, string prefix, int? promote = null)
+    {
+        var init_psums = GetInitPSumBufferRegion(call, IndexMapKey.Create(call, GNNEConv2D.PSum), glb_psum, promote, prefix, 1, ExtCompilerServices.Env.TcuActNum, out var part_condition);
+
+        var block = EAction.TileBlock(block_name).Reads(glb_w.BufferRegions, is_init_psum ? init_psums[0].BufferRegions.Concat(init_psums[1].BufferRegions.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : glb_psum.BufferRegions, glb_if.BufferRegions, glb_act.BufferRegions).Writes(glb_of.BufferRegions).Body(
+          T.Unrolled(out var kh, new(0, glb_w.Dimensions[2], ExtCompilerServices.Env.PuHeight)).Body(
+            T.Unrolled(out var kw, new(0, glb_w.Dimensions[3], ExtCompilerServices.Env.PuKernelSpad)).Body(
+              T.Let(out var m_once, 1).Body(
+              T.Let(out var c_once, MathF.Select(MathF.Equal(m_once, glb_w.RegionSize(0)), MathF.Min(MathF.Min(ExtCompilerServices.Env.PuWidth / m_once, ExtCompilerServices.Env.PuHeight / MathF.Min(glb_w.Dimensions[2], ExtCompilerServices.Env.PuHeight)), glb_w.RegionSize(0)), 1)).Body(// note 我这里没有实现dw卷积的多输出channel的, 默认都是 1 ic : 1 oc.
+                T.Let(out var tcu_oc_chunk, TileUtilities.Split(glb_of.RegionSize(1), ExtCompilerServices.Env.TcuActNum)).Body(// 1. determine tcu act num
+                T.Let(out var n_active_tcu, TileUtilities.SplitTimes(glb_of.RegionSize(1), tcu_oc_chunk)).Body(// 2. broadcast action
+                  EAction.TcuDmBroadCast(TcuDivideStrategy.NoShare),
+                  T.Unrolled(out var tcu_oc, new(glb_of.Region[1].Start, glb_of.Region[1].Stop, tcu_oc_chunk)).Body(// 3. loop over tcus and config each tcu
+                    T.Let(out var m_once_tcu, 1).Body(
+                    T.Let(out var c_once_tcu, MathF.Min(ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2), MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc)).Body(
+                      EAction.TcuPuConfAct(
+                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
+                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_act, out _),
+                        call[GNNEConv2D.FusedClamp][0],
+                        call[GNNEConv2D.FusedClamp][1]),
+                      EAction.TcuPuConf(
+                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
+                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_if, out _),
+                        glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..],
+                        IR.F.Math.Min(glb_w.Dimensions[2], ExtCompilerServices.Env.PuHeight),
+                        IR.F.Math.Min(glb_w.Dimensions[3], ExtCompilerServices.Env.PuKernelSpad),
+                        m_once: m_once_tcu,
+                        c_once: c_once_tcu,
+                        groups: 1,
+                        mode: TcuComputeMode.DwConv2d),
+                      EAction.TcuDmConfOf(// todo 这里hardcode两个tcu, 后面需要改进
+                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
+                        is_init_psum ? MathF.Select(MathF.Equal(tcu_oc, glb_of.Region[1].Start), init_psums[0][.., (0, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc), .., ..], init_psums[1][.., (0, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc), .., ..]) : GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_psum, out _),
+                        glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..],
+                        0),
+                      EAction.TcuDmConfIf(
+                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
+                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_if, out var if_paddings),
+                        stride_w: call[GNNEConv2D.Stride][1],
+                        stride_h: call[GNNEConv2D.Stride][0],
+                        input_c_pre_pu: c_once_tcu,
+                        dilation_h: call[GNNEConv2D.Dilation][0],
+                        padding_top: if_paddings[2].Before,
+                        padding_bottom: if_paddings[2].After,
+                        padding_left: if_paddings[3].Before,
+                        padding_right: if_paddings[3].After),
+                      EAction.TcuDmConfW(
+                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
+                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_w, out _)),
+                      EAction.TcuDmFetchW(// 4. fetch weights
+                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
+                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_w, out _)),
+                      EAction.TcuDmFetchIf(// 5. loop over tcus and fetch if for each tcu
+                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
+                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_if, out _))))),
+                  EAction.TcuPuCompute(// 6. pu compute   NOTE 这里我没有在weight的kh和kw上切,所以默认都是一次算完的
+                    TileUtilities.GetNTcuIndexBits(n_active_tcu),
+                    true,
+                    true,
+                    call[GNNEConv2D.PSum] is not Call { Target: Uninitialized },
+                    TileUtilities.GetNTcuIndexBits(n_active_tcu)))))))));
+
+        if (promote is null)
+        {
+            block.Alloc(glb_of.Buffers, is_init_psum ? init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : None.Default);
+        }
+        else if (promote is int promoteIndex)
+        {
+            if (is_init_psum)
+            {
+                NestedBlocks[promoteIndex + 1].Alloc(init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray());
+            }
+        }
+
+        return block;
+    }
+
+    protected virtual BufferRegionView[] GetInitPSumBufferRegion(Call call, IndexMapKey key, BufferRegionView glb_psum, int? promote, string prefix, int split_axis, int tcuActNum, out Expr part_condition)
+    {
+        var chunk = TileUtilities.Split(glb_psum.Dimensions[split_axis], tcuActNum);
+        part_condition = TileUtilities.SplitTimes(glb_psum.Dimensions[split_axis], chunk);
+        var views = new BufferRegionView[2];
+        var psum_dimensions = glb_psum.Dimensions.ToArray();
+        psum_dimensions[split_axis] = chunk;
+        var dimensions = psum_dimensions;
+
+        // build psum a and b
+        foreach (var (part, i) in new[] { "_a", "_b" }.Select((p, i) => (p, i)))
+        {
+            var name = prefix + "." + TileNames.InitPSum + part;
+            var glb_init_psums = new List<Buffer>();
+            if (TileOptions.PingPong)
+            {
+                for (int p = 0; p < TileOptions.PingPongNum; p++)
+                {
+                    glb_init_psums.Add(new LogicalBuffer(name + $"(p{p})", DataTypes.Float32, MemoryLocation.L2Data, dimensions));
+                }
+            }
+            else
+            {
+                glb_init_psums.Add(new LogicalBuffer(name, DataTypes.Float32, MemoryLocation.L2Data, dimensions));
+            }
+
+            Expr loopCount;
+            if (promote is int promoteInt)
+            {
+                if (promoteInt != -1)
+                {
+                    loopCount = K510TIRExtensions.PromotedLoopCount(promoteInt, LoopVars, LoopDomains);
+                }
+                else
+                {
+                    loopCount = LoopCount;
+                }
+            }
+            else
+            {
+                loopCount = LoopCount;
+            }
+
+            views[i] = new BufferRegionView(glb_init_psums, glb_psum.Bounds, psum_dimensions.Select(d => new Range(0, d, 1)), key, loopCount, promote);
+        }
+
+        return views;
+    }
+
+    protected virtual Expr GNNEConv2DComputeActEnable(Call call, BufferRegionView glb_w, Expr khStop, Expr kHBounds, Expr kwStop, Expr kWBounds)
+    {
+        return MathF.LogicalAnd(MathF.GreaterEqual(khStop, kHBounds), MathF.GreaterEqual(kwStop, kWBounds));
+    }
+
+    protected virtual Expr GNNEConv2DComputeOfEnable(Call call, BufferRegionView glb_w, Expr khStop, Expr kHBounds, Expr kwStop, Expr kWBounds)
+    {
+        return GNNEConv2DComputeActEnable(call, glb_w, khStop, kHBounds, kwStop, kWBounds);
+    }
+
+    protected virtual Expr GNNEConv2DComputeLoadPsumEnable(Call call, BufferRegionView glb_w, Expr kh, Expr kw)
+    {
+        if (call[IR.K510.GNNEConv2D.PSum] is Call { Target: IR.Buffers.Uninitialized })
+        {
+            return IR.F.Math.LogicalNot(IR.F.Math.LogicalAnd(IR.F.Math.Equal(kh, 0), IR.F.Math.Equal(kw, 0)));
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// share if 是每个tcu计算一半的oc, 此时他们共享同一个if.
+    /// </summary>
+    protected ITileBlockBuilder GNNEConv2DSharedIF(Call call, string block_name, BufferRegionView glb_w, BufferRegionView glb_if, BufferRegionView glb_act, BufferRegionView glb_psum, BufferRegionView glb_of, bool is_init_psum, string prefix, int? promote = null)
+    {
+        var reGlbIf = GlbReIndex(glb_of, glb_if, out var sub_paddings);
+
+        var init_psums = GetInitPSumBufferRegion(call, IndexMapKey.Create(call, GNNEConv2D.PSum), glb_psum, promote, prefix, 1, ExtCompilerServices.Env.TcuActNum, out var part_condition);
+
+        var block = EAction.TileBlock(block_name).Reads(glb_w.BufferRegions, is_init_psum ? init_psums[0].BufferRegions.Concat(init_psums[1].BufferRegions.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : glb_psum.BufferRegions, glb_if.BufferRegions, glb_act.BufferRegions).Body(
+          T.Let(out var khChunck, MathF.Min(glb_w.Dimensions[2], ExtCompilerServices.Env.PuHeight)).Body(
+          T.Let(out var kwChunck, MathF.Min(glb_w.Dimensions[3], ExtCompilerServices.Env.PuKernelSpad)).Body(
+          T.Unrolled(out var kh, new(0, glb_w.Dimensions[2], khChunck)).Body(// 对kernel h/w进行tiling 暂时先不考虑
+          T.Unrolled(out var kw, new(0, glb_w.Dimensions[3], kwChunck)).Body(
+              T.Let(out var tcu_oc_chunk, TileUtilities.Split(glb_of.RegionSize(1), ExtCompilerServices.Env.TcuActNum)).Body(// 1. determine tcu act num
+              T.Let(out var n_active_tcu, TileUtilities.SplitTimes(glb_of.RegionSize(1), tcu_oc_chunk)).Body(
+                  T.If(MathF.Equal(n_active_tcu, 1)).Then(// 3. broadcast action
+                  EAction.TcuDmBroadCast(TcuDivideStrategy.NoShare)).Else(
+                  EAction.TcuDmBroadCast(TcuDivideStrategy.ShareIf)),
+                  EAction.TcuDmConfIf(// 4. conf if
+                  TileUtilities.GetNTcuIndexBits(n_active_tcu),
+                  reGlbIf,
+                  stride_w: call[GNNEConv2D.Stride][1],
+                  stride_h: call[GNNEConv2D.Stride][0],
+                  input_c_pre_pu: MathF.Min(ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2), glb_if.RegionSize(1)), // todo 这里可能有问题.
+                  dilation_h: call[GNNEConv2D.Dilation][0],
+                  padding_top: sub_paddings[2].Before,
+                  padding_bottom: sub_paddings[2].After,
+                  padding_left: sub_paddings[3].Before,
+                  padding_right: sub_paddings[3].After),
+                  T.Unrolled(out var tcu_oc, new(glb_of.Region[1].Start, glb_of.Region[1].Stop, tcu_oc_chunk)).Body(// 5. loop over tcus and config each tcu
+                  EAction.TcuPuConfAct(
+                    TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
+                    GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_act, out _),
+                    call[GNNEConv2D.FusedClamp][0],
+                    call[GNNEConv2D.FusedClamp][1]),
+                  EAction.TcuPuConf(
+                    TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
+                    reGlbIf, // 切oc对于if不影响
+                    glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..],
+                    khChunck,
+                    kwChunck,
+                    m_once: MathF.Min(ExtCompilerServices.Env.PuWidth, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc),
+                    c_once: MathF.Min(MathF.Min(ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2), glb_w.RegionSize(1)), glb_if.RegionSize(1)),
+                    groups: call[GNNEConv2D.Groups],
+                    mode: TcuComputeMode.NormalConv2d),
+                  EAction.TcuDmConfOf(// todo 这里hardcode两个tcu, 后面需要改进
+                    TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
+                    is_init_psum ? MathF.Select(MathF.Equal(tcu_oc, glb_of.Region[1].Start), init_psums[0][.., (0, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc), .., ..], init_psums[1][.., (0, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc), .., ..]) : GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_psum, out _),
+                    glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..],
+                    0),
+                  EAction.TcuDmConfW(
+                    TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
+                    GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_w, out _))),
+                  T.Unrolled(out var tcu_oc2, new(glb_of.Region[1].Start, glb_of.Region[1].Stop, tcu_oc_chunk)).Body(
+                    EAction.TcuDmFetchW(// 6. fetch weights.
+                      TileUtilities.GetTcuIndexBits(tcu_oc2 / tcu_oc_chunk),
+                      GlbReIndex(glb_of[.., (tcu_oc2, MathF.Min(tcu_oc2 + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_w, out _))),
+                  EAction.TcuDmFetchIf(// 7. fetch if.
+                      TileUtilities.GetNTcuIndexBits(n_active_tcu),
+                      reGlbIf),
+                  EAction.TcuPuCompute(// 8. tcu compute
+                      TileUtilities.GetNTcuIndexBits(n_active_tcu),
+                      act_enable: GNNEConv2DComputeActEnable(call, glb_w, kh + khChunck, glb_w.Dimensions[2], kw + kwChunck, glb_w.Dimensions[3]),
+                      of_enable: GNNEConv2DComputeOfEnable(call, glb_w, kh + khChunck, glb_w.Dimensions[2], kw + kwChunck, glb_w.Dimensions[3]),
+                      load_psum: GNNEConv2DComputeLoadPsumEnable(call, glb_w, kh, kw),
+                      TileUtilities.GetNTcuIndexBits(n_active_tcu)))))))));
+
+        if (promote is null)
+        {
+            block.Alloc(glb_of.Buffers, is_init_psum ? init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : None.Default);
+        }
+        else if (promote is int promoteIndex)
+        {
+            if (is_init_psum)
+            {
+                NestedBlocks[promoteIndex + 1].Alloc(init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray());
+            }
+        }
+
+        return block;
+    }
+
+    /// <summary>
+    /// 假设oc为32被拆分之后每个tcu只能映射一半, 那么两个tcu共享一份weights, 在ofmap的h上进行切分.
+    /// </summary>
+    protected ITileBlockBuilder GNNEConv2DSharedW(Call call, string block_name, BufferRegionView glb_w, BufferRegionView glb_if, BufferRegionView glb_act, BufferRegionView glb_psum, BufferRegionView glb_of, bool is_depthwise, bool is_init_psum, string prefix, int? promote = null)
+    {
+        var init_psums = GetInitPSumBufferRegion(call, IndexMapKey.Create(call, GNNEConv2D.PSum), glb_psum, promote, prefix, 2, ExtCompilerServices.Env.TcuActNum, out var part_condition);
+
+        var reGlbW = GlbReIndex(glb_of[.., .., .., ..], glb_w, out _);
+        var (iH, iW) = (glb_if.Dimensions[2], glb_if.Dimensions[3]);
+        var (kH, kW) = (glb_w.Dimensions[2], glb_w.Dimensions[3]);
+        var stride = ((TensorConst)call[IR.K510.GNNEConv2D.Stride]).Value.Cast<int>();
+        var padding = ((TensorConst)call[IR.K510.GNNEConv2D.Padding]).Value.Cast<int>();
+        var dilation = ((TensorConst)call[IR.K510.GNNEConv2D.Dilation]).Value.Cast<int>();
+
+        var block = EAction.TileBlock(block_name).Reads(glb_w.BufferRegions, is_init_psum ? init_psums[0].BufferRegions.Concat(init_psums[1].BufferRegions.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : glb_psum.BufferRegions, glb_if.BufferRegions, glb_act.BufferRegions).Body(
+        T.Let(out var khChunck, MathF.Min(kH, ExtCompilerServices.Env.PuHeight)).Body(
+        T.Let(out var kwChunck, dilation[1] != 1 ? 1 : MathF.Min(kW, ExtCompilerServices.Env.PuKernelSpad)).Body(
+        T.Unrolled(out var kh, new(0, kH, khChunck)).Body(
+          T.Unrolled(out var kw, new(0, kW, kwChunck)).Body(// NOTE dw卷积时m once指的是一次ic对应输出多少个oc, 所以默认为1
+            T.Let(out var m_once, is_depthwise ? 1 : MathF.Min(ExtCompilerServices.Env.PuWidth, glb_w.RegionSize(0))).Body(
+            T.Let(out var c_once, is_depthwise ? MathF.Min(MathF.Min(ExtCompilerServices.Env.PuWidth / m_once, ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2)), glb_w.RegionSize(0)) : MathF.Min(MathF.Min(ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2), glb_w.RegionSize(1)), glb_if.RegionSize(1))).Body(// NOTE dw卷积时, if是按对角线排列的, 所以要小于min(pu w/pu h)
+            T.Let(out var tcu_oh_chunk, TileUtilities.Split(glb_of.RegionSize(2), ExtCompilerServices.Env.TcuActNum)).Body(// segment tcu h in output_h
+            T.Let(out var n_active_tcu, TileUtilities.SplitTimes(glb_of.RegionSize(2), tcu_oh_chunk)).Body(
+              T.If(MathF.Equal(n_active_tcu, 1)).Then(// NOTE 这里的psum已经被load好了, 可能到时候会存在psum大小和后续不匹配的问题.// 3. broadcast action
+                EAction.TcuDmBroadCast(TcuDivideStrategy.NoShare))
+              .Else(
+                EAction.TcuDmBroadCast(TcuDivideStrategy.ShareW)),
+              EAction.TcuDmConfW(TileUtilities.GetNTcuIndexBits(n_active_tcu), reGlbW[.., .., (kh, MathF.Min(kh + khChunck, kH)), (kw, MathF.Min(kw + kwChunck, kW))]),
+              T.Unrolled(out var tcu_oh, new(glb_of.Region[2].Start, glb_of.Region[2].Stop, tcu_oh_chunk)).Body(// 4. conf_w action
+                T.Let(out var tcu_index_bits, TileUtilities.GetTcuIndexBits(tcu_oh / tcu_oh_chunk)).Body(// 5. loop over tcus and config each tcu
+                  EAction.TcuDmConfIf(// conf if
+                    tcu_index_bits,
+                    GlbReIndex(glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..], glb_if, out var if_padding, (2, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kh, IR.F.Math.Min(kh + khChunck, kH), 1), stride[0], padding[0, 0], dilation[0])), (3, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kw, IR.F.Math.Min(kw + kwChunck, kW), 1), stride[1], padding[1, 0], dilation[1]))),
+                    stride_w: stride[1],
+                    stride_h: stride[0],
+                    input_c_pre_pu: MathF.Min(ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2), glb_if.RegionSize(1)), // todo 这里可能有问题.
+                    dilation_h: call[GNNEConv2D.Dilation][0],
+                    padding_top: if_padding[2].Before,
+                    padding_bottom: if_padding[2].After,
+                    padding_left: if_padding[3].Before,
+                    padding_right: if_padding[3].After),
+                  EAction.TcuPuConfAct(// conf act
+                    tcu_index_bits,
+                    GlbReIndex(glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..], glb_act, out _),
+                    call[GNNEConv2D.FusedClamp][0],
+                    call[GNNEConv2D.FusedClamp][1]),
+                  EAction.TcuPuConf(// conf pu
+                    tcu_index_bits,
+                    GlbReIndex(glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..], glb_if, out var _, (2, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kh, IR.F.Math.Min(kh + khChunck, kH), 1), stride[0], padding[0, 0], dilation[0])), (3, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kw, IR.F.Math.Min(kw + kwChunck, kW), 1), stride[1], padding[1, 0], dilation[1]))),
+                    glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..],
+                    khChunck,
+                    kwChunck,
+                    m_once,
+                    c_once,
+                    groups: is_depthwise ? 1 : call[GNNEConv2D.Groups], // NOTE tcu pu conf 的group其实是multiplier的意思，就是一个ic会输出多个oc, 并不是标准conv定义的groups.
+                    mode: is_depthwise ? TcuComputeMode.DwConv2d : TcuComputeMode.NormalConv2d),
+                  EAction.TcuDmConfOf(// conf of
+                    tcu_index_bits,
+                    is_init_psum ? MathF.Select(MathF.Equal(tcu_oh, glb_of.Region[2].Start), init_psums[0][.., .., (0, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop) - tcu_oh), .., ..], init_psums[1][.., .., (0, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop) - tcu_oh), .., ..]) : GlbReIndex(glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..], glb_psum, out _),
+                    glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..],
+                    0))),
+              EAction.TcuDmFetchW(TileUtilities.GetNTcuIndexBits(n_active_tcu), reGlbW[.., .., (kh, MathF.Min(kh + khChunck, kH)), (kw, MathF.Min(kw + kwChunck, kW))]),
+              T.Unrolled(out var tcu_oh2, new(glb_of.Region[2].Start, glb_of.Region[2].Stop, tcu_oh_chunk)).Body(// 6. fetch weights
+                EAction.TcuDmFetchIf(
+                  TileUtilities.GetTcuIndexBits(tcu_oh2 / tcu_oh_chunk), // 7. loop over tcus and fetch if for each tcu
+                  GlbReIndex(glb_of[.., .., (tcu_oh2, MathF.Min(tcu_oh2 + tcu_oh_chunk, glb_of.Region[2].Stop)), ..], glb_if, out _, (2, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kh, IR.F.Math.Min(kh + khChunck, kH), 1), stride[0], padding[0, 0], dilation[0])), (3, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kw, IR.F.Math.Min(kw + kwChunck, kW), 1), stride[1], padding[1, 0], dilation[1]))))),
+              EAction.TcuPuCompute(// 8. tcu compute.
+                TileUtilities.GetNTcuIndexBits(n_active_tcu),
+                GNNEConv2DComputeOfEnable(call, glb_w, kh + khChunck, kH, kw + kwChunck, kW),
+                GNNEConv2DComputeActEnable(call, glb_w, kh + khChunck, kH, kw + kwChunck, kW),
+                GNNEConv2DComputeLoadPsumEnable(call, glb_w, kh, kw),
+                TileUtilities.GetNTcuIndexBits(n_active_tcu)))))))))));
+
+        if (promote is null)
+        {
+            block.Alloc(glb_of.Buffers, is_init_psum ? init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : None.Default);
+        }
+        else if (promote is int promoteIndex)
+        {
+            if (is_init_psum)
+            {
+                NestedBlocks[promoteIndex + 1].Alloc(init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray());
+            }
+        }
+
+        return block;
+    }
+
+    protected virtual ISequentialBuilder<Sequential> LowerGnneConv2D(IndexMapKey parentKey, Call call, GNNEConv2D op, string block_name, string prefix)
+    {
+        prefix = NameAllocator.Get(nameof(GNNEConv2D));
+        bool is_depthwise;
+        {
+            var groups = ((TensorConst)call[GNNEConv2D.Groups]).Value.ToScalar<int>();
+            var input_channels = call[GNNEConv2D.Input].CheckedShape[1].FixedValue;
+            var output_channels = call.CheckedShape[1].FixedValue;
+            is_depthwise = input_channels == output_channels && output_channels == groups && groups != 1;
+        }
+
+        if (is_depthwise)
+        {
+            prefix = prefix + "(dw)";
+            block_name += "(dw)";
+        }
+
+        var call_w = IndexMapKey.Create(call, GNNEConv2D.Weights);
+        var call_in = IndexMapKey.Create(call, GNNEConv2D.Input);
+        var call_act = IndexMapKey.Create(call, GNNEConv2D.Act);
+        var call_psum = IndexMapKey.Create(call, GNNEConv2D.PSum);
+
+        bool is_init_psum = call_psum.Expr is Call { Target: Uninitialized };
+
+        TcuDivideStrategy tcu_strategy;
+        if (!is_depthwise)
+        {
+            // 优先让每个tcu的width用满
+            var out_shape = call.CheckedShape.ToValueArray();
+            if (out_shape[1] >= ExtCompilerServices.Env.PuWidth * ExtCompilerServices.Env.TcuActNum)
+            {
+                tcu_strategy = TcuDivideStrategy.ShareIf;
+            }
+            else
+            {
+                tcu_strategy = TcuDivideStrategy.ShareW;
+            }
+        }
+        else
+        { // TODO 需要一种量化的方法来决定dw卷积用什么策略.
+            tcu_strategy = TcuDivideStrategy.NoShare;
+        }
+
+        prefix = prefix + "." + tcu_strategy;
+
+        // 默认是layer group的做法, 也就是w/act全部promote
+        return T.Sequential().Body(
+          Visit(call_w, prefix, -1),
+          Visit(call_in, prefix),
+          Visit(call_act, prefix, -1),
+          Visit(call_psum, prefix),
+          GetBufferRegion(call_w, out var glb_w),
+          GetBufferRegion(call_in, out var glb_if), // glb if 存在padding的情况.
+          GetBufferRegion(call_act, out var glb_act),
+          GetBufferRegion(call_psum, out var glb_psum, TileOptions.PingPong, name: prefix + "." + GNNEConv2D.PSum.Name), // note 这里的pusm申请了但不记录到allocs中,仅用于给psum apart使用.
+          GetBufferRegion(parentKey, out var glb_of, TileOptions.PingPong, name: prefix + "." + TileNames.Output),
+          tcu_strategy switch { TcuDivideStrategy.ShareIf => GNNEConv2DSharedIF(call, block_name, glb_w, glb_if, glb_act, glb_psum, glb_of, is_init_psum, prefix), TcuDivideStrategy.ShareW => GNNEConv2DSharedW(call, block_name, glb_w, glb_if, glb_act, glb_psum, glb_of, is_depthwise, is_init_psum, prefix), TcuDivideStrategy.NoShare => GNNEConv2DSharedNone(call, block_name, glb_w, glb_if, glb_act, glb_psum, glb_of, is_init_psum, prefix), _ => throw new NotSupportedException(), });
+    }
+
+    protected virtual ISequentialBuilder<Sequential> LowerGnneTranspose(IndexMapKey parentKey, Call call, GNNETranspose op, string block_name, string prefix)
+    {
+        prefix = NameAllocator.Get(nameof(GNNETranspose));
+        var call_in = IndexMapKey.Create(call, GNNETranspose.Input);
+        var seq = T.Sequential().Body(
+          Visit(call_in, prefix), GetBufferRegion(call_in, out var glb_trans_input), GetBufferRegion(parentKey, out var glb_trans_output, TileOptions.PingPong, name: prefix), EAction.TileBlock(block_name).Alloc(glb_trans_output.Buffers).Reads(glb_trans_input.BufferRegions).Body(EAction.MfuTranspose(glb_trans_input, glb_trans_output, op.Perm)));
+
+        return seq;
+    }
+
+    protected virtual ISequentialBuilder<Sequential> LowerGnneCrop(IndexMapKey parentKey, Call call, GNNECrop op, string block_name, string prefix)
+    {
+        prefix = NameAllocator.Get(nameof(GNNECrop));
+        var call_in = IndexMapKey.Create(call, GNNECrop.Input);
+        var call_in_bbox = IndexMapKey.Create(call, GNNECrop.InputBBox);
+        var seq = T.Sequential().Body(
+          Visit(call_in, prefix),
+          Visit(call_in_bbox, prefix),
+          GetBufferRegion(call_in, out var glb_crop_input),
+          GetBufferRegion(call_in_bbox, out var glb_crop_bbox),
+          GetBufferRegion(parentKey, out var glb_crop_output, TileOptions.PingPong, name: prefix),
+          EAction.TileBlock(block_name).Alloc(glb_crop_output.Buffers).
+            Reads(glb_crop_input.BufferRegions, glb_crop_bbox.BufferRegions).
+            Body(
+              EAction.MfuCrop(
+                glb_crop_input,
+                glb_crop_output,
+                glb_crop_bbox,
+                op.ResizeMethod,
+                op.AlignMethod,
+                op.HalfPixelCenters)));
+
+        return seq;
+    }
+
+    protected virtual ISequentialBuilder<Sequential> LowerGnneActivation(IndexMapKey parentKey, Call call, GNNEActivation op, string block_name, string prefix)
+    {
+        prefix = NameAllocator.Get(nameof(GNNEActivation));
+        var fusedclamps = ((TensorConst)call[GNNEActivation.FusedClamp]).Value.Cast<BFloat16>();
+        var call_in = IndexMapKey.Create(call, GNNEActivation.Input);
+        var call_in_act = IndexMapKey.Create(call, GNNEActivation.Act);
+
+        var seq = T.Sequential().Body(
+          Visit(call_in, prefix),
+          Visit(call_in_act, prefix),
+          GetBufferRegion(call_in, out var glb_if),
+          GetBufferRegion(call_in_act, out var glb_act),
+          GetBufferRegion(parentKey, out var glb_of, TileOptions.PingPong, name: prefix),
+          EAction.TileBlock(block_name).Alloc(glb_of.Buffers).Reads(glb_if.BufferRegions, glb_act.BufferRegions).Body(
+            T.Let(out var m_once, 1).Body(
+            T.Let(out var c_once, MathF.Min(glb_if.RegionSize(1), ExtCompilerServices.Env.TcuActNum)).Body(
+            T.Let(out var tcu_h_chunk, TileUtilities.Split(glb_of.RegionSize(2), ExtCompilerServices.Env.TcuActNum)).Body(// segment tcu h in output_h
+            T.Let(out var n_active_tcu, TileUtilities.SplitTimes(glb_of.RegionSize(2), tcu_h_chunk)).Body(
+              T.Unrolled(out var tcu_oh, new(glb_of.Region[2].Start, glb_of.Region[2].Stop, tcu_h_chunk)).Body(
+                T.Let(out var tcu_index_bits, TileUtilities.GetTcuIndexBits(tcu_oh / tcu_h_chunk)).Body(
+                  EAction.TcuPuConfAct(// 1. conf act
+                    tcu_index_bits,
+                    glb_act,
+                    fusedclamps[0],
+                    fusedclamps[1]),
+                  EAction.TcuPuConf(
+                    tcu_index_bits,
+                    glb_if[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_h_chunk, glb_if.Region[2].Stop)), ..],
+                    glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_h_chunk, glb_of.Region[2].Stop)), ..],
+                    1,
+                    1,
+                    m_once,
+                    c_once,
+                    1,
+                    TcuComputeMode.Activation),
+                  EAction.TcuDmConfOf(
+                    tcu_index_bits,
+                    glb_if[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_h_chunk, glb_if.Region[2].Stop)), ..],
+                    glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_h_chunk, glb_of.Region[2].Stop)), ..],
+                    0))),
+              EAction.TcuPuComputeDummy(TileUtilities.GetNTcuIndexBits(n_active_tcu), true)))))));
+        return seq;
+    }
+
+    protected virtual ISequentialBuilder<Sequential> LowerGnnePdpReduce(IndexMapKey parentKey, Call call, GNNEPdpReduce op, string block_name, string prefix)
+    {
+        prefix = NameAllocator.Get(nameof(GNNEPdpReduce));
+        var call_in = IndexMapKey.Create(call, GNNEPdpReduce.Input);
+
+        // var ddr_if = BoundsInferGraph[call_in];
+        // GlbReIndex(glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_h_chunk, glb_of.Region[2].Stop)), ..], glb_if, out var if_paddings)
+        var seq = T.Sequential().Body(
+          Visit(call_in, prefix),
+          GetBufferRegion(call_in, out var glb_if),
+          GetBufferRegion(parentKey, out var glb_of, TileOptions.PingPong, name: prefix));
+        GlbReIndex(glb_of, glb_if, out var sub_paddings);
+        seq.Body(
+          EAction.TileBlock(block_name).Alloc(glb_of.Buffers).Reads(glb_if.BufferRegions).Body(
+            EAction.PdpReduce(
+              glb_if,
+              glb_of,
+              call[GNNEPdpReduce.Filter],
+              call[GNNEPdpReduce.Stride],
+              sub_paddings[2].Before,
+              sub_paddings[2].After,
+              sub_paddings[3].Before,
+              sub_paddings[3].After,
+              op.ReduceOp)));
+        return seq;
+    }
+
+    protected virtual ISequentialBuilder<Sequential> LowerGnneConv2DTranspose(IndexMapKey parentKey, Call call, GNNEConv2DTranspose op, string block_name, string prefix)
+    {
+        throw new NotSupportedException();
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs b/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs
new file mode 100644
index 0000000000..a3a4380d74
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs
@@ -0,0 +1,251 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.TIR.CPU;
+
+namespace Nncase.Passes.Tile;
+
+/// <summary>
+/// the multi Fusion checker.
+/// </summary>
+internal sealed class MultiFusionChecker : IFusionChecker
+{
+    private readonly List<(MultiLayerFusionConverter, int[], BufferSchedule.ScheduledResponse)> _caches = new();
+
+    private readonly TileOptions _tileOptions;
+
+    public MultiFusionChecker(TileOptions tileOptions)
+    {
+        _tileOptions = tileOptions;
+    }
+
+    [Flags]
+    public enum DeviceKind
+    {
+        Load,
+        Store,
+        Mfu,
+        Tcu,
+        None,
+    }
+
+    public TIR.PrimFunction Convert(RunPassContext passOptions)
+    {
+        var (convertVisitor, final_tile_size, response) = _caches.First();
+        if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
+        {
+            response.Dump($"{response.LogicalPrimfunc.Name}_{string.Join("_", final_tile_size)}", convertVisitor.GetType().Name);
+        }
+
+        return convertVisitor.BuildPhysicalPrimFunc(final_tile_size, response.SchedCandidate, response.LogicalPrimfunc);
+    }
+
+    public bool Check(Fusion fusion, RunPassContext passOptions)
+    {
+        // 1. check all conv2d weights size less than glb size
+        var visitor = new MultiFusionPreCheckVisitor();
+        visitor.Visit(fusion);
+        if (visitor.AllWeightSizeInBytes > ExtCompilerServices.Env.GlbSize)
+        {
+            return false;
+        }
+
+        // note not support conv2d transpose in layer group.
+        if (visitor.CountCallOp<IR.K510.GNNEConv2DTranspose>() > 0)
+        {
+            return false;
+        }
+
+        var curTileOptions = _tileOptions;
+        if ((visitor.DeviceUsage[DeviceKind.Mfu], visitor.DeviceUsage[DeviceKind.Tcu]) switch
+        {
+            (> 1, > 1) => true,
+            (> 1, 1) => true,
+            (1, > 1) => true,
+            _ => false,
+        })
+        {
+            curTileOptions = curTileOptions with { PingPongNum = 3 };
+        }
+
+        // 2. try convert
+        var convertVisitor = new MultiLayerFusionConverter(curTileOptions); // note the grouped fusion must pingpong input.
+        var bodySeq = convertVisitor.Visit(fusion);
+
+        // 3. search the tile size
+        var originLogicalPrimFunc = convertVisitor.BuildLogicalPrimFunc(bodySeq);
+
+        var output_shape = fusion.Body.CheckedShape.ToValueArray();
+        var search_space = convertVisitor.BoundsInferGraph.RootTileStep.ToArray();
+        var candidate_tile_size = convertVisitor.SearchTileSize(TileOhSearchGenerator(curTileOptions, search_space, convertVisitor.BoundsInferGraph.RootPerm.ToArray()), originLogicalPrimFunc, curTileOptions.MultiWorkers, false, out var sched_response);
+        if (!candidate_tile_size.Any())
+        {
+            return false;
+        }
+
+        int[] final_tile_size = new int[candidate_tile_size.Length];
+        if (convertVisitor.BalanceTileSize(candidate_tile_size, search_space))
+        {
+            final_tile_size = convertVisitor.SearchTileSize(new TargetTileGenerator(candidate_tile_size), originLogicalPrimFunc, curTileOptions.MultiWorkers, true, out sched_response);
+        }
+        else
+        {
+            Array.Copy(candidate_tile_size, final_tile_size, candidate_tile_size.Length);
+        }
+
+        // 5. check the input load usage and compute overlap
+        var input_shape = fusion.Parameters[0].CheckedShape.ToValueArray();
+        var each_axis_tile_nums = final_tile_size.Zip(output_shape).Select(p => (int)System.Math.Ceiling(p.Second / (float)p.First)).ToArray();
+        var total_tile_nums = TensorUtilities.GetProduct(each_axis_tile_nums);
+        if (total_tile_nums > 1)
+        {
+            var clamp = (TIR.K510.Segment seg, int i) =>
+            {
+                return new TIR.K510.Segment(Math.Max(0, seg.Start), Math.Min(input_shape[i], seg.Stop), 1);
+            };
+
+            var first_segment = convertVisitor.BoundsInferGraph[convertVisitor.VarToKeyMap[fusion.Parameters[0]]].
+              Eval(final_tile_size.Select(t => new TIR.K510.Segment(0, t, 1)).ToArray()).
+              Select((s, i) => clamp(s, i)).
+              ToArray();
+
+            int first_split_axis = 0;
+            for (int i = input_shape.Length - 1; i >= 0; i--)
+            {
+                if (first_segment[i].Length != input_shape[i])
+                {
+                    first_split_axis = i;
+                    break;
+                }
+            }
+
+            // when once load less than load burst, false
+            var burst_load_data = TensorUtilities.GetProduct(first_segment.Skip(first_split_axis).Select(s => s.Length).ToArray());
+            if (burst_load_data < ExtCompilerServices.Env.LoadBurst)
+            {
+                return false;
+            }
+
+            var second_segment = convertVisitor.BoundsInferGraph[convertVisitor.VarToKeyMap[fusion.Parameters[0]]].Eval(final_tile_size.Select((t, i) =>
+                  t < output_shape[i] ?
+                  new TIR.K510.Segment(t, System.Math.Min(t * 2, output_shape[i]), 1) :
+                  new TIR.K510.Segment(0, t, 1)).ToArray()).
+                  Select((s, i) => clamp(s, i)).
+                  ToArray();
+
+            // Todo 因为我无法知道在当前维度切分会影响哪个维度的变化, 比如带有transpose的, 可能我在c上切,只影响 h w. 所以直接计算所有的的交集
+            var overlaps = first_segment.Zip(second_segment).Select(p => p.First.Intersect(p.Second)).ToArray();
+            if (Array.IndexOf(convertVisitor.BoundsInferGraph.RootPerm.ToArray(), TIR.K510.NamedAxis.H) is int h && h != -1)
+            {
+                // 如果只在h上切分, 只需要考虑h上的overlap有没有超过0.3
+                if (overlaps[h] > (input_shape[h] * 0.3))
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                if (TensorUtilities.GetProduct(overlaps) > TensorUtilities.GetProduct(input_shape) * 0.3)
+                {
+                    return false;
+                }
+            }
+        }
+
+        _caches.Add((convertVisitor, candidate_tile_size, sched_response));
+        if (_caches.Count > 1)
+        {
+            _caches.RemoveAt(0);
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// <remark>
+    /// 只在oh上切分.
+    /// </remark>
+    /// </summary>
+    private ISearchTileGenerator TileOhSearchGenerator(TileOptions tileOptions, Segment[] search_spaces, TIR.K510.NamedAxis[] rootPerm)
+    {
+        if (Array.IndexOf(rootPerm, TIR.K510.NamedAxis.C) is int c && c != -1)
+        {
+            search_spaces[c].Start = search_spaces[c].Stop; // not tile oc
+        }
+
+        if (Array.IndexOf(rootPerm, TIR.K510.NamedAxis.H) is int h && h != -1)
+        {
+            // 因为在h上切分, 如果ping pong那么需要限制大小
+            if (tileOptions.PingPong)
+            {
+                if (search_spaces[h].ClampStop(2, out var new_h_seg))
+                {
+                    // assume tile h must > 8 for tcu use.
+                    search_spaces[h] = new Segment(Math.Min(Math.Max(search_spaces[h].Step, ExtCompilerServices.Env.TcuActNum), new_h_seg.Stop), new_h_seg.Stop, new_h_seg.Step);
+                }
+            }
+        }
+
+        if (Array.IndexOf(rootPerm, TIR.K510.NamedAxis.W) is int w && w != -1)
+        {
+            search_spaces[w].Start = Math.Min(search_spaces[w].Stop, Math.Max(search_spaces[w].Step, ExtCompilerServices.Env.PuWidth)); // no tile w
+        }
+
+        // 如果有perm, 那就是 c w h n 方式搜, 没有perm就是从最后搜到最前 所以在有ping pong的时候需要限制切分.
+        if (rootPerm.All(r => r == NamedAxis.UnKnow) && tileOptions.PingPong)
+        {
+            if (search_spaces[^1].ClampStop(2, out var new_seg))
+            {
+                search_spaces[^1] = new_seg;
+            }
+        }
+
+        return new DefaultSearchTileGenerator(search_spaces, rootPerm);
+    }
+
+    internal sealed class MultiFusionPreCheckVisitor : ExprVisitor<bool, bool>
+    {
+        public Dictionary<DeviceKind, int> DeviceUsage { get; } = new()
+        {
+            { DeviceKind.Load, 0 },
+            { DeviceKind.Store, 0 },
+            { DeviceKind.Mfu, 0 },
+            { DeviceKind.Tcu, 0 },
+            { DeviceKind.None, 0 },
+        };
+
+        public int AllWeightSizeInBytes { get; private set; }
+
+        public int CountCallOp<T>()
+          where T : Op
+        {
+            return ExprMemo.Keys.Count(e => e is Call { Target: Op t } && t.GetType() == typeof(T));
+        }
+
+        protected override bool DefaultVisitLeaf(Expr expr) => true;
+
+        protected override bool VisitLeafCall(Call expr)
+        {
+            if (expr is Call { Target: IR.K510.GNNEConv2D } && expr[IR.K510.GNNEConv2D.Weights] is Expr weights)
+            {
+                AllWeightSizeInBytes += weights.CheckedShape.Prod().FixedValue * weights.CheckedDataType.SizeInBytes;
+            }
+
+            DeviceUsage[GetDeviceType(expr.Target)]++;
+            return true;
+        }
+
+        private static DeviceKind GetDeviceType(Expr op) => op switch
+        {
+            IR.K510.GNNELoad => DeviceKind.Load,
+            IR.K510.GNNEStore => DeviceKind.Store,
+            IR.K510.GNNEConv2D or IR.K510.GNNEActivation => DeviceKind.Tcu,
+            IR.K510.GNNEReduce or IR.K510.GNNEMeshNet or IR.K510.GNNETranspose or IR.K510.GNNEPdpReduce or IR.K510.GNNECrop => DeviceKind.Mfu,
+            _ => DeviceKind.None,
+        };
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs
new file mode 100644
index 0000000000..4a07a4a17c
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs
@@ -0,0 +1,228 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Runtime.CompilerServices;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.Passes.BufferSchedule;
+using Nncase.TIR;
+using Nncase.TIR.Builders;
+using Nncase.TIR.K510;
+using Nncase.TIR.K510.Builders;
+using MathF = Nncase.IR.F.Math;
+
+namespace Nncase.Passes.Tile;
+
+internal class MultiLayerFusionConverter : LayerFusionConverter
+{
+    public MultiLayerFusionConverter(TileOptions tileOptions)
+    {
+        TileOptions = tileOptions;
+    }
+
+    public override Fusion CurrentFusion { get; protected set; } = null!;
+
+    public override IBoundsInferGraph BoundsInferGraph { get; protected set; } = null!;
+
+    /// <summary>
+    /// Gets or sets calc the loop count.
+    /// </summary>
+    public override Expr LoopCount { get; protected set; } = null!;
+
+    public override Expr LoopCountOuter { get; protected set; } = null!; // LoopCount / TileOptions.PingPongNum;
+
+    public override Expr LoopCountInner { get; protected set; } = null!; // LoopCount % TileOptions.PingPongNum;
+
+    public override Expr Visit(Fusion fusion)
+    {
+        if (CurrentFusion is null)
+        {
+            CurrentFusion = fusion;
+        }
+        else
+        {
+            throw new InvalidOperationException("Can't Visit More Than One Fusion!");
+        }
+
+        // 0. init the fields
+        var output_shape = Tile.TileUtilities.GetFusionRealOutputShape(fusion.Body);
+        BoundsInferGraph = ExtCompilerServices.MakeBoundsInferGraph((Call)fusion.Body);
+        TileSizeVars.AddRange(output_shape.Select((_, i) => new Var($"dim{i}_tile", new TensorType(DataTypes.Int32, Shape.Scalar))));
+
+        // 1. make the tile gird loop
+        NestedBlocks.AddRange(new[] { EAction.TileBlock("MainBlock") }.Concat(Enumerable.Range(0, TileSizeVars.Count).Select(i => EAction.TileBlock($"TileBlock_{i}"))));
+
+        LoopDomains.AddRange(output_shape.Zip(TileSizeVars).Select(t => new TIR.Range(0, t.First, t.Second)));
+        for (int i = 0; i < TileSizeVars.Count; i++)
+        {
+            NestedLoops.Add(T.ForLoop(out var loopVar, LoopDomains[i], LoopMode.Unrolled, $"loop_var_{i}"));
+            LoopVars.Add(loopVar);
+        }
+
+        object lastBody = NestedBlocks[^1];
+        for (int i = NestedLoops.Count - 1; i >= 0; i--)
+        {
+            lastBody = NestedLoops[i].Body(lastBody);
+            lastBody = NestedBlocks[i].Body(lastBody);
+        }
+
+        // 2. create the bounds infer function input arguments with the new loop var.
+        BoundsInferGraph.RootBounds = output_shape.Select((s, i) =>
+         {
+             var loopVar = LoopVars[i];
+             return new TIR.Range(loopVar, IR.F.Math.Min(loopVar + TileSizeVars[i], s), 1);
+         }).ToList();
+
+        // 3. set up loop count
+        var shape = new Expr[LoopVars.Count];
+        var upbounds = CurrentFusion.Body.CheckedShape.ToValueArray();
+        for (int j = LoopVars.Count - 1; j >= 0; j--)
+        {
+            shape[j] = TileUtilities.SplitTimes(upbounds[j], TileSizeVars[j]);
+        }
+
+        var strides = TensorUtilities.GetStrides(shape).ToArray();
+        var indices = LoopVars.Select((v, j) => (Expr)(v / TileSizeVars[j])).ToArray();
+        LoopCount = TensorUtilities.GetIndex(strides, indices);
+        LoopCountOuter = LoopCount / TileOptions.PingPongNum;
+        LoopCountInner = LoopCount % TileOptions.PingPongNum;
+
+        return Visit((Call)fusion.Body, "root");
+    }
+
+    /// <summary>
+    /// convert to the final prim func.
+    /// </summary>
+    /// <returns>.</returns>
+    public PrimFunction VisitToPrimFunc(Fusion fusion)
+    {
+        // 1. visit the fusion
+        var bodySeq = Visit(fusion);
+
+        // 2. build the prim func with tile size vars.
+        var logicalPrimFunc = BuildLogicalPrimFunc(bodySeq);
+
+        // 3. seach the tiling size
+        var search_spaces = BoundsInferGraph.RootTileStep.ToArray();
+        ISearchTileGenerator tileGenerator;
+        if (TileOptions.TargetTileSize.Any())
+        {
+            for (int i = 0; i < TileOptions.TargetTileSize.Length; i++)
+            {
+                System.Diagnostics.Trace.Assert(TileOptions.TargetTileSize[i] <= search_spaces[i].Stop);
+            }
+
+            tileGenerator = new TargetTileGenerator(TileOptions.TargetTileSize);
+        }
+        else
+        {
+            var perm = BoundsInferGraph.RootPerm.ToArray();
+
+            // when ping pong all, clamp the upper bounds by perm order.
+            if (TileOptions.PingPong)
+            {
+                var re_perm = perm.Zip(Enumerable.Range(0, perm.Length)).OrderBy(t => t.First).Select(t => t.Second).ToArray();
+
+                var pp_axis = NamedAxis.H;
+
+                // 如果已知维度, 那么在pp axis上进行切分
+                if (Array.IndexOf(perm, NamedAxis.H) is var h && h != -1 && Array.IndexOf(perm, NamedAxis.W) is var w && w != -1)
+                {
+                    // if split the h will less than one burst, split on c.
+                    if ((int)System.Math.Ceiling(search_spaces[h].Stop / (float)TileOptions.PingPongNum) * search_spaces[w].Stop < 128)
+                    {
+                        pp_axis = NamedAxis.C;
+                    }
+                    else
+                    {
+                        pp_axis = NamedAxis.H;
+                    }
+                }
+
+                for (int i = 0; i < perm.Length; i++)
+                {
+                    var p = re_perm[i];
+                    if (perm[i] == pp_axis && search_spaces[p].ClampStop(TileOptions.PingPongNum, out var new_seg))
+                    {
+                        search_spaces[p] = new_seg;
+                        break;
+                    }
+                }
+            }
+
+            {
+                if (Array.IndexOf(perm, NamedAxis.H) is var h && h != -1 && Array.IndexOf(perm, NamedAxis.W) is var w && w != -1)
+                {
+                    // if one layer output less than 128, don't split the hw
+                    if (search_spaces[h].Stop * search_spaces[w].Stop < ExtCompilerServices.Env.LoadBurst)
+                    {
+                        search_spaces[h].Start = search_spaces[h].Stop;
+                        search_spaces[w].Start = search_spaces[w].Stop;
+                    }
+                    else
+                    {
+                        search_spaces[h].Start = Math.Min(Math.Max(search_spaces[h].Step, ExtCompilerServices.Env.TcuActNum), search_spaces[h].Stop);
+                        search_spaces[w].Start = Math.Min(Math.Max(search_spaces[w].Step, ExtCompilerServices.Env.PuWidth), search_spaces[w].Stop);
+                    }
+                }
+            }
+
+            tileGenerator = new DefaultSearchTileGenerator(search_spaces, BoundsInferGraph.RootPerm);
+        }
+
+        int[] candidate_tile_size = SearchTileSize(tileGenerator, logicalPrimFunc, TileOptions.MultiWorkers, false, out var response);
+        if (!candidate_tile_size.Any())
+        {
+            throw new TileFailedException();
+        }
+
+        int[] final_tile_size = Array.Empty<int>();
+        if (!TileOptions.TargetTileSize.Any() && TileOptions.PingPong && BalanceTileSize(candidate_tile_size, search_spaces))
+        {
+            final_tile_size = SearchTileSize(new TargetTileGenerator(candidate_tile_size), logicalPrimFunc, TileOptions.MultiWorkers, true, out response);
+        }
+        else
+        {
+            final_tile_size = candidate_tile_size;
+        }
+
+        if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
+        {
+            response.Dump($"{CurrentFusion.Name}_{string.Join("_", final_tile_size)}", GetType().Name);
+        }
+
+        // 4. the local logical buffer to phsy buffer
+        return BuildPhysicalPrimFunc(final_tile_size, response.SchedCandidate, response.LogicalPrimfunc);
+    }
+
+    /// <summary>
+    /// 1. if inner loop var > half, balance it.
+    /// 2. find the highest axis loop var == up_bounds, split it.
+    /// </summary>
+    public override bool BalanceTileSize(int[] tile_size, Segment[] search_spaces)
+    {
+        bool changed = false;
+
+        // balance tile
+        for (int i = search_spaces.Length - 1; i >= 0; i--)
+        {
+            if (search_spaces[i].BalanceTile(tile_size[i], out var newTile))
+            {
+                tile_size[i] = newTile;
+                return true;
+            }
+        }
+
+        // force ping pong
+        for (int i = 0; i < search_spaces.Length; i++)
+        {
+            if (search_spaces[i].ClampStop(2, out var new_seg) && new_seg.Stop < tile_size[i])
+            {
+                tile_size[i] = new_seg.Stop;
+                return true;
+            }
+        }
+
+        return changed;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
new file mode 100644
index 0000000000..1016a0c681
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Nncase.Passes.Tile;
+
+/// <summary>
+/// TileOptions.
+/// </summary>
+/// <param name="TargetTileSize">TargetTileSize.</param>
+/// <param name="ForceFence">ForceFence.</param>
+/// <param name="PingPong"> 是否进行ping pong. </param>
+/// <param name="PingPongNum">PingPongNum. </param>
+/// <param name="ForceMultiLayer"> 对于测试. </param>
+/// <param name="MultiWorkers"> 是否开启多线程搜索. </param>
+public sealed record TileOptions(int[] TargetTileSize, bool ForceFence, bool PingPong, int PingPongNum, bool ForceMultiLayer, bool MultiWorkers)
+{
+    public static TileOptions Default { get; } = new(Array.Empty<int>(), false, true, 2, false, true);
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TwoFusionChecker.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TwoFusionChecker.cs
new file mode 100644
index 0000000000..b0a8a858c3
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TwoFusionChecker.cs
@@ -0,0 +1,131 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+#if false
+using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.PatternMatch;
+using Nncase.TIR.K510;
+using static Nncase.PatternMatch.Utility;
+
+[assembly: InternalsVisibleTo("Nncase.Tests.K510")]
+
+namespace Nncase.Passes.Tile;
+
+/// <summary>
+/// the two Fusion checker.
+/// 专门前一层可以在conv的ic上tiling的情况.
+/// </summary>
+internal sealed class TwoFusionChecker : IFusionChecker
+{
+    private readonly List<(LayerFusionConverter, int[], BufferSchedule.ScheduledResponse)> _caches = new();
+
+    private readonly TileOptions _tileOptions;
+
+    public TwoFusionChecker(TileOptions tileOptions)
+    {
+        _tileOptions = tileOptions;
+    }
+
+    /// <summary>
+    /// Gets 匹配 conv2d + 非reduction.
+    /// </summary>
+    public static Pattern TwoFusionPattern { get; } = IsCallWildcard(
+        null,
+        IsOp<IR.K510.GNNEStore>(),
+        IsCallWildcard(
+          "conv2d",
+          IsOp<IR.K510.GNNEConv2D>(),
+          IsCallWildcard(null, IsOp<Op>("calleeOp", op => op is IR.K510.GNNEMeshNet or IR.K510.GNNEPdpReduce), IsCallWildcard(null, IsOp<IR.K510.GNNELoad>()))));
+
+    public TIR.PrimFunction Convert(RunPassContext passOptions)
+    {
+        var (convertVisitor, final_tile_size, response) = _caches.First();
+        if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
+        {
+            response.Dump($"{response.LogicalPrimfunc.Name}_{string.Join("_", final_tile_size)}", nameof(LayerFusionOcIcConverter));
+        }
+
+        return convertVisitor.BuildPhysicalPrimFunc(final_tile_size, response.SchedCandidate, response.LogicalPrimfunc);
+    }
+
+    public bool Check(Fusion fusion, RunPassContext passOptions)
+    {
+        // 1. try match pattern
+        if (!CompilerServices.TryMatchRoot(fusion.Body, TwoFusionPattern, out var matchResult))
+        {
+            return false;
+        }
+
+        // 2. try convert
+        var convertVisitor = new LayerFusionOcIcConverter(_tileOptions, TileUtilities.ChoiceTcuStrategy((Call)matchResult["conv2d"], out _), false); // note the grouped fusion must pingpong input.
+        var bodySeq = convertVisitor.Visit(fusion);
+
+        // 3. search the tile size
+        var originLogicalPrimFunc = convertVisitor.BuildLogicalPrimFunc(bodySeq);
+        _ = fusion.Body.CheckedShape.ToValueArray();
+        var search_space = convertVisitor.OCBoundsInferGraph.RootTileStep.ToArray();
+        search_space = search_space.Concat(new[] { new Segment(1, convertVisitor.Conv2DInShape[1], 1) }).ToArray();
+        var candidate_tile_size = convertVisitor.SearchTileSize(
+            SearchGenerator(search_space),
+            originLogicalPrimFunc,
+            _tileOptions.MultiWorkers,
+            false,
+            out var sched_response);
+        if (!candidate_tile_size.Any())
+        {
+            return false;
+        }
+
+        if (_tileOptions.PingPong && convertVisitor.BalanceTileSize(candidate_tile_size, search_space))
+        {
+            _ = convertVisitor.SearchTileSize(new TargetTileGenerator(candidate_tile_size), originLogicalPrimFunc, _tileOptions.MultiWorkers, true, out sched_response);
+        }
+        else
+        {
+        }
+
+        _caches.Add((convertVisitor, candidate_tile_size, sched_response));
+        if (_caches.Count > 1)
+        {
+            _caches.RemoveAt(0);
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// <remark>
+    /// do not tile on w dimension.
+    /// </remark>
+    /// </summary>
+    /// <returns>.</returns>
+    private ISearchTileGenerator SearchGenerator(Segment[] search_spaces)
+    {
+        var newSpaces = search_spaces.ToArray();
+
+        // 这里就优先在ic上切分ping pong. 因为在ic上切分对于if来说都是不一样的.
+        var ic = newSpaces.Length - 1;
+        if (newSpaces[ic].ClampStop(2, out var new_seg))
+        {
+            newSpaces[ic] = new_seg;
+        }
+
+        // ic最小也得分两个tcu.
+        newSpaces[ic].Start = Math.Min(ExtCompilerServices.Env.TcuActNum * ExtCompilerServices.Env.PuHeight, newSpaces[ic].Stop);
+
+        var w = 3;
+        newSpaces[w].Start = newSpaces[w].Stop; // no tile w
+
+        return new QueuedSearchTileGenerator(newSpaces, g =>
+        {
+            g.Queue.Add((1, System.Math.Min(ExtCompilerServices.Env.PuWidth * ExtCompilerServices.Env.TcuActNum, g.UpperBounds[1]))); // oc
+            g.Queue.Add((4, g.UpperBounds[4])); // ic
+            g.Queue.Add((2, g.UpperBounds[2])); // h
+            g.Queue.Add((1, g.UpperBounds[1])); // oc
+        });
+    }
+}
+#endif
diff --git a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
index c82f0d24d1..fc7c392e6f 100644
--- a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
@@ -7,8 +7,6 @@
 using System.Text;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Options;
-using Microsoft.VisualBasic;
 using Nncase.CodeGen;
 using Nncase.CodeGen.StackVM;
 using Nncase.IR;
diff --git a/modules/Nncase.Modules.CPU/packages.lock.json b/modules/Nncase.Modules.CPU/packages.lock.json
index 444b371070..4ed711f699 100644
--- a/modules/Nncase.Modules.CPU/packages.lock.json
+++ b/modules/Nncase.Modules.CPU/packages.lock.json
@@ -11,6 +11,31 @@
           "StyleCop.Analyzers.Unstable": "1.2.0.435"
         }
       },
+      "Google.OrTools.runtime.linux-arm64": {
+        "type": "Transitive",
+        "resolved": "9.4.1874",
+        "contentHash": "Z46ndZcZa2Lt5b76xU9kxVYbPLg/LfuMufhUVsu3Qo3L7Bibf7WXd9j7RRldjnuv8RIHWTqb0b+2FwwMxs0c5A=="
+      },
+      "Google.OrTools.runtime.linux-x64": {
+        "type": "Transitive",
+        "resolved": "9.4.1874",
+        "contentHash": "zGeDb8FuvP9HXjrsU7krVXtSDFpR+DUGNEsH51k94jL9tzf2vWYI8+WUBRHZ/cGe50dpLr+vIjfcNo3gFyOpkQ=="
+      },
+      "Google.OrTools.runtime.osx-arm64": {
+        "type": "Transitive",
+        "resolved": "9.4.1874",
+        "contentHash": "Wo0ZfDaH6DhiQw0jZm4HWJm/oPGPpWNwOLUz+EYaoH3MLtocSxItHGQj/Ta3HyhXnYNOv+TliAH8L+8RCXu/2w=="
+      },
+      "Google.OrTools.runtime.osx-x64": {
+        "type": "Transitive",
+        "resolved": "9.4.1874",
+        "contentHash": "IAfGgKR1og6vU87axK1d37Ak/4jy8B4NMoElovG/KZc/2UY+cJEAQDA709UMegtI4lBhuxTWFNUiHQYmRIB9yQ=="
+      },
+      "Google.OrTools.runtime.win-x64": {
+        "type": "Transitive",
+        "resolved": "9.4.1874",
+        "contentHash": "fUs5qDnZA6itygolcX6nPuachQkY9CVvQbakIzIiRAWKcaj8umQAbFdGwbkyzp3qp34BKW5mtPVsmMyfQBBjOQ=="
+      },
       "libortki": {
         "type": "Transitive",
         "resolved": "0.0.2",
@@ -116,6 +141,7 @@
         "type": "Project",
         "dependencies": {
           "GiGraph.Dot": "[2.0.0, )",
+          "Google.OrTools": "[9.4.1874, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
           "Nncase.Core": "[1.0.0, )",
           "Nncase.Evaluator": "[1.0.0, )",
@@ -173,6 +199,26 @@
         "resolved": "2.0.0",
         "contentHash": "ThvS2mQVveSkTMUm04tMbRYzu1XFPV8xBHISrUMp02APjhv9IRbLu3v3upTPCywORx2Ds/c6AqEUL1WU6kPfuQ=="
       },
+      "Google.OrTools": {
+        "type": "CentralTransitive",
+        "requested": "[9.4.1874, )",
+        "resolved": "9.4.1874",
+        "contentHash": "jqRoI+pYlym+fhoU25u+13oti5h+772bllQ9zDitTVMclDXVTiG6pxzvmYO74wnADBMdpb2SQlgiNQxoNk5dlA==",
+        "dependencies": {
+          "Google.OrTools.runtime.linux-arm64": "9.4.1874",
+          "Google.OrTools.runtime.linux-x64": "9.4.1874",
+          "Google.OrTools.runtime.osx-arm64": "9.4.1874",
+          "Google.OrTools.runtime.osx-x64": "9.4.1874",
+          "Google.OrTools.runtime.win-x64": "9.4.1874",
+          "Google.Protobuf": "3.19.4"
+        }
+      },
+      "Google.Protobuf": {
+        "type": "CentralTransitive",
+        "requested": "[3.19.4, )",
+        "resolved": "3.19.4",
+        "contentHash": "fd07/ykL4O4FhqrZIELm5lmiyOHfdPg9+o+hWr6tcfRdS7tHXnImg/2wtogLzlW2eEmr0J7j6ZrZvaWOLiJbxQ=="
+      },
       "Microsoft.Extensions.Hosting.Abstractions": {
         "type": "CentralTransitive",
         "requested": "[6.0.0, )",
diff --git a/src/Nncase.Tests/Properties/launchSettings.json b/src/Nncase.Tests/Properties/launchSettings.json
index d081379b07..3109588c45 100644
--- a/src/Nncase.Tests/Properties/launchSettings.json
+++ b/src/Nncase.Tests/Properties/launchSettings.json
@@ -2,7 +2,7 @@
   "profiles": {
     "Nncase.Tests": {
       "commandName": "Project",
-      "nativeDebugging": true
+      "nativeDebugging": false
     }
   }
 }
\ No newline at end of file

From dc1598dab0ca9482d3b7aa936318bf71ea8af2fb Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 14 Jul 2023 15:31:21 +0800
Subject: [PATCH 004/308] fix build

---
 .../Passes/CPUFusionToTirPass.cs              | 43 ++++++++-------
 .../Passes/Tile/CPUFusionGroupMutator.cs      | 55 ++++++++++---------
 .../Passes/Tile/IFusionChecker.cs             |  5 +-
 .../Passes/Tile/LayerFusionConverter.cs       |  2 +
 .../Passes/Tile/MultiFusionChecker.cs         |  3 +-
 .../Passes/Tile/MultiLayerFusionConverter.cs  |  4 +-
 .../Passes/Tile/TileOptions.cs                |  5 +-
 .../Nncase.Modules.CPU/Targets/CPUTarget.cs   |  2 +-
 8 files changed, 67 insertions(+), 52 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs b/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
index 128ca15c91..5e1ff781b0 100644
--- a/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
+++ b/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
@@ -1,4 +1,8 @@
-using System;
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+#if false
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -9,6 +13,7 @@
 using Nncase.Passes.Analysis;
 using Nncase.Passes.Mutators;
 using Nncase.Passes.Tile;
+using Nncase.Targets;
 using Nncase.TIR;
 
 namespace Nncase.Passes;
@@ -32,33 +37,30 @@ protected override Task<IRModule> RunCoreAsync(IRModule module, RunPassContext o
         Dictionary<Fusion, BaseFunction> fusionConertedCache = new(ReferenceEqualityComparer.Instance);
 
         // convert the fusion as entry.
-        for (int i = 0; i < module.Functions.Count; i++)
-        {
-            if (module.Functions[i] is Fusion { ModuleKind: "cpu" } fusion)
-            {
-                TIR.PrimFunction primFunction;
-                var visitor = new MultiLayerFusionConverter(_tileOptions);
-                primFunction = visitor.VisitToPrimFunc(fusion);
-
-                CompilerServices.InferenceType(primFunction);
-                fusionConertedCache[fusion] = primFunction;
-                module.Replace(i, primFunction);
-            }
-        }
+        // for (int i = 0; i < module.Functions.Count; i++)
+        // {
+        //     if (module.Functions[i] is Fusion { ModuleKind: CPUTarget.Kind } fusion)
+        //     {
+        //         TIR.PrimFunction primFunction;
+        //         var visitor = new MultiLayerFusionConverter(_tileOptions);
+        //         primFunction = visitor.VisitToPrimFunc(fusion);
+        //
+        //         CompilerServices.InferenceType(primFunction);
+        //         fusionConertedCache[fusion] = primFunction;
+        //         module.Replace(i, primFunction);
+        //     }
+        // }
 
         // convert the stackvm function call k510 fusion
         for (int i = 0; i < module.Functions.Count; i++)
         {
-            if (module.Functions[i] is Function { ModuleKind: "stackvm" } func)
+            if (module.Functions[i] is Function { ModuleKind: CPUTarget.Kind } func)
             {
-                var analysis = new Dictionary<Type, IAnalysisResult>
-                {
-                    [typeof(IExprUserAnalysisResult)] = AnalyzerManager.GetAnaylsis<IExprUserAnalysisResult>(func),
-                };
+                var analysis = new Dictionary<Type, IAnalysisResult> { [typeof(IExprUserAnalysisResult)] = AnalyzerManager.GetAnaylsis<IExprUserAnalysisResult>(func), };
                 var rewriter = new DataFlowMergeRewriter();
                 var fusionCheckCache = new Dictionary<Fusion, IFusionChecker>(ReferenceEqualityComparer.Instance);
 
-                var post = (Function)rewriter.Rewrite(func, new Mutators.IMergeRewriteRule[] { new GNNESameInputFusionMergeRule(), }, (rule, option) => new CPUFusionGroupMutator<MultiFusionChecker>(fusionCheckCache, _tileOptions, rule, option), new() { AnalysisResults = analysis, MatchOptions = new Mutators.FusionGroupMutator.GroupedMatchOptions() });
+                // var post = (Function)rewriter.Rewrite(func, new Mutators.IMergeRewriteRule[] { new GNNESameInputFusionMergeRule(), }, (rule, option) => new CPUFusionGroupMutator<MultiFusionChecker>(fusionCheckCache, _tileOptions, rule, option), new() { AnalysisResults = analysis, MatchOptions = new Mutators.FusionGroupMutator.GroupedMatchOptions() });
 
                 // if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
                 // {
@@ -115,3 +117,4 @@ protected override async Task OnPassEndAsync(IRModule post, RunPassContext conte
         _fusionMacsMap.Clear();
     }
 }
+#endif
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
index 4b206ca688..3cd7ab7c9d 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
@@ -1,6 +1,6 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
+#if false
 using System.Runtime.CompilerServices;
 using Nncase.IR;
 using Nncase.PatternMatch;
@@ -9,7 +9,7 @@
 
 namespace Nncase.Passes.Tile;
 
-internal sealed class GNNESameInputFusionMergeRule : Mutators.SameInputFusionMergeRule
+internal sealed class CPUSameInputFusionMergeRule : Mutators.SameInputFusionMergeRule
 {
     public override string ModuleKind => CPUTarget.Kind;
 
@@ -57,11 +57,11 @@ public CPUFusionGroupMutator(
     public override bool MergedFusionCheckCallBack(Fusion mergedFusion, HashSet<Fusion> candidateFusions)
     {
         // note the gnne activate must be first layer.
-        if (mergedFusion.Body is Call { Target: IR.K510.GNNEStore } st_call &&
-          st_call[IR.K510.GNNEStore.Input] is Call { Target: IR.K510.GNNEActivation })
-        {
-            return false;
-        }
+        // if (mergedFusion.Body is Call { Target: IR.K510.GNNEStore } st_call &&
+        //   st_call[IR.K510.GNNEStore.Input] is Call { Target: IR.K510.GNNEActivation })
+        // {
+        //     return false;
+        // }
 
         var checker = (IFusionChecker)Activator.CreateInstance(typeof(T), new object[] { _tileOptions })!;
         var ret = checker.Check(mergedFusion, PassOptions);
@@ -103,7 +103,7 @@ public CheckedConvertMutator(Dictionary<Fusion, BaseFunction> fusion_converted_c
     /// <inheritdoc/>
     protected override Expr RewriteLeafFusion(Fusion expr)
     {
-        if (expr is Fusion { ModuleKind: K510Target.Kind } fusion)
+        if (expr is Fusion { ModuleKind: CPUTarget.Kind } fusion)
         {
             if (!_fusionConertedCache.TryGetValue(fusion, out _))
             {
@@ -114,28 +114,27 @@ protected override Expr RewriteLeafFusion(Fusion expr)
                 }
                 else
                 {
-                    if (CompilerServices.TryMatchRoot(fusion, Conv2DFusionConverter.Conv2DFusionPattern, out var matchResult))
-                    {
-                        prim_func = Conv2DFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
-                    }
-                    else if (CompilerServices.TryMatchRoot(fusion, Conv2DTransposeFusionConverter.Conv2DFusionPattern, out matchResult))
-                    {
-                        prim_func = Conv2DTransposeFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
-                    }
-                    else if (!_tileOptions.ForceMultiLayer && CompilerServices.TryMatchRoot(fusion, LSTMFusionConverter.FusionPattern, out matchResult))
-                    {
-                        prim_func = LSTMFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
-                    }
-                    else
-                    {
-                        var visitor = new MultiLayerFusionConverter(_tileOptions);
-                        prim_func = visitor.VisitToPrimFunc(fusion);
-                    }
+                    // if (CompilerServices.TryMatchRoot(fusion, Conv2DFusionConverter.Conv2DFusionPattern, out var matchResult))
+                    // {
+                    //     prim_func = Conv2DFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
+                    // }
+                    // else if (CompilerServices.TryMatchRoot(fusion, Conv2DTransposeFusionConverter.Conv2DFusionPattern, out matchResult))
+                    // {
+                    //     prim_func = Conv2DTransposeFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
+                    // }
+                    // else if (!_tileOptions.ForceMultiLayer && CompilerServices.TryMatchRoot(fusion, LSTMFusionConverter.FusionPattern, out matchResult))
+                    // {
+                    //     prim_func = LSTMFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
+                    // }
+                    // else
+                    // {
+                    //     var visitor = new MultiLayerFusionConverter(_tileOptions);
+                    //     prim_func = visitor.VisitToPrimFunc(fusion);
+                    // }
                 }
 
                 BaseFunction? convert_func = prim_func;
                 _fusionConertedCache.Add(fusion, convert_func);
-                new DDrMacCalcVisitor(_fusionMacsMap).Visit(fusion);
             }
         }
 
@@ -144,7 +143,7 @@ protected override Expr RewriteLeafFusion(Fusion expr)
 
     protected override Expr RewriteLeafCall(Call expr)
     {
-        if (expr.Target is Fusion { ModuleKind: K510Target.Kind } fusion)
+        if (expr.Target is Fusion { ModuleKind: CPUTarget.Kind } fusion)
         {
             var convert_func = _fusionConertedCache[fusion];
             PrimFunctionWrapper wrapper;
@@ -185,3 +184,5 @@ protected override Expr RewriteLeafCall(Call expr)
         return expr;
     }
 }
+
+#endif
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/IFusionChecker.cs b/modules/Nncase.Modules.CPU/Passes/Tile/IFusionChecker.cs
index 84b2d37072..9c7bd70876 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/IFusionChecker.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/IFusionChecker.cs
@@ -1,4 +1,7 @@
-using System;
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs
index 8cf139f3fc..f205692a57 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
+#if false
 using System.Reactive;
 using System.Runtime.CompilerServices;
 using NetFabric.Hyperlinq;
@@ -1260,3 +1261,4 @@ protected virtual ISequentialBuilder<Sequential> LowerGnneConv2DTranspose(IndexM
         throw new NotSupportedException();
     }
 }
+#endif
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs b/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs
index a3a4380d74..7cbeab67c8 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs
@@ -1,6 +1,6 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
+#if false
 using System.Collections.Immutable;
 using System.Runtime.CompilerServices;
 using Nncase.Diagnostics;
@@ -249,3 +249,4 @@ protected override bool VisitLeafCall(Call expr)
         };
     }
 }
+#endif
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs
index 4a07a4a17c..a99248cf14 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs
@@ -1,13 +1,14 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
+#if false
 using System.Runtime.CompilerServices;
 using Nncase.Diagnostics;
 using Nncase.IR;
 using Nncase.Passes.BufferSchedule;
 using Nncase.TIR;
 using Nncase.TIR.Builders;
-using Nncase.TIR.K510;
+using Nncase.TIR.CPU;
 using Nncase.TIR.K510.Builders;
 using MathF = Nncase.IR.F.Math;
 
@@ -226,3 +227,4 @@ public override bool BalanceTileSize(int[] tile_size, Segment[] search_spaces)
         return changed;
     }
 }
+#endif
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
index 1016a0c681..ba3368a679 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
@@ -1,4 +1,7 @@
-using System;
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
diff --git a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
index fc7c392e6f..6bee77d2a7 100644
--- a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
@@ -24,7 +24,7 @@ public class CPUTarget : ITarget
     /// <summary>
     /// Gets kind.
     /// </summary>
-    public static readonly string Kind = "cpu";
+    public const string Kind = "cpu";
 
     string ITarget.Kind => Kind;
 

From ba3ca85ca017d0d7b098a1d8eeb2c77534351178 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 14 Jul 2023 15:33:26 +0800
Subject: [PATCH 005/308] basic cpu module builder

---
 modules/Nncase.Modules.CPU/CodeGen/CSource.cs | 283 ++++++++++++++
 .../CodeGen/CSourceVisitor.cs                 | 365 ++++++++++++++++++
 .../CodeGen/FunctionBuilder.cs                | 119 ++++++
 .../CodeGen/LinkableFunction.cs               |  30 ++
 .../CodeGen/LinkableModule.cs                 |  45 +++
 .../CodeGen/LinkedModule.cs                   |  31 ++
 .../CodeGen/ModuleBuilder.cs                  |  39 ++
 .../Nncase.Modules.CPU.csproj                 |   1 +
 .../Passes/Tile/CPUFusionConverter.cs         | 148 +++++++
 .../Runtime/CPU/CPURTModule.cs                |  23 ++
 modules/Nncase.Modules.CPU/packages.lock.json |   6 +
 src/Nncase.Cli/packages.lock.json             |   1 +
 src/Nncase.Compiler/packages.lock.json        |   1 +
 .../packages.lock.json                        |   7 +
 src/Nncase.Tests/packages.lock.json           |   1 +
 15 files changed, 1100 insertions(+)
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/CSource.cs
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/CSourceVisitor.cs
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionConverter.cs
 create mode 100644 modules/Nncase.Modules.CPU/Runtime/CPU/CPURTModule.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSource.cs b/modules/Nncase.Modules.CPU/CodeGen/CSource.cs
new file mode 100644
index 0000000000..8570adf641
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSource.cs
@@ -0,0 +1,283 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+#if false
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using Nncase.IR;
+using Nncase.Schedule;
+using Nncase.TIR;
+
+namespace Nncase.CodeGen;
+
+/// <summary>
+/// the c source runtime function.
+/// </summary>
+/// <param name="name"></param>
+/// <param name="handle"></param>
+public record CSourceRTFunction(string name, Delegate handle) : IRTFunction
+{
+    public string Name { get => name; set { } }
+    public Delegate Handle { get => handle; set { } }
+}
+
+public class CSourceSerializeResult : ISerializeResult
+{
+
+}
+
+/// <summary>
+/// c runtime module impl
+/// </summary>
+public class CSourceRTModel : IRTModule, IRTModel
+{
+    /// <inheritdoc/>
+    public ModuleType ModuleType { get => CodeGen.ModuleType.Create("CSource"); set { } }
+
+    /// <inheritdoc/>
+    public ITarget Target { get; set; }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<IRTModule> Modules => throw new NotImplementedException();
+
+    /// <inheritdoc/>
+    public string SourcePath { get; private set; }
+
+    public IRModel Model { get; set; }
+    IRTFunction? _entry = null;
+
+    /// <inheritdoc/>
+    public bool IsSerialized { get; private set; }
+
+    readonly List<IRTFunction> _functions = new();
+
+    /// <summary>
+    /// <see cref="CSourceRTModel"/>
+    /// </summary>
+    public CSourceRTModel(IRModel model, ITarget target)
+    {
+        SourcePath = CodeGenUtil.GetTempFileName("c");
+        Model = model;
+        Target = target;
+    }
+
+    /// <inheritdoc/>
+    public byte[] Source { get => File.ReadAllBytes(SourcePath); set { } }
+
+    /// <inheritdoc/>
+    public string SourceExt { get => "c"; set { } }
+
+    /// <inheritdoc/>
+    public IRTFunction? Entry => _entry;
+
+    /// <inheritdoc/>
+    public IReadOnlyList<IRTFunction> Functions => _functions;
+
+    /// <inheritdoc/>
+    string _dllPath = "";
+
+    /// <summary>
+    /// write the c source code into source path.
+    /// </summary>
+    /// <exception cref="InvalidProgramException"></exception>
+    void BuildCode()
+    {
+        if (File.Exists(SourcePath))
+            File.Delete(SourcePath);
+        using (var writer = new StreamWriter(SourcePath, false, Encoding.UTF8))
+        {
+            var visior = new CSourceHostBuildVisior(writer);
+            if (Model.Entry is null) { throw new InvalidProgramException("The Model Entry Is Null!"); }
+            if (Model.Entry.CheckedType is null && Model.Entry.InferenceType() == false) { throw new InvalidProgramException("The Model Entry Can't Inference Type!"); }
+            visior.Visit(Model.Entry);
+        }
+    }
+
+    public void CompileCode()
+    {
+        if (!File.Exists(SourcePath))
+            throw new InvalidProgramException("The Source Code Path Is Invalid!");
+        var compiler = new CSourceCompiler();
+        _dllPath = compiler.Compile(SourcePath);
+    }
+
+    /// <summary>
+    /// bind each IR.Funtion with C function
+    /// </summary>
+    /// <exception cref="InvalidProgramException"></exception>
+    public void ExportCode()
+    {
+        if (!File.Exists(_dllPath))
+            throw new InvalidProgramException("The DLL Path Is Invalid!");
+        var dllPtr = NativeLibrary.Load(_dllPath);
+        foreach (var module in Model.Modules)
+        {
+            foreach (var f in module.Callables)
+            {
+                var funcType = f.ToDelegateType(Path.GetFileName(_dllPath));
+                var funPtr = NativeLibrary.GetExport(dllPtr, f.Name);
+                _functions.Add(new CSourceRTFunction(f.Name, funPtr.BindDelegate(funcType)));
+                if (f == Model.Entry) { _entry = _functions.Last(); }
+            }
+        }
+    }
+
+    /// <inheritdoc/>
+    public ISerializeResult Serialize()
+    {
+        if (IsSerialized) { return new CSourceSerializeResult(); }
+        BuildCode();
+        CompileCode();
+        ExportCode();
+        return new CSourceSerializeResult();
+    }
+
+    /// <summary>
+    /// invoke the module entry
+    /// </summary>
+    /// <param name="args">input args</param>
+    /// <returns> results </returns>
+    /// <exception cref="InvalidOperationException"></exception>
+    public object? Invoke(params object?[]? args)
+    {
+        if (Entry is null)
+            throw new InvalidOperationException("This RTModule Have No Entry Function!");
+        return Entry.Handle.DynamicInvoke(args);
+    }
+
+    public string Dump(string name, string DumpDirPath)
+    {
+        var dump_path = $"{DumpDirPath}/{name}.{SourceExt}";
+        using var file = File.Open(dump_path, FileMode.OpenOrCreate, FileAccess.Write);
+        using var writer = new StreamWriter(file);
+        writer.Write(Source);
+        return dump_path;
+    }
+
+}
+
+/// <summary>
+/// the csource code compiler.
+/// </summary>
+public class CSourceCompiler
+{
+    /// <summary>
+    /// compiler exe name
+    /// </summary>
+    string _exe = "", _arch = "", _ext = "";
+
+    /// <summary>
+    /// select current pattern's exe
+    /// </summary>
+    /// <exception cref="NotSupportedException"></exception>
+    void PlatformSpecific()
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+        {
+            _exe = "gcc";
+            _ext = "so";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            _exe = "clang";
+            _ext = "dylib";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            _exe = "cmd";
+            _ext = "dll";
+        }
+    }
+
+    void ArchSpecific()
+    {
+        _arch = RuntimeInformation.OSArchitecture switch
+        {
+            Architecture.X64 => RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "x86-64" : "x86_64",
+            Architecture.Arm64 => "arm64",
+            _ => throw new NotSupportedException(RuntimeInformation.OSArchitecture.ToString()),
+        };
+    }
+
+    string ArgumentsSpecific(string sourcePath, string outPath)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+        {
+            return $"{sourcePath} -fPIC -shared -march={Arch} -o {outPath}";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            return $"{sourcePath} -fPIC -shared -arch {Arch} -o {outPath}";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            var vsdir = Environment.GetEnvironmentVariable("VSAPPIDDIR") ?? throw new InvalidOperationException("Cannot find vs");
+            var vcvardir = Path.Combine(vsdir, "..\\..\\VC\\Auxiliary\\Build\\vcvarsall.bat");
+            return $"/C (\"{vcvardir}\" x64) && (cl /D_USRDLL /D_WINDLL \"{sourcePath}\" /MT /link /DLL /OUT:\"{outPath}\")";
+        }
+        throw new System.ArgumentOutOfRangeException("Only Support Linux/Osx/Windows");
+    }
+
+    protected string Exe
+    {
+        get => _exe;
+    }
+
+    protected string Arch
+    {
+        get => _arch;
+    }
+
+    protected string Ext
+    {
+        get => _ext;
+    }
+
+    public CSourceCompiler()
+    {
+        PlatformSpecific();
+        ArchSpecific();
+    }
+
+    /// <summary>
+    /// compile the source txt, write to the out_path
+    /// </summary>
+    /// <param name="sourcePath"> c source code</param>
+    /// <param name="outPath"> out .so path </param>
+    /// <returns> outPath </returns>
+    public string Compile(string sourcePath, string outPath)
+    {
+        var errMsg = new StringBuilder();
+        using (var errWriter = new StringWriter(errMsg))
+        {
+            using (var proc = new Process())
+            {
+                proc.StartInfo.FileName = Exe;
+                proc.StartInfo.Arguments = ArgumentsSpecific(sourcePath, outPath);
+                proc.StartInfo.RedirectStandardError = true;
+                proc.ErrorDataReceived += (sender, e) => errWriter.WriteLine(e.Data);
+                proc.Start();
+                proc.BeginErrorReadLine();
+                proc.WaitForExit();
+                if (proc.ExitCode != 0)
+                {
+                    throw new InvalidOperationException(errMsg.ToString());
+                }
+            }
+        }
+        return outPath;
+    }
+
+    /// <summary>
+    /// create the temp dll file and compile source
+    /// <see cref="Compile(string, string)"/>
+    /// </summary>
+    public string Compile(string sourcePath) => Compile(sourcePath, CodeGenUtil.GetTempFileName(Ext));
+}
+#endif
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceVisitor.cs
new file mode 100644
index 0000000000..60453f1563
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceVisitor.cs
@@ -0,0 +1,365 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using NetFabric.Hyperlinq;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.Runtime;
+using Nncase.TIR;
+
+namespace Nncase.CodeGen;
+
+/// <summary>
+/// the c symbol define.
+/// </summary>
+internal struct CSymbol
+{
+    public string Type;
+    public StringBuilder Doc;
+
+    public CSymbol(string type, StringBuilder doc)
+    {
+        Type = type;
+        Doc = doc;
+    }
+
+    public override string ToString() => $"{Type} {Doc}";
+}
+
+/// <summary>
+/// convert the type/op to c name.
+/// </summary>
+internal static class NameConverter
+{
+    private static readonly Dictionary<PrimType, string> _primTypeToC = new()
+    {
+        { DataTypes.Boolean, "bool" },
+        { DataTypes.Int8, "int8_t" },
+        { DataTypes.Int16, "int16_t" },
+        { DataTypes.Int32, "int32_t" },
+        { DataTypes.Int64, "int64_t" },
+        { DataTypes.UInt8, "uint8_t" },
+        { DataTypes.UInt16, "uint16_t" },
+        { DataTypes.UInt32, "uint32_t" },
+        { DataTypes.UInt64, "uint64_t" },
+        { DataTypes.Float32, "float" },
+        { DataTypes.Float64, "double" },
+    };
+
+    public static string ToC(this PrimType primType) =>
+        _primTypeToC[primType];
+
+    public static string ToC(this DataType dataType) => dataType switch
+    {
+        PrimType ptype => ptype.ToC(),
+        PointerType { ElemType: PrimType etype } => etype.ToC() + "*",
+        _ => throw new NotSupportedException(dataType.ToString()),
+    };
+}
+
+/// <summary>
+/// collect the csymbol's parameter.
+/// </summary>
+internal class CSymbolParamList : IParameterList<CSymbol>, IEnumerable<CSymbol>
+{
+    private CSymbol[] _symbols;
+
+    public CSymbolParamList(CSymbol[] symbols)
+    {
+        this._symbols = symbols;
+    }
+
+    public CSymbol this[ParameterInfo parameter] => _symbols[parameter.Index];
+
+    public CSymbol this[int index] => _symbols[index];
+
+    public IEnumerator<CSymbol> GetEnumerator()
+    {
+        return ((IEnumerable<CSymbol>)_symbols).GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return _symbols.GetEnumerator();
+    }
+}
+
+/// <summary>
+/// visitor for the build c source code, the expr vistor return (type string , name string).
+/// </summary>
+internal class CSourceHostBuildVisior : ExprFunctor<CSymbol, string>
+{
+    /// <summary>
+    /// source writer .
+    /// TODO we need the decl writer.
+    /// </summary>
+    private readonly ScopeWriter _scope;
+
+    /// <summary>
+    /// symbols name memo.
+    /// </summary>
+    private readonly Dictionary<Expr, CSymbol> _symbols = new(ReferenceEqualityComparer.Instance);
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CSourceHostBuildVisior"/> class.
+    /// <see cref="CSourceHostBuildVisior"/>.
+    /// </summary>
+    /// <param name="textWriter">TextWriter.</param>
+    public CSourceHostBuildVisior(TextWriter textWriter)
+    {
+        _scope = new ScopeWriter(textWriter);
+
+        // insert some declare
+        _scope.IndWriteLine(@"
+#ifdef _WIN32
+#define EXPORT_API __declspec(dllexport)
+#else
+#define EXPORT_API
+#endif");
+        _scope.IndWriteLine("#include <stdint.h>");
+    }
+
+    /// <example>
+    /// void (*fun_ptr)(int).
+    /// </example>
+    public string CallableTypeToPtr(CallableType type, string name) => $"{VisitType(type.ReturnType)} (*{name}_ptr)({string.Join(",", type.Parameters.Select(VisitType))})";
+
+    /// <inheritdoc/>
+    public override string VisitType(TensorType type)
+    {
+        if (!type.IsScalar)
+        {
+            throw new NotSupportedException($"{type}");
+        }
+
+        return type.DType.ToC();
+    }
+
+    /// <inheritdoc/>
+    public override string VisitType(TupleType type) => type == TupleType.Void ? "void" : throw new InvalidProgramException($"The C Source Must Not Have TupleType {type}!");
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitCall(Call expr)
+    {
+        if (_symbols.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        var target = Visit(expr.Target);
+        var args = new CSymbolParamList(expr.Arguments.AsValueEnumerable().Select(Visit).ToArray());
+        var type = VisitType(expr.CheckedType!);
+        _scope.Push();
+        switch (expr.Target)
+        {
+            case IR.Math.Binary:
+                _scope.Append($"({args[0].Doc} {target.Doc} {args[1].Doc})");
+                break;
+            case Store:
+                _scope.Append($"{args[Store.Handle].Doc}[{args[Store.Index].Doc}] = {args[Store.Value].Doc}");
+                break;
+            case Load:
+                _scope.Append($"{args[Store.Handle].Doc}[{args[Store.Index].Doc}]");
+                break;
+            case IR.Tensors.Cast:
+                _scope.Append($"(({type}){args[IR.Tensors.Cast.Input].Doc})");
+                break;
+            default:
+                _scope.Append($"{target.Doc}({string.Join(", ", args.Select(x => x.Doc))})");
+                break;
+        }
+
+        symbol = new(type, _scope.Pop());
+        _symbols.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitConst(Const expr)
+    {
+        if (_symbols.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        if (expr.CheckedType is TensorType ttype && ttype.IsScalar)
+        {
+            var literal = $"{expr}" switch
+            {
+                "True" => "1",
+                "False" => "0",
+                var x => x,
+            };
+            symbol = new(VisitType(ttype), new(literal));
+        }
+        else
+        {
+            throw new NotSupportedException($"Not Support {expr.CheckedType} Const");
+        }
+
+        _symbols.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitPrimFunction(PrimFunction expr)
+    {
+        if (_symbols.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        var retType = VisitType(((CallableType)expr.CheckedType!).ReturnType);
+        _scope.Push();
+
+        // 1. Function signature
+        _scope.IndWrite($"EXPORT_API {retType} {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(Visit).ToArray())}) {{");
+
+        // 2. Function body
+        using (_scope.IndentUp())
+        {
+            _scope.Append(Visit(expr.Body).Doc);
+        }
+
+        // 3. Function closing
+        _scope.IndWrite("}");
+        symbol = new(CallableTypeToPtr((CallableType)expr.CheckedType!, expr.Name), _scope.Pop());
+
+        // 4. write whole code
+        _scope.IndWrite(symbol.Doc);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitOp(Op expr)
+    {
+        if (_symbols.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        symbol = new("Invalid Op", new(expr switch
+        {
+            IR.Math.Binary op => op.BinaryOp switch
+            {
+                BinaryOp.Add => "+",
+                BinaryOp.Sub => "-",
+                BinaryOp.Mul => "*",
+                BinaryOp.Div => "/",
+                BinaryOp.Mod => "%",
+                _ => throw new ArgumentOutOfRangeException(op.BinaryOp.ToString()),
+            },
+            TIR.Store op => "Store",
+            TIR.Load op => "Load",
+            IR.Tensors.Cast op => op.NewType.ToC(),
+            _ => throw new NotSupportedException($"{expr.GetType().Name}"),
+        }));
+        _symbols.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitVar(Var expr)
+    {
+        if (_symbols.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        var isymbol = _scope.GetUniqueVarSymbol(expr);
+        symbol = new(VisitType(expr.CheckedType!), isymbol.Span);
+        _symbols.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitFor(For expr)
+    {
+        if (_symbols.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        _scope.Push();
+
+        // 1. For Loop signature
+        var loopVar = Visit(expr.LoopVar);
+        _scope.Append($"for ({loopVar} = {Visit(expr.Domain.Start).Doc}; {loopVar.Doc} < {Visit(expr.Domain.Stop).Doc}; {loopVar.Doc}+={expr.Domain.Step}) {{");
+
+        // 2. For Body
+        _scope.Append(Visit(expr.Body).Doc);
+
+        // 3. For closing
+        _scope.IndWrite("}");
+        symbol = new(VisitType(expr.CheckedType!), _scope.Pop());
+        _symbols.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitSequential(Sequential expr)
+    {
+        if (_symbols.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        _scope.Push();
+        _scope.AppendLine(string.Empty);
+        using (_scope.IndentUp())
+        {
+            foreach (var i in Enumerable.Range(0, expr.Count))
+            {
+                if (i == expr.Count - 1 &&
+                    expr.Fields[i].CheckedType is TensorType)
+                {
+                    _scope.IndWrite("return ");
+                }
+                else
+                {
+                    _scope.IndWrite(string.Empty);
+                }
+
+                _scope.Append(Visit(expr.Fields[i]).Doc);
+                if (expr.Fields[i] is Call)
+                {
+                    _scope.AppendLine(";");
+                }
+                else
+                {
+                    _scope.AppendLine(string.Empty);
+                }
+            }
+        }
+
+        symbol = new(VisitType(expr.CheckedType!), _scope.Pop());
+        _symbols.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitIfThenElse(IfThenElse expr)
+    {
+        if (_symbols.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        _scope.Push();
+        _scope.Append($"if({Visit(expr.Condition).Doc}) {{");
+        _scope.Append(Visit(expr.Then).Doc);
+        _scope.IndWrite("} else {");
+        _scope.Append(Visit(expr.Else).Doc);
+        _scope.IndWrite("}");
+        symbol = new(VisitType(expr.CheckedType!), _scope.Pop());
+        _symbols.Add(expr, symbol);
+        return symbol;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
new file mode 100644
index 0000000000..854a8582b0
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
@@ -0,0 +1,119 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+#pragma warning disable
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using NetFabric.Hyperlinq;
+using Nncase.IR;
+
+namespace Nncase.CodeGen.CPU;
+
+/// <summary>
+/// StackVM function builder.
+/// </summary>
+internal class FunctionBuilder : IDisposable
+{
+    private readonly uint _id;
+    private readonly MemoryStream _textContent = new MemoryStream();
+    private readonly BinaryWriter _textWriter;
+    private readonly BinaryWriter _rdataWriter;
+
+    /// <summary>
+    /// NOTE sync with the cpu runtime function.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MemoryRange
+    {
+        public uint Start;
+        public uint Size;
+    }
+
+    /// <summary>
+    /// NOTE sync with the cpu runtime function.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    private unsafe struct DescHeader
+    {
+        /// <summary>
+        /// input pool size.
+        /// </summary>
+        public uint InputPoolSize;
+
+        /// <summary>
+        /// output pool size.
+        /// </summary>
+        public uint OutputPoolSize;
+
+        /// <summary>
+        /// input numbers.
+        /// </summary>
+        public uint Inputs;
+
+        /// <summary>
+        /// output numbers.
+        /// </summary>
+        public uint Outputs;
+    }
+
+    public FunctionBuilder(uint id, BinaryWriter rdataWriter)
+    {
+        _id = id;
+        _textWriter = new BinaryWriter(_textContent, Encoding.UTF8, leaveOpen: true);
+        _rdataWriter = rdataWriter;
+    }
+
+    public unsafe LinkableFunction Build(TIR.PrimFunction function)
+    {
+        // 1. write the inst
+        // new InstSerializeVisitor(_textWriter).Visit(function.Body);
+
+        // 2. write the desc
+        var descContent = new MemoryStream();
+        using (var descWriter = new BinaryWriter(descContent, Encoding.UTF8))
+        {
+            DescHeader header = new() { InputPoolSize = 0, OutputPoolSize = 0, Inputs = 0, Outputs = 0 };
+            long headerStart = descWriter.Position();
+            descWriter.Skip((ulong)sizeof(DescHeader));
+
+            foreach (var input in function.Parameters.AsValueEnumerable()
+                                .Where(buf => buf.MemLocation == Schedule.MemoryLocation.Input))
+            {
+                header.Inputs++;
+                var rg = new MemoryRange { Start = checked((uint)input.Start), Size = checked((uint)input.Size) };
+                descWriter.Write(ref rg);
+                header.InputPoolSize = Math.Max(header.InputPoolSize, rg.Start + rg.Size);
+            }
+
+            foreach (var output in function.Parameters.AsValueEnumerable().Where(buf => buf.MemLocation == Schedule.MemoryLocation.Output))
+            {
+                header.Outputs++;
+                var rg = new MemoryRange { Start = checked((uint)output.Start), Size = checked((uint)output.Size) };
+                descWriter.Write(ref rg);
+                header.OutputPoolSize = Math.Max(header.OutputPoolSize, rg.Start + rg.Size);
+            }
+
+            descWriter.Position(headerStart);
+            descWriter.Write(ref header);
+        }
+
+        // 3. write the rdata
+        foreach (var buffer in function.SchedResult.Rdatas)
+        {
+            var bytes = buffer.Const!.Value.BytesBuffer;
+            if ((uint)bytes.Length != buffer.Size)
+            {
+                throw new InvalidDataException("The Buffer Szie Not Equal!");
+            }
+
+            _rdataWriter.Position((uint)buffer.Start);
+            _rdataWriter.Write(bytes);
+        }
+
+        return new LinkableFunction(_id, function, _textContent.ToArray(), descContent.ToArray());
+    }
+
+    public void Dispose()
+    {
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
new file mode 100644
index 0000000000..e92d1f5b4e
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+
+namespace Nncase.CodeGen.CPU;
+
+internal sealed class LinkableFunction : ILinkableFunction
+{
+    private readonly byte[] _desc;
+
+    public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, byte[] text, byte[] desc)
+    {
+        Id = id;
+        SourceFunction = sourceFunction;
+        Text = text;
+        _desc = desc;
+        Sections = new LinkedSection[] { new(_desc, ".desc", 0, 8, (uint)_desc.Length) };
+    }
+
+    public uint Id { get; }
+
+    public BaseFunction SourceFunction { get; }
+
+    public byte[] Text { get; }
+
+    public IEnumerable<FunctionRef> FunctionRefs => Enumerable.Empty<FunctionRef>();
+
+    public IReadOnlyList<ILinkedSection> Sections { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
new file mode 100644
index 0000000000..53d8c79b18
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -0,0 +1,45 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.Runtime.StackVM;
+
+namespace Nncase.CodeGen.CPU;
+
+internal sealed class LinkableModule : ILinkableModule
+{
+    private const int _textAlignment = 8;
+
+    private readonly byte[] _rdata;
+
+    private readonly IReadOnlyList<LinkableFunction> _functions;
+
+    public LinkableModule(byte[] rdata, IReadOnlyList<LinkableFunction> functions)
+    {
+        _rdata = rdata;
+        _functions = functions;
+    }
+
+    public ILinkedModule Link(ILinkContext linkContext)
+    {
+        var linkedFunctions = new List<LinkedFunction>();
+        var text = new MemoryStream();
+        using (var bw = new BinaryWriter(text, Encoding.UTF8, true))
+        {
+            foreach (var func in _functions)
+            {
+                // FixFunctionRefs(func, linkContext);
+                bw.AlignPosition(_textAlignment);
+                var textBegin = bw.Position();
+                bw.Write(func.Text);
+                linkedFunctions.Add(new LinkedFunction(func.Id, func.SourceFunction, (uint)textBegin, (uint)func.Text.Length, func.Sections));
+            }
+        }
+
+        return new LinkedModule(linkedFunctions, text.ToArray(), _rdata);
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
new file mode 100644
index 0000000000..4ad317298f
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
@@ -0,0 +1,31 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.Runtime.StackVM;
+
+namespace Nncase.CodeGen.CPU;
+
+internal sealed class LinkedModule : ILinkedModule
+{
+    public LinkedModule(IReadOnlyList<ILinkedFunction> functions, byte[] text, byte[] rdata)
+    {
+        Functions = functions;
+        Sections = new[] {
+            new LinkedSection(text, ".text", 0, 8, (uint)text.Length),
+            new LinkedSection(rdata, ".rdata", 0, 8, (uint)rdata.Length),
+        };
+    }
+
+    public string ModuleKind => Runtime.CPU.CPURTModule.Kind;
+
+    public uint Version => Runtime.CPU.CPURTModule.Version;
+
+    public IReadOnlyList<ILinkedFunction> Functions { get; }
+
+    public IReadOnlyList<ILinkedSection> Sections { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
new file mode 100644
index 0000000000..659a16dc9b
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
@@ -0,0 +1,39 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Text;
+using Nncase.Diagnostics;
+using Nncase.IR;
+
+namespace Nncase.CodeGen.CPU;
+
+/// <summary>
+/// K230CoreModule builder.
+/// </summary>
+public sealed class ModuleBuilder : IModuleBuilder, IDisposable
+{
+    private readonly MemoryStream _rdataContent = new MemoryStream();
+    private readonly BinaryWriter _rdataWriter;
+
+    public ModuleBuilder(CompileOptions options)
+    {
+        _rdataWriter = new BinaryWriter(_rdataContent, Encoding.UTF8, leaveOpen: true);
+        CompileOptions = options;
+    }
+
+    public CompileOptions CompileOptions { get; }
+
+    /// <inheritdoc/>
+    public string ModuleKind => Runtime.CPU.CPURTModule.Kind;
+
+    /// <inheritdoc/>
+    public ILinkableModule Build(IReadOnlyList<BaseFunction> functions)
+    {
+        var linkableFunctions = functions.OfType<TIR.PrimFunction>().Select((f, i) => new FunctionBuilder((uint)i, _rdataWriter).Build(f)).ToArray();
+        _rdataWriter.Flush();
+
+        return new LinkableModule(_rdataContent.ToArray(), linkableFunctions);
+    }
+
+    public void Dispose() => ((IDisposable)_rdataContent).Dispose();
+}
diff --git a/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj b/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj
index fb4674b51c..60eb18e05d 100644
--- a/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj
+++ b/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj
@@ -9,6 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\src\Nncase.Diagnostics\Nncase.Diagnostics.csproj" />
     <ProjectReference Include="..\..\src\Nncase.Passes\Nncase.Passes.csproj" />
     <ProjectReference Include="..\..\src\Nncase.CodeGen\Nncase.CodeGen.csproj" />
   </ItemGroup>
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionConverter.cs
new file mode 100644
index 0000000000..2c85b4deca
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionConverter.cs
@@ -0,0 +1,148 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+#if true
+using System.Reactive;
+using System.Runtime.CompilerServices;
+using NetFabric.Hyperlinq;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.IR.Buffers;
+using Nncase.IR.CPU;
+using Nncase.IR.F;
+using Nncase.IR.Math;
+using Nncase.Passes.Mutators;
+using Nncase.PatternMatch;
+using Nncase.Schedule;
+using Nncase.Targets;
+using Nncase.TIR;
+using Nncase.TIR.Builders;
+using Buffer = Nncase.TIR.Buffer;
+using MathF = Nncase.IR.F.Math;
+using Range = Nncase.TIR.Range;
+using Tuple = Nncase.IR.Tuple;
+
+namespace Nncase.Passes.Tile;
+
+/// <summary>
+/// name 分配器.
+/// </summary>
+internal sealed class NameAllocator
+{
+    public Dictionary<string, int> NamePool { get; } = new();
+
+    public string Get(string name)
+    {
+        if (!NamePool.TryGetValue(name, out var count))
+        {
+            count = 0;
+        }
+
+        NamePool[name] = count + 1;
+        return count == 0 ? name : $"{name}_{count}";
+    }
+}
+
+internal class CPUFusionConverter
+{
+    public NameAllocator NameAllocator { get; } = new();
+
+    /// <summary>
+    /// Gets tile size 的变量.
+    /// </summary>
+    public List<Var> TileSizeVars { get; } = new();
+
+    /// <summary>
+    /// Gets loop 变量.
+    /// </summary>
+    // public List<Var> LoopVars { get; } = new();
+
+    /// <summary>
+    /// Gets loop domains.
+    /// </summary>
+    public List<Range> LoopDomains { get; } = new();
+
+    /// <summary>
+    /// Gets nested loops.
+    /// </summary>
+    // public List<ISequentialBuilder<For>> NestedLoops { get; } = new();
+
+    public TileOptions TileOptions { get; protected set; } = null!;
+
+    /// <summary>
+    /// Gets or sets 总的loop count.
+    /// </summary>/
+    public virtual Expr LoopCount { get; protected set; }
+
+    /// <summary>
+    /// Gets or sets ping pong 外层的tiling.
+    /// </summary>
+    public virtual Expr LoopCountOuter { get; protected set; }
+
+    /// <summary>
+    /// Gets or sets ping pong 内侧的tiling.
+    /// </summary>
+    public virtual Expr LoopCountInner { get; protected set; }
+
+    /// <summary>
+    /// Gets or sets 当前的fusion.
+    /// </summary>
+    public virtual Fusion CurrentFusion { get; protected set; }
+
+    public virtual PrimFunction BuildPrimFunc(Fusion fusion)
+    {
+        // TODO: buffer顺序可能需要调整以保持原图的顺序
+        var primFuncBuilder = T.PrimFunc(CurrentFusion.Name, CPUTarget.Kind, _ifBufferMap.Values.Union(_ofBufferMap.Values).Select(b => (PhysicalBuffer)b).ToArray());
+        return primFuncBuilder.Build();
+    }
+
+    public virtual Expr Visit(Expr root)
+    {
+        return root switch
+        {
+            Call call => (call.Target switch
+            {
+                CPUUnary op => LowerCPUUnary(call, op),
+                _ => throw new NotSupportedException(),
+            }).Build(),
+            _ => T.Nop(),
+        };
+    }
+
+    protected virtual ISequentialBuilder<Sequential> LowerCPUUnary(Call call, CPUUnary op)
+    {
+        var prefix = NameAllocator.Get(nameof(CPUUnary));
+        var inputCall = call[CPUUnary.Input];
+        T.PhysicalBuffer(inputCall.CheckedDataType, MemoryLocation.Input, inputCall.CheckedShape, out var ddrIf);
+        T.PhysicalBuffer(call.CheckedDataType, MemoryLocation.Output, call.CheckedShape.ToValueArray(), out var ddrOf);
+        _ifBufferMap.Add(call, ddrIf);
+        _ofBufferMap.Add(call, ddrOf);
+
+        List<Var> LoopVars = new();
+        List<ISequentialBuilder<For>> NestedLoops = new();
+        List<Range> LoopDomains = call.CheckedShape.Select(s => new Range(0, 1, s.FixedValue)).ToList();
+
+        var seq = T.Sequential().Body(Visit(inputCall));
+
+        for (int i = 0; i < call.CheckedShape.Rank; i++)
+        {
+            NestedLoops.Add(T.ForLoop(out var loopVar, LoopDomains[i], LoopMode.Unrolled, $"loop_var_{i}"));
+            LoopVars.Add(loopVar);
+        }
+
+        NestedLoops[^1].Body(
+            op.UnaryOp switch
+            {
+                // TODO: body的实现
+                UnaryOp.Abs => T.Nop(),
+                _ => throw new NotSupportedException(),
+            });
+
+        seq.Body(NestedLoops[0].Body());
+        return seq;
+    }
+
+    private readonly Dictionary<Expr, Buffer> _ifBufferMap = new(ReferenceEqualityComparer.Instance);
+    private readonly Dictionary<Expr, Buffer> _ofBufferMap = new(ReferenceEqualityComparer.Instance);
+}
+#endif
diff --git a/modules/Nncase.Modules.CPU/Runtime/CPU/CPURTModule.cs b/modules/Nncase.Modules.CPU/Runtime/CPU/CPURTModule.cs
new file mode 100644
index 0000000000..0ed89e20f3
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Runtime/CPU/CPURTModule.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Nncase.Runtime.CPU;
+
+internal class CPURTModule
+{
+    /// <summary>
+    /// KPU module kind.
+    /// </summary>
+    public static readonly string Kind = "cpu";
+
+    /// <summary>
+    /// KPU module version.
+    /// </summary>
+    public static readonly uint Version = 1;
+}
diff --git a/modules/Nncase.Modules.CPU/packages.lock.json b/modules/Nncase.Modules.CPU/packages.lock.json
index 4ed711f699..5dd73e5bda 100644
--- a/modules/Nncase.Modules.CPU/packages.lock.json
+++ b/modules/Nncase.Modules.CPU/packages.lock.json
@@ -137,6 +137,12 @@
           "System.Reactive": "[5.0.0, )"
         }
       },
+      "nncase.diagnostics": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.Core": "[1.0.0, )"
+        }
+      },
       "nncase.egraph": {
         "type": "Project",
         "dependencies": {
diff --git a/src/Nncase.Cli/packages.lock.json b/src/Nncase.Cli/packages.lock.json
index 7ba8ee7204..712cc915f1 100644
--- a/src/Nncase.Cli/packages.lock.json
+++ b/src/Nncase.Cli/packages.lock.json
@@ -747,6 +747,7 @@
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Diagnostics": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }
diff --git a/src/Nncase.Compiler/packages.lock.json b/src/Nncase.Compiler/packages.lock.json
index 1655cc14b1..8cede23417 100644
--- a/src/Nncase.Compiler/packages.lock.json
+++ b/src/Nncase.Compiler/packages.lock.json
@@ -724,6 +724,7 @@
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Diagnostics": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }
diff --git a/src/Nncase.Tests.TestFixture/packages.lock.json b/src/Nncase.Tests.TestFixture/packages.lock.json
index cafcae2049..94827ead5b 100644
--- a/src/Nncase.Tests.TestFixture/packages.lock.json
+++ b/src/Nncase.Tests.TestFixture/packages.lock.json
@@ -1098,6 +1098,12 @@
           "System.Reactive": "[5.0.0, )"
         }
       },
+      "nncase.diagnostics": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.Core": "[1.0.0, )"
+        }
+      },
       "nncase.egraph": {
         "type": "Project",
         "dependencies": {
@@ -1130,6 +1136,7 @@
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Diagnostics": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }
diff --git a/src/Nncase.Tests/packages.lock.json b/src/Nncase.Tests/packages.lock.json
index 6d25e0bccb..02b0e823c7 100644
--- a/src/Nncase.Tests/packages.lock.json
+++ b/src/Nncase.Tests/packages.lock.json
@@ -1543,6 +1543,7 @@
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Diagnostics": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }

From 7de0b568a88bc04b1e63791bfbe165b95bd6ce32 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 21 Jul 2023 16:27:35 +0800
Subject: [PATCH 006/308] add csource codegen

---
 modules/Nncase.Modules.CPU/CodeGen/CSource.cs |  283 ----
 .../CodeGen/CSourceBuiltn.cs                  |   22 +
 .../CodeGen/CSourceConvertVisitor.cs          |  323 +++++
 .../CodeGen/CSourceExtensions.cs              |   45 +
 .../CodeGen/CSourceUtilities.cs               |   40 +
 .../CodeGen/CSourceVisitor.cs                 |  365 -----
 .../CodeGen/FunctionBuilder.cs                |   76 +-
 .../CodeGen/FunctionCSource.cs                |  149 ++
 .../CodeGen/LinkableFunction.cs               |   10 +-
 .../CodeGen/LinkableModule.cs                 |   53 +-
 .../CodeGen/LinkedModule.cs                   |    9 +-
 .../CodeGen/ModuleBuilder.cs                  |    2 +-
 .../Evaluator/CPU/CPUKernelOp.cs              |   34 +
 .../Evaluator/CPU/CPUModule.cs                |    2 +-
 .../Evaluator/CPU/CPUUnary.cs                 |  141 --
 .../IR/CPU/{CPUUnary.cs => CPUKernelOp.cs}    |    8 +-
 .../Nncase.Modules.CPU/IR/CPU/Functional.cs   |   10 +-
 .../Passes/CPUFusionToTirPass.cs              |   63 +-
 .../Passes/Rules/LowerUnary.cs                |    2 +-
 .../Passes/Rules/MakeFusion.cs                |    4 +-
 .../Passes/Tile/CPUFusionConverter.cs         |  148 --
 .../Passes/Tile/CPUFusionGroupMutator.cs      |   57 +-
 .../Passes/Tile/LayerFusionConverter.cs       | 1264 -----------------
 .../Passes/Tile/MultiFusionChecker.cs         |  240 +---
 .../Passes/Tile/MultiLayerFusionConverter.cs  |  230 ---
 .../Passes/Tile/SingleCPUFusionConverter.cs   |  119 ++
 .../Passes/Tile/TileOptions.cs                |   10 +-
 .../Passes/Tile/TwoFusionChecker.cs           |  131 --
 .../Runtime/CPU/CPURTModule.cs                |   23 -
 .../Nncase.Modules.CPU/Targets/CPUTarget.cs   |   16 +-
 src/Nncase.CodeGen/CodeGen/LinkedFunction.cs  |    1 -
 src/Nncase.Core/IR/Buffers/BufferOf.cs        |    4 +-
 src/Nncase.Core/IR/Buffers/Functional.cs      |    2 +-
 src/Nncase.Core/IR/Buffers/Uninitialized.cs   |    4 +-
 src/Nncase.Core/IR/ExprCloner.g.cs            |    8 +
 src/Nncase.Core/IR/ExprFunctor.g.cs           |   11 +
 src/Nncase.Core/IR/ExprRewriter.g.cs          |   11 +
 src/Nncase.Core/IR/ExprVisitor.g.cs           |   27 +
 src/Nncase.Core/Schedule/ScheduleTypes.cs     |   45 -
 src/Nncase.Core/TIR/Buffer.cs                 |   20 +-
 src/Nncase.Core/TIR/MemSpan.cs                |   86 ++
 src/Nncase.Core/TIR/Ops.cs                    |   16 +-
 src/Nncase.Core/TIR/Script.cs                 |   30 +-
 src/Nncase.Evaluator/TIR/Load.cs              |    8 +-
 src/Nncase.Evaluator/TIR/Store.cs             |    8 +-
 src/Nncase.Passes/DDrBufferSchdeulePass.cs    |   18 +-
 .../Rules/Neutral/PrimFuncMergeRule.cs        |   10 +-
 src/Nncase.Tests/CodeGen/CSourceHostCases.cs  |    8 +-
 src/Nncase.Tests/Core/UnitTestExpression.cs   |   10 +-
 .../Core/UnitTestStringUtility.cs             |    6 +-
 src/Nncase.Tests/Core/UnitTestTIR.cs          |   23 +-
 .../Diagnostics/UnitTestDumpper.cs            |    2 +-
 .../Evaluator/UnitTestEvaluator.cs            |    6 +-
 .../Evaluator/UnitTestEvaluatorBuffers.cs     |    2 +-
 .../TIR/PrimFunc/IDataFlowPrimFuncCase.cs     |   36 +-
 .../TIR/PrimFunc/UnitTestPrimFuncMerge.cs     |   10 +-
 src/Nncase.Tests/TIR/UnitTestMutators.cs      |   20 +-
 .../Targets/UnitTestCPUTargetTiling.cs        |   51 +
 .../Transform/UnitTestPassManager.cs          |   12 +-
 .../Transform/UnitTestSubstitutor.cs          |   15 +-
 .../Nncase.Targets.CSource/CSourceTarget.cs   |   34 -
 .../Nncase.Targets.CSource/CodeGen/CSource.cs |  278 ----
 .../CodeGen/CSourceVisitor.cs                 |  317 -----
 .../Nncase.Targets.CSource/CodeGen/Interop.cs |  140 --
 .../Nncase.Targets.CSource.csproj             |   16 -
 .../Schedule/CSourceScheduler.cs              |   22 -
 .../Pattern/PatternGenerator.cs               |    4 +-
 67 files changed, 1165 insertions(+), 4035 deletions(-)
 delete mode 100644 modules/Nncase.Modules.CPU/CodeGen/CSource.cs
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
 delete mode 100644 modules/Nncase.Modules.CPU/CodeGen/CSourceVisitor.cs
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/CPU/CPUKernelOp.cs
 delete mode 100644 modules/Nncase.Modules.CPU/Evaluator/CPU/CPUUnary.cs
 rename modules/Nncase.Modules.CPU/IR/CPU/{CPUUnary.cs => CPUKernelOp.cs} (69%)
 delete mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionConverter.cs
 delete mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs
 delete mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
 delete mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/TwoFusionChecker.cs
 delete mode 100644 modules/Nncase.Modules.CPU/Runtime/CPU/CPURTModule.cs
 create mode 100644 src/Nncase.Core/TIR/MemSpan.cs
 create mode 100644 src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
 delete mode 100644 targets/Nncase.Targets.CSource/CSourceTarget.cs
 delete mode 100644 targets/Nncase.Targets.CSource/CodeGen/CSource.cs
 delete mode 100644 targets/Nncase.Targets.CSource/CodeGen/CSourceVisitor.cs
 delete mode 100644 targets/Nncase.Targets.CSource/CodeGen/Interop.cs
 delete mode 100644 targets/Nncase.Targets.CSource/Nncase.Targets.CSource.csproj
 delete mode 100644 targets/Nncase.Targets.CSource/Schedule/CSourceScheduler.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSource.cs b/modules/Nncase.Modules.CPU/CodeGen/CSource.cs
deleted file mode 100644
index 8570adf641..0000000000
--- a/modules/Nncase.Modules.CPU/CodeGen/CSource.cs
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-#if false
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Text;
-using Nncase.IR;
-using Nncase.Schedule;
-using Nncase.TIR;
-
-namespace Nncase.CodeGen;
-
-/// <summary>
-/// the c source runtime function.
-/// </summary>
-/// <param name="name"></param>
-/// <param name="handle"></param>
-public record CSourceRTFunction(string name, Delegate handle) : IRTFunction
-{
-    public string Name { get => name; set { } }
-    public Delegate Handle { get => handle; set { } }
-}
-
-public class CSourceSerializeResult : ISerializeResult
-{
-
-}
-
-/// <summary>
-/// c runtime module impl
-/// </summary>
-public class CSourceRTModel : IRTModule, IRTModel
-{
-    /// <inheritdoc/>
-    public ModuleType ModuleType { get => CodeGen.ModuleType.Create("CSource"); set { } }
-
-    /// <inheritdoc/>
-    public ITarget Target { get; set; }
-
-    /// <inheritdoc/>
-    public IReadOnlyList<IRTModule> Modules => throw new NotImplementedException();
-
-    /// <inheritdoc/>
-    public string SourcePath { get; private set; }
-
-    public IRModel Model { get; set; }
-    IRTFunction? _entry = null;
-
-    /// <inheritdoc/>
-    public bool IsSerialized { get; private set; }
-
-    readonly List<IRTFunction> _functions = new();
-
-    /// <summary>
-    /// <see cref="CSourceRTModel"/>
-    /// </summary>
-    public CSourceRTModel(IRModel model, ITarget target)
-    {
-        SourcePath = CodeGenUtil.GetTempFileName("c");
-        Model = model;
-        Target = target;
-    }
-
-    /// <inheritdoc/>
-    public byte[] Source { get => File.ReadAllBytes(SourcePath); set { } }
-
-    /// <inheritdoc/>
-    public string SourceExt { get => "c"; set { } }
-
-    /// <inheritdoc/>
-    public IRTFunction? Entry => _entry;
-
-    /// <inheritdoc/>
-    public IReadOnlyList<IRTFunction> Functions => _functions;
-
-    /// <inheritdoc/>
-    string _dllPath = "";
-
-    /// <summary>
-    /// write the c source code into source path.
-    /// </summary>
-    /// <exception cref="InvalidProgramException"></exception>
-    void BuildCode()
-    {
-        if (File.Exists(SourcePath))
-            File.Delete(SourcePath);
-        using (var writer = new StreamWriter(SourcePath, false, Encoding.UTF8))
-        {
-            var visior = new CSourceHostBuildVisior(writer);
-            if (Model.Entry is null) { throw new InvalidProgramException("The Model Entry Is Null!"); }
-            if (Model.Entry.CheckedType is null && Model.Entry.InferenceType() == false) { throw new InvalidProgramException("The Model Entry Can't Inference Type!"); }
-            visior.Visit(Model.Entry);
-        }
-    }
-
-    public void CompileCode()
-    {
-        if (!File.Exists(SourcePath))
-            throw new InvalidProgramException("The Source Code Path Is Invalid!");
-        var compiler = new CSourceCompiler();
-        _dllPath = compiler.Compile(SourcePath);
-    }
-
-    /// <summary>
-    /// bind each IR.Funtion with C function
-    /// </summary>
-    /// <exception cref="InvalidProgramException"></exception>
-    public void ExportCode()
-    {
-        if (!File.Exists(_dllPath))
-            throw new InvalidProgramException("The DLL Path Is Invalid!");
-        var dllPtr = NativeLibrary.Load(_dllPath);
-        foreach (var module in Model.Modules)
-        {
-            foreach (var f in module.Callables)
-            {
-                var funcType = f.ToDelegateType(Path.GetFileName(_dllPath));
-                var funPtr = NativeLibrary.GetExport(dllPtr, f.Name);
-                _functions.Add(new CSourceRTFunction(f.Name, funPtr.BindDelegate(funcType)));
-                if (f == Model.Entry) { _entry = _functions.Last(); }
-            }
-        }
-    }
-
-    /// <inheritdoc/>
-    public ISerializeResult Serialize()
-    {
-        if (IsSerialized) { return new CSourceSerializeResult(); }
-        BuildCode();
-        CompileCode();
-        ExportCode();
-        return new CSourceSerializeResult();
-    }
-
-    /// <summary>
-    /// invoke the module entry
-    /// </summary>
-    /// <param name="args">input args</param>
-    /// <returns> results </returns>
-    /// <exception cref="InvalidOperationException"></exception>
-    public object? Invoke(params object?[]? args)
-    {
-        if (Entry is null)
-            throw new InvalidOperationException("This RTModule Have No Entry Function!");
-        return Entry.Handle.DynamicInvoke(args);
-    }
-
-    public string Dump(string name, string DumpDirPath)
-    {
-        var dump_path = $"{DumpDirPath}/{name}.{SourceExt}";
-        using var file = File.Open(dump_path, FileMode.OpenOrCreate, FileAccess.Write);
-        using var writer = new StreamWriter(file);
-        writer.Write(Source);
-        return dump_path;
-    }
-
-}
-
-/// <summary>
-/// the csource code compiler.
-/// </summary>
-public class CSourceCompiler
-{
-    /// <summary>
-    /// compiler exe name
-    /// </summary>
-    string _exe = "", _arch = "", _ext = "";
-
-    /// <summary>
-    /// select current pattern's exe
-    /// </summary>
-    /// <exception cref="NotSupportedException"></exception>
-    void PlatformSpecific()
-    {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-        {
-            _exe = "gcc";
-            _ext = "so";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-        {
-            _exe = "clang";
-            _ext = "dylib";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-        {
-            _exe = "cmd";
-            _ext = "dll";
-        }
-    }
-
-    void ArchSpecific()
-    {
-        _arch = RuntimeInformation.OSArchitecture switch
-        {
-            Architecture.X64 => RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "x86-64" : "x86_64",
-            Architecture.Arm64 => "arm64",
-            _ => throw new NotSupportedException(RuntimeInformation.OSArchitecture.ToString()),
-        };
-    }
-
-    string ArgumentsSpecific(string sourcePath, string outPath)
-    {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-        {
-            return $"{sourcePath} -fPIC -shared -march={Arch} -o {outPath}";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-        {
-            return $"{sourcePath} -fPIC -shared -arch {Arch} -o {outPath}";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-        {
-            var vsdir = Environment.GetEnvironmentVariable("VSAPPIDDIR") ?? throw new InvalidOperationException("Cannot find vs");
-            var vcvardir = Path.Combine(vsdir, "..\\..\\VC\\Auxiliary\\Build\\vcvarsall.bat");
-            return $"/C (\"{vcvardir}\" x64) && (cl /D_USRDLL /D_WINDLL \"{sourcePath}\" /MT /link /DLL /OUT:\"{outPath}\")";
-        }
-        throw new System.ArgumentOutOfRangeException("Only Support Linux/Osx/Windows");
-    }
-
-    protected string Exe
-    {
-        get => _exe;
-    }
-
-    protected string Arch
-    {
-        get => _arch;
-    }
-
-    protected string Ext
-    {
-        get => _ext;
-    }
-
-    public CSourceCompiler()
-    {
-        PlatformSpecific();
-        ArchSpecific();
-    }
-
-    /// <summary>
-    /// compile the source txt, write to the out_path
-    /// </summary>
-    /// <param name="sourcePath"> c source code</param>
-    /// <param name="outPath"> out .so path </param>
-    /// <returns> outPath </returns>
-    public string Compile(string sourcePath, string outPath)
-    {
-        var errMsg = new StringBuilder();
-        using (var errWriter = new StringWriter(errMsg))
-        {
-            using (var proc = new Process())
-            {
-                proc.StartInfo.FileName = Exe;
-                proc.StartInfo.Arguments = ArgumentsSpecific(sourcePath, outPath);
-                proc.StartInfo.RedirectStandardError = true;
-                proc.ErrorDataReceived += (sender, e) => errWriter.WriteLine(e.Data);
-                proc.Start();
-                proc.BeginErrorReadLine();
-                proc.WaitForExit();
-                if (proc.ExitCode != 0)
-                {
-                    throw new InvalidOperationException(errMsg.ToString());
-                }
-            }
-        }
-        return outPath;
-    }
-
-    /// <summary>
-    /// create the temp dll file and compile source
-    /// <see cref="Compile(string, string)"/>
-    /// </summary>
-    public string Compile(string sourcePath) => Compile(sourcePath, CodeGenUtil.GetTempFileName(Ext));
-}
-#endif
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
new file mode 100644
index 0000000000..eda007050f
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.CodeGen.CPU;
+
+public static class CSourceBuiltn
+{
+
+    public const string BufferType = "buffer_t";
+
+    public const string BufferStruct = @"typedef struct buffer {
+    void *ptr;
+    int *shape;
+    int *stride;
+    int rank;
+} buffer_t;";
+
+    public const string Include = @"#include<stdio.h>";
+
+    public static string Header => Include + "\n" + BufferStruct;
+
+}
\ No newline at end of file
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
new file mode 100644
index 0000000000..71b8d5ee65
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -0,0 +1,323 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reactive;
+using System.Runtime.InteropServices;
+using System.Text;
+using NetFabric.Hyperlinq;
+using Nncase.IR;
+using Nncase.Runtime;
+using Nncase.TIR;
+
+namespace Nncase.CodeGen.CPU;
+
+/// <summary>
+/// the c symbol define.
+/// </summary>
+internal sealed class CSymbol
+{
+    public CSymbol(string type, string name)
+    {
+        Type = type;
+        Name = name;
+    }
+
+    public string Type { get; }
+    public string Name { get; }
+
+    public override string ToString() => $"{Type} {Name}";
+}
+
+internal struct IndentScope : IDisposable
+{
+    private static readonly AsyncLocal<IndentWriter?> _writer = new AsyncLocal<IndentWriter?>();
+
+    private readonly bool _initialized;
+
+    private readonly IndentWriter? _originalWriter;
+
+    public IndentScope(StringBuilder sb)
+    {
+        _initialized = true;
+        _writer.Value = new IndentWriter(sb);
+        _originalWriter = null;
+    }
+
+    public IndentScope()
+    {
+        _initialized = true;
+        if (_writer.Value is null)
+        {
+            return;
+        }
+
+        _originalWriter = _writer.Value;
+        _writer.Value = new(_originalWriter.GetStringBuilder(), _originalWriter.Indent + 2);
+    }
+
+    public static IndentWriter Writer => _writer.Value!;
+
+    public void Dispose()
+    {
+        if (_initialized)
+        {
+            _writer.Value = _originalWriter;
+        }
+    }
+}
+
+
+internal sealed class IndentWriter : StringWriter
+{
+    public int Indent;
+
+    public IndentWriter(StringBuilder sb, int indent = 0) : base(sb)
+    {
+        Indent = indent;
+    }
+
+    public void IndWrite(string? value)
+    {
+        for (int i = 0; i < Indent; i++)
+        {
+            this.Write(' ');
+        }
+        this.Write(value);
+    }
+}
+
+/// <summary>
+/// convert single prim function to c source
+/// </summary>
+internal sealed class CSourceConvertVisitor : ExprFunctor<CSymbol, Unit>
+{
+    private readonly StringBuilder _implBuilder;
+    public readonly Dictionary<Expr, CSymbol> ExprMemo;
+
+    public CSourceConvertVisitor()
+    {
+        _implBuilder = new StringBuilder();
+        ExprMemo = new(ReferenceEqualityComparer.Instance);
+    }
+
+    public FunctionCSource GetFunctionCSource()
+    {
+        return new(ExprMemo[VisitRoot!].Type + ";", _implBuilder.ToString());
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitPrimFunction(PrimFunction expr)
+    {
+        if (ExprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        if (expr.CheckedType is not CallableType { ReturnType: TupleType r } || r != TupleType.Void)
+        {
+            throw new NotSupportedException("The PrimFunction must return void!");
+        }
+
+        var type = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(b => Visit(b).ToString()).ToArray())})";
+
+        using (var scope = new IndentScope(_implBuilder))
+        {
+            // 1. Function signature
+            IndentScope.Writer.IndWrite($"{type} {{\n");
+            // 2. Function body
+            using (var _ = new IndentScope())
+            {
+                Visit(expr.Body);
+            }
+            // 3. Function closing
+            IndentScope.Writer.IndWrite("}\n");
+        }
+
+        symbol = new(type, new(expr.Name));
+        ExprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitCall(Call expr)
+    {
+        if (ExprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        var arguments = expr.Arguments.AsValueEnumerable().Select(Visit).ToArray();
+        string type = expr.CheckedType switch
+        {
+            TupleType x when x == TupleType.Void => "",
+            TensorType { IsScalar: true } x => x.DType.ToC(),
+            _ => throw new NotSupportedException()
+        };
+
+        string str;
+        switch (expr.Target)
+        {
+            case IR.Math.Binary op:
+                str = CSourceUtilities.ContertBinary(op, arguments);
+                break;
+            case IR.Math.Unary op:
+                str = CSourceUtilities.ContertUnary(op, arguments);
+                break;
+            case Store:
+                str = $"((({arguments[2].Type} *){arguments[0].Name}->ptr)[{arguments[1].Name}] = {arguments[2].Name})";
+                break;
+            case Load:
+                str = $"((({type} *){arguments[0].Name}->ptr)[{arguments[1].Name}])";
+                break;
+            default:
+                throw new NotSupportedException();
+        }
+
+        symbol = new(type, str);
+        ExprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitConst(Const expr)
+    {
+        if (ExprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+        string type;
+        string str;
+        if (expr is TensorConst { Value: Tensor { ElementType: PrimType ptype, Shape: { IsScalar: true } } scalar })
+        {
+            str = scalar[0].ToString() switch
+            {
+                "True" => "1",
+                "False" => "0",
+                null => string.Empty,
+                var x => x,
+            };
+
+            type = ptype.ToC();
+        }
+        else
+        {
+            throw new NotSupportedException($"Not Support {expr.CheckedType} Const");
+        }
+
+        symbol = new(type, str);
+        ExprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitVar(Var expr)
+    {
+        if (ExprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        if (expr.CheckedType is not TensorType { Shape: { IsScalar: true } } ttype)
+        {
+            throw new NotSupportedException();
+        }
+
+        symbol = new(ttype.DType.ToC(), new($"{expr.Name}_{expr.GlobalVarIndex}"));
+        ExprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitFor(For expr)
+    {
+        if (ExprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        // 1. For Loop signature
+        var loopVar = Visit(expr.LoopVar);
+        IndentScope.Writer.IndWrite($"for ({loopVar.Type} {loopVar.Name} = {Visit(expr.Domain.Start).Name}; {loopVar.Name} < {Visit(expr.Domain.Stop).Name}; {loopVar.Name}+={Visit(expr.Domain.Step).Name}) {{\n");
+        using (_ = new IndentScope())
+        {
+            // 2. For Body
+            Visit(expr.Body);
+        }
+        // 3. For closing
+        IndentScope.Writer.IndWrite("}\n");
+
+        symbol = new(string.Empty, string.Empty);
+        ExprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitSequential(Sequential expr)
+    {
+        if (ExprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        foreach (var field in expr.Fields)
+        {
+            if (field is Call call)
+            {
+                IndentScope.Writer.IndWrite(Visit(call).Name);
+                IndentScope.Writer.Write(";\n");
+            }
+            else
+            {
+                Visit(field);
+            }
+        }
+
+        symbol = new(string.Empty, string.Empty);
+        ExprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitIfThenElse(IfThenElse expr)
+    {
+        if (ExprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        IndentScope.Writer.IndWrite($"if({Visit(expr.Condition).Name}) {{\n");
+        using (var _ = new IndentScope())
+        {
+            Visit(expr.Then);
+        }
+
+        IndentScope.Writer.IndWrite("} else {\n");
+        using (var _ = new IndentScope())
+        {
+            Visit(expr.Else);
+        }
+
+        IndentScope.Writer.IndWrite("}\n");
+
+        symbol = new(string.Empty, string.Empty);
+        ExprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    protected override CSymbol VisitPhysicalBuffer(PhysicalBuffer expr)
+    {
+        if (ExprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        symbol = new(CSourceBuiltn.BufferType + "*", expr.Name);
+        ExprMemo.Add(expr, symbol);
+        return symbol;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
new file mode 100644
index 0000000000..63618df79e
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -0,0 +1,45 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+
+namespace Nncase.CodeGen.CPU;
+
+/// <summary>
+/// convert the type/op to c name.
+/// </summary>
+internal static class CSourceExtensions
+{
+    private static readonly Dictionary<PrimType, string> _primTypeToC = new()
+    {
+        { DataTypes.Boolean, "uint8_t" },
+        { DataTypes.Int8, "int8_t" },
+        { DataTypes.Int16, "int16_t" },
+        { DataTypes.Int32, "int32_t" },
+        { DataTypes.Int64, "int64_t" },
+        { DataTypes.UInt8, "uint8_t" },
+        { DataTypes.UInt16, "uint16_t" },
+        { DataTypes.UInt32, "uint32_t" },
+        { DataTypes.UInt64, "uint64_t" },
+        { DataTypes.Float32, "float" },
+        { DataTypes.Float64, "double" },
+    };
+
+    public static string ToC(this PrimType primType) =>
+        _primTypeToC[primType];
+
+    public static string ToC(this DataType dataType) => dataType switch
+    {
+        PrimType ptype => ptype.ToC(),
+        PointerType { ElemType: PrimType etype } => etype.ToC() + "*",
+        _ => throw new NotSupportedException(dataType.ToString()),
+    };
+
+    public static string ToC(this BinaryOp binaryOp) => binaryOp switch
+    {
+        BinaryOp.Add => "+",
+        BinaryOp.Sub => "-",
+        BinaryOp.Mul => "*",
+        BinaryOp.Div => "/",
+        _ => throw new NotSupportedException(binaryOp.ToString())
+    };
+}
\ No newline at end of file
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
new file mode 100644
index 0000000000..fbcf4e372d
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
@@ -0,0 +1,40 @@
+using Nncase.Diagnostics;
+using Nncase.IR.Math;
+namespace Nncase.CodeGen.CPU;
+
+internal static class CSourceUtilities
+{
+    public static string ContertBinary(Binary binary, CSymbol[] arguments)
+    {
+        var lhs = arguments[Binary.Lhs.Index].Name;
+        var rhs = arguments[Binary.Rhs.Index].Name;
+        string str;
+        switch (binary.BinaryOp)
+        {
+            case BinaryOp.Add or BinaryOp.Sub or BinaryOp.Mul or BinaryOp.Div:
+                str = ($"({lhs} {binary.BinaryOp.ToC()} {rhs})");
+                break;
+            default:
+                throw new NotSupportedException();
+        }
+
+        return str;
+    }
+
+    internal static string ContertUnary(Unary op, CSymbol[] arguments)
+    {
+        var input = arguments[Unary.Input.Index].Name;
+        string str;
+        switch (op.UnaryOp)
+        {
+            case UnaryOp.Neg:
+                str = ($"!{input}");
+                break;
+            default:
+                str = ($"nncase_mt->{op.UnaryOp.ToString()}{input}");
+                break;
+        }
+
+        return str;
+    }
+}
\ No newline at end of file
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceVisitor.cs
deleted file mode 100644
index 60453f1563..0000000000
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceVisitor.cs
+++ /dev/null
@@ -1,365 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Text;
-using NetFabric.Hyperlinq;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.Runtime;
-using Nncase.TIR;
-
-namespace Nncase.CodeGen;
-
-/// <summary>
-/// the c symbol define.
-/// </summary>
-internal struct CSymbol
-{
-    public string Type;
-    public StringBuilder Doc;
-
-    public CSymbol(string type, StringBuilder doc)
-    {
-        Type = type;
-        Doc = doc;
-    }
-
-    public override string ToString() => $"{Type} {Doc}";
-}
-
-/// <summary>
-/// convert the type/op to c name.
-/// </summary>
-internal static class NameConverter
-{
-    private static readonly Dictionary<PrimType, string> _primTypeToC = new()
-    {
-        { DataTypes.Boolean, "bool" },
-        { DataTypes.Int8, "int8_t" },
-        { DataTypes.Int16, "int16_t" },
-        { DataTypes.Int32, "int32_t" },
-        { DataTypes.Int64, "int64_t" },
-        { DataTypes.UInt8, "uint8_t" },
-        { DataTypes.UInt16, "uint16_t" },
-        { DataTypes.UInt32, "uint32_t" },
-        { DataTypes.UInt64, "uint64_t" },
-        { DataTypes.Float32, "float" },
-        { DataTypes.Float64, "double" },
-    };
-
-    public static string ToC(this PrimType primType) =>
-        _primTypeToC[primType];
-
-    public static string ToC(this DataType dataType) => dataType switch
-    {
-        PrimType ptype => ptype.ToC(),
-        PointerType { ElemType: PrimType etype } => etype.ToC() + "*",
-        _ => throw new NotSupportedException(dataType.ToString()),
-    };
-}
-
-/// <summary>
-/// collect the csymbol's parameter.
-/// </summary>
-internal class CSymbolParamList : IParameterList<CSymbol>, IEnumerable<CSymbol>
-{
-    private CSymbol[] _symbols;
-
-    public CSymbolParamList(CSymbol[] symbols)
-    {
-        this._symbols = symbols;
-    }
-
-    public CSymbol this[ParameterInfo parameter] => _symbols[parameter.Index];
-
-    public CSymbol this[int index] => _symbols[index];
-
-    public IEnumerator<CSymbol> GetEnumerator()
-    {
-        return ((IEnumerable<CSymbol>)_symbols).GetEnumerator();
-    }
-
-    IEnumerator IEnumerable.GetEnumerator()
-    {
-        return _symbols.GetEnumerator();
-    }
-}
-
-/// <summary>
-/// visitor for the build c source code, the expr vistor return (type string , name string).
-/// </summary>
-internal class CSourceHostBuildVisior : ExprFunctor<CSymbol, string>
-{
-    /// <summary>
-    /// source writer .
-    /// TODO we need the decl writer.
-    /// </summary>
-    private readonly ScopeWriter _scope;
-
-    /// <summary>
-    /// symbols name memo.
-    /// </summary>
-    private readonly Dictionary<Expr, CSymbol> _symbols = new(ReferenceEqualityComparer.Instance);
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="CSourceHostBuildVisior"/> class.
-    /// <see cref="CSourceHostBuildVisior"/>.
-    /// </summary>
-    /// <param name="textWriter">TextWriter.</param>
-    public CSourceHostBuildVisior(TextWriter textWriter)
-    {
-        _scope = new ScopeWriter(textWriter);
-
-        // insert some declare
-        _scope.IndWriteLine(@"
-#ifdef _WIN32
-#define EXPORT_API __declspec(dllexport)
-#else
-#define EXPORT_API
-#endif");
-        _scope.IndWriteLine("#include <stdint.h>");
-    }
-
-    /// <example>
-    /// void (*fun_ptr)(int).
-    /// </example>
-    public string CallableTypeToPtr(CallableType type, string name) => $"{VisitType(type.ReturnType)} (*{name}_ptr)({string.Join(",", type.Parameters.Select(VisitType))})";
-
-    /// <inheritdoc/>
-    public override string VisitType(TensorType type)
-    {
-        if (!type.IsScalar)
-        {
-            throw new NotSupportedException($"{type}");
-        }
-
-        return type.DType.ToC();
-    }
-
-    /// <inheritdoc/>
-    public override string VisitType(TupleType type) => type == TupleType.Void ? "void" : throw new InvalidProgramException($"The C Source Must Not Have TupleType {type}!");
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitCall(Call expr)
-    {
-        if (_symbols.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        var target = Visit(expr.Target);
-        var args = new CSymbolParamList(expr.Arguments.AsValueEnumerable().Select(Visit).ToArray());
-        var type = VisitType(expr.CheckedType!);
-        _scope.Push();
-        switch (expr.Target)
-        {
-            case IR.Math.Binary:
-                _scope.Append($"({args[0].Doc} {target.Doc} {args[1].Doc})");
-                break;
-            case Store:
-                _scope.Append($"{args[Store.Handle].Doc}[{args[Store.Index].Doc}] = {args[Store.Value].Doc}");
-                break;
-            case Load:
-                _scope.Append($"{args[Store.Handle].Doc}[{args[Store.Index].Doc}]");
-                break;
-            case IR.Tensors.Cast:
-                _scope.Append($"(({type}){args[IR.Tensors.Cast.Input].Doc})");
-                break;
-            default:
-                _scope.Append($"{target.Doc}({string.Join(", ", args.Select(x => x.Doc))})");
-                break;
-        }
-
-        symbol = new(type, _scope.Pop());
-        _symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitConst(Const expr)
-    {
-        if (_symbols.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        if (expr.CheckedType is TensorType ttype && ttype.IsScalar)
-        {
-            var literal = $"{expr}" switch
-            {
-                "True" => "1",
-                "False" => "0",
-                var x => x,
-            };
-            symbol = new(VisitType(ttype), new(literal));
-        }
-        else
-        {
-            throw new NotSupportedException($"Not Support {expr.CheckedType} Const");
-        }
-
-        _symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitPrimFunction(PrimFunction expr)
-    {
-        if (_symbols.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        var retType = VisitType(((CallableType)expr.CheckedType!).ReturnType);
-        _scope.Push();
-
-        // 1. Function signature
-        _scope.IndWrite($"EXPORT_API {retType} {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(Visit).ToArray())}) {{");
-
-        // 2. Function body
-        using (_scope.IndentUp())
-        {
-            _scope.Append(Visit(expr.Body).Doc);
-        }
-
-        // 3. Function closing
-        _scope.IndWrite("}");
-        symbol = new(CallableTypeToPtr((CallableType)expr.CheckedType!, expr.Name), _scope.Pop());
-
-        // 4. write whole code
-        _scope.IndWrite(symbol.Doc);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitOp(Op expr)
-    {
-        if (_symbols.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        symbol = new("Invalid Op", new(expr switch
-        {
-            IR.Math.Binary op => op.BinaryOp switch
-            {
-                BinaryOp.Add => "+",
-                BinaryOp.Sub => "-",
-                BinaryOp.Mul => "*",
-                BinaryOp.Div => "/",
-                BinaryOp.Mod => "%",
-                _ => throw new ArgumentOutOfRangeException(op.BinaryOp.ToString()),
-            },
-            TIR.Store op => "Store",
-            TIR.Load op => "Load",
-            IR.Tensors.Cast op => op.NewType.ToC(),
-            _ => throw new NotSupportedException($"{expr.GetType().Name}"),
-        }));
-        _symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitVar(Var expr)
-    {
-        if (_symbols.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        var isymbol = _scope.GetUniqueVarSymbol(expr);
-        symbol = new(VisitType(expr.CheckedType!), isymbol.Span);
-        _symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitFor(For expr)
-    {
-        if (_symbols.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        _scope.Push();
-
-        // 1. For Loop signature
-        var loopVar = Visit(expr.LoopVar);
-        _scope.Append($"for ({loopVar} = {Visit(expr.Domain.Start).Doc}; {loopVar.Doc} < {Visit(expr.Domain.Stop).Doc}; {loopVar.Doc}+={expr.Domain.Step}) {{");
-
-        // 2. For Body
-        _scope.Append(Visit(expr.Body).Doc);
-
-        // 3. For closing
-        _scope.IndWrite("}");
-        symbol = new(VisitType(expr.CheckedType!), _scope.Pop());
-        _symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitSequential(Sequential expr)
-    {
-        if (_symbols.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        _scope.Push();
-        _scope.AppendLine(string.Empty);
-        using (_scope.IndentUp())
-        {
-            foreach (var i in Enumerable.Range(0, expr.Count))
-            {
-                if (i == expr.Count - 1 &&
-                    expr.Fields[i].CheckedType is TensorType)
-                {
-                    _scope.IndWrite("return ");
-                }
-                else
-                {
-                    _scope.IndWrite(string.Empty);
-                }
-
-                _scope.Append(Visit(expr.Fields[i]).Doc);
-                if (expr.Fields[i] is Call)
-                {
-                    _scope.AppendLine(";");
-                }
-                else
-                {
-                    _scope.AppendLine(string.Empty);
-                }
-            }
-        }
-
-        symbol = new(VisitType(expr.CheckedType!), _scope.Pop());
-        _symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitIfThenElse(IfThenElse expr)
-    {
-        if (_symbols.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        _scope.Push();
-        _scope.Append($"if({Visit(expr.Condition).Doc}) {{");
-        _scope.Append(Visit(expr.Then).Doc);
-        _scope.IndWrite("} else {");
-        _scope.Append(Visit(expr.Else).Doc);
-        _scope.IndWrite("}");
-        symbol = new(VisitType(expr.CheckedType!), _scope.Pop());
-        _symbols.Add(expr, symbol);
-        return symbol;
-    }
-}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
index 854a8582b0..969fbcec47 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
@@ -19,43 +19,6 @@ internal class FunctionBuilder : IDisposable
     private readonly BinaryWriter _textWriter;
     private readonly BinaryWriter _rdataWriter;
 
-    /// <summary>
-    /// NOTE sync with the cpu runtime function.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    private struct MemoryRange
-    {
-        public uint Start;
-        public uint Size;
-    }
-
-    /// <summary>
-    /// NOTE sync with the cpu runtime function.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    private unsafe struct DescHeader
-    {
-        /// <summary>
-        /// input pool size.
-        /// </summary>
-        public uint InputPoolSize;
-
-        /// <summary>
-        /// output pool size.
-        /// </summary>
-        public uint OutputPoolSize;
-
-        /// <summary>
-        /// input numbers.
-        /// </summary>
-        public uint Inputs;
-
-        /// <summary>
-        /// output numbers.
-        /// </summary>
-        public uint Outputs;
-    }
-
     public FunctionBuilder(uint id, BinaryWriter rdataWriter)
     {
         _id = id;
@@ -65,39 +28,12 @@ public FunctionBuilder(uint id, BinaryWriter rdataWriter)
 
     public unsafe LinkableFunction Build(TIR.PrimFunction function)
     {
-        // 1. write the inst
-        // new InstSerializeVisitor(_textWriter).Visit(function.Body);
-
-        // 2. write the desc
-        var descContent = new MemoryStream();
-        using (var descWriter = new BinaryWriter(descContent, Encoding.UTF8))
-        {
-            DescHeader header = new() { InputPoolSize = 0, OutputPoolSize = 0, Inputs = 0, Outputs = 0 };
-            long headerStart = descWriter.Position();
-            descWriter.Skip((ulong)sizeof(DescHeader));
-
-            foreach (var input in function.Parameters.AsValueEnumerable()
-                                .Where(buf => buf.MemLocation == Schedule.MemoryLocation.Input))
-            {
-                header.Inputs++;
-                var rg = new MemoryRange { Start = checked((uint)input.Start), Size = checked((uint)input.Size) };
-                descWriter.Write(ref rg);
-                header.InputPoolSize = Math.Max(header.InputPoolSize, rg.Start + rg.Size);
-            }
-
-            foreach (var output in function.Parameters.AsValueEnumerable().Where(buf => buf.MemLocation == Schedule.MemoryLocation.Output))
-            {
-                header.Outputs++;
-                var rg = new MemoryRange { Start = checked((uint)output.Start), Size = checked((uint)output.Size) };
-                descWriter.Write(ref rg);
-                header.OutputPoolSize = Math.Max(header.OutputPoolSize, rg.Start + rg.Size);
-            }
-
-            descWriter.Position(headerStart);
-            descWriter.Write(ref header);
-        }
+        // 1. convert func to csource
+        var visitor = new CSourceConvertVisitor();
+        visitor.Visit(function);
+        var functionCSource = visitor.GetFunctionCSource();
 
-        // 3. write the rdata
+        // 2. write the rdata
         foreach (var buffer in function.SchedResult.Rdatas)
         {
             var bytes = buffer.Const!.Value.BytesBuffer;
@@ -110,7 +46,7 @@ public unsafe LinkableFunction Build(TIR.PrimFunction function)
             _rdataWriter.Write(bytes);
         }
 
-        return new LinkableFunction(_id, function, _textContent.ToArray(), descContent.ToArray());
+        return new LinkableFunction(_id, function, functionCSource);
     }
 
     public void Dispose()
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
new file mode 100644
index 0000000000..c3a1e15066
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -0,0 +1,149 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using Nncase.IR;
+using Nncase.Schedule;
+using Nncase.TIR;
+
+namespace Nncase.CodeGen;
+
+internal sealed class FunctionCSource
+{
+    public FunctionCSource(string declaration, string implementation)
+    {
+        Declaration = declaration;
+        Implementation = implementation;
+    }
+
+    public string Declaration { get; }
+    public string Implementation { get; }
+}
+
+
+/// <summary>
+/// the csource code compiler.
+/// </summary>
+public class CSourceCompiler
+{
+    /// <summary>
+    /// compiler exe name
+    /// </summary>
+    string _exe = "", _arch = "", _ext = "";
+
+    /// <summary>
+    /// select current pattern's exe
+    /// </summary>
+    /// <exception cref="NotSupportedException"></exception>
+    void PlatformSpecific()
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+        {
+            _exe = "gcc";
+            _ext = "so";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            _exe = "clang";
+            _ext = "dylib";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            _exe = "cmd";
+            _ext = "dll";
+        }
+    }
+
+    void ArchSpecific()
+    {
+        _arch = RuntimeInformation.OSArchitecture switch
+        {
+            Architecture.X64 => RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "x86-64" : "x86_64",
+            Architecture.Arm64 => "arm64",
+            _ => throw new NotSupportedException(RuntimeInformation.OSArchitecture.ToString()),
+        };
+    }
+
+    string ArgumentsSpecific(string sourcePath, string outPath)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+        {
+            return $"{sourcePath} -fPIC -shared -march={Arch} -o {outPath}";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            return $"{sourcePath} -fPIC -shared -arch {Arch} -o {outPath}";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            var vsdir = Environment.GetEnvironmentVariable("VSAPPIDDIR") ?? throw new InvalidOperationException("Cannot find vs");
+            var vcvardir = Path.Combine(vsdir, "..\\..\\VC\\Auxiliary\\Build\\vcvarsall.bat");
+            return $"/C (\"{vcvardir}\" x64) && (cl /D_USRDLL /D_WINDLL \"{sourcePath}\" /MT /link /DLL /OUT:\"{outPath}\")";
+        }
+        throw new System.ArgumentOutOfRangeException("Only Support Linux/Osx/Windows");
+    }
+
+    protected string Exe
+    {
+        get => _exe;
+    }
+
+    protected string Arch
+    {
+        get => _arch;
+    }
+
+    protected string Ext
+    {
+        get => _ext;
+    }
+
+    public CSourceCompiler()
+    {
+        PlatformSpecific();
+        ArchSpecific();
+    }
+
+    /// <summary>
+    /// compile the source txt, write to the out_path
+    /// </summary>
+    /// <param name="sourcePath"> c source code</param>
+    /// <param name="outPath"> out .so path </param>
+    /// <returns> outPath </returns>
+    public string Compile(string sourcePath, string outPath)
+    {
+        var errMsg = new StringBuilder();
+        using (var errWriter = new StringWriter(errMsg))
+        {
+            using (var proc = new Process())
+            {
+                proc.StartInfo.FileName = Exe;
+                proc.StartInfo.Arguments = ArgumentsSpecific(sourcePath, outPath);
+                proc.StartInfo.RedirectStandardError = true;
+                proc.ErrorDataReceived += (sender, e) => errWriter.WriteLine(e.Data);
+                proc.Start();
+                proc.BeginErrorReadLine();
+                proc.WaitForExit();
+                if (proc.ExitCode != 0)
+                {
+                    throw new InvalidOperationException(errMsg.ToString());
+                }
+            }
+        }
+        return outPath;
+    }
+
+    /// <summary>
+    /// create the temp dll file and compile source
+    /// <see cref="Compile(string, string)"/>
+    /// </summary>
+    public string Compile(string sourcePath) => Compile(sourcePath, CodeGenUtil.GetTempFileName(Ext));
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
index e92d1f5b4e..bd6dc4c270 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
@@ -9,19 +9,21 @@ internal sealed class LinkableFunction : ILinkableFunction
 {
     private readonly byte[] _desc;
 
-    public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, byte[] text, byte[] desc)
+    public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, FunctionCSource funcCSource)
     {
         Id = id;
         SourceFunction = sourceFunction;
-        Text = text;
-        _desc = desc;
-        Sections = new LinkedSection[] { new(_desc, ".desc", 0, 8, (uint)_desc.Length) };
+        FunctionCSource = funcCSource;
+        Text = Array.Empty<byte>();
+        Sections = new LinkedSection[] { };
     }
 
     public uint Id { get; }
 
     public BaseFunction SourceFunction { get; }
 
+    public FunctionCSource FunctionCSource { get; }
+
     public byte[] Text { get; }
 
     public IEnumerable<FunctionRef> FunctionRefs => Enumerable.Empty<FunctionRef>();
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index 53d8c79b18..8c8f5952a3 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Nncase.Diagnostics;
 using Nncase.Runtime.StackVM;
 
 namespace Nncase.CodeGen.CPU;
@@ -26,20 +27,54 @@ public LinkableModule(byte[] rdata, IReadOnlyList<LinkableFunction> functions)
 
     public ILinkedModule Link(ILinkContext linkContext)
     {
+        var csourcePath = LinkCSources();
+        var elfPath = CompileCSource(csourcePath);
+        var text = File.ReadAllBytes(elfPath);
+
+        if (DumpScope.Current.IsEnabled(DumpFlags.CodeGen))
+        {
+            using (var fs = DumpScope.Current.OpenFile("cpuModule.c"))
+            {
+                File.Open(csourcePath, FileMode.Open, FileAccess.Read).CopyTo(fs);
+            }
+        }
+
         var linkedFunctions = new List<LinkedFunction>();
-        var text = new MemoryStream();
-        using (var bw = new BinaryWriter(text, Encoding.UTF8, true))
+        foreach (var func in _functions)
         {
-            foreach (var func in _functions)
+            linkedFunctions.Add(new LinkedFunction(func.Id, func.SourceFunction, 0, 0, func.Sections));
+        }
+
+        return new LinkedModule(linkedFunctions, text, _rdata);
+    }
+
+    private string LinkCSources()
+    {
+        var path = Path.GetTempFileName();
+        using (var fs = File.OpenWrite(path))
+        {
+            using (var writer = new StreamWriter(fs))
             {
-                // FixFunctionRefs(func, linkContext);
-                bw.AlignPosition(_textAlignment);
-                var textBegin = bw.Position();
-                bw.Write(func.Text);
-                linkedFunctions.Add(new LinkedFunction(func.Id, func.SourceFunction, (uint)textBegin, (uint)func.Text.Length, func.Sections));
+                writer.WriteLine(CSourceBuiltn.Header);
+                foreach (var func in _functions)
+                {
+                    writer.WriteLine(func.FunctionCSource.Declaration);
+                }
+
+                foreach (var func in _functions)
+                {
+                    writer.WriteLine(func.FunctionCSource.Implementation);
+                }
             }
         }
 
-        return new LinkedModule(linkedFunctions, text.ToArray(), _rdata);
+        return path;
     }
+
+    private string CompileCSource(string sourcePath)
+    {
+        var compiler = new CSourceCompiler();
+        return compiler.Compile(sourcePath, Path.GetTempFileName());
+    }
+
 }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
index 4ad317298f..8a300e55bf 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
@@ -15,15 +15,12 @@ internal sealed class LinkedModule : ILinkedModule
     public LinkedModule(IReadOnlyList<ILinkedFunction> functions, byte[] text, byte[] rdata)
     {
         Functions = functions;
-        Sections = new[] {
-            new LinkedSection(text, ".text", 0, 8, (uint)text.Length),
-            new LinkedSection(rdata, ".rdata", 0, 8, (uint)rdata.Length),
-        };
+        Sections = new[] { new LinkedSection(text, ".text", 0, 8, (uint)text.Length) };
     }
 
-    public string ModuleKind => Runtime.CPU.CPURTModule.Kind;
+    public string ModuleKind => Targets.CPUTarget.Kind;
 
-    public uint Version => Runtime.CPU.CPURTModule.Version;
+    public uint Version => 0;
 
     public IReadOnlyList<ILinkedFunction> Functions { get; }
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
index 659a16dc9b..c68b7b16da 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
@@ -24,7 +24,7 @@ public ModuleBuilder(CompileOptions options)
     public CompileOptions CompileOptions { get; }
 
     /// <inheritdoc/>
-    public string ModuleKind => Runtime.CPU.CPURTModule.Kind;
+    public string ModuleKind => Targets.CPUTarget.Kind;
 
     /// <inheritdoc/>
     public ILinkableModule Build(IReadOnlyList<BaseFunction> functions)
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUKernelOp.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUKernelOp.cs
new file mode 100644
index 0000000000..fa18c5439c
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUKernelOp.cs
@@ -0,0 +1,34 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Linq;
+using Nncase.CostModel;
+using Nncase.IR;
+using Nncase.IR.CPU;
+
+namespace Nncase.Evaluator.CPU;
+
+/// <summary>
+/// Evaluator for <see cref="CPUKernelOp"/>.
+/// </summary>
+public class CPUKernelOpEvaluator : IEvaluator<CPUKernelOp>, ITypeInferencer<CPUKernelOp>, ICostEvaluator<CPUKernelOp>
+{
+    /// <inheritdoc/>
+    public IValue Visit(IEvaluateContext context, CPUKernelOp target)
+    {
+        return CompilerServices.EvaluateOp(target.Target, context);
+    }
+
+    /// <inheritdoc/>
+    public IRType Visit(ITypeInferenceContext context, CPUKernelOp target)
+    {
+        return CompilerServices.InferenceOp(target.Target, context, new());
+    }
+
+    /// <inheritdoc/>
+    public Cost Visit(ICostEvaluateContext context, CPUKernelOp target)
+    {
+        return CompilerServices.EvaluateOpCost(target.Target, context);
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
index 025c6e3b1b..aa01122091 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
@@ -13,6 +13,6 @@ internal class CPUModule : IApplicationPart
 {
     public void ConfigureServices(IRegistrator registrator)
     {
-        registrator.RegisterManyInterface<CPUUnaryEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<CPUKernelOpEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUUnary.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUUnary.cs
deleted file mode 100644
index d48a45b8e0..0000000000
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUUnary.cs
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Linq;
-using Nncase.CostModel;
-using Nncase.IR;
-using Nncase.IR.CPU;
-using OrtKISharp;
-
-namespace Nncase.Evaluator.CPU;
-
-/// <summary>
-/// Evaluator for <see cref="CPUUnary"/>.
-/// </summary>
-public class CPUUnaryEvaluator : IEvaluator<CPUUnary>, ITypeInferencer<CPUUnary>, ICostEvaluator<CPUUnary>, IOpPrinter<CPUUnary>
-{
-    /// <inheritdoc/>
-    public IValue Visit(IEvaluateContext context, CPUUnary unary)
-    {
-        var input_tensor = context.GetArgumentValueAsTensor(unary, CPUUnary.Input);
-        if (input_tensor.Shape.IsScalar)
-        {
-            if (input_tensor.ElementType == DataTypes.Int32)
-            {
-                return Value.FromTensor(Tensor.FromScalar<int>(Compute_int(input_tensor.ToScalar<int>(), unary.UnaryOp)));
-            }
-            else if (input_tensor.ElementType == DataTypes.Float32)
-            {
-                return Value.FromTensor(Tensor.FromScalar<float>(Compute_float(input_tensor.ToScalar<float>(), unary.UnaryOp)));
-            }
-        }
-
-        var input = context.GetOrtArgumentValue(unary, CPUUnary.Input);
-        var result = unary.UnaryOp switch
-        {
-            UnaryOp.Abs => OrtKI.Abs(input),
-            UnaryOp.Acos => OrtKI.Acos(input),
-            UnaryOp.Acosh => OrtKI.Acosh(input),
-            UnaryOp.Asin => OrtKI.Asin(input),
-            UnaryOp.Asinh => OrtKI.Asinh(input),
-            UnaryOp.Ceil => OrtKI.Ceil(input),
-            UnaryOp.Cos => OrtKI.Cos(input),
-            UnaryOp.Cosh => OrtKI.Cosh(input),
-            UnaryOp.Exp => OrtKI.Exp(input),
-            UnaryOp.Floor => OrtKI.Floor(input),
-            UnaryOp.Log => OrtKI.Log(input),
-            UnaryOp.Neg => OrtKI.Neg(input),
-            UnaryOp.Round => OrtKI.Round(input),
-            UnaryOp.Rsqrt => OrtKI.Rsqrt(input),
-            UnaryOp.Sin => OrtKI.Sin(input),
-            UnaryOp.Sinh => OrtKI.Sinh(input),
-            UnaryOp.Sign => OrtKI.Sign(input),
-            UnaryOp.Sqrt => OrtKI.Sqrt(input),
-            UnaryOp.Square => OrtKI.Square(input),
-            UnaryOp.Tanh => OrtKI.Tanh(input),
-            UnaryOp.BitwiseNot => throw new NotSupportedException("NotSupported UnaryOp BitwiseNot"),
-            UnaryOp.LogicalNot => OrtKI.Not(input),
-            _ => throw new ArgumentOutOfRangeException(nameof(unary)),
-        };
-        return result.ToValue();
-    }
-
-    /// <inheritdoc/>
-    public IRType Visit(ITypeInferenceContext context, CPUUnary target)
-    {
-        var input = context.CheckArgumentType<TensorType>(target, CPUUnary.Input);
-        return Visit(input);
-    }
-
-    /// <inheritdoc/>
-    public Cost Visit(ICostEvaluateContext context, CPUUnary target)
-    {
-        var inputType = context.GetArgumentType<TensorType>(target, CPUUnary.Input);
-        var outputType = context.GetReturnType<TensorType>();
-
-        return new()
-        {
-            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType),
-            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(outputType),
-            [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(outputType, CostUtility.GetCPUCyclesOfUnary(target.UnaryOp)),
-        };
-    }
-
-    /// <inheritdoc/>
-    public string Visit(IIRPrinterContext context, CPUUnary target, bool iLmode)
-    {
-        var op_str = target.UnaryOp switch
-        {
-            UnaryOp.BitwiseNot => "!",
-            UnaryOp.LogicalNot => "!",
-            var op => op.ToString(),
-        };
-        if (!iLmode)
-        {
-            return $"{op_str}({string.Join(", ", target.Parameters.Select(p => p.Name + ": " + context.GetArgument(target, p).Serialize()))})";
-        }
-
-        throw new NotSupportedException("ILmode = true");
-    }
-
-    private int Compute_int(int input, UnaryOp op) => op switch
-    {
-        UnaryOp.Ceil => input,
-        UnaryOp.Floor => input,
-        UnaryOp.Neg => -input,
-        UnaryOp.Abs => System.Math.Abs(input),
-        UnaryOp.Square => input * input,
-        _ => throw new ArgumentOutOfRangeException(nameof(op), $"NotSupported {nameof(op)} For Int"),
-    };
-
-    private float Compute_float(float input, UnaryOp op) => op switch
-    {
-        UnaryOp.Abs => System.MathF.Abs(input),
-        UnaryOp.Acos => System.MathF.Acos(input),
-        UnaryOp.Acosh => System.MathF.Acosh(input),
-        UnaryOp.Asin => System.MathF.Asin(input),
-        UnaryOp.Asinh => System.MathF.Asinh(input),
-        UnaryOp.Ceil => System.MathF.Ceiling(input),
-        UnaryOp.Cos => System.MathF.Cos(input),
-        UnaryOp.Cosh => System.MathF.Cosh(input),
-        UnaryOp.Exp => System.MathF.Exp(input),
-        UnaryOp.Floor => System.MathF.Floor(input),
-        UnaryOp.Log => System.MathF.Log(input),
-        UnaryOp.Neg => -input,
-        UnaryOp.Round => System.MathF.Round(input),
-        UnaryOp.Rsqrt => 1.0f / System.MathF.Sqrt(input),
-        UnaryOp.Sin => System.MathF.Sin(input),
-        UnaryOp.Sinh => System.MathF.Sinh(input),
-        UnaryOp.Sign => System.MathF.Sign(input),
-        UnaryOp.Sqrt => System.MathF.Sqrt(input),
-        UnaryOp.Square => input * input,
-        UnaryOp.Tanh => System.MathF.Tanh(input),
-        _ => throw new ArgumentOutOfRangeException(nameof(op), $"NotSupported {nameof(op)} For Float"),
-    };
-
-    private IRType Visit(TensorType input)
-    {
-        return input;
-    }
-}
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/CPUUnary.cs b/modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs
similarity index 69%
rename from modules/Nncase.Modules.CPU/IR/CPU/CPUUnary.cs
rename to modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs
index 44dbb59fd8..1113d70e55 100644
--- a/modules/Nncase.Modules.CPU/IR/CPU/CPUUnary.cs
+++ b/modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs
@@ -12,12 +12,12 @@
 namespace Nncase.IR.CPU;
 
 [PatternFunctionalGenerator]
-public sealed partial class CPUUnary : Op
+public sealed partial class CPUKernelOp : Op
 {
     /// <summary>
-    /// Gets input.
+    /// Gets the target.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(CPUUnary), 0, "input");
+    public Op Target { get; }
 
-    public UnaryOp UnaryOp { get; }
+    public override string DisplayProperty() => Target.GetType().Name;
 }
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
index 9fd63b63a6..52869d0153 100644
--- a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
@@ -14,13 +14,13 @@ namespace Nncase.IR.F;
 public partial class CPU
 {
     /// <summary>
-    /// Call unary.
+    /// Call cpu kernel.
     /// </summary>
-    /// <param name="unaryOp">Unary operator.</param>
-    /// <param name="expr">Source expression.</param>
+    /// <param name="target">Unary operator.</param>
+    /// <param name="inputs">Source inputs.</param>
     /// <returns>Result expression.</returns>
-    public static Call CPUUnary(UnaryOp unaryOp, Expr expr)
+    public static Call CPUKernel(Op target, params Expr[] inputs)
     {
-        return new Call(new CPUUnary(unaryOp), expr);
+        return new Call(new CPUKernelOp(target), inputs);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs b/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
index 5e1ff781b0..4afc56cb6f 100644
--- a/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
+++ b/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
-#if false
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -21,12 +20,10 @@ namespace Nncase.Passes;
 internal sealed class CPUFusionToTirPass : ModulePass
 {
     private readonly TileOptions _tileOptions;
-    private readonly Dictionary<Fusion, ulong> _fusionMacsMap;
 
     public CPUFusionToTirPass(TileOptions tileOptions)
     {
         _tileOptions = tileOptions;
-        _fusionMacsMap = new(ReferenceEqualityComparer.Instance);
     }
 
     private IAnalyzerManager AnalyzerManager => CompileSession.GetRequiredService<IAnalyzerManager>();
@@ -36,50 +33,21 @@ protected override Task<IRModule> RunCoreAsync(IRModule module, RunPassContext o
     {
         Dictionary<Fusion, BaseFunction> fusionConertedCache = new(ReferenceEqualityComparer.Instance);
 
-        // convert the fusion as entry.
-        // for (int i = 0; i < module.Functions.Count; i++)
-        // {
-        //     if (module.Functions[i] is Fusion { ModuleKind: CPUTarget.Kind } fusion)
-        //     {
-        //         TIR.PrimFunction primFunction;
-        //         var visitor = new MultiLayerFusionConverter(_tileOptions);
-        //         primFunction = visitor.VisitToPrimFunc(fusion);
-        //
-        //         CompilerServices.InferenceType(primFunction);
-        //         fusionConertedCache[fusion] = primFunction;
-        //         module.Replace(i, primFunction);
-        //     }
-        // }
-
-        // convert the stackvm function call k510 fusion
         for (int i = 0; i < module.Functions.Count; i++)
         {
-            if (module.Functions[i] is Function { ModuleKind: CPUTarget.Kind } func)
+            if (module.Functions[i] is Function { ModuleKind: string kind } func && kind == Callable.StackVMModuleKind)
             {
                 var analysis = new Dictionary<Type, IAnalysisResult> { [typeof(IExprUserAnalysisResult)] = AnalyzerManager.GetAnaylsis<IExprUserAnalysisResult>(func), };
                 var rewriter = new DataFlowMergeRewriter();
                 var fusionCheckCache = new Dictionary<Fusion, IFusionChecker>(ReferenceEqualityComparer.Instance);
 
-                // var post = (Function)rewriter.Rewrite(func, new Mutators.IMergeRewriteRule[] { new GNNESameInputFusionMergeRule(), }, (rule, option) => new CPUFusionGroupMutator<MultiFusionChecker>(fusionCheckCache, _tileOptions, rule, option), new() { AnalysisResults = analysis, MatchOptions = new Mutators.FusionGroupMutator.GroupedMatchOptions() });
-
-                // if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
-                // {
-                //     DumpScope.Current.DumpDotIR(post, "MultiLayer");
-                // }
-                // post = (Function)rewriter.Rewrite(
-                //    post,
-                //    new Mutators.IMergeRewriteRule[] {
-                //    new GNNESameInputFusionMergeRule(),
-                //  },
-                //    (rule, option) => new CPUFusionGroupMutator<TwoFusionChecker>(fusionCheckCache, _tileOptions, rule, option),
-                //    new() { AnalysisResults = analysis, MatchOptions = new Mutators.FusionGroupMutator.GroupedMatchOptions() });
+                var post = (Function)rewriter.Rewrite(
+                    func,
+                    new Mutators.IMergeRewriteRule[] { new CPUSameInputFusionMergeRule() }, 
+                    (rule, option) => new CPUFusionGroupMutator<MultiFusionChecker>(fusionCheckCache, _tileOptions, rule, option),
+                    new() { AnalysisResults = analysis, MatchOptions = new Mutators.FusionGroupMutator.GroupedMatchOptions() });
 
-                // if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
-                // {
-                //     DumpScope.Current.DumpDotIR(post, "TwoLayer");
-                // }
-                // var post = func;
-                var mutator = new CheckedConvertMutator(fusionConertedCache, _fusionMacsMap, fusionCheckCache, _tileOptions, options);
+                var mutator = new CheckedConvertMutator(fusionConertedCache, fusionCheckCache, _tileOptions, options);
                 var new_func = (Function)mutator.Rewrite(post);
                 CompilerServices.InferenceType(new_func);
                 if (mutator.IsMutated)
@@ -89,7 +57,6 @@ protected override Task<IRModule> RunCoreAsync(IRModule module, RunPassContext o
             }
         }
 
-        // add all prim func.
         foreach (var item in fusionConertedCache.Values)
         {
             if (item is PrimFunctionWrapper wrapper)
@@ -101,20 +68,4 @@ protected override Task<IRModule> RunCoreAsync(IRModule module, RunPassContext o
 
         return Task.FromResult(module);
     }
-
-    protected override async Task OnPassEndAsync(IRModule post, RunPassContext context)
-    {
-        await base.OnPassEndAsync(post, context);
-        if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
-        {
-            using var writer = new StreamWriter(DumpScope.Current.OpenFile("mac.csv"));
-            foreach (var (fusion, mac) in _fusionMacsMap)
-            {
-                writer.WriteLine($"mac: {fusion.Name},{mac}");
-            }
-        }
-
-        _fusionMacsMap.Clear();
-    }
 }
-#endif
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs b/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs
index bb77cc1354..f0cbd5a862 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs
@@ -28,6 +28,6 @@ public partial class LowerUnary : RewriteRule<Pattern>
 
     private Expr GetReplace(Unary unary, Expr input)
     {
-        return CPUUnary(unary.UnaryOp, input);
+        return CPUKernel(unary, input);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
index fb1bd25a22..d7644bf2b5 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
@@ -37,7 +37,7 @@ internal partial class CPUSingleInputFusion<T> : FusionMaker
     }
 }
 
-internal sealed class CPUUnaryFusion : CPUSingleInputFusion<CPUUnary>
+internal sealed class CPUFusion : CPUSingleInputFusion<CPUKernelOp>
 {
-    public override string Name => "Unary";
+    public override string Name => nameof(CPUFusion);
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionConverter.cs
deleted file mode 100644
index 2c85b4deca..0000000000
--- a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionConverter.cs
+++ /dev/null
@@ -1,148 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-#if true
-using System.Reactive;
-using System.Runtime.CompilerServices;
-using NetFabric.Hyperlinq;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.IR.Buffers;
-using Nncase.IR.CPU;
-using Nncase.IR.F;
-using Nncase.IR.Math;
-using Nncase.Passes.Mutators;
-using Nncase.PatternMatch;
-using Nncase.Schedule;
-using Nncase.Targets;
-using Nncase.TIR;
-using Nncase.TIR.Builders;
-using Buffer = Nncase.TIR.Buffer;
-using MathF = Nncase.IR.F.Math;
-using Range = Nncase.TIR.Range;
-using Tuple = Nncase.IR.Tuple;
-
-namespace Nncase.Passes.Tile;
-
-/// <summary>
-/// name 分配器.
-/// </summary>
-internal sealed class NameAllocator
-{
-    public Dictionary<string, int> NamePool { get; } = new();
-
-    public string Get(string name)
-    {
-        if (!NamePool.TryGetValue(name, out var count))
-        {
-            count = 0;
-        }
-
-        NamePool[name] = count + 1;
-        return count == 0 ? name : $"{name}_{count}";
-    }
-}
-
-internal class CPUFusionConverter
-{
-    public NameAllocator NameAllocator { get; } = new();
-
-    /// <summary>
-    /// Gets tile size 的变量.
-    /// </summary>
-    public List<Var> TileSizeVars { get; } = new();
-
-    /// <summary>
-    /// Gets loop 变量.
-    /// </summary>
-    // public List<Var> LoopVars { get; } = new();
-
-    /// <summary>
-    /// Gets loop domains.
-    /// </summary>
-    public List<Range> LoopDomains { get; } = new();
-
-    /// <summary>
-    /// Gets nested loops.
-    /// </summary>
-    // public List<ISequentialBuilder<For>> NestedLoops { get; } = new();
-
-    public TileOptions TileOptions { get; protected set; } = null!;
-
-    /// <summary>
-    /// Gets or sets 总的loop count.
-    /// </summary>/
-    public virtual Expr LoopCount { get; protected set; }
-
-    /// <summary>
-    /// Gets or sets ping pong 外层的tiling.
-    /// </summary>
-    public virtual Expr LoopCountOuter { get; protected set; }
-
-    /// <summary>
-    /// Gets or sets ping pong 内侧的tiling.
-    /// </summary>
-    public virtual Expr LoopCountInner { get; protected set; }
-
-    /// <summary>
-    /// Gets or sets 当前的fusion.
-    /// </summary>
-    public virtual Fusion CurrentFusion { get; protected set; }
-
-    public virtual PrimFunction BuildPrimFunc(Fusion fusion)
-    {
-        // TODO: buffer顺序可能需要调整以保持原图的顺序
-        var primFuncBuilder = T.PrimFunc(CurrentFusion.Name, CPUTarget.Kind, _ifBufferMap.Values.Union(_ofBufferMap.Values).Select(b => (PhysicalBuffer)b).ToArray());
-        return primFuncBuilder.Build();
-    }
-
-    public virtual Expr Visit(Expr root)
-    {
-        return root switch
-        {
-            Call call => (call.Target switch
-            {
-                CPUUnary op => LowerCPUUnary(call, op),
-                _ => throw new NotSupportedException(),
-            }).Build(),
-            _ => T.Nop(),
-        };
-    }
-
-    protected virtual ISequentialBuilder<Sequential> LowerCPUUnary(Call call, CPUUnary op)
-    {
-        var prefix = NameAllocator.Get(nameof(CPUUnary));
-        var inputCall = call[CPUUnary.Input];
-        T.PhysicalBuffer(inputCall.CheckedDataType, MemoryLocation.Input, inputCall.CheckedShape, out var ddrIf);
-        T.PhysicalBuffer(call.CheckedDataType, MemoryLocation.Output, call.CheckedShape.ToValueArray(), out var ddrOf);
-        _ifBufferMap.Add(call, ddrIf);
-        _ofBufferMap.Add(call, ddrOf);
-
-        List<Var> LoopVars = new();
-        List<ISequentialBuilder<For>> NestedLoops = new();
-        List<Range> LoopDomains = call.CheckedShape.Select(s => new Range(0, 1, s.FixedValue)).ToList();
-
-        var seq = T.Sequential().Body(Visit(inputCall));
-
-        for (int i = 0; i < call.CheckedShape.Rank; i++)
-        {
-            NestedLoops.Add(T.ForLoop(out var loopVar, LoopDomains[i], LoopMode.Unrolled, $"loop_var_{i}"));
-            LoopVars.Add(loopVar);
-        }
-
-        NestedLoops[^1].Body(
-            op.UnaryOp switch
-            {
-                // TODO: body的实现
-                UnaryOp.Abs => T.Nop(),
-                _ => throw new NotSupportedException(),
-            });
-
-        seq.Body(NestedLoops[0].Body());
-        return seq;
-    }
-
-    private readonly Dictionary<Expr, Buffer> _ifBufferMap = new(ReferenceEqualityComparer.Instance);
-    private readonly Dictionary<Expr, Buffer> _ofBufferMap = new(ReferenceEqualityComparer.Instance);
-}
-#endif
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
index 3cd7ab7c9d..d11af85bb5 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
@@ -1,6 +1,5 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
-#if false
 using System.Runtime.CompilerServices;
 using Nncase.IR;
 using Nncase.PatternMatch;
@@ -56,45 +55,38 @@ public CPUFusionGroupMutator(
     /// <inheritdoc/>
     public override bool MergedFusionCheckCallBack(Fusion mergedFusion, HashSet<Fusion> candidateFusions)
     {
-        // note the gnne activate must be first layer.
-        // if (mergedFusion.Body is Call { Target: IR.K510.GNNEStore } st_call &&
-        //   st_call[IR.K510.GNNEStore.Input] is Call { Target: IR.K510.GNNEActivation })
+
+        // var checker = (IFusionChecker)Activator.CreateInstance(typeof(T), new object[] { _tileOptions })!;
+        // var ret = checker.Check(mergedFusion, PassOptions);
+        // if (ret)
         // {
-        //     return false;
+        //     FusioncheckerCache.Add(mergedFusion, checker);
+        //     foreach (var cand in candidateFusions)
+        //     { // release the merged fusion.
+        //         FusioncheckerCache.Remove(cand);
+        //     }
         // }
 
-        var checker = (IFusionChecker)Activator.CreateInstance(typeof(T), new object[] { _tileOptions })!;
-        var ret = checker.Check(mergedFusion, PassOptions);
-        if (ret)
-        {
-            FusioncheckerCache.Add(mergedFusion, checker);
-            foreach (var cand in candidateFusions)
-            { // release the merged fusion.
-                FusioncheckerCache.Remove(cand);
-            }
-        }
-
-        return ret;
+        // return ret;
+        return false;
     }
 
     public override Expr MergedFusionRewriteCallBack(Expr mergedFusionBody)
     {
-        return CompilerServices.Rewrite(mergedFusionBody, new[] { new Rules.GNNE.Opt.FoldLoadStore() }, new());
+        return mergedFusionBody;
     }
 }
 
 internal sealed class CheckedConvertMutator : ExprRewriter
 {
     private readonly Dictionary<Fusion, BaseFunction> _fusionConertedCache;
-    private readonly IDictionary<Fusion, ulong> _fusionMacsMap;
     private readonly IReadOnlyDictionary<Fusion, IFusionChecker> _fusionCheckerCache;
     private readonly TileOptions _tileOptions;
     private readonly RunPassContext _passOptions;
 
-    public CheckedConvertMutator(Dictionary<Fusion, BaseFunction> fusion_converted_cache, Dictionary<Fusion, ulong> fusionMacsMap, IReadOnlyDictionary<Fusion, IFusionChecker> fusionchecker_cache, TileOptions tileOptions, RunPassContext passOptions)
+    public CheckedConvertMutator(Dictionary<Fusion, BaseFunction> fusion_converted_cache, IReadOnlyDictionary<Fusion, IFusionChecker> fusionchecker_cache, TileOptions tileOptions, RunPassContext passOptions)
     {
         _fusionConertedCache = fusion_converted_cache;
-        _fusionMacsMap = fusionMacsMap;
         _fusionCheckerCache = fusionchecker_cache;
         _tileOptions = tileOptions;
         _passOptions = passOptions;
@@ -114,23 +106,8 @@ protected override Expr RewriteLeafFusion(Fusion expr)
                 }
                 else
                 {
-                    // if (CompilerServices.TryMatchRoot(fusion, Conv2DFusionConverter.Conv2DFusionPattern, out var matchResult))
-                    // {
-                    //     prim_func = Conv2DFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
-                    // }
-                    // else if (CompilerServices.TryMatchRoot(fusion, Conv2DTransposeFusionConverter.Conv2DFusionPattern, out matchResult))
-                    // {
-                    //     prim_func = Conv2DTransposeFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
-                    // }
-                    // else if (!_tileOptions.ForceMultiLayer && CompilerServices.TryMatchRoot(fusion, LSTMFusionConverter.FusionPattern, out matchResult))
-                    // {
-                    //     prim_func = LSTMFusionConverter.VisitToPrimFunc(_tileOptions, fusion, matchResult, out _, out _);
-                    // }
-                    // else
-                    // {
-                    //     var visitor = new MultiLayerFusionConverter(_tileOptions);
-                    //     prim_func = visitor.VisitToPrimFunc(fusion);
-                    // }
+                    var converter = new SingleCPUFusionConverter();
+                    prim_func = converter.Visit(fusion);
                 }
 
                 BaseFunction? convert_func = prim_func;
@@ -153,7 +130,7 @@ protected override Expr RewriteLeafCall(Call expr)
                 int param_count = 0;
                 foreach (var b in prim_func.Parameters)
                 {
-                    if (b.MemLocation == Schedule.MemoryLocation.Input)
+                    if (b.MemLocation == TIR.MemoryLocation.Input)
                     {
                         if (is_input)
                         {
@@ -184,5 +161,3 @@ protected override Expr RewriteLeafCall(Call expr)
         return expr;
     }
 }
-
-#endif
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs
deleted file mode 100644
index f205692a57..0000000000
--- a/modules/Nncase.Modules.CPU/Passes/Tile/LayerFusionConverter.cs
+++ /dev/null
@@ -1,1264 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-#if false
-using System.Reactive;
-using System.Runtime.CompilerServices;
-using NetFabric.Hyperlinq;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.IR.Buffers;
-using Nncase.IR.F;
-using Nncase.IR.K510;
-using Nncase.IR.Math;
-using Nncase.Passes.BufferSchedule;
-using Nncase.Passes.Mutators;
-using Nncase.Runtime.K510;
-using Nncase.Schedule;
-using Nncase.TIR;
-using Nncase.TIR.Builders;
-using Nncase.TIR.K510;
-using Nncase.TIR.K510.Builders;
-using Nncase.TIR.K510.Instructions;
-using Buffer = Nncase.TIR.Buffer;
-using MathF = Nncase.IR.F.Math;
-using Range = Nncase.TIR.Range;
-using Tuple = Nncase.IR.Tuple;
-
-namespace Nncase.Passes.Tile;
-
-public sealed class BufferRegionView
-{
-    private Expr? _cache;
-
-    private Expr[]? _condtion_buffer_regions;
-
-    private Expr[]? _region_size;
-
-    public BufferRegionView(IEnumerable<Buffer> buffers, IEnumerable<Range> bounds, IEnumerable<Range> region, IndexMapKey key)
-        : this(buffers, bounds, region, key, 0, null)
-    {
-    }
-
-    public BufferRegionView(IEnumerable<Buffer> buffers, IEnumerable<Range> bounds, IEnumerable<Range> region, IndexMapKey key, Expr loopCount, int? promote)
-    {
-        Buffers = buffers.ToArray();
-        Region = region.ToArray();
-        LoopCount = loopCount;
-        Parent = null;
-        Key = key;
-        Promote = promote;
-        Bounds = bounds.ToArray();
-    }
-
-    public IndexMapKey Key { get; }
-
-    /// <summary>
-    /// Gets 记录他的loop count.
-    /// </summary>
-    public Expr LoopCount { get; }
-
-    public int? Promote { get; }
-
-    public IReadOnlyList<Range> Bounds { get; }
-
-    public IReadOnlyList<Buffer> Buffers { get; }
-
-    public IReadOnlyList<Range> Region { get; }
-
-    public BufferRegionView? Parent { get; set; }
-
-    public ReadOnlySpan<Expr> Dimensions => Buffers[0].Dimensions;
-
-    /// <summary>
-    /// Gets 返回带有condition的buffer region的表达式.
-    /// </summary>
-    public IReadOnlyList<Expr> BufferRegions
-    {
-        get
-        {
-            _condtion_buffer_regions ??= Buffers.Count == 0 ? Array.Empty<Expr>() : Buffers.Select(b => new BufferRegion(b, Region.ToArray())).ToArray();
-            return _condtion_buffer_regions;
-        }
-    }
-
-    public BufferRegionView this[params Range[] ranges]
-    {
-        get => new(Buffers, Bounds, Region.Zip(ranges).Select(tp => tp.Second.Equals(Range.All) ? tp.First : tp.Second.Stop switch { Call { Target: Unary { UnaryOp: UnaryOp.Neg } } => throw new NotSupportedException("Neg Region!"), _ => tp.Second, }), Key, LoopCount, Promote) { Parent = Parent is null ? this : Parent, }; // if stop is neg, add the shape, else return the origin range.
-    }
-
-    /// <summary>
-    /// convert the BufferRegionView to expr.
-    /// <remarks>
-    /// 当开启ping pong时,如果
-    /// </remarks>
-    /// </summary>
-    /// <param name="view">view.</param>
-    public static implicit operator Expr(BufferRegionView view)
-    {
-        if (view._cache is not null)
-        {
-            return view._cache;
-        }
-
-        Expr expr;
-        if (view.Buffers.Count == 0)
-        {
-            expr = IR.None.Default;
-        }
-        else if (view.Buffers.Count == 1)
-        {
-            expr = view.BufferRegions[0];
-        }
-        else if (view.Buffers.Count >= 2)
-        {
-            expr = new Tuple(view.BufferRegions.ToArray())[view.LoopCount % view.Buffers.Count];
-        }
-        else
-        {
-            throw new NotSupportedException();
-        }
-
-        view._cache = expr;
-        return view._cache;
-    }
-
-    public static BufferRegionView None(IndexMapKey key) => new(Array.Empty<Buffer>(), new IRArray<Range>(), new IRArray<Range>(), key);
-
-    public ReadOnlySpan<Expr> RegionSize()
-    {
-        _region_size ??= Region.AsValueEnumerable().Select(r => r.Stop - r.Start).ToArray();
-        return _region_size;
-    }
-
-    public Expr RegionSize(int i) => RegionSize()[i];
-}
-
-/// <summary>
-/// name 分配器.
-/// </summary>
-internal sealed class NameAllocator
-{
-    public Dictionary<string, int> NamePool { get; } = new();
-
-    public string Get(string name)
-    {
-        if (!NamePool.TryGetValue(name, out var count))
-        {
-            count = 0;
-        }
-
-        NamePool[name] = count + 1;
-        return count == 0 ? name : $"{name}_{count}";
-    }
-}
-
-/// <summary>
-/// buffer region view.
-/// </summary>
-internal sealed class LogiclPrimFuncCloner : ExprCloner<Unit>
-{
-    protected override Expr VisitLeafLogicalBuffer(LogicalBuffer buffer, Unit context)
-    {
-        return buffer;
-    }
-
-    protected override Expr VisitLeafPhysicalBuffer(PhysicalBuffer buffer, Unit context)
-    {
-        return buffer;
-    }
-
-    protected override Expr VisitVar(Var var, Unit context)
-    {
-        return var;
-    }
-}
-
-internal sealed record ReIndexCacheKey(IBoundsInferGraph BoundsInferGraph, IndexMapKey From, IndexMapKey To, IRArray<TIR.Range> FromRegion, int? Promote)
-{
-}
-
-internal abstract class LayerFusionConverter
-{
-    public NameAllocator NameAllocator { get; } = new();
-
-    /// <summary>
-    /// Gets map the graph expression and it's bufferRegion.
-    /// </summary>
-    public Dictionary<IndexMapKey, BufferRegionView> KeyToViewMap { get; } = new();
-
-    /// <summary>
-    /// Gets because of the index map can't create by var, so need other map save the relationship.
-    /// </summary>
-    public Dictionary<Var, IndexMapKey> VarToKeyMap { get; } = new(ReferenceEqualityComparer.Instance);
-
-    /// <summary>
-    /// Gets tile size 的变量.
-    /// </summary>
-    public List<Var> TileSizeVars { get; } = new();
-
-    /// <summary>
-    /// Gets loop 变量.
-    /// </summary>
-    public List<Var> LoopVars { get; } = new();
-
-    /// <summary>
-    /// Gets loop domains.
-    /// </summary>
-    public List<Range> LoopDomains { get; } = new();
-
-    /// <summary>
-    /// Gets 所有的blocks
-    /// 最终是:
-    /// mainBlock
-    ///   loop n
-    ///     block n
-    ///       loop c
-    ///         block c
-    ///          .
-    ///          .
-    /// </summary>
-    public List<ITileBlockBuilder> NestedBlocks { get; } = new();
-
-    /// <summary>
-    /// Gets nested loops.
-    /// </summary>
-    public List<ISequentialBuilder<For>> NestedLoops { get; } = new();
-
-    public TileOptions TileOptions { get; protected set; } = null!;
-
-    /// <summary>
-    /// Gets or sets 默认的bounds infer graph.
-    /// </summary>
-    public abstract IBoundsInferGraph BoundsInferGraph { get; protected set; }
-
-    /// <summary>
-    /// Gets or sets 总的loop count.
-    /// </summary>/
-    public abstract Expr LoopCount { get; protected set; }
-
-    /// <summary>
-    /// Gets or sets ping pong 外层的tiling.
-    /// </summary>
-    public abstract Expr LoopCountOuter { get; protected set; }
-
-    /// <summary>
-    /// Gets or sets ping pong 内侧的tiling.
-    /// </summary>
-    public abstract Expr LoopCountInner { get; protected set; }
-
-    /// <summary>
-    /// Gets or sets 当前的fusion.
-    /// </summary>
-    public abstract Fusion CurrentFusion { get; protected set; }
-
-    /// <summary>
-    /// Gets glb reindex cache.
-    /// </summary>
-    protected Dictionary<ReIndexCacheKey, (IRArray<TIR.Range> ToRegion, IReadOnlyList<(Expr Before, Expr After)> Paddings)> GlbReindexCache { get; } = new();
-
-    public abstract Expr Visit(Fusion fusion);
-
-    public virtual PrimFunction BuildLogicalPrimFunc(Expr bodySeq)
-    {
-        var inputs_buffer = CurrentFusion.Parameters.ToArray().Select(p => (PhysicalBuffer)KeyToViewMap[VarToKeyMap[p]].Buffers[0]);
-        var primFuncBuilder = T.PrimFunc(CurrentFusion.Name, K510RTModule.Kind, inputs_buffer.Concat(new[] { (PhysicalBuffer)KeyToViewMap[(Call)CurrentFusion.Body].Buffers[0] }).ToArray());
-
-        NestedBlocks[^1].Body(bodySeq);
-        primFuncBuilder.Body(
-          I.MmuConf(0, 0, MMU_CONF_WIDTH._8, 0, ExtCompilerServices.Env.GlbDepth), // 把整个glb当作连续内存使用.
-          NestedBlocks[0],
-          I.Fence());
-
-        var logicalPrimFunc = primFuncBuilder.Build();
-        logicalPrimFunc = (PrimFunction)new Mutators.SimplifyBounds().Rewrite(logicalPrimFunc);
-        logicalPrimFunc.InferenceType();
-        GlbReindexCache.Clear();
-        return logicalPrimFunc;
-    }
-
-    public abstract bool BalanceTileSize(int[] tile_size, Segment[] search_spaces);
-
-    public virtual PrimFunction BuildPhysicalPrimFunc(int[] final_tile_size, IReadOnlyDictionary<Buffer, PhysicalBuffer> sched_result, PrimFunction logicalPrimFunc)
-    {
-        var physicalizer = new BufferPhysicalizer(final_tile_size, sched_result, TileSizeVars);
-        var physicalPrimFunc = (PrimFunction)physicalizer.Rewrite(logicalPrimFunc);
-        return physicalPrimFunc;
-    }
-
-    public virtual int[] SearchTileSize(ISearchTileGenerator tile_generator, PrimFunction logicalPrimFunc, bool multi_workers, bool hasResult, out ScheduledResponse response)
-    {
-        AllocationCache<int[], ScheduledResponse> response_cache = new();
-        bool schedule_status = false;
-        int[] final_tile = Array.Empty<int>();
-
-        while (true)
-        {
-            var next_tile = tile_generator.GetNextTile(schedule_status).ToArray();
-            if (next_tile.Length == 0)
-            {
-                break;
-            }
-
-            schedule_status = TryScheduleNextTileSize(next_tile, logicalPrimFunc, response_cache, multi_workers, hasResult);
-            if (schedule_status)
-            {
-                final_tile = next_tile;
-                response_cache.CheckIn();
-            }
-        }
-
-        if (!final_tile.Any())
-        {
-            response = new(new Dictionary<TIR.Buffer, TIR.PhysicalBuffer>(), null!, null!, logicalPrimFunc, null!, 0, false);
-            return final_tile;
-        }
-
-        // take back last success allocation result
-        response = response_cache.GetLastSuccess(final_tile);
-        return final_tile;
-    }
-
-    public virtual Expr Visit(IndexMapKey mapKey, string prefix, int? promote = null)
-    {
-        prefix = prefix + mapKey.Prefix;
-        return mapKey.Expr switch
-        {
-            Call call => (call.Target switch
-            {
-                GNNELoad op => LowerGnneLoad(mapKey, call, op, NameAllocator.Get(nameof(GNNELoad)), prefix, promote, true),
-                GNNEStore op => LowerGnneStore(call, op, NameAllocator.Get(nameof(GNNEStore)), prefix),
-                GNNEConv2D op => LowerGnneConv2D(mapKey, call, op, NameAllocator.Get(nameof(GNNEConv2D)), prefix),
-                GNNEConv2DTranspose op => LowerGnneConv2DTranspose(mapKey, call, op, NameAllocator.Get(nameof(GNNEConv2D)), prefix),
-                GNNEReduce op => LowerGnneReduce(mapKey, call, op, NameAllocator.Get(nameof(GNNEReduce)), prefix),
-                GNNEMeshNet op => LowerGnneMeshNet(mapKey, call, op, NameAllocator.Get(nameof(GNNEMeshNet)), prefix),
-                GNNETranspose op => LowerGnneTranspose(mapKey, call, op, NameAllocator.Get(nameof(GNNETranspose)), prefix),
-                GNNEActivation op => LowerGnneActivation(mapKey, call, op, NameAllocator.Get(nameof(GNNEActivation)), prefix),
-                GNNEPdpReduce op => LowerGnnePdpReduce(mapKey, call, op, NameAllocator.Get(nameof(GNNEPdpReduce)), prefix),
-                GNNECrop op => LowerGnneCrop(mapKey, call, op, NameAllocator.Get(nameof(GNNECrop)), prefix),
-                Uninitialized => T.Sequential(),
-                _ => throw new NotSupportedException(),
-            }).Build(),
-            _ => T.Nop(),
-        };
-    }
-
-    /// <summary>
-    /// 子偏移输入到bounds infer后反推子偏移.
-    /// </summary>
-    /// <param name="from">from.</param>
-    /// <param name="to">to.</param>
-    /// <param name="sub_paddings">sub_paddings.</param>
-    /// <param name="partialFuncs">the partial compute funcs.</param>
-    /// <returns>.</returns>
-    public virtual BufferRegionView GlbReIndex(BufferRegionView from, BufferRegionView to, out IReadOnlyList<(Expr Before, Expr After)> sub_paddings, params (int Axis, Func<TIR.Range, TIR.Range> CallBack)[] partialFuncs)
-    {
-        var key = new ReIndexCacheKey(BoundsInferGraph, from.Key, to.Key, new(from.Region), to.Promote);
-        IReadOnlyList<Range> to_region;
-        if (partialFuncs.Length == 0 && GlbReindexCache.TryGetValue(key, out var result))
-        {
-            to_region = result.ToRegion;
-            sub_paddings = result.Paddings;
-        }
-        else
-        {
-            to_region = TileUtilities.GetRelativeNoPadBounds(BoundsInferGraph, from.Key, to.Key, from.Region, to.Promote, partialFuncs, out sub_paddings);
-            if (partialFuncs.Length == 0)
-            {
-                GlbReindexCache.Add(key, (new(to_region), sub_paddings));
-            }
-        }
-
-        return to[to_region.ToArray()];
-    }
-
-    protected virtual bool TryScheduleNextTileSize(int[] next_tile_size, PrimFunction logicalPrimFunc, AllocationCache<int[], ScheduledResponse> response_cache, bool multi_workers, bool hasResult)
-    {
-        // 1. make one tile feed dict
-        var feed_dict = next_tile_size.Select((s, i) =>
-                    new[] { (LoopVars[i], (IValue)Value.FromTensor(Tensor.FromScalar(0))),
-                     (TileSizeVars[i], (IValue)Value.FromTensor(Tensor.FromScalar(s))), }).
-                    SelectMany(i => i).
-                    ToDictionary(kv => kv.Item1, kv => kv.Item2);
-        var sched_candidate = new Dictionary<Buffer, PhysicalBuffer>(ReferenceEqualityComparer.Instance);
-
-        // 2. folding the tileblock op to the block
-        PrimFunction new_logical_primfunc;
-        using (var dumpScope = new DumpScope(NullDumpper.Instance))
-        {
-            var pass = new PrimFuncPass { Name = "FoldingTileBlock" };
-            pass.Add<RemoveFoldOfMakers>(feed_dict);
-            pass.Add<FoldCondition>();
-            pass.Add<FoldTileBlock>();
-            var task = pass.RunAsync(new LogiclPrimFuncCloner().Clone(logicalPrimFunc, default), new());
-            task.Wait();
-            new_logical_primfunc = task.Result;
-        }
-
-        BufferScheduler bufferScheduler = new(new_logical_primfunc);
-
-        // 3. clloction buffers
-        bufferScheduler.LifeTimeAnalysis();
-
-        // compute the size in bytes
-        foreach (var buffer in bufferScheduler.RecordBuffers)
-        {
-            var dimensions = buffer.Dimensions.ToArray().Select(d => d.Evaluate(feed_dict).AsTensor().ToScalar<int>()).ToArray();
-            var strides = TensorUtilities.GetStrides(dimensions);
-            var glb_strides = strides.Select(s => s * buffer.ElemType.SizeInBytes).ToArray();
-
-            if (bufferScheduler.InnerConstraints[buffer] == ConstraintsMode.Channel &&
-
-               // 当load psum的时候,如果shape过小, 那么不额外添加stride.
-               !(buffer.Name.Split(".").Last().StartsWith(GNNEConv2D.PSum.Name) &&
-                 dimensions[2] * dimensions[3] < 14 * 14))
-            {
-                glb_strides = TileUtilities.PaddingAvoidConflict(dimensions, glb_strides, 1);
-                strides = glb_strides.Select(s =>
-                {
-                    if (s % buffer.ElemType.SizeInBytes != 0)
-                    {
-                        throw new NotSupportedException();
-                    }
-
-                    return s / buffer.ElemType.SizeInBytes;
-                }).ToArray();
-            }
-
-            var size_n_byte = dimensions[0] * glb_strides[0];
-
-            // todo 可以不用align到一整行, 到一个bank即可.
-            var glb_size = TileUtilities.AlignBy(size_n_byte, ExtCompilerServices.Env.GlbBankWidth * ExtCompilerServices.Env.GlbWidth);
-            var physical_candidate = new PhysicalBuffer(buffer.Name, buffer.ElemType, buffer.MemLocation, dimensions, strides, start: 0, size: glb_size);
-            sched_candidate.Add(buffer, physical_candidate);
-        }
-
-        var respose = bufferScheduler.Schedule(sched_candidate, multi_workers, hasResult);
-        response_cache.Add(next_tile_size, respose);
-        return respose.Success;
-    }
-
-    /// <summary>
-    /// 申请 buffer.
-    /// NOTE 会自动添加到buffer map, 同时会记录他ddr 上的padding到字典中.
-    /// 如果给定 ddr buf region, 那么默认glb buffer region则是通过ddr buffer load 进来的,此时glb buffer的region是减去过padding的.
-    /// 如果promote到对应的循环后,那么申请buffer的时候在promote内部的循环都应该被调整到最大值.
-    /// </summary>
-    /// <param name="mapKey">mapKey.</param>
-    /// <param name="region">region.</param>
-    /// <param name="ping_pong">开启ping pong就会多开一块相同的buffer.</param>
-    /// <param name="promote"> 如果promote为int,那么就会提升buffer到指定循环, 为-1那么就是整个计算块, 会忽略ping pong. </param>
-    /// <param name="specificLoopBounds">specificLoopBounds.</param>
-    /// <param name="name">name.</param>
-    /// <returns>.</returns>
-    /// <exception cref="NotSupportedException">NotSupportedException.</exception>
-    /// <exception cref="System.ArgumentOutOfRangeException">System.ArgumentOutOfRangeException.</exception>
-    protected virtual Expr GetBufferRegion(IndexMapKey mapKey, out BufferRegionView region, bool ping_pong = false, int? promote = null, Dictionary<IndexMapKey, List<Range>>? specificLoopBounds = null, [CallerArgumentExpression("region")] string name = "region")
-    {
-        if (name.StartsWith("var "))
-        {
-            name = name[4..];
-        }
-
-        if (KeyToViewMap.ContainsKey(mapKey))
-        {
-            region = KeyToViewMap[mapKey];
-            return T.Nop();
-        }
-
-        name = NameAllocator.Get(name);
-        switch (mapKey.Expr)
-        {
-            case TensorConst con:
-                {
-                    IEnumerable<Range> bounds;
-                    IEnumerable<Range> clampedBounds;
-                    if (promote is int promoteInt)
-                    {
-                        if (promoteInt == -1)
-                        {
-                            clampedBounds = mapKey.Expr.CheckedShape.Select(s => new Range(0, s.FixedValue, 1));
-                            bounds = BoundsInferGraph[mapKey].Bounds;
-                        }
-                        else
-                        {
-                            if (specificLoopBounds is null || !specificLoopBounds.TryGetValue(mapKey, out var newBounds))
-                            {
-                                newBounds = K510TIRExtensions.PromotedBounds(promoteInt, BoundsInferGraph, mapKey, LoopVars, LoopDomains).ToList();
-                            }
-
-                            bounds = newBounds;
-                            clampedBounds = TIRUtilities.ClampBounds(newBounds, mapKey.Expr.CheckedShape);
-                        }
-                    }
-                    else
-                    {
-                        bounds = BoundsInferGraph[mapKey].Bounds;
-                        clampedBounds = BoundsInferGraph[mapKey].ClampedBounds;
-                    }
-
-                    T.ConstBuffer(con, out var ddr_buffer, name);
-                    if (ping_pong)
-                    {
-                        throw new NotSupportedException();
-                    }
-
-                    region = new BufferRegionView(new[] { ddr_buffer }, bounds, clampedBounds, mapKey);
-                    break;
-                }
-
-            case Call call:
-                {
-                    // 1. 对于glb buffer来说, 他的总大小要跟着申请buffer维度来变化.
-                    // note 实际上对于
-                    List<Range> bounds;
-                    Expr loopCount;
-                    if (promote is int promoteInt)
-                    {
-                        if (promoteInt == -1)
-                        {
-                            bounds = mapKey.Expr.CheckedShape.Select(s => new Range(0, s.FixedValue, 1)).ToList();
-                            loopCount = 0;
-                        }
-                        else
-                        {
-                            if (specificLoopBounds is null || !specificLoopBounds.TryGetValue(mapKey, out var newBounds))
-                            {
-                                newBounds = K510TIRExtensions.PromotedBounds(promoteInt, BoundsInferGraph, mapKey, LoopVars, LoopDomains).ToList();
-                            }
-
-                            bounds = newBounds;
-                            loopCount = K510TIRExtensions.PromotedLoopCount(promoteInt, LoopVars, LoopDomains);
-                        }
-                    }
-                    else
-                    {
-                        bounds = BoundsInferGraph[mapKey].Bounds.ToList();
-                        loopCount = LoopCount;
-                    }
-
-                    // note 这里的bounds实际上会因为输入不同的var而被改变, 所以后面要获取dimension的地方需要注意.
-                    var dimensions = bounds.Select(r => r.Stop - r.Start).Select((b, i) => MathF.Min(b, call.CheckedShape[i].FixedValue)).ToArray();
-                    List<Buffer> glb_buffers = new();
-                    if (ping_pong)
-                    {
-                        for (int i = 0; i < TileOptions.PingPongNum; i++)
-                        {
-                            glb_buffers.Add(new LogicalBuffer(name + $"(p{i})", call.CheckedDataType, MemoryLocation.L2Data, dimensions));
-                        }
-                    }
-                    else
-                    {
-                        glb_buffers.Add(new LogicalBuffer(name, call.CheckedDataType, MemoryLocation.L2Data, dimensions));
-                    }
-
-                    // 对于glb_buffer来说, 默认region 从0 开始, 但是要减去输入ddr index 的padding.
-                    var noPadBounds = TIRUtilities.ComputeNoPadBounds(bounds, TIRUtilities.ComputePaddings(bounds, mapKey.Expr.CheckedShape));
-                    region = new BufferRegionView(glb_buffers, bounds, noPadBounds, mapKey, loopCount, promote);
-                    break;
-                }
-
-            case Var v:
-                {
-                    // the different mapkey will point to same var: add(v,conv(v))
-                    if (!VarToKeyMap.TryGetValue(v, out var old_map_key))
-                    {
-                        T.PhysicalBuffer(v.CheckedDataType, MemoryLocation.Input, v.CheckedShape.ToValueArray(), out var ddr_buffer, name);
-                        IEnumerable<Range> clampedBounds;
-                        IReadOnlyList<Range> bounds;
-                        if (promote is int promoteInt)
-                        {
-                            if (promoteInt != -1)
-                            {
-                                if (specificLoopBounds is null || !specificLoopBounds.TryGetValue(mapKey, out var newBounds))
-                                {
-                                    newBounds = K510TIRExtensions.PromotedBounds(promoteInt, BoundsInferGraph, mapKey, LoopVars, LoopDomains).ToList();
-                                }
-
-                                bounds = newBounds;
-                            }
-                            else
-                            {
-                                bounds = mapKey.Expr.CheckedShape.Select(s => new Range(0, s.FixedValue, 1)).ToList();
-                            }
-
-                            clampedBounds = TIRUtilities.ClampBounds(bounds, mapKey.Expr.CheckedShape);
-                        }
-                        else
-                        {
-                            bounds = BoundsInferGraph[mapKey].Bounds;
-                            clampedBounds = BoundsInferGraph[mapKey].ClampedBounds;
-                        }
-
-                        if (ping_pong)
-                        {
-                            throw new NotSupportedException();
-                        }
-
-                        region = new BufferRegionView(new[] { ddr_buffer }, bounds, clampedBounds, mapKey);
-                        VarToKeyMap.Add(v, mapKey);
-                    }
-                    else
-                    {
-                        region = KeyToViewMap[old_map_key];
-                    }
-
-                    break;
-                }
-
-            case None none:
-                region = BufferRegionView.None(mapKey);
-                break;
-            default:
-                throw new NotSupportedException();
-        }
-
-        KeyToViewMap.Add(mapKey, region);
-        return T.Nop();
-    }
-
-    /// <summary>
-    /// promote 的逻辑, 根据值选择移动当前的buffer开在哪个循环.
-    /// -1 表示在所有循环之外
-    /// 0 表示在N循环内
-    /// 3 表示在W循环内.
-    ///
-    /// </summary>
-    /// <param name="parentKey">上一级传入的key.</param>
-    /// <param name="call">call.</param>
-    /// <param name="op">op.</param>
-    /// <param name="block_name">block_name.</param>
-    /// <param name="prefix">prefix.</param>
-    /// <param name="promote">promote.</param>
-    /// <param name="softPipeLine">is enable soft pipe line.</param>
-    /// <returns>.</returns>
-    protected virtual ISequentialBuilder<Sequential> LowerGnneLoad(IndexMapKey parentKey, Call call, GNNELoad op, string block_name, string prefix, int? promote, bool softPipeLine)
-    {
-        var call_input = IndexMapKey.Create(call, GNNELoad.Input);
-        var call_deq = IndexMapKey.Create(call, GNNELoad.DeqParams);
-
-        var seq = T.Sequential().Body(
-          Visit(call_deq, prefix, promote),
-          GetBufferRegion(call_input, out var ddr_ld_input, name: prefix + "." + TileNames.DdrInput, promote: promote), // loadif 的输入可能来自于const或输入
-          GetBufferRegion(call_deq, out var glb_ld_qarg_input), // 只有promote到n循环外时,才不进行ping pong.
-          GetBufferRegion(parentKey, out var glb_ld_output, promote == -1 ? false : TileOptions.PingPong, name: prefix, promote: promote)); // load if 要用的glb buffer
-
-        var block = EAction.TileBlock(block_name).
-          Alloc(promote is null ? glb_ld_output.Buffers : None.Default).
-          Reads(ddr_ld_input.BufferRegions, glb_ld_qarg_input.BufferRegions).
-          Writes(glb_ld_output.BufferRegions).
-          Predicate(true).// todo 这里先不做局部加载, 后面再实现
-          Body(// promote这里load用的是full region, 但是在字典中存的还应该是partial的, 因为后面是每个glb的tile在使用.
-            softPipeLine ?
-              (TileOptions.PingPong & (promote != -1) ? K510.PingPongSlot(block_name, glb_ld_output.LoopCount / TileOptions.PingPongNum, glb_ld_output.LoopCount % TileOptions.PingPongNum) : T.Nop()) :
-              T.Nop(),
-            EAction.LoadT(ddr_ld_input, glb_ld_output, glb_ld_qarg_input, op.DeqAxis));
-
-        if (promote is int promoteIndex)
-        {
-            // 如果promote, 那么在这个循环的所有block外执行
-            NestedBlocks[promoteIndex + 1].Init(block);
-            NestedBlocks[promoteIndex + 1].Alloc(glb_ld_output.Buffers);
-        }
-        else
-        {
-            seq.Body(block);
-        }
-
-        return seq;
-    }
-
-    protected virtual ISequentialBuilder<Sequential> LowerGnneMeshNet(IndexMapKey parentKey, Call call, GNNEMeshNet target, string block_name, string prefix)
-    {
-        prefix = NameAllocator.Get(nameof(GNNEMeshNet));
-        var call_in_a = IndexMapKey.Create(call, GNNEMeshNet.InputA);
-        var call_in_b = IndexMapKey.Create(call, GNNEMeshNet.InputB);
-        var call_in_seg0 = IndexMapKey.Create(call, GNNEMeshNet.SegFittingParam0);
-        var call_in_seg1 = IndexMapKey.Create(call, GNNEMeshNet.SegFittingParam1);
-        var seq = T.Sequential().Body(
-          Visit(call_in_a, prefix),
-          Visit(call_in_b, prefix),
-          GetBufferRegion(call_in_a, out var meshnet_input_a),
-          GetBufferRegion(call_in_b, out var meshnet_input_b),
-          GetBufferRegion(call_in_seg0, out var meshnet_input_seg0),
-          GetBufferRegion(call_in_seg1, out var meshnet_input_seg1),
-          GetBufferRegion(parentKey, out var meshnet_output, TileOptions.PingPong, name: prefix),
-          EAction.TileBlock(block_name).
-            Alloc(meshnet_output.Buffers).
-            Reads(
-                meshnet_input_a.BufferRegions,
-                meshnet_input_b.BufferRegions,
-                meshnet_input_seg0.BufferRegions,
-                meshnet_input_seg1.BufferRegions).
-            Body(
-              EAction.MeshNetCompute(
-                  (Fusion)call[GNNEMeshNet.MeshFunc],
-                  meshnet_input_a,
-                  meshnet_input_b,
-                  meshnet_input_seg0,
-                  meshnet_input_seg1,
-                  meshnet_output)));
-
-        if (!(call[GNNEMeshNet.InputB] is None && call[GNNEMeshNet.NewShape] is None && call[GNNEMeshNet.SegFittingParam0] is None && call[GNNEMeshNet.SegFittingParam1] is None && !TileUtilities.MeshFuncHasConstants((Fusion)call[GNNEMeshNet.MeshFunc])))
-        {
-            foreach (var item in meshnet_output.Buffers)
-            {
-                item.Metadata = new TileMetadata() { StrideByShape = true };
-            }
-        }
-
-        return seq;
-    }
-
-    protected virtual ISequentialBuilder<Sequential> LowerGnneStore(Call call, GNNEStore op, string block_name, string prefix, bool promoteQarg = true)
-    {
-        prefix = NameAllocator.Get(nameof(GNNEStore));
-        var cropPadding = ((TensorConst)call[GNNEStore.CropPadding]).Value.Cast<int>();
-        var channel = call.CheckedShape[1].FixedValue;
-        bool is_quant_by_channel = false;
-        if (call[GNNEStore.QuantParams] is Call { Target: GNNELoad } l_qarg && l_qarg[GNNELoad.Input] is TensorConst qarg)
-        {
-            _ = qarg.Value.Cast<QuantizeParam>();
-            if (qarg[0] != qarg[channel - 1])
-            {
-                is_quant_by_channel = true;
-            }
-        }
-
-        var outputShape = call.CheckedShape.ToValueArray();
-        T.PhysicalBuffer(call.CheckedDataType, MemoryLocation.Output, outputShape, out var ddr_st_buffer, name: prefix + ".ddr_buffer");
-        var bounds = BoundsInferGraph[call].Bounds;
-
-        var (paddingHBefore, paddingHafter) = TileUtilities.ComputePadding(bounds[2] - cropPadding[0, 0], outputShape[2]);
-        var (paddingWBefore, paddingWafter) = TileUtilities.ComputePadding(bounds[3] - cropPadding[1, 0], outputShape[3]);
-
-        var newBounds = bounds.ToArray();
-        newBounds[2] = newBounds[2] - cropPadding[0, 0];
-        newBounds[3] = newBounds[3] - cropPadding[1, 0];
-        var ddrRegion = TIRUtilities.ClampBounds(newBounds, outputShape);
-        var ddr_st_output = new BufferRegionView(new[] { ddr_st_buffer }, BoundsInferGraph[call].Bounds, ddrRegion, call);
-        KeyToViewMap.Add(call, ddr_st_output);
-
-        var call_in = IndexMapKey.Create(call, GNNEStore.Input);
-        var call_qarg = IndexMapKey.Create(call, GNNEStore.QuantParams);
-        return T.Sequential().Body(
-          Visit(call_in, prefix),
-          Visit(call_qarg, prefix, promoteQarg ? -1 : null), // 多层是只按h切, 此时oc满的,默认promote.
-          GetBufferRegion(call_in, out var glb_st_input),
-          GetBufferRegion(call_qarg, out var glb_st_qarg_input),
-          EAction.TileBlock(block_name).Reads(glb_st_input.BufferRegions, glb_st_qarg_input.BufferRegions).Body(
-            EAction.StoreT(ddr_st_output, glb_st_input[.., .., (glb_st_input.Region[2].Start + paddingHBefore, glb_st_input.Region[2].Stop - paddingHafter), (glb_st_input.Region[3].Start + paddingWBefore, glb_st_input.Region[3].Stop - paddingWafter)], glb_st_qarg_input, null, is_quant_by_channel)));
-    }
-
-    protected virtual ISequentialBuilder<Sequential> LowerGnneReduce(IndexMapKey parentKey, Call call, GNNEReduce op, string block_name, string prefix)
-    {
-        prefix = NameAllocator.Get(nameof(GNNEReduce));
-        var reduce_in = IndexMapKey.Create(call, GNNEReduce.Input);
-        var seq = T.Sequential().Body(
-          Visit(reduce_in, prefix),
-          GetBufferRegion(reduce_in, out var gnne_reduce_input),
-          GetBufferRegion(parentKey, out var gnne_reduce_output, TileOptions.PingPong, name: prefix),
-          EAction.TileBlock(block_name).
-            Alloc(gnne_reduce_output.Buffers).
-            Reads(gnne_reduce_input.BufferRegions).Body(
-              EAction.Reduce(
-                gnne_reduce_input,
-                gnne_reduce_output,
-                call[GNNEReduce.InitValue],
-                op.ReduceOp,
-                op.ReduceDim)));
-
-        return seq;
-    }
-
-    /// <summary>
-    /// 对于dw卷积来说,每个ic对应一个oc, 因此让每个tcu计算一半的if.
-    /// </summary>
-    protected ITileBlockBuilder GNNEConv2DSharedNone(Call call, string block_name, BufferRegionView glb_w, BufferRegionView glb_if, BufferRegionView glb_act, BufferRegionView glb_psum, BufferRegionView glb_of, bool is_init_psum, string prefix, int? promote = null)
-    {
-        var init_psums = GetInitPSumBufferRegion(call, IndexMapKey.Create(call, GNNEConv2D.PSum), glb_psum, promote, prefix, 1, ExtCompilerServices.Env.TcuActNum, out var part_condition);
-
-        var block = EAction.TileBlock(block_name).Reads(glb_w.BufferRegions, is_init_psum ? init_psums[0].BufferRegions.Concat(init_psums[1].BufferRegions.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : glb_psum.BufferRegions, glb_if.BufferRegions, glb_act.BufferRegions).Writes(glb_of.BufferRegions).Body(
-          T.Unrolled(out var kh, new(0, glb_w.Dimensions[2], ExtCompilerServices.Env.PuHeight)).Body(
-            T.Unrolled(out var kw, new(0, glb_w.Dimensions[3], ExtCompilerServices.Env.PuKernelSpad)).Body(
-              T.Let(out var m_once, 1).Body(
-              T.Let(out var c_once, MathF.Select(MathF.Equal(m_once, glb_w.RegionSize(0)), MathF.Min(MathF.Min(ExtCompilerServices.Env.PuWidth / m_once, ExtCompilerServices.Env.PuHeight / MathF.Min(glb_w.Dimensions[2], ExtCompilerServices.Env.PuHeight)), glb_w.RegionSize(0)), 1)).Body(// note 我这里没有实现dw卷积的多输出channel的, 默认都是 1 ic : 1 oc.
-                T.Let(out var tcu_oc_chunk, TileUtilities.Split(glb_of.RegionSize(1), ExtCompilerServices.Env.TcuActNum)).Body(// 1. determine tcu act num
-                T.Let(out var n_active_tcu, TileUtilities.SplitTimes(glb_of.RegionSize(1), tcu_oc_chunk)).Body(// 2. broadcast action
-                  EAction.TcuDmBroadCast(TcuDivideStrategy.NoShare),
-                  T.Unrolled(out var tcu_oc, new(glb_of.Region[1].Start, glb_of.Region[1].Stop, tcu_oc_chunk)).Body(// 3. loop over tcus and config each tcu
-                    T.Let(out var m_once_tcu, 1).Body(
-                    T.Let(out var c_once_tcu, MathF.Min(ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2), MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc)).Body(
-                      EAction.TcuPuConfAct(
-                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
-                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_act, out _),
-                        call[GNNEConv2D.FusedClamp][0],
-                        call[GNNEConv2D.FusedClamp][1]),
-                      EAction.TcuPuConf(
-                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
-                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_if, out _),
-                        glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..],
-                        IR.F.Math.Min(glb_w.Dimensions[2], ExtCompilerServices.Env.PuHeight),
-                        IR.F.Math.Min(glb_w.Dimensions[3], ExtCompilerServices.Env.PuKernelSpad),
-                        m_once: m_once_tcu,
-                        c_once: c_once_tcu,
-                        groups: 1,
-                        mode: TcuComputeMode.DwConv2d),
-                      EAction.TcuDmConfOf(// todo 这里hardcode两个tcu, 后面需要改进
-                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
-                        is_init_psum ? MathF.Select(MathF.Equal(tcu_oc, glb_of.Region[1].Start), init_psums[0][.., (0, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc), .., ..], init_psums[1][.., (0, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc), .., ..]) : GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_psum, out _),
-                        glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..],
-                        0),
-                      EAction.TcuDmConfIf(
-                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
-                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_if, out var if_paddings),
-                        stride_w: call[GNNEConv2D.Stride][1],
-                        stride_h: call[GNNEConv2D.Stride][0],
-                        input_c_pre_pu: c_once_tcu,
-                        dilation_h: call[GNNEConv2D.Dilation][0],
-                        padding_top: if_paddings[2].Before,
-                        padding_bottom: if_paddings[2].After,
-                        padding_left: if_paddings[3].Before,
-                        padding_right: if_paddings[3].After),
-                      EAction.TcuDmConfW(
-                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
-                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_w, out _)),
-                      EAction.TcuDmFetchW(// 4. fetch weights
-                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
-                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_w, out _)),
-                      EAction.TcuDmFetchIf(// 5. loop over tcus and fetch if for each tcu
-                        TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
-                        GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_if, out _))))),
-                  EAction.TcuPuCompute(// 6. pu compute   NOTE 这里我没有在weight的kh和kw上切,所以默认都是一次算完的
-                    TileUtilities.GetNTcuIndexBits(n_active_tcu),
-                    true,
-                    true,
-                    call[GNNEConv2D.PSum] is not Call { Target: Uninitialized },
-                    TileUtilities.GetNTcuIndexBits(n_active_tcu)))))))));
-
-        if (promote is null)
-        {
-            block.Alloc(glb_of.Buffers, is_init_psum ? init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : None.Default);
-        }
-        else if (promote is int promoteIndex)
-        {
-            if (is_init_psum)
-            {
-                NestedBlocks[promoteIndex + 1].Alloc(init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray());
-            }
-        }
-
-        return block;
-    }
-
-    protected virtual BufferRegionView[] GetInitPSumBufferRegion(Call call, IndexMapKey key, BufferRegionView glb_psum, int? promote, string prefix, int split_axis, int tcuActNum, out Expr part_condition)
-    {
-        var chunk = TileUtilities.Split(glb_psum.Dimensions[split_axis], tcuActNum);
-        part_condition = TileUtilities.SplitTimes(glb_psum.Dimensions[split_axis], chunk);
-        var views = new BufferRegionView[2];
-        var psum_dimensions = glb_psum.Dimensions.ToArray();
-        psum_dimensions[split_axis] = chunk;
-        var dimensions = psum_dimensions;
-
-        // build psum a and b
-        foreach (var (part, i) in new[] { "_a", "_b" }.Select((p, i) => (p, i)))
-        {
-            var name = prefix + "." + TileNames.InitPSum + part;
-            var glb_init_psums = new List<Buffer>();
-            if (TileOptions.PingPong)
-            {
-                for (int p = 0; p < TileOptions.PingPongNum; p++)
-                {
-                    glb_init_psums.Add(new LogicalBuffer(name + $"(p{p})", DataTypes.Float32, MemoryLocation.L2Data, dimensions));
-                }
-            }
-            else
-            {
-                glb_init_psums.Add(new LogicalBuffer(name, DataTypes.Float32, MemoryLocation.L2Data, dimensions));
-            }
-
-            Expr loopCount;
-            if (promote is int promoteInt)
-            {
-                if (promoteInt != -1)
-                {
-                    loopCount = K510TIRExtensions.PromotedLoopCount(promoteInt, LoopVars, LoopDomains);
-                }
-                else
-                {
-                    loopCount = LoopCount;
-                }
-            }
-            else
-            {
-                loopCount = LoopCount;
-            }
-
-            views[i] = new BufferRegionView(glb_init_psums, glb_psum.Bounds, psum_dimensions.Select(d => new Range(0, d, 1)), key, loopCount, promote);
-        }
-
-        return views;
-    }
-
-    protected virtual Expr GNNEConv2DComputeActEnable(Call call, BufferRegionView glb_w, Expr khStop, Expr kHBounds, Expr kwStop, Expr kWBounds)
-    {
-        return MathF.LogicalAnd(MathF.GreaterEqual(khStop, kHBounds), MathF.GreaterEqual(kwStop, kWBounds));
-    }
-
-    protected virtual Expr GNNEConv2DComputeOfEnable(Call call, BufferRegionView glb_w, Expr khStop, Expr kHBounds, Expr kwStop, Expr kWBounds)
-    {
-        return GNNEConv2DComputeActEnable(call, glb_w, khStop, kHBounds, kwStop, kWBounds);
-    }
-
-    protected virtual Expr GNNEConv2DComputeLoadPsumEnable(Call call, BufferRegionView glb_w, Expr kh, Expr kw)
-    {
-        if (call[IR.K510.GNNEConv2D.PSum] is Call { Target: IR.Buffers.Uninitialized })
-        {
-            return IR.F.Math.LogicalNot(IR.F.Math.LogicalAnd(IR.F.Math.Equal(kh, 0), IR.F.Math.Equal(kw, 0)));
-        }
-
-        return true;
-    }
-
-    /// <summary>
-    /// share if 是每个tcu计算一半的oc, 此时他们共享同一个if.
-    /// </summary>
-    protected ITileBlockBuilder GNNEConv2DSharedIF(Call call, string block_name, BufferRegionView glb_w, BufferRegionView glb_if, BufferRegionView glb_act, BufferRegionView glb_psum, BufferRegionView glb_of, bool is_init_psum, string prefix, int? promote = null)
-    {
-        var reGlbIf = GlbReIndex(glb_of, glb_if, out var sub_paddings);
-
-        var init_psums = GetInitPSumBufferRegion(call, IndexMapKey.Create(call, GNNEConv2D.PSum), glb_psum, promote, prefix, 1, ExtCompilerServices.Env.TcuActNum, out var part_condition);
-
-        var block = EAction.TileBlock(block_name).Reads(glb_w.BufferRegions, is_init_psum ? init_psums[0].BufferRegions.Concat(init_psums[1].BufferRegions.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : glb_psum.BufferRegions, glb_if.BufferRegions, glb_act.BufferRegions).Body(
-          T.Let(out var khChunck, MathF.Min(glb_w.Dimensions[2], ExtCompilerServices.Env.PuHeight)).Body(
-          T.Let(out var kwChunck, MathF.Min(glb_w.Dimensions[3], ExtCompilerServices.Env.PuKernelSpad)).Body(
-          T.Unrolled(out var kh, new(0, glb_w.Dimensions[2], khChunck)).Body(// 对kernel h/w进行tiling 暂时先不考虑
-          T.Unrolled(out var kw, new(0, glb_w.Dimensions[3], kwChunck)).Body(
-              T.Let(out var tcu_oc_chunk, TileUtilities.Split(glb_of.RegionSize(1), ExtCompilerServices.Env.TcuActNum)).Body(// 1. determine tcu act num
-              T.Let(out var n_active_tcu, TileUtilities.SplitTimes(glb_of.RegionSize(1), tcu_oc_chunk)).Body(
-                  T.If(MathF.Equal(n_active_tcu, 1)).Then(// 3. broadcast action
-                  EAction.TcuDmBroadCast(TcuDivideStrategy.NoShare)).Else(
-                  EAction.TcuDmBroadCast(TcuDivideStrategy.ShareIf)),
-                  EAction.TcuDmConfIf(// 4. conf if
-                  TileUtilities.GetNTcuIndexBits(n_active_tcu),
-                  reGlbIf,
-                  stride_w: call[GNNEConv2D.Stride][1],
-                  stride_h: call[GNNEConv2D.Stride][0],
-                  input_c_pre_pu: MathF.Min(ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2), glb_if.RegionSize(1)), // todo 这里可能有问题.
-                  dilation_h: call[GNNEConv2D.Dilation][0],
-                  padding_top: sub_paddings[2].Before,
-                  padding_bottom: sub_paddings[2].After,
-                  padding_left: sub_paddings[3].Before,
-                  padding_right: sub_paddings[3].After),
-                  T.Unrolled(out var tcu_oc, new(glb_of.Region[1].Start, glb_of.Region[1].Stop, tcu_oc_chunk)).Body(// 5. loop over tcus and config each tcu
-                  EAction.TcuPuConfAct(
-                    TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
-                    GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_act, out _),
-                    call[GNNEConv2D.FusedClamp][0],
-                    call[GNNEConv2D.FusedClamp][1]),
-                  EAction.TcuPuConf(
-                    TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
-                    reGlbIf, // 切oc对于if不影响
-                    glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..],
-                    khChunck,
-                    kwChunck,
-                    m_once: MathF.Min(ExtCompilerServices.Env.PuWidth, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc),
-                    c_once: MathF.Min(MathF.Min(ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2), glb_w.RegionSize(1)), glb_if.RegionSize(1)),
-                    groups: call[GNNEConv2D.Groups],
-                    mode: TcuComputeMode.NormalConv2d),
-                  EAction.TcuDmConfOf(// todo 这里hardcode两个tcu, 后面需要改进
-                    TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
-                    is_init_psum ? MathF.Select(MathF.Equal(tcu_oc, glb_of.Region[1].Start), init_psums[0][.., (0, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc), .., ..], init_psums[1][.., (0, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop) - tcu_oc), .., ..]) : GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_psum, out _),
-                    glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..],
-                    0),
-                  EAction.TcuDmConfW(
-                    TileUtilities.GetTcuIndexBits(tcu_oc / tcu_oc_chunk),
-                    GlbReIndex(glb_of[.., (tcu_oc, MathF.Min(tcu_oc + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_w, out _))),
-                  T.Unrolled(out var tcu_oc2, new(glb_of.Region[1].Start, glb_of.Region[1].Stop, tcu_oc_chunk)).Body(
-                    EAction.TcuDmFetchW(// 6. fetch weights.
-                      TileUtilities.GetTcuIndexBits(tcu_oc2 / tcu_oc_chunk),
-                      GlbReIndex(glb_of[.., (tcu_oc2, MathF.Min(tcu_oc2 + tcu_oc_chunk, glb_of.Region[1].Stop)), .., ..], glb_w, out _))),
-                  EAction.TcuDmFetchIf(// 7. fetch if.
-                      TileUtilities.GetNTcuIndexBits(n_active_tcu),
-                      reGlbIf),
-                  EAction.TcuPuCompute(// 8. tcu compute
-                      TileUtilities.GetNTcuIndexBits(n_active_tcu),
-                      act_enable: GNNEConv2DComputeActEnable(call, glb_w, kh + khChunck, glb_w.Dimensions[2], kw + kwChunck, glb_w.Dimensions[3]),
-                      of_enable: GNNEConv2DComputeOfEnable(call, glb_w, kh + khChunck, glb_w.Dimensions[2], kw + kwChunck, glb_w.Dimensions[3]),
-                      load_psum: GNNEConv2DComputeLoadPsumEnable(call, glb_w, kh, kw),
-                      TileUtilities.GetNTcuIndexBits(n_active_tcu)))))))));
-
-        if (promote is null)
-        {
-            block.Alloc(glb_of.Buffers, is_init_psum ? init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : None.Default);
-        }
-        else if (promote is int promoteIndex)
-        {
-            if (is_init_psum)
-            {
-                NestedBlocks[promoteIndex + 1].Alloc(init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray());
-            }
-        }
-
-        return block;
-    }
-
-    /// <summary>
-    /// 假设oc为32被拆分之后每个tcu只能映射一半, 那么两个tcu共享一份weights, 在ofmap的h上进行切分.
-    /// </summary>
-    protected ITileBlockBuilder GNNEConv2DSharedW(Call call, string block_name, BufferRegionView glb_w, BufferRegionView glb_if, BufferRegionView glb_act, BufferRegionView glb_psum, BufferRegionView glb_of, bool is_depthwise, bool is_init_psum, string prefix, int? promote = null)
-    {
-        var init_psums = GetInitPSumBufferRegion(call, IndexMapKey.Create(call, GNNEConv2D.PSum), glb_psum, promote, prefix, 2, ExtCompilerServices.Env.TcuActNum, out var part_condition);
-
-        var reGlbW = GlbReIndex(glb_of[.., .., .., ..], glb_w, out _);
-        var (iH, iW) = (glb_if.Dimensions[2], glb_if.Dimensions[3]);
-        var (kH, kW) = (glb_w.Dimensions[2], glb_w.Dimensions[3]);
-        var stride = ((TensorConst)call[IR.K510.GNNEConv2D.Stride]).Value.Cast<int>();
-        var padding = ((TensorConst)call[IR.K510.GNNEConv2D.Padding]).Value.Cast<int>();
-        var dilation = ((TensorConst)call[IR.K510.GNNEConv2D.Dilation]).Value.Cast<int>();
-
-        var block = EAction.TileBlock(block_name).Reads(glb_w.BufferRegions, is_init_psum ? init_psums[0].BufferRegions.Concat(init_psums[1].BufferRegions.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : glb_psum.BufferRegions, glb_if.BufferRegions, glb_act.BufferRegions).Body(
-        T.Let(out var khChunck, MathF.Min(kH, ExtCompilerServices.Env.PuHeight)).Body(
-        T.Let(out var kwChunck, dilation[1] != 1 ? 1 : MathF.Min(kW, ExtCompilerServices.Env.PuKernelSpad)).Body(
-        T.Unrolled(out var kh, new(0, kH, khChunck)).Body(
-          T.Unrolled(out var kw, new(0, kW, kwChunck)).Body(// NOTE dw卷积时m once指的是一次ic对应输出多少个oc, 所以默认为1
-            T.Let(out var m_once, is_depthwise ? 1 : MathF.Min(ExtCompilerServices.Env.PuWidth, glb_w.RegionSize(0))).Body(
-            T.Let(out var c_once, is_depthwise ? MathF.Min(MathF.Min(ExtCompilerServices.Env.PuWidth / m_once, ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2)), glb_w.RegionSize(0)) : MathF.Min(MathF.Min(ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2), glb_w.RegionSize(1)), glb_if.RegionSize(1))).Body(// NOTE dw卷积时, if是按对角线排列的, 所以要小于min(pu w/pu h)
-            T.Let(out var tcu_oh_chunk, TileUtilities.Split(glb_of.RegionSize(2), ExtCompilerServices.Env.TcuActNum)).Body(// segment tcu h in output_h
-            T.Let(out var n_active_tcu, TileUtilities.SplitTimes(glb_of.RegionSize(2), tcu_oh_chunk)).Body(
-              T.If(MathF.Equal(n_active_tcu, 1)).Then(// NOTE 这里的psum已经被load好了, 可能到时候会存在psum大小和后续不匹配的问题.// 3. broadcast action
-                EAction.TcuDmBroadCast(TcuDivideStrategy.NoShare))
-              .Else(
-                EAction.TcuDmBroadCast(TcuDivideStrategy.ShareW)),
-              EAction.TcuDmConfW(TileUtilities.GetNTcuIndexBits(n_active_tcu), reGlbW[.., .., (kh, MathF.Min(kh + khChunck, kH)), (kw, MathF.Min(kw + kwChunck, kW))]),
-              T.Unrolled(out var tcu_oh, new(glb_of.Region[2].Start, glb_of.Region[2].Stop, tcu_oh_chunk)).Body(// 4. conf_w action
-                T.Let(out var tcu_index_bits, TileUtilities.GetTcuIndexBits(tcu_oh / tcu_oh_chunk)).Body(// 5. loop over tcus and config each tcu
-                  EAction.TcuDmConfIf(// conf if
-                    tcu_index_bits,
-                    GlbReIndex(glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..], glb_if, out var if_padding, (2, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kh, IR.F.Math.Min(kh + khChunck, kH), 1), stride[0], padding[0, 0], dilation[0])), (3, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kw, IR.F.Math.Min(kw + kwChunck, kW), 1), stride[1], padding[1, 0], dilation[1]))),
-                    stride_w: stride[1],
-                    stride_h: stride[0],
-                    input_c_pre_pu: MathF.Min(ExtCompilerServices.Env.PuHeight / glb_w.RegionSize(2), glb_if.RegionSize(1)), // todo 这里可能有问题.
-                    dilation_h: call[GNNEConv2D.Dilation][0],
-                    padding_top: if_padding[2].Before,
-                    padding_bottom: if_padding[2].After,
-                    padding_left: if_padding[3].Before,
-                    padding_right: if_padding[3].After),
-                  EAction.TcuPuConfAct(// conf act
-                    tcu_index_bits,
-                    GlbReIndex(glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..], glb_act, out _),
-                    call[GNNEConv2D.FusedClamp][0],
-                    call[GNNEConv2D.FusedClamp][1]),
-                  EAction.TcuPuConf(// conf pu
-                    tcu_index_bits,
-                    GlbReIndex(glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..], glb_if, out var _, (2, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kh, IR.F.Math.Min(kh + khChunck, kH), 1), stride[0], padding[0, 0], dilation[0])), (3, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kw, IR.F.Math.Min(kw + kwChunck, kW), 1), stride[1], padding[1, 0], dilation[1]))),
-                    glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..],
-                    khChunck,
-                    kwChunck,
-                    m_once,
-                    c_once,
-                    groups: is_depthwise ? 1 : call[GNNEConv2D.Groups], // NOTE tcu pu conf 的group其实是multiplier的意思，就是一个ic会输出多个oc, 并不是标准conv定义的groups.
-                    mode: is_depthwise ? TcuComputeMode.DwConv2d : TcuComputeMode.NormalConv2d),
-                  EAction.TcuDmConfOf(// conf of
-                    tcu_index_bits,
-                    is_init_psum ? MathF.Select(MathF.Equal(tcu_oh, glb_of.Region[2].Start), init_psums[0][.., .., (0, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop) - tcu_oh), .., ..], init_psums[1][.., .., (0, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop) - tcu_oh), .., ..]) : GlbReIndex(glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..], glb_psum, out _),
-                    glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_oh_chunk, glb_of.Region[2].Stop)), ..],
-                    0))),
-              EAction.TcuDmFetchW(TileUtilities.GetNTcuIndexBits(n_active_tcu), reGlbW[.., .., (kh, MathF.Min(kh + khChunck, kH)), (kw, MathF.Min(kw + kwChunck, kW))]),
-              T.Unrolled(out var tcu_oh2, new(glb_of.Region[2].Start, glb_of.Region[2].Stop, tcu_oh_chunk)).Body(// 6. fetch weights
-                EAction.TcuDmFetchIf(
-                  TileUtilities.GetTcuIndexBits(tcu_oh2 / tcu_oh_chunk), // 7. loop over tcus and fetch if for each tcu
-                  GlbReIndex(glb_of[.., .., (tcu_oh2, MathF.Min(tcu_oh2 + tcu_oh_chunk, glb_of.Region[2].Stop)), ..], glb_if, out _, (2, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kh, IR.F.Math.Min(kh + khChunck, kH), 1), stride[0], padding[0, 0], dilation[0])), (3, r => TileUtilities.Conv2DSubSlice(r, new TIR.Range(kw, IR.F.Math.Min(kw + kwChunck, kW), 1), stride[1], padding[1, 0], dilation[1]))))),
-              EAction.TcuPuCompute(// 8. tcu compute.
-                TileUtilities.GetNTcuIndexBits(n_active_tcu),
-                GNNEConv2DComputeOfEnable(call, glb_w, kh + khChunck, kH, kw + kwChunck, kW),
-                GNNEConv2DComputeActEnable(call, glb_w, kh + khChunck, kH, kw + kwChunck, kW),
-                GNNEConv2DComputeLoadPsumEnable(call, glb_w, kh, kw),
-                TileUtilities.GetNTcuIndexBits(n_active_tcu)))))))))));
-
-        if (promote is null)
-        {
-            block.Alloc(glb_of.Buffers, is_init_psum ? init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray() : None.Default);
-        }
-        else if (promote is int promoteIndex)
-        {
-            if (is_init_psum)
-            {
-                NestedBlocks[promoteIndex + 1].Alloc(init_psums[0].Buffers.OfType<Expr>().Concat(init_psums[1].Buffers.Select(b => MathF.Condition(EAction.FoldOfMarker(part_condition > 1), b))).ToArray());
-            }
-        }
-
-        return block;
-    }
-
-    protected virtual ISequentialBuilder<Sequential> LowerGnneConv2D(IndexMapKey parentKey, Call call, GNNEConv2D op, string block_name, string prefix)
-    {
-        prefix = NameAllocator.Get(nameof(GNNEConv2D));
-        bool is_depthwise;
-        {
-            var groups = ((TensorConst)call[GNNEConv2D.Groups]).Value.ToScalar<int>();
-            var input_channels = call[GNNEConv2D.Input].CheckedShape[1].FixedValue;
-            var output_channels = call.CheckedShape[1].FixedValue;
-            is_depthwise = input_channels == output_channels && output_channels == groups && groups != 1;
-        }
-
-        if (is_depthwise)
-        {
-            prefix = prefix + "(dw)";
-            block_name += "(dw)";
-        }
-
-        var call_w = IndexMapKey.Create(call, GNNEConv2D.Weights);
-        var call_in = IndexMapKey.Create(call, GNNEConv2D.Input);
-        var call_act = IndexMapKey.Create(call, GNNEConv2D.Act);
-        var call_psum = IndexMapKey.Create(call, GNNEConv2D.PSum);
-
-        bool is_init_psum = call_psum.Expr is Call { Target: Uninitialized };
-
-        TcuDivideStrategy tcu_strategy;
-        if (!is_depthwise)
-        {
-            // 优先让每个tcu的width用满
-            var out_shape = call.CheckedShape.ToValueArray();
-            if (out_shape[1] >= ExtCompilerServices.Env.PuWidth * ExtCompilerServices.Env.TcuActNum)
-            {
-                tcu_strategy = TcuDivideStrategy.ShareIf;
-            }
-            else
-            {
-                tcu_strategy = TcuDivideStrategy.ShareW;
-            }
-        }
-        else
-        { // TODO 需要一种量化的方法来决定dw卷积用什么策略.
-            tcu_strategy = TcuDivideStrategy.NoShare;
-        }
-
-        prefix = prefix + "." + tcu_strategy;
-
-        // 默认是layer group的做法, 也就是w/act全部promote
-        return T.Sequential().Body(
-          Visit(call_w, prefix, -1),
-          Visit(call_in, prefix),
-          Visit(call_act, prefix, -1),
-          Visit(call_psum, prefix),
-          GetBufferRegion(call_w, out var glb_w),
-          GetBufferRegion(call_in, out var glb_if), // glb if 存在padding的情况.
-          GetBufferRegion(call_act, out var glb_act),
-          GetBufferRegion(call_psum, out var glb_psum, TileOptions.PingPong, name: prefix + "." + GNNEConv2D.PSum.Name), // note 这里的pusm申请了但不记录到allocs中,仅用于给psum apart使用.
-          GetBufferRegion(parentKey, out var glb_of, TileOptions.PingPong, name: prefix + "." + TileNames.Output),
-          tcu_strategy switch { TcuDivideStrategy.ShareIf => GNNEConv2DSharedIF(call, block_name, glb_w, glb_if, glb_act, glb_psum, glb_of, is_init_psum, prefix), TcuDivideStrategy.ShareW => GNNEConv2DSharedW(call, block_name, glb_w, glb_if, glb_act, glb_psum, glb_of, is_depthwise, is_init_psum, prefix), TcuDivideStrategy.NoShare => GNNEConv2DSharedNone(call, block_name, glb_w, glb_if, glb_act, glb_psum, glb_of, is_init_psum, prefix), _ => throw new NotSupportedException(), });
-    }
-
-    protected virtual ISequentialBuilder<Sequential> LowerGnneTranspose(IndexMapKey parentKey, Call call, GNNETranspose op, string block_name, string prefix)
-    {
-        prefix = NameAllocator.Get(nameof(GNNETranspose));
-        var call_in = IndexMapKey.Create(call, GNNETranspose.Input);
-        var seq = T.Sequential().Body(
-          Visit(call_in, prefix), GetBufferRegion(call_in, out var glb_trans_input), GetBufferRegion(parentKey, out var glb_trans_output, TileOptions.PingPong, name: prefix), EAction.TileBlock(block_name).Alloc(glb_trans_output.Buffers).Reads(glb_trans_input.BufferRegions).Body(EAction.MfuTranspose(glb_trans_input, glb_trans_output, op.Perm)));
-
-        return seq;
-    }
-
-    protected virtual ISequentialBuilder<Sequential> LowerGnneCrop(IndexMapKey parentKey, Call call, GNNECrop op, string block_name, string prefix)
-    {
-        prefix = NameAllocator.Get(nameof(GNNECrop));
-        var call_in = IndexMapKey.Create(call, GNNECrop.Input);
-        var call_in_bbox = IndexMapKey.Create(call, GNNECrop.InputBBox);
-        var seq = T.Sequential().Body(
-          Visit(call_in, prefix),
-          Visit(call_in_bbox, prefix),
-          GetBufferRegion(call_in, out var glb_crop_input),
-          GetBufferRegion(call_in_bbox, out var glb_crop_bbox),
-          GetBufferRegion(parentKey, out var glb_crop_output, TileOptions.PingPong, name: prefix),
-          EAction.TileBlock(block_name).Alloc(glb_crop_output.Buffers).
-            Reads(glb_crop_input.BufferRegions, glb_crop_bbox.BufferRegions).
-            Body(
-              EAction.MfuCrop(
-                glb_crop_input,
-                glb_crop_output,
-                glb_crop_bbox,
-                op.ResizeMethod,
-                op.AlignMethod,
-                op.HalfPixelCenters)));
-
-        return seq;
-    }
-
-    protected virtual ISequentialBuilder<Sequential> LowerGnneActivation(IndexMapKey parentKey, Call call, GNNEActivation op, string block_name, string prefix)
-    {
-        prefix = NameAllocator.Get(nameof(GNNEActivation));
-        var fusedclamps = ((TensorConst)call[GNNEActivation.FusedClamp]).Value.Cast<BFloat16>();
-        var call_in = IndexMapKey.Create(call, GNNEActivation.Input);
-        var call_in_act = IndexMapKey.Create(call, GNNEActivation.Act);
-
-        var seq = T.Sequential().Body(
-          Visit(call_in, prefix),
-          Visit(call_in_act, prefix),
-          GetBufferRegion(call_in, out var glb_if),
-          GetBufferRegion(call_in_act, out var glb_act),
-          GetBufferRegion(parentKey, out var glb_of, TileOptions.PingPong, name: prefix),
-          EAction.TileBlock(block_name).Alloc(glb_of.Buffers).Reads(glb_if.BufferRegions, glb_act.BufferRegions).Body(
-            T.Let(out var m_once, 1).Body(
-            T.Let(out var c_once, MathF.Min(glb_if.RegionSize(1), ExtCompilerServices.Env.TcuActNum)).Body(
-            T.Let(out var tcu_h_chunk, TileUtilities.Split(glb_of.RegionSize(2), ExtCompilerServices.Env.TcuActNum)).Body(// segment tcu h in output_h
-            T.Let(out var n_active_tcu, TileUtilities.SplitTimes(glb_of.RegionSize(2), tcu_h_chunk)).Body(
-              T.Unrolled(out var tcu_oh, new(glb_of.Region[2].Start, glb_of.Region[2].Stop, tcu_h_chunk)).Body(
-                T.Let(out var tcu_index_bits, TileUtilities.GetTcuIndexBits(tcu_oh / tcu_h_chunk)).Body(
-                  EAction.TcuPuConfAct(// 1. conf act
-                    tcu_index_bits,
-                    glb_act,
-                    fusedclamps[0],
-                    fusedclamps[1]),
-                  EAction.TcuPuConf(
-                    tcu_index_bits,
-                    glb_if[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_h_chunk, glb_if.Region[2].Stop)), ..],
-                    glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_h_chunk, glb_of.Region[2].Stop)), ..],
-                    1,
-                    1,
-                    m_once,
-                    c_once,
-                    1,
-                    TcuComputeMode.Activation),
-                  EAction.TcuDmConfOf(
-                    tcu_index_bits,
-                    glb_if[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_h_chunk, glb_if.Region[2].Stop)), ..],
-                    glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_h_chunk, glb_of.Region[2].Stop)), ..],
-                    0))),
-              EAction.TcuPuComputeDummy(TileUtilities.GetNTcuIndexBits(n_active_tcu), true)))))));
-        return seq;
-    }
-
-    protected virtual ISequentialBuilder<Sequential> LowerGnnePdpReduce(IndexMapKey parentKey, Call call, GNNEPdpReduce op, string block_name, string prefix)
-    {
-        prefix = NameAllocator.Get(nameof(GNNEPdpReduce));
-        var call_in = IndexMapKey.Create(call, GNNEPdpReduce.Input);
-
-        // var ddr_if = BoundsInferGraph[call_in];
-        // GlbReIndex(glb_of[.., .., (tcu_oh, MathF.Min(tcu_oh + tcu_h_chunk, glb_of.Region[2].Stop)), ..], glb_if, out var if_paddings)
-        var seq = T.Sequential().Body(
-          Visit(call_in, prefix),
-          GetBufferRegion(call_in, out var glb_if),
-          GetBufferRegion(parentKey, out var glb_of, TileOptions.PingPong, name: prefix));
-        GlbReIndex(glb_of, glb_if, out var sub_paddings);
-        seq.Body(
-          EAction.TileBlock(block_name).Alloc(glb_of.Buffers).Reads(glb_if.BufferRegions).Body(
-            EAction.PdpReduce(
-              glb_if,
-              glb_of,
-              call[GNNEPdpReduce.Filter],
-              call[GNNEPdpReduce.Stride],
-              sub_paddings[2].Before,
-              sub_paddings[2].After,
-              sub_paddings[3].Before,
-              sub_paddings[3].After,
-              op.ReduceOp)));
-        return seq;
-    }
-
-    protected virtual ISequentialBuilder<Sequential> LowerGnneConv2DTranspose(IndexMapKey parentKey, Call call, GNNEConv2DTranspose op, string block_name, string prefix)
-    {
-        throw new NotSupportedException();
-    }
-}
-#endif
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs b/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs
index 7cbeab67c8..0a5d5a31e3 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs
@@ -1,11 +1,11 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
-#if false
+
 using System.Collections.Immutable;
 using System.Runtime.CompilerServices;
 using Nncase.Diagnostics;
 using Nncase.IR;
-using Nncase.TIR.CPU;
+using Nncase.TIR;
 
 namespace Nncase.Passes.Tile;
 
@@ -14,239 +14,7 @@ namespace Nncase.Passes.Tile;
 /// </summary>
 internal sealed class MultiFusionChecker : IFusionChecker
 {
-    private readonly List<(MultiLayerFusionConverter, int[], BufferSchedule.ScheduledResponse)> _caches = new();
-
-    private readonly TileOptions _tileOptions;
-
-    public MultiFusionChecker(TileOptions tileOptions)
-    {
-        _tileOptions = tileOptions;
-    }
-
-    [Flags]
-    public enum DeviceKind
-    {
-        Load,
-        Store,
-        Mfu,
-        Tcu,
-        None,
-    }
-
-    public TIR.PrimFunction Convert(RunPassContext passOptions)
-    {
-        var (convertVisitor, final_tile_size, response) = _caches.First();
-        if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
-        {
-            response.Dump($"{response.LogicalPrimfunc.Name}_{string.Join("_", final_tile_size)}", convertVisitor.GetType().Name);
-        }
-
-        return convertVisitor.BuildPhysicalPrimFunc(final_tile_size, response.SchedCandidate, response.LogicalPrimfunc);
-    }
-
-    public bool Check(Fusion fusion, RunPassContext passOptions)
-    {
-        // 1. check all conv2d weights size less than glb size
-        var visitor = new MultiFusionPreCheckVisitor();
-        visitor.Visit(fusion);
-        if (visitor.AllWeightSizeInBytes > ExtCompilerServices.Env.GlbSize)
-        {
-            return false;
-        }
-
-        // note not support conv2d transpose in layer group.
-        if (visitor.CountCallOp<IR.K510.GNNEConv2DTranspose>() > 0)
-        {
-            return false;
-        }
-
-        var curTileOptions = _tileOptions;
-        if ((visitor.DeviceUsage[DeviceKind.Mfu], visitor.DeviceUsage[DeviceKind.Tcu]) switch
-        {
-            (> 1, > 1) => true,
-            (> 1, 1) => true,
-            (1, > 1) => true,
-            _ => false,
-        })
-        {
-            curTileOptions = curTileOptions with { PingPongNum = 3 };
-        }
-
-        // 2. try convert
-        var convertVisitor = new MultiLayerFusionConverter(curTileOptions); // note the grouped fusion must pingpong input.
-        var bodySeq = convertVisitor.Visit(fusion);
-
-        // 3. search the tile size
-        var originLogicalPrimFunc = convertVisitor.BuildLogicalPrimFunc(bodySeq);
-
-        var output_shape = fusion.Body.CheckedShape.ToValueArray();
-        var search_space = convertVisitor.BoundsInferGraph.RootTileStep.ToArray();
-        var candidate_tile_size = convertVisitor.SearchTileSize(TileOhSearchGenerator(curTileOptions, search_space, convertVisitor.BoundsInferGraph.RootPerm.ToArray()), originLogicalPrimFunc, curTileOptions.MultiWorkers, false, out var sched_response);
-        if (!candidate_tile_size.Any())
-        {
-            return false;
-        }
-
-        int[] final_tile_size = new int[candidate_tile_size.Length];
-        if (convertVisitor.BalanceTileSize(candidate_tile_size, search_space))
-        {
-            final_tile_size = convertVisitor.SearchTileSize(new TargetTileGenerator(candidate_tile_size), originLogicalPrimFunc, curTileOptions.MultiWorkers, true, out sched_response);
-        }
-        else
-        {
-            Array.Copy(candidate_tile_size, final_tile_size, candidate_tile_size.Length);
-        }
-
-        // 5. check the input load usage and compute overlap
-        var input_shape = fusion.Parameters[0].CheckedShape.ToValueArray();
-        var each_axis_tile_nums = final_tile_size.Zip(output_shape).Select(p => (int)System.Math.Ceiling(p.Second / (float)p.First)).ToArray();
-        var total_tile_nums = TensorUtilities.GetProduct(each_axis_tile_nums);
-        if (total_tile_nums > 1)
-        {
-            var clamp = (TIR.K510.Segment seg, int i) =>
-            {
-                return new TIR.K510.Segment(Math.Max(0, seg.Start), Math.Min(input_shape[i], seg.Stop), 1);
-            };
-
-            var first_segment = convertVisitor.BoundsInferGraph[convertVisitor.VarToKeyMap[fusion.Parameters[0]]].
-              Eval(final_tile_size.Select(t => new TIR.K510.Segment(0, t, 1)).ToArray()).
-              Select((s, i) => clamp(s, i)).
-              ToArray();
-
-            int first_split_axis = 0;
-            for (int i = input_shape.Length - 1; i >= 0; i--)
-            {
-                if (first_segment[i].Length != input_shape[i])
-                {
-                    first_split_axis = i;
-                    break;
-                }
-            }
-
-            // when once load less than load burst, false
-            var burst_load_data = TensorUtilities.GetProduct(first_segment.Skip(first_split_axis).Select(s => s.Length).ToArray());
-            if (burst_load_data < ExtCompilerServices.Env.LoadBurst)
-            {
-                return false;
-            }
-
-            var second_segment = convertVisitor.BoundsInferGraph[convertVisitor.VarToKeyMap[fusion.Parameters[0]]].Eval(final_tile_size.Select((t, i) =>
-                  t < output_shape[i] ?
-                  new TIR.K510.Segment(t, System.Math.Min(t * 2, output_shape[i]), 1) :
-                  new TIR.K510.Segment(0, t, 1)).ToArray()).
-                  Select((s, i) => clamp(s, i)).
-                  ToArray();
-
-            // Todo 因为我无法知道在当前维度切分会影响哪个维度的变化, 比如带有transpose的, 可能我在c上切,只影响 h w. 所以直接计算所有的的交集
-            var overlaps = first_segment.Zip(second_segment).Select(p => p.First.Intersect(p.Second)).ToArray();
-            if (Array.IndexOf(convertVisitor.BoundsInferGraph.RootPerm.ToArray(), TIR.K510.NamedAxis.H) is int h && h != -1)
-            {
-                // 如果只在h上切分, 只需要考虑h上的overlap有没有超过0.3
-                if (overlaps[h] > (input_shape[h] * 0.3))
-                {
-                    return false;
-                }
-            }
-            else
-            {
-                if (TensorUtilities.GetProduct(overlaps) > TensorUtilities.GetProduct(input_shape) * 0.3)
-                {
-                    return false;
-                }
-            }
-        }
-
-        _caches.Add((convertVisitor, candidate_tile_size, sched_response));
-        if (_caches.Count > 1)
-        {
-            _caches.RemoveAt(0);
-        }
-
-        return true;
-    }
-
-    /// <summary>
-    /// <remark>
-    /// 只在oh上切分.
-    /// </remark>
-    /// </summary>
-    private ISearchTileGenerator TileOhSearchGenerator(TileOptions tileOptions, Segment[] search_spaces, TIR.K510.NamedAxis[] rootPerm)
-    {
-        if (Array.IndexOf(rootPerm, TIR.K510.NamedAxis.C) is int c && c != -1)
-        {
-            search_spaces[c].Start = search_spaces[c].Stop; // not tile oc
-        }
-
-        if (Array.IndexOf(rootPerm, TIR.K510.NamedAxis.H) is int h && h != -1)
-        {
-            // 因为在h上切分, 如果ping pong那么需要限制大小
-            if (tileOptions.PingPong)
-            {
-                if (search_spaces[h].ClampStop(2, out var new_h_seg))
-                {
-                    // assume tile h must > 8 for tcu use.
-                    search_spaces[h] = new Segment(Math.Min(Math.Max(search_spaces[h].Step, ExtCompilerServices.Env.TcuActNum), new_h_seg.Stop), new_h_seg.Stop, new_h_seg.Step);
-                }
-            }
-        }
-
-        if (Array.IndexOf(rootPerm, TIR.K510.NamedAxis.W) is int w && w != -1)
-        {
-            search_spaces[w].Start = Math.Min(search_spaces[w].Stop, Math.Max(search_spaces[w].Step, ExtCompilerServices.Env.PuWidth)); // no tile w
-        }
-
-        // 如果有perm, 那就是 c w h n 方式搜, 没有perm就是从最后搜到最前 所以在有ping pong的时候需要限制切分.
-        if (rootPerm.All(r => r == NamedAxis.UnKnow) && tileOptions.PingPong)
-        {
-            if (search_spaces[^1].ClampStop(2, out var new_seg))
-            {
-                search_spaces[^1] = new_seg;
-            }
-        }
-
-        return new DefaultSearchTileGenerator(search_spaces, rootPerm);
-    }
-
-    internal sealed class MultiFusionPreCheckVisitor : ExprVisitor<bool, bool>
-    {
-        public Dictionary<DeviceKind, int> DeviceUsage { get; } = new()
-        {
-            { DeviceKind.Load, 0 },
-            { DeviceKind.Store, 0 },
-            { DeviceKind.Mfu, 0 },
-            { DeviceKind.Tcu, 0 },
-            { DeviceKind.None, 0 },
-        };
-
-        public int AllWeightSizeInBytes { get; private set; }
-
-        public int CountCallOp<T>()
-          where T : Op
-        {
-            return ExprMemo.Keys.Count(e => e is Call { Target: Op t } && t.GetType() == typeof(T));
-        }
-
-        protected override bool DefaultVisitLeaf(Expr expr) => true;
-
-        protected override bool VisitLeafCall(Call expr)
-        {
-            if (expr is Call { Target: IR.K510.GNNEConv2D } && expr[IR.K510.GNNEConv2D.Weights] is Expr weights)
-            {
-                AllWeightSizeInBytes += weights.CheckedShape.Prod().FixedValue * weights.CheckedDataType.SizeInBytes;
-            }
-
-            DeviceUsage[GetDeviceType(expr.Target)]++;
-            return true;
-        }
+    public bool Check(Fusion fusion, RunPassContext passOptions) => false;
 
-        private static DeviceKind GetDeviceType(Expr op) => op switch
-        {
-            IR.K510.GNNELoad => DeviceKind.Load,
-            IR.K510.GNNEStore => DeviceKind.Store,
-            IR.K510.GNNEConv2D or IR.K510.GNNEActivation => DeviceKind.Tcu,
-            IR.K510.GNNEReduce or IR.K510.GNNEMeshNet or IR.K510.GNNETranspose or IR.K510.GNNEPdpReduce or IR.K510.GNNECrop => DeviceKind.Mfu,
-            _ => DeviceKind.None,
-        };
-    }
+    public PrimFunction Convert(RunPassContext passOptions) => throw new NotImplementedException();
 }
-#endif
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs
deleted file mode 100644
index a99248cf14..0000000000
--- a/modules/Nncase.Modules.CPU/Passes/Tile/MultiLayerFusionConverter.cs
+++ /dev/null
@@ -1,230 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-#if false
-using System.Runtime.CompilerServices;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.Passes.BufferSchedule;
-using Nncase.TIR;
-using Nncase.TIR.Builders;
-using Nncase.TIR.CPU;
-using Nncase.TIR.K510.Builders;
-using MathF = Nncase.IR.F.Math;
-
-namespace Nncase.Passes.Tile;
-
-internal class MultiLayerFusionConverter : LayerFusionConverter
-{
-    public MultiLayerFusionConverter(TileOptions tileOptions)
-    {
-        TileOptions = tileOptions;
-    }
-
-    public override Fusion CurrentFusion { get; protected set; } = null!;
-
-    public override IBoundsInferGraph BoundsInferGraph { get; protected set; } = null!;
-
-    /// <summary>
-    /// Gets or sets calc the loop count.
-    /// </summary>
-    public override Expr LoopCount { get; protected set; } = null!;
-
-    public override Expr LoopCountOuter { get; protected set; } = null!; // LoopCount / TileOptions.PingPongNum;
-
-    public override Expr LoopCountInner { get; protected set; } = null!; // LoopCount % TileOptions.PingPongNum;
-
-    public override Expr Visit(Fusion fusion)
-    {
-        if (CurrentFusion is null)
-        {
-            CurrentFusion = fusion;
-        }
-        else
-        {
-            throw new InvalidOperationException("Can't Visit More Than One Fusion!");
-        }
-
-        // 0. init the fields
-        var output_shape = Tile.TileUtilities.GetFusionRealOutputShape(fusion.Body);
-        BoundsInferGraph = ExtCompilerServices.MakeBoundsInferGraph((Call)fusion.Body);
-        TileSizeVars.AddRange(output_shape.Select((_, i) => new Var($"dim{i}_tile", new TensorType(DataTypes.Int32, Shape.Scalar))));
-
-        // 1. make the tile gird loop
-        NestedBlocks.AddRange(new[] { EAction.TileBlock("MainBlock") }.Concat(Enumerable.Range(0, TileSizeVars.Count).Select(i => EAction.TileBlock($"TileBlock_{i}"))));
-
-        LoopDomains.AddRange(output_shape.Zip(TileSizeVars).Select(t => new TIR.Range(0, t.First, t.Second)));
-        for (int i = 0; i < TileSizeVars.Count; i++)
-        {
-            NestedLoops.Add(T.ForLoop(out var loopVar, LoopDomains[i], LoopMode.Unrolled, $"loop_var_{i}"));
-            LoopVars.Add(loopVar);
-        }
-
-        object lastBody = NestedBlocks[^1];
-        for (int i = NestedLoops.Count - 1; i >= 0; i--)
-        {
-            lastBody = NestedLoops[i].Body(lastBody);
-            lastBody = NestedBlocks[i].Body(lastBody);
-        }
-
-        // 2. create the bounds infer function input arguments with the new loop var.
-        BoundsInferGraph.RootBounds = output_shape.Select((s, i) =>
-         {
-             var loopVar = LoopVars[i];
-             return new TIR.Range(loopVar, IR.F.Math.Min(loopVar + TileSizeVars[i], s), 1);
-         }).ToList();
-
-        // 3. set up loop count
-        var shape = new Expr[LoopVars.Count];
-        var upbounds = CurrentFusion.Body.CheckedShape.ToValueArray();
-        for (int j = LoopVars.Count - 1; j >= 0; j--)
-        {
-            shape[j] = TileUtilities.SplitTimes(upbounds[j], TileSizeVars[j]);
-        }
-
-        var strides = TensorUtilities.GetStrides(shape).ToArray();
-        var indices = LoopVars.Select((v, j) => (Expr)(v / TileSizeVars[j])).ToArray();
-        LoopCount = TensorUtilities.GetIndex(strides, indices);
-        LoopCountOuter = LoopCount / TileOptions.PingPongNum;
-        LoopCountInner = LoopCount % TileOptions.PingPongNum;
-
-        return Visit((Call)fusion.Body, "root");
-    }
-
-    /// <summary>
-    /// convert to the final prim func.
-    /// </summary>
-    /// <returns>.</returns>
-    public PrimFunction VisitToPrimFunc(Fusion fusion)
-    {
-        // 1. visit the fusion
-        var bodySeq = Visit(fusion);
-
-        // 2. build the prim func with tile size vars.
-        var logicalPrimFunc = BuildLogicalPrimFunc(bodySeq);
-
-        // 3. seach the tiling size
-        var search_spaces = BoundsInferGraph.RootTileStep.ToArray();
-        ISearchTileGenerator tileGenerator;
-        if (TileOptions.TargetTileSize.Any())
-        {
-            for (int i = 0; i < TileOptions.TargetTileSize.Length; i++)
-            {
-                System.Diagnostics.Trace.Assert(TileOptions.TargetTileSize[i] <= search_spaces[i].Stop);
-            }
-
-            tileGenerator = new TargetTileGenerator(TileOptions.TargetTileSize);
-        }
-        else
-        {
-            var perm = BoundsInferGraph.RootPerm.ToArray();
-
-            // when ping pong all, clamp the upper bounds by perm order.
-            if (TileOptions.PingPong)
-            {
-                var re_perm = perm.Zip(Enumerable.Range(0, perm.Length)).OrderBy(t => t.First).Select(t => t.Second).ToArray();
-
-                var pp_axis = NamedAxis.H;
-
-                // 如果已知维度, 那么在pp axis上进行切分
-                if (Array.IndexOf(perm, NamedAxis.H) is var h && h != -1 && Array.IndexOf(perm, NamedAxis.W) is var w && w != -1)
-                {
-                    // if split the h will less than one burst, split on c.
-                    if ((int)System.Math.Ceiling(search_spaces[h].Stop / (float)TileOptions.PingPongNum) * search_spaces[w].Stop < 128)
-                    {
-                        pp_axis = NamedAxis.C;
-                    }
-                    else
-                    {
-                        pp_axis = NamedAxis.H;
-                    }
-                }
-
-                for (int i = 0; i < perm.Length; i++)
-                {
-                    var p = re_perm[i];
-                    if (perm[i] == pp_axis && search_spaces[p].ClampStop(TileOptions.PingPongNum, out var new_seg))
-                    {
-                        search_spaces[p] = new_seg;
-                        break;
-                    }
-                }
-            }
-
-            {
-                if (Array.IndexOf(perm, NamedAxis.H) is var h && h != -1 && Array.IndexOf(perm, NamedAxis.W) is var w && w != -1)
-                {
-                    // if one layer output less than 128, don't split the hw
-                    if (search_spaces[h].Stop * search_spaces[w].Stop < ExtCompilerServices.Env.LoadBurst)
-                    {
-                        search_spaces[h].Start = search_spaces[h].Stop;
-                        search_spaces[w].Start = search_spaces[w].Stop;
-                    }
-                    else
-                    {
-                        search_spaces[h].Start = Math.Min(Math.Max(search_spaces[h].Step, ExtCompilerServices.Env.TcuActNum), search_spaces[h].Stop);
-                        search_spaces[w].Start = Math.Min(Math.Max(search_spaces[w].Step, ExtCompilerServices.Env.PuWidth), search_spaces[w].Stop);
-                    }
-                }
-            }
-
-            tileGenerator = new DefaultSearchTileGenerator(search_spaces, BoundsInferGraph.RootPerm);
-        }
-
-        int[] candidate_tile_size = SearchTileSize(tileGenerator, logicalPrimFunc, TileOptions.MultiWorkers, false, out var response);
-        if (!candidate_tile_size.Any())
-        {
-            throw new TileFailedException();
-        }
-
-        int[] final_tile_size = Array.Empty<int>();
-        if (!TileOptions.TargetTileSize.Any() && TileOptions.PingPong && BalanceTileSize(candidate_tile_size, search_spaces))
-        {
-            final_tile_size = SearchTileSize(new TargetTileGenerator(candidate_tile_size), logicalPrimFunc, TileOptions.MultiWorkers, true, out response);
-        }
-        else
-        {
-            final_tile_size = candidate_tile_size;
-        }
-
-        if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
-        {
-            response.Dump($"{CurrentFusion.Name}_{string.Join("_", final_tile_size)}", GetType().Name);
-        }
-
-        // 4. the local logical buffer to phsy buffer
-        return BuildPhysicalPrimFunc(final_tile_size, response.SchedCandidate, response.LogicalPrimfunc);
-    }
-
-    /// <summary>
-    /// 1. if inner loop var > half, balance it.
-    /// 2. find the highest axis loop var == up_bounds, split it.
-    /// </summary>
-    public override bool BalanceTileSize(int[] tile_size, Segment[] search_spaces)
-    {
-        bool changed = false;
-
-        // balance tile
-        for (int i = search_spaces.Length - 1; i >= 0; i--)
-        {
-            if (search_spaces[i].BalanceTile(tile_size[i], out var newTile))
-            {
-                tile_size[i] = newTile;
-                return true;
-            }
-        }
-
-        // force ping pong
-        for (int i = 0; i < search_spaces.Length; i++)
-        {
-            if (search_spaces[i].ClampStop(2, out var new_seg) && new_seg.Stop < tile_size[i])
-            {
-                tile_size[i] = new_seg.Stop;
-                return true;
-            }
-        }
-
-        return changed;
-    }
-}
-#endif
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
new file mode 100644
index 0000000000..a2c932eb92
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -0,0 +1,119 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Reactive;
+using System.Runtime.CompilerServices;
+using NetFabric.Hyperlinq;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.IR.Buffers;
+using Nncase.IR.CPU;
+using Nncase.IR.F;
+using Nncase.IR.Math;
+using Nncase.Passes.Mutators;
+using Nncase.PatternMatch;
+using Nncase.Schedule;
+using Nncase.Targets;
+using Nncase.TIR;
+using Nncase.TIR.Builders;
+using Buffer = Nncase.TIR.Buffer;
+using MathF = Nncase.IR.F.Math;
+using Range = Nncase.TIR.Range;
+using Tuple = Nncase.IR.Tuple;
+
+namespace Nncase.Passes.Tile;
+
+/// <summary>
+/// convert the fusion to prim func.
+/// </summary>
+internal sealed class SingleCPUFusionConverter
+{
+    public TIR.PrimFunction Visit(Fusion fusion)
+    {
+        var body = new List<Expr>();
+        var visitor = new ConvertVisitor(body);
+        visitor.Visit(fusion);
+        return T.PrimFunc(fusion.Name, fusion.ModuleKind, visitor.InputBuffers.Concat(visitor.OutputBuffers).ToArray()).Body(body.ToArray()).Build();
+    }
+
+    private sealed class ConvertVisitor : ExprVisitor<Unit, Unit>
+    {
+        private readonly Dictionary<Expr, TIR.Buffer> _buffersMap = new(ReferenceEqualityComparer.Instance);
+        private readonly List<Expr> _mainBody;
+
+        public ConvertVisitor(List<Expr> mainBody)
+        {
+            _mainBody = mainBody;
+        }
+
+        public Fusion VisitRootFusion => (Fusion)(VisitRoot!);
+
+        public IEnumerable<TIR.PhysicalBuffer> OutputBuffers => _buffersMap.Values.OfType<TIR.PhysicalBuffer>().Where(b => b.MemLocation == MemoryLocation.Output);
+
+        public IEnumerable<TIR.PhysicalBuffer> InputBuffers => _buffersMap.Values.OfType<TIR.PhysicalBuffer>().Where(b => b.MemLocation == MemoryLocation.Input);
+
+        protected override Unit DefaultVisitLeaf(Expr expr)
+        {
+            return new();
+        }
+
+        protected override Unit VisitLeafCall(Call expr)
+        {
+            var arguments = expr.Arguments.AsValueEnumerable().Select(TryAllocateBuffer).ToArray();
+            var ret = TryAllocateBuffer(expr);
+            var op = ((CPUKernelOp)expr.Target).Target;
+
+            switch (op)
+            {
+                case Unary unary:
+                    GenerateUnary(unary, arguments, ret);
+                    break;
+                default:
+                    throw new NotSupportedException();
+            }
+            return new();
+        }
+
+        private void GenerateUnary(Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
+        {
+            var input = arguments[Unary.Input.Index];
+            var loops = Enumerable.Range(0, input.Rank).Select(i => (T.ForLoop(out var loopVar, (0, input.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
+            var input_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + input.Strides[i] * loops[i].Item2);
+            var output_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + ret.Strides[i] * loops[i].Item2);
+            Expr stmt = T.Store(ret, output_index, IR.F.Math.Unary(unary.UnaryOp, T.Load(input, output_index)));
+            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
+            _mainBody.Add(T.Block(nameof(Unary)).Body(final).Build());
+        }
+
+        private TIR.Buffer TryAllocateBuffer(Expr expr)
+        {
+            var name = $"buffer_{_buffersMap.Keys.Count}";
+            if (!_buffersMap.TryGetValue(expr, out var buffer))
+            {
+                switch (expr)
+                {
+                    case Call c:
+                        if (ReferenceEquals(c, VisitRootFusion.Body))
+                        {
+                            buffer = T.PhysicalBuffer(c.CheckedDataType, MemoryLocation.Output, c.CheckedShape.ToValueArray(), out _, name);
+                        }
+                        else
+                        {
+                            buffer = T.Buffer(c.CheckedDataType, MemoryLocation.Data, c.CheckedShape.ToValueArray().Select(i => (Expr)i).ToArray(), out _, name);
+                        }
+                        break;
+                    case Var v:
+                        buffer = T.PhysicalBuffer(v.CheckedDataType, MemoryLocation.Input, v.CheckedShape.ToValueArray(), out _, name);
+                        break;
+                    case TensorConst c:
+                        buffer = T.PhysicalBuffer(c.Value.ElementType, MemoryLocation.Rdata, c.Value.Dimensions, out _, name);
+                        break;
+                    default:
+                        throw new NotSupportedException();
+                }
+                _buffersMap.Add(expr, buffer);
+            }
+            return buffer;
+        }
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
index ba3368a679..749355b5da 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
@@ -13,12 +13,8 @@ namespace Nncase.Passes.Tile;
 /// TileOptions.
 /// </summary>
 /// <param name="TargetTileSize">TargetTileSize.</param>
-/// <param name="ForceFence">ForceFence.</param>
-/// <param name="PingPong"> 是否进行ping pong. </param>
-/// <param name="PingPongNum">PingPongNum. </param>
-/// <param name="ForceMultiLayer"> 对于测试. </param>
-/// <param name="MultiWorkers"> 是否开启多线程搜索. </param>
-public sealed record TileOptions(int[] TargetTileSize, bool ForceFence, bool PingPong, int PingPongNum, bool ForceMultiLayer, bool MultiWorkers)
+/// <param name="CacheSize">the cache size.</param>
+public sealed record TileOptions(int[] TargetTileSize, int CacheSize)
 {
-    public static TileOptions Default { get; } = new(Array.Empty<int>(), false, true, 2, false, true);
+    public static TileOptions Default { get; } = new(Array.Empty<int>(), 4 * 1024 * 1024 * 8);
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TwoFusionChecker.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TwoFusionChecker.cs
deleted file mode 100644
index b0a8a858c3..0000000000
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TwoFusionChecker.cs
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-#if false
-using System.Collections.Immutable;
-using System.Runtime.CompilerServices;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.PatternMatch;
-using Nncase.TIR.K510;
-using static Nncase.PatternMatch.Utility;
-
-[assembly: InternalsVisibleTo("Nncase.Tests.K510")]
-
-namespace Nncase.Passes.Tile;
-
-/// <summary>
-/// the two Fusion checker.
-/// 专门前一层可以在conv的ic上tiling的情况.
-/// </summary>
-internal sealed class TwoFusionChecker : IFusionChecker
-{
-    private readonly List<(LayerFusionConverter, int[], BufferSchedule.ScheduledResponse)> _caches = new();
-
-    private readonly TileOptions _tileOptions;
-
-    public TwoFusionChecker(TileOptions tileOptions)
-    {
-        _tileOptions = tileOptions;
-    }
-
-    /// <summary>
-    /// Gets 匹配 conv2d + 非reduction.
-    /// </summary>
-    public static Pattern TwoFusionPattern { get; } = IsCallWildcard(
-        null,
-        IsOp<IR.K510.GNNEStore>(),
-        IsCallWildcard(
-          "conv2d",
-          IsOp<IR.K510.GNNEConv2D>(),
-          IsCallWildcard(null, IsOp<Op>("calleeOp", op => op is IR.K510.GNNEMeshNet or IR.K510.GNNEPdpReduce), IsCallWildcard(null, IsOp<IR.K510.GNNELoad>()))));
-
-    public TIR.PrimFunction Convert(RunPassContext passOptions)
-    {
-        var (convertVisitor, final_tile_size, response) = _caches.First();
-        if (DumpScope.Current.IsEnabled(DumpFlags.PassIR))
-        {
-            response.Dump($"{response.LogicalPrimfunc.Name}_{string.Join("_", final_tile_size)}", nameof(LayerFusionOcIcConverter));
-        }
-
-        return convertVisitor.BuildPhysicalPrimFunc(final_tile_size, response.SchedCandidate, response.LogicalPrimfunc);
-    }
-
-    public bool Check(Fusion fusion, RunPassContext passOptions)
-    {
-        // 1. try match pattern
-        if (!CompilerServices.TryMatchRoot(fusion.Body, TwoFusionPattern, out var matchResult))
-        {
-            return false;
-        }
-
-        // 2. try convert
-        var convertVisitor = new LayerFusionOcIcConverter(_tileOptions, TileUtilities.ChoiceTcuStrategy((Call)matchResult["conv2d"], out _), false); // note the grouped fusion must pingpong input.
-        var bodySeq = convertVisitor.Visit(fusion);
-
-        // 3. search the tile size
-        var originLogicalPrimFunc = convertVisitor.BuildLogicalPrimFunc(bodySeq);
-        _ = fusion.Body.CheckedShape.ToValueArray();
-        var search_space = convertVisitor.OCBoundsInferGraph.RootTileStep.ToArray();
-        search_space = search_space.Concat(new[] { new Segment(1, convertVisitor.Conv2DInShape[1], 1) }).ToArray();
-        var candidate_tile_size = convertVisitor.SearchTileSize(
-            SearchGenerator(search_space),
-            originLogicalPrimFunc,
-            _tileOptions.MultiWorkers,
-            false,
-            out var sched_response);
-        if (!candidate_tile_size.Any())
-        {
-            return false;
-        }
-
-        if (_tileOptions.PingPong && convertVisitor.BalanceTileSize(candidate_tile_size, search_space))
-        {
-            _ = convertVisitor.SearchTileSize(new TargetTileGenerator(candidate_tile_size), originLogicalPrimFunc, _tileOptions.MultiWorkers, true, out sched_response);
-        }
-        else
-        {
-        }
-
-        _caches.Add((convertVisitor, candidate_tile_size, sched_response));
-        if (_caches.Count > 1)
-        {
-            _caches.RemoveAt(0);
-        }
-
-        return true;
-    }
-
-    /// <summary>
-    /// <remark>
-    /// do not tile on w dimension.
-    /// </remark>
-    /// </summary>
-    /// <returns>.</returns>
-    private ISearchTileGenerator SearchGenerator(Segment[] search_spaces)
-    {
-        var newSpaces = search_spaces.ToArray();
-
-        // 这里就优先在ic上切分ping pong. 因为在ic上切分对于if来说都是不一样的.
-        var ic = newSpaces.Length - 1;
-        if (newSpaces[ic].ClampStop(2, out var new_seg))
-        {
-            newSpaces[ic] = new_seg;
-        }
-
-        // ic最小也得分两个tcu.
-        newSpaces[ic].Start = Math.Min(ExtCompilerServices.Env.TcuActNum * ExtCompilerServices.Env.PuHeight, newSpaces[ic].Stop);
-
-        var w = 3;
-        newSpaces[w].Start = newSpaces[w].Stop; // no tile w
-
-        return new QueuedSearchTileGenerator(newSpaces, g =>
-        {
-            g.Queue.Add((1, System.Math.Min(ExtCompilerServices.Env.PuWidth * ExtCompilerServices.Env.TcuActNum, g.UpperBounds[1]))); // oc
-            g.Queue.Add((4, g.UpperBounds[4])); // ic
-            g.Queue.Add((2, g.UpperBounds[2])); // h
-            g.Queue.Add((1, g.UpperBounds[1])); // oc
-        });
-    }
-}
-#endif
diff --git a/modules/Nncase.Modules.CPU/Runtime/CPU/CPURTModule.cs b/modules/Nncase.Modules.CPU/Runtime/CPU/CPURTModule.cs
deleted file mode 100644
index 0ed89e20f3..0000000000
--- a/modules/Nncase.Modules.CPU/Runtime/CPU/CPURTModule.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Nncase.Runtime.CPU;
-
-internal class CPURTModule
-{
-    /// <summary>
-    /// KPU module kind.
-    /// </summary>
-    public static readonly string Kind = "cpu";
-
-    /// <summary>
-    /// KPU module version.
-    /// </summary>
-    public static readonly uint Version = 1;
-}
diff --git a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
index 6bee77d2a7..3f9c2bc9cc 100644
--- a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
@@ -77,7 +77,15 @@ public void RegisterTargetDependentAfterQuantPass(IPassManager passManager, Comp
     {
         passManager.AddWithName<DataflowPass>("MakeFusion").Configure(p =>
         {
-            p.Add<CPUUnaryFusion>();
+            p.Add<CPUFusion>();
+        });
+
+        passManager.Add<CPUFusionToTirPass>(Passes.Tile.TileOptions.Default);
+
+        passManager.Add<PrimFuncPass>().Configure(p =>
+        {
+            p.Add<Passes.Mutators.UnFoldBlock>();
+            p.Add<Passes.Mutators.FlattenSequential>();
         });
     }
 
@@ -92,9 +100,11 @@ public IModuleBuilder CreateModuleBuilder(string moduleKind, CompileOptions opti
         {
             return new StackVMModuleBuilder();
         }
-        else
+        else if (moduleKind == CPUTarget.Kind)
         {
-            throw new NotSupportedException($"{moduleKind} module is not supported.");
+            return new CodeGen.CPU.ModuleBuilder(options);
         }
+
+        throw new NotSupportedException();
     }
 }
diff --git a/src/Nncase.CodeGen/CodeGen/LinkedFunction.cs b/src/Nncase.CodeGen/CodeGen/LinkedFunction.cs
index df9ff51a28..e1fe76b67a 100644
--- a/src/Nncase.CodeGen/CodeGen/LinkedFunction.cs
+++ b/src/Nncase.CodeGen/CodeGen/LinkedFunction.cs
@@ -15,7 +15,6 @@ public class LinkedFunction : ILinkedFunction
     public LinkedFunction(uint id, Callable sourceFunction, uint textBegin, uint textLength, IReadOnlyList<ILinkedSection> sections)
     {
         Id = id;
-        CompilerServices.InferenceType(sourceFunction);
         ParameterTypes = ((CallableType)sourceFunction.CheckedType).Parameters.ToArray();
         ReturnType = ((CallableType)sourceFunction.CheckedType).ReturnType;
         TextBegin = textBegin;
diff --git a/src/Nncase.Core/IR/Buffers/BufferOf.cs b/src/Nncase.Core/IR/Buffers/BufferOf.cs
index a3bb033275..baf982d17e 100644
--- a/src/Nncase.Core/IR/Buffers/BufferOf.cs
+++ b/src/Nncase.Core/IR/Buffers/BufferOf.cs
@@ -16,8 +16,8 @@ public sealed partial class BufferOf : Op
     /// </summary>
     public static readonly ParameterInfo Input = new(typeof(BufferOf), 0, "input", IsTensor());
 
-    public Schedule.MemoryLocation MemoryLocation { get; }
+    public TIR.MemoryLocation MemoryLocation { get; }
 
     /// <inheritdoc/>
-    public override string DisplayProperty() => $"Schedule.MemoryLocation.{MemoryLocation}";
+    public override string DisplayProperty() => $"MemoryLocation.{MemoryLocation}";
 }
diff --git a/src/Nncase.Core/IR/Buffers/Functional.cs b/src/Nncase.Core/IR/Buffers/Functional.cs
index 54cd9f59cf..a2e3507a5f 100644
--- a/src/Nncase.Core/IR/Buffers/Functional.cs
+++ b/src/Nncase.Core/IR/Buffers/Functional.cs
@@ -41,5 +41,5 @@ public static Call BaseMentOf(Expr input) =>
     /// <summary>
     /// create the uninitialized buffer.
     /// </summary>
-    public static Call Uninitialized(DataType dataType, Schedule.MemoryLocation memoryLocation, Expr shape) => new Call(new Uninitialized(dataType, memoryLocation), shape);
+    public static Call Uninitialized(DataType dataType, TIR.MemoryLocation memoryLocation, Expr shape) => new Call(new Uninitialized(dataType, memoryLocation), shape);
 }
diff --git a/src/Nncase.Core/IR/Buffers/Uninitialized.cs b/src/Nncase.Core/IR/Buffers/Uninitialized.cs
index 2f529638b9..42564bbc4c 100644
--- a/src/Nncase.Core/IR/Buffers/Uninitialized.cs
+++ b/src/Nncase.Core/IR/Buffers/Uninitialized.cs
@@ -19,11 +19,11 @@ public sealed partial class Uninitialized : Op
 
     public DataType DType { get; }
 
-    public Schedule.MemoryLocation MemoryLocation { get; }
+    public TIR.MemoryLocation MemoryLocation { get; }
 
     /// <inheritdoc/>
     public override bool CanFoldConstCall => false;
 
     /// <inheritdoc/>
-    public override string DisplayProperty() => $"{DType.GetCSharpName()}, Schedule.MemoryLocation.{MemoryLocation}";
+    public override string DisplayProperty() => $"{DType.GetCSharpName()}, MemoryLocation.{MemoryLocation}";
 }
diff --git a/src/Nncase.Core/IR/ExprCloner.g.cs b/src/Nncase.Core/IR/ExprCloner.g.cs
index 214605c69e..78d5d2bda4 100644
--- a/src/Nncase.Core/IR/ExprCloner.g.cs
+++ b/src/Nncase.Core/IR/ExprCloner.g.cs
@@ -256,4 +256,12 @@ protected override Expr VisitLeafIterVar(TIR.IterVar expr, TContext context)
         );
     }
 
+    /// <inheritdoc />
+    protected override Expr VisitLeafMemSpan(TIR.MemSpan expr, TContext context)
+    {
+        return expr.With(
+            start: Clone(expr.Start, context),
+            size: Clone(expr.Size, context)
+        );
+    }
 }
diff --git a/src/Nncase.Core/IR/ExprFunctor.g.cs b/src/Nncase.Core/IR/ExprFunctor.g.cs
index 642b2709e4..57e1ef86d5 100644
--- a/src/Nncase.Core/IR/ExprFunctor.g.cs
+++ b/src/Nncase.Core/IR/ExprFunctor.g.cs
@@ -154,6 +154,10 @@ public partial class ExprFunctor<TExprResult, TTypeResult, TContext>
     /// </summary>
     internal protected virtual TExprResult VisitIterVar(TIR.IterVar expr, TContext context) => DefaultVisit(expr, context);
 
+    /// <summary>
+    /// Visit <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    internal protected virtual TExprResult VisitMemSpan(TIR.MemSpan expr, TContext context) => DefaultVisit(expr, context);
 }
 
 public partial class ExprFunctor<TExprResult, TTypeResult>
@@ -354,4 +358,11 @@ public partial class ExprFunctor<TExprResult, TTypeResult>
     
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitIterVar(TIR.IterVar expr, Unit context) => VisitIterVar(expr);
+    /// <summary>
+    /// Visit <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    internal protected virtual TExprResult VisitMemSpan(TIR.MemSpan expr) => base.VisitMemSpan(expr, default);
+
+    /// <inheritdoc/>
+    internal protected sealed override TExprResult VisitMemSpan(TIR.MemSpan expr, Unit context) => VisitMemSpan(expr);
 }
diff --git a/src/Nncase.Core/IR/ExprRewriter.g.cs b/src/Nncase.Core/IR/ExprRewriter.g.cs
index 4c8cece3f2..2f0b6c1233 100644
--- a/src/Nncase.Core/IR/ExprRewriter.g.cs
+++ b/src/Nncase.Core/IR/ExprRewriter.g.cs
@@ -322,6 +322,10 @@ protected sealed override Expr VisitLeafIterVar(TIR.IterVar expr, TContext conte
     /// </summary>
     protected virtual Expr RewriteLeafIterVar(TIR.IterVar expr, TContext context) => DefaultRewriteLeaf(expr, context);
 
+    /// <summary>
+    /// Rewrite leaf <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    protected virtual Expr RewriteLeafMemSpan(TIR.MemSpan expr, TContext context) => DefaultRewriteLeaf(expr, context);
 }
 
 public partial class ExprRewriter
@@ -550,4 +554,11 @@ public partial class ExprRewriter
     /// <inheritdoc />
     protected sealed override Expr RewriteLeafIterVar(TIR.IterVar expr, Unit context) => RewriteLeafIterVar(expr);
 
+    /// <summary>
+    /// Rewrite leaf <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    protected virtual Expr RewriteLeafMemSpan(TIR.MemSpan expr) => DefaultRewriteLeaf(expr);
+
+    /// <inheritdoc />
+    protected sealed override Expr RewriteLeafMemSpan(TIR.MemSpan expr, Unit context) => RewriteLeafMemSpan(expr);
 }
diff --git a/src/Nncase.Core/IR/ExprVisitor.g.cs b/src/Nncase.Core/IR/ExprVisitor.g.cs
index c296f5f7e0..5e5a609a6a 100644
--- a/src/Nncase.Core/IR/ExprVisitor.g.cs
+++ b/src/Nncase.Core/IR/ExprVisitor.g.cs
@@ -205,6 +205,13 @@ protected internal override TExprResult VisitIterVar(TIR.IterVar expr, TContext
         return VisitLeafIterVar(expr, context);
     }
 
+    /// <inheritdoc />
+    protected internal override TExprResult VisitMemSpan(TIR.MemSpan expr, TContext context)
+    {
+        VisitOperands(expr, context);
+        return VisitLeafMemSpan(expr, context);
+    }
+
     /// <summary>
     /// Visit leaf <see cref="BaseFunction"/>.
     /// </summary>
@@ -345,6 +352,11 @@ protected internal override TExprResult VisitIterVar(TIR.IterVar expr, TContext
     /// </summary>
     protected virtual TExprResult VisitLeafIterVar(TIR.IterVar expr, TContext context) => DefaultVisitLeaf(expr, context);
 
+    /// <summary>
+    /// Visit leaf <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    protected virtual TExprResult VisitLeafMemSpan(TIR.MemSpan expr, TContext context) => DefaultVisitLeaf(expr, context);
+
 }
 
 public partial class ExprVisitor<TExprResult, TTypeResult>
@@ -524,6 +536,14 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
 
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitIterVar(TIR.IterVar expr, Unit context) => VisitIterVar(expr);
+    /// <summary>
+    /// Visit <see cref="TIR.IterVar"/>.
+    /// </summary>
+    internal protected virtual TExprResult VisitMemSpan(TIR.MemSpan expr) => base.VisitMemSpan(expr, default);
+
+    /// <inheritdoc/>
+    internal protected sealed override TExprResult VisitMemSpan(TIR.MemSpan expr, Unit context) => VisitMemSpan(expr);
+
     /// <summary>
     /// Visit leaf <see cref="BaseFunction"/>.
     /// </summary>
@@ -748,4 +768,11 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafIterVar(TIR.IterVar expr, Unit context) => VisitLeafIterVar(expr);
 
+    /// <summary>
+    /// Visit leaf <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    protected virtual TExprResult VisitLeafMemSpan(TIR.MemSpan expr) => base.VisitLeafMemSpan(expr, default);
+
+    /// <inheritdoc/>
+    protected sealed override TExprResult VisitLeafMemSpan(TIR.MemSpan expr, Unit context) => VisitLeafMemSpan(expr);
 }
diff --git a/src/Nncase.Core/Schedule/ScheduleTypes.cs b/src/Nncase.Core/Schedule/ScheduleTypes.cs
index 55b89ce8a0..9c2e47f8e2 100644
--- a/src/Nncase.Core/Schedule/ScheduleTypes.cs
+++ b/src/Nncase.Core/Schedule/ScheduleTypes.cs
@@ -10,51 +10,6 @@
 
 namespace Nncase.Schedule;
 
-/// <summary>
-/// the memory type.
-/// </summary>
-public enum MemoryLocation : byte
-{
-    /// <summary>
-    /// input.
-    /// </summary>
-    Input = 0,
-
-    /// <summary>
-    /// output.
-    /// </summary>
-    Output = 1,
-
-    /// <summary>
-    /// constant data.
-    /// </summary>
-    Rdata = 2,
-
-    /// <summary>
-    /// compute temp data.
-    /// </summary>
-    Data = 3,
-
-    /// <summary>
-    /// shared data.
-    /// </summary>
-    SharedData = 4,
-
-    /// <summary>
-    /// l2 data.
-    /// </summary>
-    L2Data = 5,
-
-    /// <summary>
-    /// L1 data.
-    /// </summary>
-    L1Data = 6,
-
-    /// <summary>
-    /// base addr.
-    /// </summary>
-    PrivateBase = 64,
-}
 
 /// <summary>
 /// the scheduler interface.
diff --git a/src/Nncase.Core/TIR/Buffer.cs b/src/Nncase.Core/TIR/Buffer.cs
index a3a35aac52..9289d1afec 100644
--- a/src/Nncase.Core/TIR/Buffer.cs
+++ b/src/Nncase.Core/TIR/Buffer.cs
@@ -269,7 +269,7 @@ public SelectedRange Slice(Segment1D segment)
 /// </summary>
 public abstract class Buffer : Expr
 {
-    public Buffer(string name, DataType elemType, Schedule.MemoryLocation memoryLocation, Expr[] operands)
+    public Buffer(string name, DataType elemType, MemoryLocation memoryLocation, Expr[] operands)
         : base(operands.ToArray())
     {
         Name = name;
@@ -281,7 +281,7 @@ public Buffer(string name, DataType elemType, Schedule.MemoryLocation memoryLoca
 
     public DataType ElemType { get; }
 
-    public Schedule.MemoryLocation MemLocation { get; }
+    public MemoryLocation MemLocation { get; }
 
     /// <summary>
     /// Gets if this buffer from the constant !.
@@ -341,7 +341,7 @@ public sealed class LogicalBuffer : Buffer
     /// <param name="elemType">prim type.</param>
     /// <param name="dimensions">the shape.</param>
     /// <param name="strides">the strides.</param>
-    public LogicalBuffer(string name, DataType elemType, Schedule.MemoryLocation location, ReadOnlySpan<Expr> dimensions, ReadOnlySpan<Expr> strides)
+    public LogicalBuffer(string name, DataType elemType, MemoryLocation location, ReadOnlySpan<Expr> dimensions, ReadOnlySpan<Expr> strides)
         : base(name, elemType, location, ArrayUtility.Concat(dimensions, strides))
     {
         Rank = dimensions.Length;
@@ -351,7 +351,7 @@ public LogicalBuffer(string name, DataType elemType, Schedule.MemoryLocation loc
     /// Initializes a new instance of the <see cref="LogicalBuffer"/> class.
     /// <see cref="LogicalBuffer"/>.
     /// </summary>
-    public LogicalBuffer(string name, Schedule.MemoryLocation location, TensorConst tensor)
+    public LogicalBuffer(string name, MemoryLocation location, TensorConst tensor)
         : this(name, tensor.Value.ElementType, location, ArrayUtility.ToExprArray(tensor.Value.Dimensions), ArrayUtility.ToExprArray(tensor.Value.Strides))
     {
         Const = tensor;
@@ -361,7 +361,7 @@ public LogicalBuffer(string name, Schedule.MemoryLocation location, TensorConst
     /// Initializes a new instance of the <see cref="LogicalBuffer"/> class.
     /// <seealso cref="LogicalBuffer"/>
     /// </summary>
-    public LogicalBuffer(string name, DataType elemType, Schedule.MemoryLocation location, ReadOnlySpan<Expr> dimensions)
+    public LogicalBuffer(string name, DataType elemType, MemoryLocation location, ReadOnlySpan<Expr> dimensions)
         : this(name, elemType, location, dimensions, TensorUtilities.GetStrides(dimensions))
     {
     }
@@ -394,7 +394,7 @@ public override string ToString()
     public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context)
         => functor.VisitLogicalBuffer(this, context);
 
-    public LogicalBuffer With(string? name = null, DataType? elemType = null, Schedule.MemoryLocation? location = null, Expr[]? dimensions = null, Expr[]? strides = null)
+    public LogicalBuffer With(string? name = null, DataType? elemType = null, MemoryLocation? location = null, Expr[]? dimensions = null, Expr[]? strides = null)
         => new LogicalBuffer(name ?? Name, elemType ?? ElemType, location ?? MemLocation, dimensions ?? Dimensions, strides ?? Strides) { Const = Const };
 }
 
@@ -410,7 +410,7 @@ public sealed class PhysicalBuffer : Buffer
     /// Initializes a new instance of the <see cref="PhysicalBuffer"/> class.
     /// ctor for physical buffer.
     /// </summary>
-    public PhysicalBuffer(string name, DataType elemType, Schedule.MemoryLocation location, ReadOnlySpan<int> dimensions, ReadOnlySpan<int> strides, int start, int size)
+    public PhysicalBuffer(string name, DataType elemType, MemoryLocation location, ReadOnlySpan<int> dimensions, ReadOnlySpan<int> strides, int start, int size)
         : base(name, elemType, location, Array.Empty<Expr>())
     {
         Start = start;
@@ -423,7 +423,7 @@ public PhysicalBuffer(string name, DataType elemType, Schedule.MemoryLocation lo
     /// Initializes a new instance of the <see cref="PhysicalBuffer"/> class.
     /// <see cref="PhysicalBuffer"/>.
     /// </summary>
-    public PhysicalBuffer(string name, DataType elemType, Schedule.MemoryLocation location, ReadOnlySpan<int> dimensions, int start, int size)
+    public PhysicalBuffer(string name, DataType elemType, MemoryLocation location, ReadOnlySpan<int> dimensions, int start, int size)
         : this(name, elemType, location, dimensions, TensorUtilities.GetStrides(dimensions), start, size)
     {
     }
@@ -432,7 +432,7 @@ public PhysicalBuffer(string name, DataType elemType, Schedule.MemoryLocation lo
     /// Initializes a new instance of the <see cref="PhysicalBuffer"/> class.
     /// <see cref="PhysicalBuffer"/>.
     /// </summary>
-    public PhysicalBuffer(string name, Schedule.MemoryLocation location, TensorConst tensor, int start, int size)
+    public PhysicalBuffer(string name, MemoryLocation location, TensorConst tensor, int start, int size)
         : this(name, tensor.Value.ElementType, location, tensor.Value.Dimensions, tensor.Value.Strides, start, size)
     {
         Const = tensor;
@@ -494,6 +494,6 @@ public override bool Equals(object? obj)
     public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context)
         => functor.VisitPhysicalBuffer(this, context);
 
-    public PhysicalBuffer With(string? name = null, DataType? elemType = null, Schedule.MemoryLocation? location = null, int[]? dimensions = null, int[]? strides = null, int? start = null, int? size = null)
+    public PhysicalBuffer With(string? name = null, DataType? elemType = null, MemoryLocation? location = null, int[]? dimensions = null, int[]? strides = null, int? start = null, int? size = null)
         => new PhysicalBuffer(name ?? Name, elemType ?? ElemType, location ?? MemLocation, dimensions ?? FixedDimensions, strides ?? FixedStrides, start ?? Start, size ?? Size) { Const = Const };
 }
diff --git a/src/Nncase.Core/TIR/MemSpan.cs b/src/Nncase.Core/TIR/MemSpan.cs
new file mode 100644
index 0000000000..c360932c46
--- /dev/null
+++ b/src/Nncase.Core/TIR/MemSpan.cs
@@ -0,0 +1,86 @@
+using Nncase;
+using Nncase.IR;
+
+namespace Nncase.TIR;
+
+
+/// <summary>
+/// the memory type.
+/// </summary>
+public enum MemoryLocation : byte
+{
+    /// <summary>
+    /// input.
+    /// </summary>
+    Input = 0,
+
+    /// <summary>
+    /// output.
+    /// </summary>
+    Output = 1,
+
+    /// <summary>
+    /// constant data.
+    /// </summary>
+    Rdata = 2,
+
+    /// <summary>
+    /// compute temp data.
+    /// </summary>
+    Data = 3,
+
+    /// <summary>
+    /// shared data.
+    /// </summary>
+    SharedData = 4,
+
+    /// <summary>
+    /// l2 data.
+    /// </summary>
+    L2Data = 5,
+
+    /// <summary>
+    /// L1 data.
+    /// </summary>
+    L1Data = 6,
+
+    /// <summary>
+    /// base addr.
+    /// </summary>
+    PrivateBase = 64,
+}
+
+public sealed class MemSpan : Expr
+{
+    public MemSpan(Expr size, MemoryLocation location) : base(new[] { None.Default, size })
+    {
+        Location = location;
+    }
+
+    public MemSpan(Expr start, Expr size, MemoryLocation location) : base(new[] { start, size })
+    {
+        Location = location;
+    }
+
+    /// <summary>
+    /// Gets the start.
+    /// </summary>
+    public Expr Start => Operands[0];
+
+    /// <summary>
+    /// Gets the size of bytes.
+    /// </summary>
+    public Expr Size => Operands[1];
+
+    /// <summary>
+    /// Gets the memory location.
+    /// </summary>
+    public MemoryLocation Location { get; }
+
+    /// <inheritdoc/>
+    public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context)
+        => functor.VisitMemSpan(this, context);
+
+
+    public MemSpan With(Expr? start = null, Expr? size = null, MemoryLocation? location = null) => new(start ?? Start, size ?? Size, location ?? Location);
+}
\ No newline at end of file
diff --git a/src/Nncase.Core/TIR/Ops.cs b/src/Nncase.Core/TIR/Ops.cs
index 76f9e395b6..cb6446fb76 100644
--- a/src/Nncase.Core/TIR/Ops.cs
+++ b/src/Nncase.Core/TIR/Ops.cs
@@ -12,7 +12,7 @@
 namespace Nncase.TIR;
 
 /// <summary>
-/// <see cref="T.Load(Var, Expr)"/>.
+/// Load op.
 /// </summary>
 public sealed partial class Load : Op
 {
@@ -24,7 +24,10 @@ public sealed partial class Load : Op
     /// <summary>
     /// Gets index.
     /// </summary>
-    public static readonly ParameterInfo Index = new(typeof(Load), 1, "index", HasDataType(DataTypes.Int32) & (IsScalar() | HasRank(1)));
+    public static readonly ParameterInfo Index = new(typeof(Load), 1, "index", IsIntegralScalar());
+
+    /// <inheritdoc/>
+    public override bool CanFoldConstCall => false;
 }
 
 /// <summary>
@@ -53,17 +56,20 @@ public sealed partial class Store : Op
     /// <summary>
     /// The buffer variable handle.
     /// </summary>
-    public static readonly ParameterInfo Handle = new(typeof(Store), 0, "handle", IsPointer());
+    public static readonly ParameterInfo Handle = new(typeof(Store), 0, "handle");
 
     /// <summary>
     /// The index locations to be stored.
     /// </summary>
-    public static readonly ParameterInfo Index = new(typeof(Store), 1, "index", HasDataType(DataTypes.Int32));
+    public static readonly ParameterInfo Index = new(typeof(Store), 1, "index", IsIntegralScalar());
 
     /// <summary>
     /// The value to be stored.
     /// </summary>
-    public static readonly ParameterInfo Value = new(typeof(Store), 2, "value");
+    public static readonly ParameterInfo Value = new(typeof(Store), 2, "value", IsScalar());
+
+    /// <inheritdoc/>
+    public override bool CanFoldConstCall => false;
 }
 
 /// <summary>
diff --git a/src/Nncase.Core/TIR/Script.cs b/src/Nncase.Core/TIR/Script.cs
index 9d9a212e46..8f640a0419 100644
--- a/src/Nncase.Core/TIR/Script.cs
+++ b/src/Nncase.Core/TIR/Script.cs
@@ -52,7 +52,7 @@ public static class T
     /// </summary>
     /// <param name="handle">The buffer handle variable in the load expression.</param>
     /// <param name="index">The index in the load.</param>
-    public static Call Load(Var handle, Expr index) => new Call(new Load(), handle, index);
+    public static Call Load(TIR.Buffer handle, Expr index) => new Call(new Load(), handle, index);
 
     /// <summary>
     /// get the nop op.
@@ -76,25 +76,7 @@ public static class T
     /// <param name="handle">The buffer Variable.</param>
     /// <param name="index">The index in the store expression.</param>
     /// <param name="value">The value we want to store.</param>
-    public static Call Store(Var handle, Expr index, Expr value) => new Call(new Store(), handle, index, value);
-
-    /// <summary>
-    /// If the op is BufferLoad, it will return BufferStore
-    /// If the op is Load, it will return Store.
-    /// </summary>
-    /// <param name="op">the op call.</param>
-    /// <param name="value">update value.</param>
-    /// <returns>new store call.</returns>
-    public static Expr Store(Expr op, Expr value) => op switch
-    {
-        Call load => load.Target switch
-        {
-            TIR.Load => T.Store((Var)load[TIR.Load.Handle], load[TIR.Load.Index], value),
-            _ => throw new InvalidOperationException("Only Can build Store Op from Load!"),
-        },
-        TIR.BufferLoad bufload => new BufferStore(bufload.Buffer, bufload.Indices, value),
-        _ => throw new InvalidOperationException("Only Can build Store Op from Load!"),
-    };
+    public static Call Store(TIR.Buffer handle, Expr index, Expr value) => new Call(new Store(), handle, index, value);
 
     /// <summary>
     /// build for loop.
@@ -226,7 +208,7 @@ public static IIfThenElseBuilder If(Expr condition)
     /// <summary>
     /// create the memRef by tensortype.
     /// </summary>
-    public static LogicalBuffer Buffer(DataType elem_type, Schedule.MemoryLocation location, ReadOnlySpan<Expr> dimensions, out LogicalBuffer buffer, [CallerArgumentExpression("buffer")] string name = "")
+    public static LogicalBuffer Buffer(DataType elem_type, MemoryLocation location, ReadOnlySpan<Expr> dimensions, out LogicalBuffer buffer, [CallerArgumentExpression("buffer")] string name = "")
     {
         if (name.StartsWith("var "))
         {
@@ -240,7 +222,7 @@ public static LogicalBuffer Buffer(DataType elem_type, Schedule.MemoryLocation l
     /// <summary>
     /// ctor for physical buffer.
     /// </summary>
-    public static PhysicalBuffer PhysicalBuffer(DataType elem_type, Schedule.MemoryLocation location, ReadOnlySpan<int> dimensions, out PhysicalBuffer buffer, [CallerArgumentExpression("buffer")] string name = "")
+    public static PhysicalBuffer PhysicalBuffer(DataType elem_type, MemoryLocation location, ReadOnlySpan<int> dimensions, out PhysicalBuffer buffer, [CallerArgumentExpression("buffer")] string name = "")
     {
         if (name.StartsWith("var "))
         {
@@ -271,7 +253,7 @@ public static PhysicalBuffer ConstBuffer(Const expr, out PhysicalBuffer buffer,
             throw new NotSupportedException();
         }
 
-        buffer = new PhysicalBuffer(name, Schedule.MemoryLocation.Rdata, (TensorConst)expr, 0, size);
+        buffer = new PhysicalBuffer(name, MemoryLocation.Rdata, (TensorConst)expr, 0, size);
         return buffer;
     }
 
@@ -294,7 +276,7 @@ public static Expr MayBeConst(Const? expr, out Buffer? buffer, [CallerArgumentEx
         {
             name = name[4..];
         }
-        buffer = new Buffer(name, Schedule.MemoryLocation.Rdata, (TensorType)expr.ValueType)
+        buffer = new Buffer(name, MemoryLocation.Rdata, (TensorType)expr.ValueType)
         {
             Const = expr,
         };
diff --git a/src/Nncase.Evaluator/TIR/Load.cs b/src/Nncase.Evaluator/TIR/Load.cs
index 6ea6faddff..86885bcc48 100644
--- a/src/Nncase.Evaluator/TIR/Load.cs
+++ b/src/Nncase.Evaluator/TIR/Load.cs
@@ -30,12 +30,6 @@ public string Visit(IIRPrinterContext context, Load target, bool iLmode)
 
     private IRType Visit(Load target, TensorType handle, TensorType index)
     {
-        if (!handle.IsScalar && handle.DType is not PointerType)
-        {
-            throw new NotSupportedException(handle.DType.ToString());
-        }
-
-        _ = index.IsScalar ? 1 : index.Shape[0].FixedValue;
-        return TensorType.Scalar(((PointerType)handle.DType).ElemType);
+        return TensorType.Scalar(handle.DType);
     }
 }
diff --git a/src/Nncase.Evaluator/TIR/Store.cs b/src/Nncase.Evaluator/TIR/Store.cs
index b29459bfe2..573a5e8660 100644
--- a/src/Nncase.Evaluator/TIR/Store.cs
+++ b/src/Nncase.Evaluator/TIR/Store.cs
@@ -33,12 +33,10 @@ public string Visit(IIRPrinterContext context, Store target, bool iLmode)
 
     private IRType Visit(Store target, TensorType handle, TensorType index, TensorType value)
     {
-        _ = index.IsScalar ? 1 : index.Shape[0].FixedValue;
-
-        var elemType = ((PointerType)handle.DType).ElemType;
-        if (elemType != value.DType)
+        
+        if (handle.DType != value.DType)
         {
-            return new InvalidType($"You Can't Load The {value.DType} To {elemType}");
+            return new InvalidType($"You Can't Load The {value.DType} To {handle.DType}");
         }
 
         return TupleType.Void;
diff --git a/src/Nncase.Passes/DDrBufferSchdeulePass.cs b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
index 8afdb3c5e0..e26a62ec0c 100644
--- a/src/Nncase.Passes/DDrBufferSchdeulePass.cs
+++ b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
@@ -23,7 +23,7 @@ namespace Nncase.Passes;
 /// </summary>
 public sealed class DDrBufferSchdeulePass : ModulePass
 {
-    private readonly Dictionary<string, Dictionary<Schedule.MemoryLocation, int>> _module_usage = new();
+    private readonly Dictionary<string, Dictionary<MemoryLocation, int>> _module_usage = new();
 
     private readonly Dictionary<string, HashSet<TIR.Buffer>> _module_hashset = new();
 
@@ -106,12 +106,12 @@ protected override async Task<IRModule> RunCoreAsync(IRModule module, RunPassCon
 /// </summary>
 internal sealed class DDrBufferAllocator : ExprVisitor<bool, bool>
 {
-    private readonly Dictionary<Schedule.MemoryLocation, int> _functionUsage;
+    private readonly Dictionary<MemoryLocation, int> _functionUsage;
     private readonly HashSet<TIR.Buffer> _functionHashset;
 
     private PrimFunction? _entry;
 
-    public DDrBufferAllocator(Dictionary<string, Dictionary<Schedule.MemoryLocation, int>> module_usage, Dictionary<string, HashSet<TIR.Buffer>> module_hashset)
+    public DDrBufferAllocator(Dictionary<string, Dictionary<MemoryLocation, int>> module_usage, Dictionary<string, HashSet<TIR.Buffer>> module_hashset)
     {
         ModuleUsage = module_usage;
         ModuleHashSet = module_hashset;
@@ -120,13 +120,13 @@ public DDrBufferAllocator(Dictionary<string, Dictionary<Schedule.MemoryLocation,
         Changed = false;
     }
 
-    public Dictionary<string, Dictionary<Schedule.MemoryLocation, int>> ModuleUsage { get; }
+    public Dictionary<string, Dictionary<MemoryLocation, int>> ModuleUsage { get; }
 
     public Dictionary<string, HashSet<TIR.Buffer>> ModuleHashSet { get; }
 
     public bool Changed { get; private set; }
 
-    public int DataUsage => _functionUsage.GetValueOrDefault(Schedule.MemoryLocation.Data, 0);
+    public int DataUsage => _functionUsage.GetValueOrDefault(MemoryLocation.Data, 0);
 
     /// <remarks>
     /// only visit one prim func.
@@ -138,7 +138,7 @@ protected override bool VisitPrimFunction(PrimFunction primFunction)
         {
             foreach (var physical in primFunction.Parameters)
             {
-                if (physical.MemLocation is Schedule.MemoryLocation.Input or Schedule.MemoryLocation.Output)
+                if (physical.MemLocation is MemoryLocation.Input or MemoryLocation.Output)
                 {
                     // avoid visit same buffer
                     if (!_functionHashset.Contains(physical))
@@ -175,7 +175,7 @@ protected override bool VisitLeafBuffer(TIR.Buffer buffer)
         }
 
         // rdata write into the moduleUsage
-        if (physical.MemLocation is Schedule.MemoryLocation.Rdata)
+        if (physical.MemLocation is MemoryLocation.Rdata)
         {
             if (!ModuleHashSet.TryGetValue(_entry!.ModuleKind, out var module_hashset))
             {
@@ -204,7 +204,7 @@ protected override bool VisitLeafBuffer(TIR.Buffer buffer)
                 Changed = true;
             }
         }
-        else if (physical.MemLocation is Schedule.MemoryLocation.Data)
+        else if (physical.MemLocation is MemoryLocation.Data)
         {
             // data write into the FunctionUsage
             if (!_functionHashset.Contains(physical))
@@ -220,7 +220,7 @@ protected override bool VisitLeafBuffer(TIR.Buffer buffer)
                 Changed = true;
             }
         }
-        else if (physical.MemLocation is Schedule.MemoryLocation.SharedData)
+        else if (physical.MemLocation is MemoryLocation.SharedData)
         {
             throw new NotSupportedException("Current Not Support!");
         }
diff --git a/src/Nncase.Passes/Rules/Neutral/PrimFuncMergeRule.cs b/src/Nncase.Passes/Rules/Neutral/PrimFuncMergeRule.cs
index 30cd890f12..9e1c2bc22c 100644
--- a/src/Nncase.Passes/Rules/Neutral/PrimFuncMergeRule.cs
+++ b/src/Nncase.Passes/Rules/Neutral/PrimFuncMergeRule.cs
@@ -98,7 +98,7 @@ public PrimFuncMergeRule(HashSet<IR.BaseFunction> mergedFuncs)
         }
 
         // 2. chack and create the data buffer
-        if (calleeFunc.Parameters.ToArray().Count(b => b.MemLocation == Schedule.MemoryLocation.Output) != 1)
+        if (calleeFunc.Parameters.ToArray().Count(b => b.MemLocation == MemoryLocation.Output) != 1)
         {
             // the direct call mean the callee function only have one output.
             return null;
@@ -128,7 +128,7 @@ public PrimFuncMergeRule(HashSet<IR.BaseFunction> mergedFuncs)
 
         // 5. build the new call.
         var nameWrapper = callerWrapper.Name; // + '_' + calleeWrapper.Name;
-        var newWrapper = new PrimFunctionWrapper(nameWrapper, newFunc, newFuncParams.Count(b => b.MemLocation == Schedule.MemoryLocation.Input));
+        var newWrapper = new PrimFunctionWrapper(nameWrapper, newFunc, newFuncParams.Count(b => b.MemLocation == MemoryLocation.Input));
 
         var newCallParams = new List<Expr>();
         newCallParams.AddRange(callerParams.Take(calleeBufferIndexs[0]));
@@ -151,10 +151,10 @@ private bool BufferCanMerge(TIR.PhysicalBuffer retBuffer, TIR.PhysicalBuffer inB
             retBuffer.FixedStrides.SequenceEqual(inBuffer.FixedStrides) &&
             retBuffer.ElemType == inBuffer.ElemType &&
             retBuffer.Size == inBuffer.Size &&
-            retBuffer.MemLocation == Schedule.MemoryLocation.Output &&
-            inBuffer.MemLocation == Schedule.MemoryLocation.Input)
+            retBuffer.MemLocation == MemoryLocation.Output &&
+            inBuffer.MemLocation == MemoryLocation.Input)
         {
-            dataBuffer = new TIR.PhysicalBuffer(inBuffer.Name, inBuffer.ElemType, Schedule.MemoryLocation.Data, inBuffer.FixedDimensions, inBuffer.FixedStrides, inBuffer.Start, inBuffer.Size);
+            dataBuffer = new TIR.PhysicalBuffer(inBuffer.Name, inBuffer.ElemType, MemoryLocation.Data, inBuffer.FixedDimensions, inBuffer.FixedStrides, inBuffer.Start, inBuffer.Size);
             return true;
         }
 
diff --git a/src/Nncase.Tests/CodeGen/CSourceHostCases.cs b/src/Nncase.Tests/CodeGen/CSourceHostCases.cs
index d6be29ed3b..97101d3c15 100644
--- a/src/Nncase.Tests/CodeGen/CSourceHostCases.cs
+++ b/src/Nncase.Tests/CodeGen/CSourceHostCases.cs
@@ -27,8 +27,8 @@ public class SubCase : ICodeGenCase
     public override PrimFunction GetEntry()
     {
         var func = T.PrimFunc("sub",
-                  T.Buffer(TensorType.Scalar(DataTypes.Float32), Schedule.MemoryLocation.Input, out var x),
-                  T.Buffer(TensorType.Scalar(DataTypes.Float32), Schedule.MemoryLocation.Input, out var y)).Body(
+                  T.Buffer(TensorType.Scalar(DataTypes.Float32), MemoryLocation.Input, out var x),
+                  T.Buffer(TensorType.Scalar(DataTypes.Float32), MemoryLocation.Input, out var y)).Body(
           x - y
         );
         return func;
@@ -71,8 +71,8 @@ public override void CompareEqual(IRTModel rtmod)
     public override PrimFunction GetEntry()
     {
         return T.PrimFunc("for_loop",
-               T.Buffer(new(DataTypes.Int32, new[] { 100 }), Schedule.MemoryLocation.Input, out var A),
-               T.Buffer(TensorType.Scalar(DataTypes.Int32), Schedule.MemoryLocation.Input, out var n)
+               T.Buffer(new(DataTypes.Int32, new[] { 100 }), MemoryLocation.Input, out var A),
+               T.Buffer(TensorType.Scalar(DataTypes.Int32), MemoryLocation.Input, out var n)
                ).Body(
           T.Serial(out var i, n).Body(
             T.Store(A[i], A[i] + 1),
diff --git a/src/Nncase.Tests/Core/UnitTestExpression.cs b/src/Nncase.Tests/Core/UnitTestExpression.cs
index 8f29fbdab5..9cbe60f849 100644
--- a/src/Nncase.Tests/Core/UnitTestExpression.cs
+++ b/src/Nncase.Tests/Core/UnitTestExpression.cs
@@ -262,7 +262,7 @@ public void TestConstBufferNotEqual()
     {
         var c = IR.F.Random.Normal(DataTypes.Float32, 1, 0, 0, new[] { 1, 16, 64, 400 }).Evaluate().AsTensor();
         var ddr_ld_input = new TIR.BufferRegion(Nncase.TIR.T.ConstBuffer(Const.FromTensor(c), out _, "ddr_ld_input"), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
-        var ddr_ld_output = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
+        var ddr_ld_output = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
         Assert.NotEqual(ddr_ld_input.Buffer, ddr_ld_output.Buffer);
         Assert.NotEqual(ddr_ld_input, ddr_ld_output);
     }
@@ -270,8 +270,8 @@ public void TestConstBufferNotEqual()
     [Fact]
     public void TestBufferEqual()
     {
-        var ddr_ld_input = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
-        var ddr_ld_output = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
+        var ddr_ld_input = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
+        var ddr_ld_output = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
         Assert.Equal(ddr_ld_input.Buffer, ddr_ld_output.Buffer);
         Assert.Equal(ddr_ld_input, ddr_ld_output);
     }
@@ -279,8 +279,8 @@ public void TestBufferEqual()
     [Fact]
     public void TestBufferNotEqual()
     {
-        var ddr_ld_input = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
-        var glb_ld_output = new TIR.BufferRegion(new TIR.PhysicalBuffer("glb_ld_output", DataTypes.BFloat16, Schedule.MemoryLocation.Data, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
+        var ddr_ld_input = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
+        var glb_ld_output = new TIR.BufferRegion(new TIR.PhysicalBuffer("glb_ld_output", DataTypes.BFloat16, MemoryLocation.Data, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
         Assert.False(ddr_ld_input.Buffer.Equals(glb_ld_output.Buffer));
         Assert.False(ddr_ld_input.Equals(glb_ld_output));
     }
diff --git a/src/Nncase.Tests/Core/UnitTestStringUtility.cs b/src/Nncase.Tests/Core/UnitTestStringUtility.cs
index 0b01ae0fd6..c17f577ee2 100644
--- a/src/Nncase.Tests/Core/UnitTestStringUtility.cs
+++ b/src/Nncase.Tests/Core/UnitTestStringUtility.cs
@@ -16,14 +16,14 @@ namespace Nncase.Tests.CoreTest;
 
 public static class TestExtensions
 {
-    public static ArrayExtensions.SpanWhereEnumerable<TIR.PhysicalBuffer, FunctionWrapper<TIR.PhysicalBuffer, bool>> InputOf(this ReadOnlySpan<TIR.PhysicalBuffer> arr) => arr.AsValueEnumerable().Where(b => b.MemLocation == Schedule.MemoryLocation.Input);
+    public static ArrayExtensions.SpanWhereEnumerable<TIR.PhysicalBuffer, FunctionWrapper<TIR.PhysicalBuffer, bool>> InputOf(this ReadOnlySpan<TIR.PhysicalBuffer> arr) => arr.AsValueEnumerable().Where(b => b.MemLocation == MemoryLocation.Input);
 
-    public static ArrayExtensions.SpanWhereEnumerable<TIR.PhysicalBuffer, FunctionWrapper<TIR.PhysicalBuffer, bool>> OutputOf(this ReadOnlySpan<TIR.PhysicalBuffer> arr) => arr.AsValueEnumerable().Where(b => b.MemLocation == Schedule.MemoryLocation.Output);
+    public static ArrayExtensions.SpanWhereEnumerable<TIR.PhysicalBuffer, FunctionWrapper<TIR.PhysicalBuffer, bool>> OutputOf(this ReadOnlySpan<TIR.PhysicalBuffer> arr) => arr.AsValueEnumerable().Where(b => b.MemLocation == MemoryLocation.Output);
 }
 
 public sealed class UnitTestStringUtility
 {
-    private readonly TIR.PrimFunction _entry = new("test_module", new Sequential(1), new TIR.PhysicalBuffer("testInput", DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new TIR.PhysicalBuffer("testInput", DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0));
+    private readonly TIR.PrimFunction _entry = new("test_module", new Sequential(1), new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0));
 
     [Fact]
     public void TestJoin()
diff --git a/src/Nncase.Tests/Core/UnitTestTIR.cs b/src/Nncase.Tests/Core/UnitTestTIR.cs
index ba7131f64e..0fce4d672d 100644
--- a/src/Nncase.Tests/Core/UnitTestTIR.cs
+++ b/src/Nncase.Tests/Core/UnitTestTIR.cs
@@ -47,21 +47,10 @@ public void TestScheduler()
     [Fact]
     public void TestBufferStore()
     {
-        Assert.Throws<InvalidOperationException>(() => T.Store(null!, null!));
-
-        var variable = new Var("x", DataTypes.Int32);
-        int index = 0;
-        Expr loadOp = T.Load(variable, index);
         Expr value = 42;
-        _ = T.Store(loadOp, value);
-
-        var physicalBuffer = new TIR.PhysicalBuffer("testInput", DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0);
+        var physicalBuffer = new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0);
         var indices = new Expr[] { 0, 1 };
-        Expr storeOp = T.Store(new BufferLoad(physicalBuffer, indices), value);
-        var store = (BufferStore)storeOp;
-        Assert.Equal(physicalBuffer, store.Buffer);
-        Assert.Equal(value, store.Value);
-        Assert.Equal(new Expr[] { 0 }, store.Indices.ToArray());
+        Call store = T.Store(physicalBuffer, 0, value);
     }
 
     [Fact]
@@ -165,8 +154,8 @@ public void TestPrimFunction()
     {
         var primFunc = new PrimFunction("test_module", new Sequential(new Expr[] { 1 }), new[]
         {
-            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
-            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
+            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
+            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
         });
 
         var primFuncParameters = primFunc.Parameters;
@@ -178,8 +167,8 @@ public void TestPrimFunction()
         var newBody = new Sequential(new Expr[] { 3 });
         var newParams = new[]
         {
-            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
-            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
+            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
+            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
         };
 
         var newPrimFunc = primFunc.With(moduleKind: newModuleKind, body: newBody, parameters: newParams);
diff --git a/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs b/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
index 31c6d763ae..bd9bcc3c5c 100644
--- a/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
+++ b/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
@@ -65,7 +65,7 @@ public void TestDumpFusion()
     [Fact]
     public void TestDumpScript()
     {
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out _), T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out _)).Body(T.Nop()).Build();
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out _)).Body(T.Nop()).Build();
 
         Assert.True(CompilerServices.InferenceType(prim_func_1));
 
diff --git a/src/Nncase.Tests/Evaluator/UnitTestEvaluator.cs b/src/Nncase.Tests/Evaluator/UnitTestEvaluator.cs
index 3f230b49c5..0fdb6fe4da 100755
--- a/src/Nncase.Tests/Evaluator/UnitTestEvaluator.cs
+++ b/src/Nncase.Tests/Evaluator/UnitTestEvaluator.cs
@@ -97,10 +97,10 @@ public void TestOnnxResizeImage()
     public void TestLoadStore()
     {
         var loop_i = new Var(TensorType.Scalar(DataTypes.Int32));
-        var load = T.Load(T.Handle("hd", DataTypes.Float32), loop_i);
+        T.Buffer(DataTypes.Float32, MemoryLocation.Input, new Expr[] { 1, 2, 3 }, out var bf);
+        var load = T.Load(bf, loop_i);
         CompilerServices.InferenceType(load);
-
-        var store = T.Store((Var)load[TIR.Load.Handle], load[TIR.Load.Index], loop_i);
+        var store = T.Store(bf, loop_i, IR.F.Tensors.Cast(loop_i, DataTypes.Float32));
         CompilerServices.InferenceType(store);
     }
 
diff --git a/src/Nncase.Tests/Evaluator/UnitTestEvaluatorBuffers.cs b/src/Nncase.Tests/Evaluator/UnitTestEvaluatorBuffers.cs
index 04c7a43c44..bed1177d0d 100644
--- a/src/Nncase.Tests/Evaluator/UnitTestEvaluatorBuffers.cs
+++ b/src/Nncase.Tests/Evaluator/UnitTestEvaluatorBuffers.cs
@@ -29,7 +29,7 @@ public class UnitTestEvaluatorBuffers : TestClassBase
     public void TestUninitialized()
     {
         var shape = new[] { 1 };
-        var expr = IR.F.Buffer.Uninitialized(DataTypes.Float32, MemoryLocation.Input, shape);
+        var expr = IR.F.Buffer.Uninitialized(DataTypes.Float32, TIR.MemoryLocation.Input, shape);
         CompilerServices.InferenceType(expr);
         Assert.Equal(Value.None, expr.Evaluate());
     }
diff --git a/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs b/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs
index 9b791049d0..e514c3e09a 100644
--- a/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs
+++ b/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs
@@ -33,11 +33,11 @@ internal static class PrimFuncBuilder
     public static PrimFunctionWrapper MakeLoadStoreFunc(bool mask)
     {
         var allocator = new Allocator();
-        var fusion_input = allocator.Allocate($"fusion_{_count}_input", Schedule.MemoryLocation.Input);
+        var fusion_input = allocator.Allocate($"fusion_{_count}_input", TIR.MemoryLocation.Input);
 
-        var glb = allocator.Allocate($"fusion_{_count}_glb", Schedule.MemoryLocation.L2Data);
+        var glb = allocator.Allocate($"fusion_{_count}_glb", TIR.MemoryLocation.L2Data);
 
-        var fusion_output = allocator.Allocate($"fusion_{_count}_output", Schedule.MemoryLocation.Output);
+        var fusion_output = allocator.Allocate($"fusion_{_count}_output", TIR.MemoryLocation.Output);
 
         var fusion_1 = TIR.T.PrimFunc($"fusion_{_count}_{mask}", Callable.StackVMModuleKind, fusion_input, fusion_output).Body(
           new Call(new TIRTest.LoadT(), fusion_input, glb),
@@ -50,12 +50,12 @@ public static PrimFunctionWrapper MakeLoadStoreFunc(bool mask)
     public static PrimFunctionWrapper MakeBinaryFunc(BinaryOp binaryOp, bool mask)
     {
         var allocator = new Allocator();
-        var fusion_input_lhs = allocator.Allocate($"fusion_{_count}_input_lhs", Schedule.MemoryLocation.Input);
-        var fusion_input_rhs = allocator.Allocate($"fusion_{_count}_input_rhs", Schedule.MemoryLocation.Input);
-        var glb_lhs = allocator.Allocate($"fusion_{_count}_glb_lhs", Schedule.MemoryLocation.L2Data);
-        var glb_rhs = allocator.Allocate($"fusion_{_count}_glb_rhs", Schedule.MemoryLocation.L2Data);
-        var glb_output = allocator.Allocate($"fusion_{_count}_glb_output", Schedule.MemoryLocation.L2Data);
-        var fusion_output = allocator.Allocate($"fusion_{_count}_output", Schedule.MemoryLocation.Output);
+        var fusion_input_lhs = allocator.Allocate($"fusion_{_count}_input_lhs", TIR.MemoryLocation.Input);
+        var fusion_input_rhs = allocator.Allocate($"fusion_{_count}_input_rhs", TIR.MemoryLocation.Input);
+        var glb_lhs = allocator.Allocate($"fusion_{_count}_glb_lhs", TIR.MemoryLocation.L2Data);
+        var glb_rhs = allocator.Allocate($"fusion_{_count}_glb_rhs", TIR.MemoryLocation.L2Data);
+        var glb_output = allocator.Allocate($"fusion_{_count}_glb_output", TIR.MemoryLocation.L2Data);
+        var fusion_output = allocator.Allocate($"fusion_{_count}_output", TIR.MemoryLocation.Output);
 
         var fusion = TIR.T.PrimFunc($"fusion_{_count}_{mask}", Callable.StackVMModuleKind, fusion_input_lhs, fusion_input_rhs, fusion_output).Body(
           new Call(new TIRTest.LoadT(), fusion_input_lhs, glb_lhs),
@@ -74,13 +74,13 @@ public static PrimFunctionWrapper MakeMultiInputFunc(int length, bool mask)
         var fusion_inputs = new List<TIR.PhysicalBuffer>();
         for (int i = 0; i < length; i++)
         {
-            var fusion_input_i = allocator.Allocate($"fusion_{_count}_input_{i}", Schedule.MemoryLocation.Input);
+            var fusion_input_i = allocator.Allocate($"fusion_{_count}_input_{i}", TIR.MemoryLocation.Input);
             fusion_inputs.Add(fusion_input_i);
         }
 
-        var glb1 = allocator.Allocate($"fusion_{_count}_glb1", Schedule.MemoryLocation.L2Data);
-        var glb2 = allocator.Allocate($"fusion_{_count}_glb2", Schedule.MemoryLocation.L2Data);
-        var fusion_output = allocator.Allocate($"fusion_{_count}_output", Schedule.MemoryLocation.Output);
+        var glb1 = allocator.Allocate($"fusion_{_count}_glb1", TIR.MemoryLocation.L2Data);
+        var glb2 = allocator.Allocate($"fusion_{_count}_glb2", TIR.MemoryLocation.L2Data);
+        var fusion_output = allocator.Allocate($"fusion_{_count}_output", TIR.MemoryLocation.Output);
 
         var fusion = TIR.T.PrimFunc($"multi_fusion_{_count}_{mask}", Callable.StackVMModuleKind, fusion_inputs.Concat(new[] { fusion_output }).ToArray());
 
@@ -124,13 +124,13 @@ private static IEnumerable<BinaryOp> GetBinaryOp(int length)
 
     private sealed class Allocator
     {
-        private readonly Dictionary<Schedule.MemoryLocation, int> _useage = new() {
-          { Schedule.MemoryLocation.Input, 0 },
-          { Schedule.MemoryLocation.Output, 0 },
-          { Schedule.MemoryLocation.L2Data, 0 },
+        private readonly Dictionary<TIR.MemoryLocation, int> _useage = new() {
+          { TIR.MemoryLocation.Input, 0 },
+          { TIR.MemoryLocation.Output, 0 },
+          { TIR.MemoryLocation.L2Data, 0 },
         };
 
-        public TIR.PhysicalBuffer Allocate(string name, Schedule.MemoryLocation location)
+        public TIR.PhysicalBuffer Allocate(string name, TIR.MemoryLocation location)
         {
             var strides = TensorUtilities.GetStrides(Dimensions);
             var size = TensorUtilities.GetSize(Dimensions, strides, DataTypes.Float32.SizeInBytes);
diff --git a/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs b/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs
index 9cd1eb7139..f5183e5127 100644
--- a/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs
+++ b/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs
@@ -121,11 +121,11 @@ internal sealed class PrimFuncEvaluateVisitor
     private static readonly int _pool_size = 1 * 4 * 8 * 9 * 4 * 30;
     private readonly PrimFunctionWrapper _wrapper;
     private readonly IValue[] _args;
-    private readonly Dictionary<Schedule.MemoryLocation, byte[]> _poolMap = new() {
-          { Schedule.MemoryLocation.Input, new byte[_pool_size] },
-          { Schedule.MemoryLocation.L2Data, new byte[_pool_size] },
-          { Schedule.MemoryLocation.Data, new byte[_pool_size] },
-          { Schedule.MemoryLocation.Output, new byte[_pool_size] },
+    private readonly Dictionary<TIR.MemoryLocation, byte[]> _poolMap = new() {
+          { TIR.MemoryLocation.Input, new byte[_pool_size] },
+          { TIR.MemoryLocation.L2Data, new byte[_pool_size] },
+          { TIR.MemoryLocation.Data, new byte[_pool_size] },
+          { TIR.MemoryLocation.Output, new byte[_pool_size] },
         };
 
     public PrimFuncEvaluateVisitor(PrimFunctionWrapper wrapper, params IValue[] args)
diff --git a/src/Nncase.Tests/TIR/UnitTestMutators.cs b/src/Nncase.Tests/TIR/UnitTestMutators.cs
index 1df67941ae..a20d5f7295 100644
--- a/src/Nncase.Tests/TIR/UnitTestMutators.cs
+++ b/src/Nncase.Tests/TIR/UnitTestMutators.cs
@@ -30,9 +30,9 @@ public UnitTestMutators()
     [Fact]
     public async Task TestFoldConstCallWithTuple()
     {
-        T.PhysicalBuffer(DataTypes.BFloat16, Schedule.MemoryLocation.Input, new[] { 48 }, out var ddr_if);
-        T.PhysicalBuffer(DataTypes.BFloat16, Schedule.MemoryLocation.Data, new[] { 9 }, out var glb_if_ping);
-        T.PhysicalBuffer(DataTypes.BFloat16, Schedule.MemoryLocation.Data, new[] { 9 }, out var glb_if_pong);
+        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Input, new[] { 48 }, out var ddr_if);
+        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Data, new[] { 9 }, out var glb_if_ping);
+        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Data, new[] { 9 }, out var glb_if_pong);
         PrimFunction main;
         {
             main = T.PrimFunc("main", Callable.StackVMModuleKind, ddr_if).Body(
@@ -118,8 +118,8 @@ public async Task TestUnRollLoopSequential()
     [Fact]
     public async Task TestUnRollLoopSequential2()
     {
-        T.PhysicalBuffer(DataTypes.BFloat16, Schedule.MemoryLocation.Input, new[] { 3, 16, 24, 24 }, out var ddr_if);
-        T.PhysicalBuffer(DataTypes.BFloat16, Schedule.MemoryLocation.Data, new[] { 3, 10, 5, 9 }, out var glb_if);
+        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Input, new[] { 3, 16, 24, 24 }, out var ddr_if);
+        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Data, new[] { 3, 10, 5, 9 }, out var glb_if);
 
         PrimFunction main;
         {
@@ -201,8 +201,8 @@ public async Task TestUnRollLoopSequential2()
     [Fact]
     public async Task TestUnRollLoopSequential3()
     {
-        T.PhysicalBuffer(DataTypes.BFloat16, Schedule.MemoryLocation.Input, new[] { 3, 16, 24, 24 }, out var ddr_if);
-        T.PhysicalBuffer(DataTypes.BFloat16, Schedule.MemoryLocation.Data, new[] { 3, 10, 5, 9 }, out var glb_if);
+        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Input, new[] { 3, 16, 24, 24 }, out var ddr_if);
+        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Data, new[] { 3, 10, 5, 9 }, out var glb_if);
 
         PrimFunction main;
         {
@@ -362,9 +362,9 @@ public async Task TestFoldLet2()
     [Fact]
     public async Task TestFoldBufferIndex()
     {
-        T.PhysicalBuffer(DataTypes.BFloat16, Schedule.MemoryLocation.Input, new[] { 3, 16, 24, 24 }, out var ddr_if);
-        T.PhysicalBuffer(DataTypes.BFloat16, Schedule.MemoryLocation.Output, new[] { 3, 16, 24, 24 }, out var ddr_of);
-        T.PhysicalBuffer(DataTypes.BFloat16, Schedule.MemoryLocation.Data, new[] { 3, 10, 5, 9 }, out var glb_if);
+        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Input, new[] { 3, 16, 24, 24 }, out var ddr_if);
+        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Output, new[] { 3, 16, 24, 24 }, out var ddr_of);
+        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Data, new[] { 3, 10, 5, 9 }, out var glb_if);
         var bufferIndexMap = new Dictionary<TIR.PhysicalBuffer, int>() {
           { ddr_if, 2 },
           { ddr_of, 4 },
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
new file mode 100644
index 0000000000..28ff7ccf07
--- /dev/null
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -0,0 +1,51 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Nncase.CodeGen;
+using Nncase.IR;
+using Nncase.IR.Tensors;
+using Nncase.Runtime.Interop;
+using Nncase.Targets;
+using Nncase.Tests.TestFixture;
+using Nncase.Utilities;
+using Xunit;
+using static Nncase.IR.F.Tensors;
+using GetItem = Nncase.IR.Tensors.GetItem;
+
+namespace Nncase.Tests.Targets;
+
+[AutoSetupTestMethod(InitSession = true)]
+public class UnitTestCPUTargetTiling : TestClassBase
+{
+    public UnitTestCPUTargetTiling()
+    {
+        DefaultTargetName = CPUTarget.Kind;
+#if DEBUG
+        CompileOptions.DumpFlags = Diagnostics.DumpFlags.PassIR | Diagnostics.DumpFlags.Rewrite | Diagnostics.DumpFlags.CodeGen;
+#endif
+    }
+
+    [Fact]
+    public async Task TestCpuUnary()
+    {
+        var input = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 2, 3, 4, 5 }));
+        var main = new Function("main", IR.F.Math.Unary(UnaryOp.Asin, input), new[] { input });
+        var module = new IR.IRModule(main);
+
+        var compiler = CompileSession.Compiler;
+        compiler.ImportIRModule(module);
+        await compiler.CompileAsync();
+        using (var fs = new MemoryStream())
+        {
+            compiler.Gencode(fs);
+        }
+    }
+}
diff --git a/src/Nncase.Tests/Transform/UnitTestPassManager.cs b/src/Nncase.Tests/Transform/UnitTestPassManager.cs
index bc7cb98896..85d4cf1442 100644
--- a/src/Nncase.Tests/Transform/UnitTestPassManager.cs
+++ b/src/Nncase.Tests/Transform/UnitTestPassManager.cs
@@ -22,7 +22,7 @@ public sealed class UnitTestPassManager : TestClassBase
     [Fact]
     public void TestPassMangerUpdateDependence()
     {
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out _), T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out _)).Body(T.Nop()).Build();
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out _)).Body(T.Nop()).Build();
 
         var prim_wrapper = new PrimFunctionWrapper(prim_func_1, 1);
 
@@ -30,7 +30,7 @@ public void TestPassMangerUpdateDependence()
         var main_func = new Function("main", new Call(prim_wrapper, input), input);
 
         // prim_func_2 for update
-        var prim_func_2 = T.PrimFunc("prim_func_2", "k?", T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out _), T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out _)).Body(
+        var prim_func_2 = T.PrimFunc("prim_func_2", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out _)).Body(
           T.Nop(),
           T.Nop()).Build();
 
@@ -54,15 +54,15 @@ public void TestPassMangerUpdateDependence2()
           %3 = %func_3(%2): // f16[1,23,30,16]
         */
 
-        var prim_func_0 = T.PrimFunc("prim_func_0", "k?", T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 24, 32, 3 }, out var _), T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Output, new[] { 1, 3, 24, 32 }, out var _)).Body(
+        var prim_func_0 = T.PrimFunc("prim_func_0", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 24, 32, 3 }, out var _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 3, 24, 32 }, out var _)).Body(
           T.Nop()).Build();
         var func_0 = new PrimFunctionWrapper(prim_func_0, 1);
 
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 3, 24, 32 }, out var _), T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Output, new[] { 1, 3, 24, 32 }, out var _)).Body(
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 3, 24, 32 }, out var _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 3, 24, 32 }, out var _)).Body(
           T.Nop()).Build();
         var func_1 = new PrimFunctionWrapper(prim_func_1, 1);
 
-        var prim_func_2 = T.PrimFunc("prim_func_2", "k?", T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 3, 24, 32 }, out var _), T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Output, new[] { 1, 23, 30, 16 }, out var _)).Body(
+        var prim_func_2 = T.PrimFunc("prim_func_2", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 3, 24, 32 }, out var _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 23, 30, 16 }, out var _)).Body(
           T.Nop()).Build();
         var func_2 = new PrimFunctionWrapper(prim_func_2, 1);
 
@@ -74,7 +74,7 @@ public void TestPassMangerUpdateDependence2()
         Assert.True(CompilerServices.InferenceType(main_func));
 
         // prim_func_2 for update
-        var prim_func_1_update = T.PrimFunc("prim_func_1_update", "k?", T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 3, 24, 32 }, out var _), T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Output, new[] { 1, 3, 24, 32 }, out var _)).Body(
+        var prim_func_1_update = T.PrimFunc("prim_func_1_update", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 3, 24, 32 }, out var _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 3, 24, 32 }, out var _)).Body(
           T.Nop(),
           T.Nop()).Build();
 
diff --git a/src/Nncase.Tests/Transform/UnitTestSubstitutor.cs b/src/Nncase.Tests/Transform/UnitTestSubstitutor.cs
index 9313303252..f6a1ed969e 100644
--- a/src/Nncase.Tests/Transform/UnitTestSubstitutor.cs
+++ b/src/Nncase.Tests/Transform/UnitTestSubstitutor.cs
@@ -24,8 +24,9 @@ public sealed class UnitTestSubstitutor : TestClassBase
     public void TestSubstitutorFailed()
     {
         var loop_i = new Var("loop_i", TensorType.Scalar(DataTypes.Int32));
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out var input_a), T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out var input_b)).Body(
-          T.Load(T.Handle("hd", DataTypes.Float32), loop_i)).Build();
+        T.Buffer(DataTypes.Float32, MemoryLocation.Input, new Expr[] { 1, 2, 3, 4 }, out var hd);
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out var input_a), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out var input_b)).Body(
+          T.Load(hd, loop_i)).Build();
 
         var prim_wrapper = new PrimFunctionWrapper(prim_func_1, 1);
 
@@ -48,8 +49,9 @@ public void TestSubstitutorFailed()
     public void TestSubstitutorTrue()
     {
         var loop_i = new Var("loop_i", TensorType.Scalar(DataTypes.Int32));
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out var input_a), T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out var input_b)).Body(
-          T.Load(T.Handle("hd", DataTypes.Float32), loop_i)).Build();
+        T.Buffer(DataTypes.Float32, MemoryLocation.Input, new Expr[] { 1, 2, 3, 4 }, out var hd);
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out var input_a), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out var input_b)).Body(
+          T.Load(hd, loop_i)).Build();
 
         Dictionary<Expr, Expr> vmap = new() { { loop_i, 1 } };
         var substitutor = Mutator.Substitute(e => vmap.TryGetValue(e, out var res) ? res : null)();
@@ -65,8 +67,9 @@ public void TestSubstitutorTrue()
     public void TestSubstitutorTrue2()
     {
         var loop_i = new Var("loop_i", TensorType.Scalar(DataTypes.Int32));
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, Schedule.MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out var input_a), T.PhysicalBuffer(DataTypes.Int32, Schedule.MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out var input_b)).Body(
-          T.Load(T.Handle("hd", DataTypes.Float32), loop_i)).Build();
+        T.Buffer(DataTypes.Float32, MemoryLocation.Input, new Expr[] { 1, 2, 3, 4 }, out var hd);
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out var input_a), T.PhysicalBuffer(DataTypes.Int32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out var input_b)).Body(
+          T.Load(hd, loop_i)).Build();
 
         var prim_wrapper = new PrimFunctionWrapper(prim_func_1, 1);
 
diff --git a/targets/Nncase.Targets.CSource/CSourceTarget.cs b/targets/Nncase.Targets.CSource/CSourceTarget.cs
deleted file mode 100644
index e6f3e19a8f..0000000000
--- a/targets/Nncase.Targets.CSource/CSourceTarget.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-
-namespace Nncase.Targets;
-
-public class CSourceTarget : ITarget
-{
-    /// <inheritdoc/>
-    public string Kind { get => "CSource"; set { } }
-    /// <inheritdoc/>
-    public Dictionary<string, object> Options { get; set; } = new();
-    /// <inheritdoc/>
-    public Dictionary<string, object> Attrs { get; set; } = new();
-    /// <inheritdoc/>
-    public void ConfigOptions() { }
-    /// <inheritdoc/>
-    public void ConfigAttrs() { }
-
-    /// <inheritdoc/>
-    public Schedule.IScheduler CreateScheduler(IR.IRModule main_module)
-    {
-        return new Schedule.CSourceScheduler(main_module, this);
-    }
-
-    /// <inheritdoc/>
-    public CodeGen.IRTModel CreateRTModel(IR.IRModel model)
-    {
-        return new CodeGen.CSourceRTModel(model, this);
-    }
-
-    /// <inheritdoc/>
-    public CodeGen.IRTModule CreateRTModule(IR.IRModel model, IR.IRModule module)
-    {
-        throw new NotImplementedException("The CSource Target Only Have Runtime Model!");
-    }
-}
diff --git a/targets/Nncase.Targets.CSource/CodeGen/CSource.cs b/targets/Nncase.Targets.CSource/CodeGen/CSource.cs
deleted file mode 100644
index afc0de3b68..0000000000
--- a/targets/Nncase.Targets.CSource/CodeGen/CSource.cs
+++ /dev/null
@@ -1,278 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Text;
-using Nncase.IR;
-using Nncase.Schedule;
-using Nncase.TIR;
-
-namespace Nncase.CodeGen;
-
-/// <summary>
-/// the c source runtime function.
-/// </summary>
-/// <param name="name"></param>
-/// <param name="handle"></param>
-public record CSourceRTFunction(string name, Delegate handle) : IRTFunction
-{
-    public string Name { get => name; set { } }
-    public Delegate Handle { get => handle; set { } }
-}
-
-public class CSourceSerializeResult : ISerializeResult
-{
-
-}
-
-/// <summary>
-/// c runtime module impl
-/// </summary>
-public class CSourceRTModel : IRTModule, IRTModel
-{
-    /// <inheritdoc/>
-    public ModuleType ModuleType { get => CodeGen.ModuleType.Create("CSource"); set { } }
-
-    /// <inheritdoc/>
-    public ITarget Target { get; set; }
-
-    /// <inheritdoc/>
-    public IReadOnlyList<IRTModule> Modules => throw new NotImplementedException();
-
-    /// <inheritdoc/>
-    public string SourcePath { get; private set; }
-
-    public IRModel Model { get; set; }
-    IRTFunction? _entry = null;
-
-    /// <inheritdoc/>
-    public bool IsSerialized { get; private set; }
-
-    readonly List<IRTFunction> _functions = new();
-
-    /// <summary>
-    /// <see cref="CSourceRTModel"/>
-    /// </summary>
-    public CSourceRTModel(IRModel model, ITarget target)
-    {
-        SourcePath = CodeGenUtil.GetTempFileName("c");
-        Model = model;
-        Target = target;
-    }
-
-    /// <inheritdoc/>
-    public byte[] Source { get => File.ReadAllBytes(SourcePath); set { } }
-
-    /// <inheritdoc/>
-    public string SourceExt { get => "c"; set { } }
-
-    /// <inheritdoc/>
-    public IRTFunction? Entry => _entry;
-
-    /// <inheritdoc/>
-    public IReadOnlyList<IRTFunction> Functions => _functions;
-
-    /// <inheritdoc/>
-    string _dllPath = "";
-
-    /// <summary>
-    /// write the c source code into source path.
-    /// </summary>
-    /// <exception cref="InvalidProgramException"></exception>
-    void BuildCode()
-    {
-        if (File.Exists(SourcePath))
-            File.Delete(SourcePath);
-        using (var writer = new StreamWriter(SourcePath, false, Encoding.UTF8))
-        {
-            var visior = new CSourceHostBuildVisior(writer);
-            if (Model.Entry is null) { throw new InvalidProgramException("The Model Entry Is Null!"); }
-            if (Model.Entry.CheckedType is null && Model.Entry.InferenceType() == false) { throw new InvalidProgramException("The Model Entry Can't Inference Type!"); }
-            visior.Visit(Model.Entry);
-        }
-    }
-
-    public void CompileCode()
-    {
-        if (!File.Exists(SourcePath))
-            throw new InvalidProgramException("The Source Code Path Is Invalid!");
-        var compiler = new CSourceCompiler();
-        _dllPath = compiler.Compile(SourcePath);
-    }
-
-    /// <summary>
-    /// bind each IR.Funtion with C function
-    /// </summary>
-    /// <exception cref="InvalidProgramException"></exception>
-    public void ExportCode()
-    {
-        if (!File.Exists(_dllPath))
-            throw new InvalidProgramException("The DLL Path Is Invalid!");
-        var dllPtr = NativeLibrary.Load(_dllPath);
-        foreach (var module in Model.Modules)
-        {
-            foreach (var f in module.Callables)
-            {
-                var funcType = f.ToDelegateType(Path.GetFileName(_dllPath));
-                var funPtr = NativeLibrary.GetExport(dllPtr, f.Name);
-                _functions.Add(new CSourceRTFunction(f.Name, funPtr.BindDelegate(funcType)));
-                if (f == Model.Entry) { _entry = _functions.Last(); }
-            }
-        }
-    }
-
-    /// <inheritdoc/>
-    public ISerializeResult Serialize()
-    {
-        if (IsSerialized) { return new CSourceSerializeResult(); }
-        BuildCode();
-        CompileCode();
-        ExportCode();
-        return new CSourceSerializeResult();
-    }
-
-    /// <summary>
-    /// invoke the module entry
-    /// </summary>
-    /// <param name="args">input args</param>
-    /// <returns> results </returns>
-    /// <exception cref="InvalidOperationException"></exception>
-    public object? Invoke(params object?[]? args)
-    {
-        if (Entry is null)
-            throw new InvalidOperationException("This RTModule Have No Entry Function!");
-        return Entry.Handle.DynamicInvoke(args);
-    }
-
-    public string Dump(string name, string DumpDirPath)
-    {
-        var dump_path = $"{DumpDirPath}/{name}.{SourceExt}";
-        using var file = File.Open(dump_path, FileMode.OpenOrCreate, FileAccess.Write);
-        using var writer = new StreamWriter(file);
-        writer.Write(Source);
-        return dump_path;
-    }
-
-}
-
-/// <summary>
-/// the csource code compiler.
-/// </summary>
-public class CSourceCompiler
-{
-    /// <summary>
-    /// compiler exe name
-    /// </summary>
-    string _exe = "", _arch = "", _ext = "";
-
-    /// <summary>
-    /// select current pattern's exe
-    /// </summary>
-    /// <exception cref="NotSupportedException"></exception>
-    void PlatformSpecific()
-    {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-        {
-            _exe = "gcc";
-            _ext = "so";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-        {
-            _exe = "clang";
-            _ext = "dylib";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-        {
-            _exe = "cmd";
-            _ext = "dll";
-        }
-    }
-
-    void ArchSpecific()
-    {
-        _arch = RuntimeInformation.OSArchitecture switch
-        {
-            Architecture.X64 => RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "x86-64" : "x86_64",
-            Architecture.Arm64 => "arm64",
-            _ => throw new NotSupportedException(RuntimeInformation.OSArchitecture.ToString()),
-        };
-    }
-
-    string ArgumentsSpecific(string sourcePath, string outPath)
-    {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-        {
-            return $"{sourcePath} -fPIC -shared -march={Arch} -o {outPath}";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-        {
-            return $"{sourcePath} -fPIC -shared -arch {Arch} -o {outPath}";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-        {
-            var vsdir = Environment.GetEnvironmentVariable("VSAPPIDDIR") ?? throw new InvalidOperationException("Cannot find vs");
-            var vcvardir = Path.Combine(vsdir, "..\\..\\VC\\Auxiliary\\Build\\vcvarsall.bat");
-            return $"/C (\"{vcvardir}\" x64) && (cl /D_USRDLL /D_WINDLL \"{sourcePath}\" /MT /link /DLL /OUT:\"{outPath}\")";
-        }
-        throw new System.ArgumentOutOfRangeException("Only Support Linux/Osx/Windows");
-    }
-
-    protected string Exe
-    {
-        get => _exe;
-    }
-
-    protected string Arch
-    {
-        get => _arch;
-    }
-
-    protected string Ext
-    {
-        get => _ext;
-    }
-
-    public CSourceCompiler()
-    {
-        PlatformSpecific();
-        ArchSpecific();
-    }
-
-    /// <summary>
-    /// compile the source txt, write to the out_path
-    /// </summary>
-    /// <param name="sourcePath"> c source code</param>
-    /// <param name="outPath"> out .so path </param>
-    /// <returns> outPath </returns>
-    public string Compile(string sourcePath, string outPath)
-    {
-        var errMsg = new StringBuilder();
-        using (var errWriter = new StringWriter(errMsg))
-        {
-            using (var proc = new Process())
-            {
-                proc.StartInfo.FileName = Exe;
-                proc.StartInfo.Arguments = ArgumentsSpecific(sourcePath, outPath);
-                proc.StartInfo.RedirectStandardError = true;
-                proc.ErrorDataReceived += (sender, e) => errWriter.WriteLine(e.Data);
-                proc.Start();
-                proc.BeginErrorReadLine();
-                proc.WaitForExit();
-                if (proc.ExitCode != 0)
-                {
-                    throw new InvalidOperationException(errMsg.ToString());
-                }
-            }
-        }
-        return outPath;
-    }
-
-    /// <summary>
-    /// create the temp dll file and compile source
-    /// <see cref="Compile(string, string)"/>
-    /// </summary>
-    public string Compile(string sourcePath) => Compile(sourcePath, CodeGenUtil.GetTempFileName(Ext));
-}
\ No newline at end of file
diff --git a/targets/Nncase.Targets.CSource/CodeGen/CSourceVisitor.cs b/targets/Nncase.Targets.CSource/CodeGen/CSourceVisitor.cs
deleted file mode 100644
index 352b9dc6ea..0000000000
--- a/targets/Nncase.Targets.CSource/CodeGen/CSourceVisitor.cs
+++ /dev/null
@@ -1,317 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Text;
-using Nncase.IR;
-using Nncase.Runtime;
-using Nncase.TIR;
-
-namespace Nncase.CodeGen;
-
-/// <summary>
-/// convert the type/op to c name
-/// </summary>
-internal static class NameConverter
-{
-    private static readonly Dictionary<PrimType, string> _primTypeToC = new()
-    {
-        { DataTypes.Boolean, "bool" },
-        { DataTypes.Int8, "int8_t" },
-        { DataTypes.Int16, "int16_t" },
-        { DataTypes.Int32, "int32_t" },
-        { DataTypes.Int64, "int64_t" },
-        { DataTypes.UInt8, "uint8_t" },
-        { DataTypes.UInt16, "uint16_t" },
-        { DataTypes.UInt32, "uint32_t" },
-        { DataTypes.UInt64, "uint64_t" },
-        { DataTypes.Float32, "float" },
-        { DataTypes.Float64, "double" },
-    };
-
-    public static string toC(this PrimType primType) =>
-        _primTypeToC[primType];
-
-    public static string toC(this DataType dataType) => dataType switch
-    {
-        PrimType ptype => ptype.toC(),
-        PointerType { ElemType: PrimType etype } => etype.toC() + "*",
-        _ => throw new NotSupportedException(dataType.ToString())
-    };
-}
-
-/// <summary>
-/// the c symbol define
-/// </summary>
-internal struct CSymbol
-{
-    public string Type;
-    public StringBuilder Doc;
-    public CSymbol(string type, StringBuilder doc)
-    {
-        Type = type;
-        Doc = doc;
-    }
-    public override string ToString() => $"{Type} {Doc}";
-}
-
-/// <summary>
-/// collect the csymbol's parameter
-/// </summary>
-internal class CSymbolParamList : IParameterList<CSymbol>, IEnumerable<CSymbol>
-{
-    CSymbol[] Symbols;
-    public CSymbolParamList(CSymbol[] symbols)
-    {
-        Symbols = symbols;
-    }
-
-    public CSymbol this[ParameterInfo parameter] => Symbols[parameter.Index];
-    public CSymbol this[int index] => Symbols[index];
-
-    public IEnumerator<CSymbol> GetEnumerator()
-    {
-        return ((IEnumerable<CSymbol>)Symbols).GetEnumerator();
-    }
-
-    IEnumerator IEnumerable.GetEnumerator()
-    {
-        return Symbols.GetEnumerator();
-    }
-}
-
-
-/// <summary>
-/// visitor for the build c source code, the expr vistor return (type string , name string)
-/// </summary>
-internal class CSourceHostBuildVisior : ExprFunctor<CSymbol, string>
-{
-
-    /// <summary>
-    /// source writer .
-    /// TODO we need the decl writer
-    /// </summary>
-    readonly ScopeWriter Scope;
-
-    /// <summary>
-    /// symbols name memo
-    /// </summary>
-    readonly Dictionary<Expr, CSymbol> Symbols = new(ReferenceEqualityComparer.Instance);
-
-    /// <summary>
-    /// <see cref="CSourceHostBuildVisior"/>
-    /// </summary>
-    /// <param name="textWriter"></param>
-    public CSourceHostBuildVisior(TextWriter textWriter)
-    {
-        Scope = new ScopeWriter(textWriter);
-        // insert some declare
-        Scope.IndWriteLine(@"
-#ifdef _WIN32
-#define EXPORT_API __declspec(dllexport) 
-#else
-#define EXPORT_API
-#endif");
-        Scope.IndWriteLine("#include <stdint.h>");
-    }
-
-    /// <inheritdoc/>
-    public override CSymbol Visit(Call expr)
-    {
-        if (Symbols.TryGetValue(expr, out var symbol)) { return symbol; }
-        var target = Visit(expr.Target);
-        var args = new CSymbolParamList(expr.Parameters.Select(Visit).ToArray());
-        var type = VisitType(expr.CheckedType!);
-        Scope.Push();
-        switch (expr.Target)
-        {
-            case IR.Math.Binary:
-                Scope.Append($"({args[0].Doc} {target.Doc} {args[1].Doc})");
-                break;
-            case Store:
-                Scope.Append($"{args[Store.Handle].Doc}[{args[Store.Index].Doc}] = {args[Store.Value].Doc}");
-                break;
-            case Load:
-                Scope.Append($"{args[Store.Handle].Doc}[{args[Store.Index].Doc}]");
-                break;
-            case IR.Tensors.Cast:
-                Scope.Append($"(({type}){args[IR.Tensors.Cast.Input].Doc})");
-                break;
-            default:
-                Scope.Append($"{target.Doc}({string.Join(", ", args.Select(x => x.Doc))})");
-                break;
-        }
-        symbol = new(type, Scope.Pop());
-        Symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    public override CSymbol Visit(Const expr)
-    {
-        if (Symbols.TryGetValue(expr, out var symbol)) { return symbol; }
-        if (expr.CheckedType is TensorType ttype && ttype.IsScalar)
-        {
-            var literal = $"{expr}" switch
-            {
-                "True" => "1",
-                "False" => "0",
-                var x => x
-            };
-            symbol = new(VisitType(ttype), new(literal));
-        }
-        else
-        {
-            throw new NotSupportedException($"Not Support {expr.CheckedType} Const");
-        }
-        Symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    public override CSymbol Visit(Function expr)
-    {
-        if (Symbols.TryGetValue(expr, out var symbol)) { return symbol; }
-        var retType = VisitType(((CallableType)expr.CheckedType!).ReturnType);
-        Scope.Push();
-        // 1. Function signature
-        Scope.IndWrite($"EXPORT_API {retType} {expr.Name}({string.Join(", ", expr.Parameters.Select(Visit))}) {{");
-        // 2. Function body
-        using (Scope.IndentUp())
-        {
-            Scope.Append(Visit(expr.Body).Doc);
-        }
-        // 3. Function closing
-        Scope.IndWrite("}");
-        symbol = new(CallableTypeToPtr((CallableType)expr.CheckedType!, expr.Name), Scope.Pop());
-        // 4. write whole code
-        Scope.IndWrite(symbol.Doc);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    public override CSymbol Visit(Op expr)
-    {
-        if (Symbols.TryGetValue(expr, out var symbol)) { return symbol; }
-        symbol = new("Invalid Op", new(expr switch
-        {
-            IR.Math.Binary op => op.BinaryOp switch
-            {
-                BinaryOp.Add => "+",
-                BinaryOp.Sub => "-",
-                BinaryOp.Mul => "*",
-                BinaryOp.Div => "/",
-                BinaryOp.Mod => "%",
-                _ => throw new ArgumentOutOfRangeException(op.BinaryOp.ToString())
-            },
-            TIR.Store op => "Store",
-            TIR.Load op => "Load",
-            IR.Tensors.Cast op => op.NewType.toC(),
-            _ => throw new NotSupportedException($"{expr.GetType().Name}")
-        }));
-        Symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    public override CSymbol Visit(Var expr)
-    {
-        if (Symbols.TryGetValue(expr, out var symbol)) { return symbol; }
-        var isymbol = Scope.GetUniqueVarSymbol(expr);
-        symbol = new(VisitType(expr.CheckedType!), isymbol.Span);
-        Symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    public override CSymbol Visit(For expr)
-    {
-        if (Symbols.TryGetValue(expr, out var symbol)) { return symbol; }
-        Scope.Push();
-        // 1. For Loop signature
-        var loopVar = Visit(expr.LoopVar);
-        Scope.Append($"for ({loopVar} = {Visit(expr.Dom.Start).Doc}; {loopVar.Doc} < {Visit(expr.Dom.Stop).Doc}; {loopVar.Doc}+={expr.Dom.Step}) {{");
-        // 2. For Body
-        Scope.Append(Visit(expr.Body).Doc);
-        // 3. For closing
-        Scope.IndWrite("}");
-        symbol = new(VisitType(expr.CheckedType!), Scope.Pop());
-        Symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    public override CSymbol Visit(Sequential expr)
-    {
-        if (Symbols.TryGetValue(expr, out var symbol)) { return symbol; }
-        Scope.Push();
-        Scope.AppendLine("");
-        using (Scope.IndentUp())
-        {
-            foreach (var i in Enumerable.Range(0, expr.Fields.Count))
-            {
-                if (i == expr.Fields.Count - 1 &&
-                    expr.Fields[i].CheckedType is TensorType)
-                {
-                    Scope.IndWrite("return ");
-                }
-                else
-                {
-                    Scope.IndWrite(string.Empty);
-                }
-                Scope.Append(Visit(expr.Fields[i]).Doc);
-                if (expr.Fields[i] is Call)
-                {
-                    Scope.AppendLine(";");
-                }
-                else
-                {
-                    Scope.AppendLine(string.Empty);
-                }
-            }
-        }
-        symbol = new(VisitType(expr.CheckedType!), Scope.Pop());
-        Symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    public override CSymbol Visit(IfThenElse expr)
-    {
-        if (Symbols.TryGetValue(expr, out var symbol)) { return symbol; }
-        Scope.Push();
-        Scope.Append($"if({Visit(expr.Condition).Doc}) {{");
-        Scope.Append(Visit(expr.Then).Doc);
-        Scope.IndWrite("} else {");
-        Scope.Append(Visit(expr.Else).Doc);
-        Scope.IndWrite("}");
-        symbol = new(VisitType(expr.CheckedType!), Scope.Pop());
-        Symbols.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    /// <example>
-    /// void (*fun_ptr)(int)
-    /// </example>
-    public string CallableTypeToPtr(CallableType type, string name) => $"{VisitType(type.ReturnType)} (*{name}_ptr)({string.Join(",", type.Parameters.Select(VisitType))})";
-
-
-    /// <inheritdoc/>
-    public override string VisitType(TensorType type)
-    {
-        if (!type.IsScalar)
-        {
-            throw new NotSupportedException($"{type}");
-        }
-        return type.DType.toC();
-    }
-
-    /// <inheritdoc/>
-    public override string VisitType(TupleType type) => type == TupleType.Void ?
-      "void" :
-      throw new InvalidProgramException($"The C Source Must Not Have TupleType {type}!");
-}
\ No newline at end of file
diff --git a/targets/Nncase.Targets.CSource/CodeGen/Interop.cs b/targets/Nncase.Targets.CSource/CodeGen/Interop.cs
deleted file mode 100644
index 33d31af269..0000000000
--- a/targets/Nncase.Targets.CSource/CodeGen/Interop.cs
+++ /dev/null
@@ -1,140 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Reflection.Emit;
-using System.Runtime.InteropServices;
-using Nncase.IR;
-
-namespace Nncase.CodeGen;
-
-/// <summary>
-/// <see cref="DynamicAssemble(string)"/>
-/// </summary>
-internal class DynamicAssemble
-{
-    /// <summary>
-    /// name
-    /// </summary>
-    AssemblyName assemblyName;
-    /// <summary>
-    /// asm builder for whole module
-    /// </summary>
-    AssemblyBuilder asmBuilder;
-    /// <summary>
-    /// module buidler
-    /// </summary>
-    ModuleBuilder modBuilder;
-    /// <summary>
-    /// save the func name <=> func delegate type
-    /// </summary>
-    readonly Dictionary<string, Type> delegateTypes = new();
-
-    /// <summary>
-    /// a DynamicAssemble instance, it's contains one rtmodule's all functions defination.
-    /// </summary>
-    /// <param name="Name"> asmble name </param>
-    public DynamicAssemble(string Name)
-    {
-        assemblyName = new AssemblyName(Name);
-        asmBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndCollect);
-        modBuilder = asmBuilder.DefineDynamicModule(assemblyName.Name!);
-
-    }
-
-    /// <summary>
-    /// <see cref="CreateDelegateType(string, Type, Type[]?)"/>
-    /// </summary>
-    /// <param name="function"></param>
-    /// <returns> func delegate type</returns>
-    public Type BuildDelegateType(Callable function)
-    {
-        Type deleType;
-        if (function.CheckedType is CallableType ctype)
-        {
-            deleType = CreateDelegateType(function.Name, ctype.ReturnType.ToType(), ctype.Parameters.Select(Interop.ToType).ToArray());
-        }
-        else { throw new NotSupportedException(function.CheckedType?.ToString()); }
-        return deleType;
-    }
-
-    /// <summary>
-    /// dynamic create delegate type for function.
-    /// </summary>
-    /// <param name="funcName"></param>
-    /// <param name="returnType"></param>
-    /// <param name="ParamTypes"></param>
-    /// <returns></returns>
-    /// <exception cref="InvalidProgramException"></exception>
-    public Type CreateDelegateType(string funcName, Type returnType, params Type[]? ParamTypes)
-    {
-        if (!delegateTypes.TryGetValue(funcName, out var ret))
-        {
-            ParamTypes ??= new Type[] { };
-            TypeBuilder tb = modBuilder.DefineType(funcName, TypeAttributes.Public | TypeAttributes.Sealed, typeof(MulticastDelegate));
-            tb.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard | CallingConventions.HasThis, new[] { typeof(object), typeof(IntPtr) }).SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);
-            tb.DefineMethod("Invoke", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot, CallingConventions.Standard | CallingConventions.HasThis, returnType, ParamTypes).SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);
-            tb.DefineMethod("BeginInvoke", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot, CallingConventions.Standard | CallingConventions.HasThis, typeof(IAsyncResult), ParamTypes.Concat(new[] { typeof(IAsyncResult), typeof(object) }).ToArray()).SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);
-            tb.DefineMethod("EndInvoke", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot, CallingConventions.Standard | CallingConventions.HasThis, returnType, new[] { typeof(IAsyncResult) }).SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);
-            ret = tb.CreateType();
-            if (ret is null) { throw new InvalidProgramException($"Can't Create The Func {funcName}'s delegate Type!"); }
-            delegateTypes.Add(funcName, ret);
-        }
-        return ret;
-    }
-}
-
-/// <summary>
-/// Interop helper
-/// </summary>
-public static class Interop
-{
-    /// <summary>
-    /// collect the all dynamic asmbs
-    /// </summary>
-    private static readonly Dictionary<string, DynamicAssemble> _definedAsms = new();
-
-    /// <summary>
-    /// convert the ir type to the system type
-    /// </summary>
-    /// <param name="iRType"></param>
-    /// <returns></returns>
-    /// <exception cref="NotSupportedException"></exception>
-    public static Type ToType(this IRType iRType) => iRType switch
-    {
-        TensorType { IsScalar: true, DType: PrimType { } primType } => primType.CLRType,
-        TensorType { IsScalar: true, DType: PointerType { ElemType: PrimType primType } } => primType.CLRType.MakeArrayType(),
-        TupleType ttype => (ttype == TupleType.Void) switch
-        {
-            true => typeof(void),
-            false => throw new NotSupportedException($"Can't Support the {ttype}!")
-        },
-        _ => throw new NotSupportedException($"IRType is {iRType}!")
-    };
-
-
-    /// <summary>
-    /// convrt function to delegate type
-    /// </summary>
-    /// <param name="function"> input function </param>
-    /// <param name="libName"> the dynamic lib name </param>
-    /// <returns></returns>
-    /// <exception cref="NotSupportedException"></exception>
-    public static Type ToDelegateType(this Callable function, string libName)
-    {
-        if (!_definedAsms.TryGetValue(libName, out var dyasm))
-        {
-            dyasm = new DynamicAssemble(libName);
-            _definedAsms.Add(libName, dyasm);
-        }
-        return dyasm.BuildDelegateType(function); ;
-    }
-
-    /// <summary>
-    /// bind the delegate to funcptr.
-    /// </summary>
-    /// <param name="funcPtr"></param>
-    /// <param name="funcType"></param>
-    /// <returns></returns>
-    public static Delegate BindDelegate(this IntPtr funcPtr, Type funcType) => Marshal.GetDelegateForFunctionPointer(funcPtr, funcType);
-}
diff --git a/targets/Nncase.Targets.CSource/Nncase.Targets.CSource.csproj b/targets/Nncase.Targets.CSource/Nncase.Targets.CSource.csproj
deleted file mode 100644
index 79226f6c03..0000000000
--- a/targets/Nncase.Targets.CSource/Nncase.Targets.CSource.csproj
+++ /dev/null
@@ -1,16 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <CodeAnalysisRuleSet>$(SolutionDir)/tools/StyleCopAnalyzers.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\src\Nncase.Core\Nncase.Core.csproj" />
-    <ProjectReference Include="..\..\src\Nncase.Schedule\Nncase.Schedule.csproj" />
-    <ProjectReference Include="..\..\src\Nncase.CodeGen\Nncase.CodeGen.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/targets/Nncase.Targets.CSource/Schedule/CSourceScheduler.cs b/targets/Nncase.Targets.CSource/Schedule/CSourceScheduler.cs
deleted file mode 100644
index b57cf2419d..0000000000
--- a/targets/Nncase.Targets.CSource/Schedule/CSourceScheduler.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using Nncase.IR;
-
-namespace Nncase.Schedule;
-
-public class CSourceScheduler : IScheduler
-{
-
-    public CSourceScheduler(IR.IRModule main_module, ITarget target)
-    {
-        Module = main_module;
-        Target = target;
-    }
-
-    public ITarget Target { get; set; }
-    public IRModule Module { get; set; }
-
-
-    IRModel IScheduler.Schedule(bool skip_buffer_alias)
-    {
-        return new IRModel(new[] { Module });
-    }
-}
\ No newline at end of file
diff --git a/tools/Nncase.SourceGenerator/Pattern/PatternGenerator.cs b/tools/Nncase.SourceGenerator/Pattern/PatternGenerator.cs
index 7495791550..8e2aa7cfa2 100644
--- a/tools/Nncase.SourceGenerator/Pattern/PatternGenerator.cs
+++ b/tools/Nncase.SourceGenerator/Pattern/PatternGenerator.cs
@@ -85,7 +85,7 @@ select Parameter(Identifier(f.Name.ToLower()))
                             // var x = name_params[0];
                             statements.Add(ParseStatement(@$"return new(
 new OpPattern<{cand.Op.ToDisplayString()}>(x => {condition}, {(name_params[0] != null ? "target_name" : "null")}), 
-new VArgsPattern (new[]{{ {inputs} }}, null),
+new VArgsPattern (new Pattern[]{{ {inputs} }}, null),
 {(name_params[1] != null ? "call_name" : "null")});").
                                            WithLeadingTrivia(ElasticTab).
                                            WithTrailingTrivia(ElasticLineFeed));
@@ -125,7 +125,7 @@ select Parameter(Identifier(f.Name.ToLower()))
                             // 1.3 build method return
                             statements.Add(ParseStatement(@$"return new(
 new OpPattern<{cand.Op.ToDisplayString()}>(condition, {(name_params[0] != null ? "target_name" : "null")}),
-new VArgsPattern( new [] {{ {inputs} }}, null ),
+new VArgsPattern( new Pattern[] {{ {inputs} }}, null ),
 {(name_params[1] != null ? "call_name" : "null")});").
                                            WithLeadingTrivia(ElasticTab).
                                            WithTrailingTrivia(ElasticLineFeed));

From 49c9baac44ff75f25c025188f40b71041f04d80b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 21 Jul 2023 18:05:55 +0800
Subject: [PATCH 007/308] fix csource entry

---
 .../CodeGen/CSourceBuiltn.cs                  | 39 +++++++++++++++++--
 .../CodeGen/CSourceConvertVisitor.cs          |  6 +--
 .../CodeGen/CSourceUtilities.cs               |  2 +-
 .../CodeGen/LinkableFunction.cs               |  8 ++--
 .../CodeGen/LinkableModule.cs                 | 18 +++++++++
 5 files changed, 63 insertions(+), 10 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index eda007050f..adb7195e5f 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -9,14 +9,47 @@ public static class CSourceBuiltn
     public const string BufferType = "buffer_t";
 
     public const string BufferStruct = @"typedef struct buffer {
-    void *ptr;
+    void *vaddr;
+    size_t paddr;
     int *shape;
     int *stride;
     int rank;
 } buffer_t;";
 
-    public const string Include = @"#include<stdio.h>";
+    public const string MethodTable = @"typedef struct nncase_method_table {
+  float (*float_unary_asin)(float);
+} nncase_mt_t;";
+
+    public const string Include = @"#include <stdint.h>
+#include <stddef.h>
+";
+
+    public const string FixedParameters = "nncase_mt_t* nncase_mt, void* data, void* rdata";
+
+    public const string MainPrologue = $@"void _start(char* name, buffer_t** buffers, {FixedParameters}) {{";
+
+    public const string MainEpilogue = @"}";
+
+    public static string Header => $@"
+{Include}
+
+{MethodTable}
+
+{BufferStruct}
+
+int strcmp(const char* s1,const char* s2) {{
+  while(*s1 && *s2) {{
+    if(*s1 != *s2) {{
+      break;
+    }}
+    s1++;
+    s2++; 
+  }}
+  return (*s1 - *s2) || (*s1 - '\0') || (*s2 - '\0'); 
+}}
+
+static nncase_mt_t *nncase_mt;
+";
 
-    public static string Header => Include + "\n" + BufferStruct;
 
 }
\ No newline at end of file
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 71b8d5ee65..7df0c005dc 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -123,7 +123,7 @@ protected override CSymbol VisitPrimFunction(PrimFunction expr)
             throw new NotSupportedException("The PrimFunction must return void!");
         }
 
-        var type = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(b => Visit(b).ToString()).ToArray())})";
+        var type = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(b => Visit(b).ToString()).ToArray())}, {CSourceBuiltn.FixedParameters})";
 
         using (var scope = new IndentScope(_implBuilder))
         {
@@ -169,10 +169,10 @@ protected override CSymbol VisitCall(Call expr)
                 str = CSourceUtilities.ContertUnary(op, arguments);
                 break;
             case Store:
-                str = $"((({arguments[2].Type} *){arguments[0].Name}->ptr)[{arguments[1].Name}] = {arguments[2].Name})";
+                str = $"((({arguments[2].Type} *){arguments[0].Name}->vaddr)[{arguments[1].Name}] = {arguments[2].Name})";
                 break;
             case Load:
-                str = $"((({type} *){arguments[0].Name}->ptr)[{arguments[1].Name}])";
+                str = $"((({type} *){arguments[0].Name}->vaddr)[{arguments[1].Name}])";
                 break;
             default:
                 throw new NotSupportedException();
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
index fbcf4e372d..be8d32cabd 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
@@ -31,7 +31,7 @@ internal static string ContertUnary(Unary op, CSymbol[] arguments)
                 str = ($"!{input}");
                 break;
             default:
-                str = ($"nncase_mt->{op.UnaryOp.ToString()}{input}");
+                str = ($"nncase_mt->{arguments[0].Type}_{nameof(Unary).ToLower()}_{op.UnaryOp.ToString().ToLower()}{input}");
                 break;
         }
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
index bd6dc4c270..4ad32bd353 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
@@ -7,21 +7,23 @@ namespace Nncase.CodeGen.CPU;
 
 internal sealed class LinkableFunction : ILinkableFunction
 {
-    private readonly byte[] _desc;
-
     public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, FunctionCSource funcCSource)
     {
         Id = id;
         SourceFunction = sourceFunction;
+        PrimFunction = sourceFunction;
         FunctionCSource = funcCSource;
         Text = Array.Empty<byte>();
-        Sections = new LinkedSection[] { };
+        var desc = System.Text.Encoding.ASCII.GetBytes(sourceFunction.Name);
+        Sections = new LinkedSection[] { new(desc, ".desc", 0, 8, (uint)desc.Length) };
     }
 
     public uint Id { get; }
 
     public BaseFunction SourceFunction { get; }
 
+    public TIR.PrimFunction PrimFunction { get; }
+
     public FunctionCSource FunctionCSource { get; }
 
     public byte[] Text { get; }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index 8c8f5952a3..350460e5a2 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -33,6 +33,13 @@ public ILinkedModule Link(ILinkContext linkContext)
 
         if (DumpScope.Current.IsEnabled(DumpFlags.CodeGen))
         {
+            using (var fs = DumpScope.Current.OpenFile("cpuModule.h"))
+            {
+                using (var writer = new StreamWriter(fs))
+                {
+                    writer.Write(CSourceBuiltn.Header);
+                }
+            }
             using (var fs = DumpScope.Current.OpenFile("cpuModule.c"))
             {
                 File.Open(csourcePath, FileMode.Open, FileAccess.Read).CopyTo(fs);
@@ -56,6 +63,7 @@ private string LinkCSources()
             using (var writer = new StreamWriter(fs))
             {
                 writer.WriteLine(CSourceBuiltn.Header);
+
                 foreach (var func in _functions)
                 {
                     writer.WriteLine(func.FunctionCSource.Declaration);
@@ -65,6 +73,16 @@ private string LinkCSources()
                 {
                     writer.WriteLine(func.FunctionCSource.Implementation);
                 }
+
+                writer.WriteLine(CSourceBuiltn.MainPrologue);
+                foreach (var func in _functions)
+                {
+                    writer.WriteLine($"  if (strcmp(name,\"{func.SourceFunction.Name}\") == 0) {{");
+                    writer.WriteLine($"    {func.SourceFunction.Name}({string.Join(",", Enumerable.Range(0, func.PrimFunction.Parameters.Length).Select(i => $"buffers[{i}]"))}, nncase_mt, data, rdata);");
+                    writer.WriteLine("  } else");
+                }
+                writer.WriteLine("  { }");
+                writer.WriteLine(CSourceBuiltn.MainEpilogue);
             }
         }
 

From 33673656064d62b541ffbc6e5e834c33fe63b858 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 21 Jul 2023 19:29:40 +0800
Subject: [PATCH 008/308] add cpu target compile

---
 CMakeLists.txt                                |  2 +-
 modules/cpu/CMakeLists.txt                    | 56 +++++++++++++++
 .../nncase_rt_modules_cpuConfig.cmake.in      |  1 +
 .../nncase/runtime/cpu/compiler_defs.h        | 28 ++++++++
 .../nncase/runtime/cpu/runtime_module.h       | 29 ++++++++
 modules/cpu/src/runtime/CMakeLists.txt        | 18 +++++
 modules/cpu/src/runtime/runtime_function.cpp  | 52 ++++++++++++++
 modules/cpu/src/runtime/runtime_function.h    | 37 ++++++++++
 modules/cpu/src/runtime/runtime_module.cpp    | 70 +++++++++++++++++++
 modules/cpu/src/runtime/runtime_module.h      | 38 ++++++++++
 10 files changed, 330 insertions(+), 1 deletion(-)
 create mode 100644 modules/cpu/CMakeLists.txt
 create mode 100644 modules/cpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
 create mode 100644 modules/cpu/include/nncase/runtime/cpu/compiler_defs.h
 create mode 100644 modules/cpu/include/nncase/runtime/cpu/runtime_module.h
 create mode 100644 modules/cpu/src/runtime/CMakeLists.txt
 create mode 100644 modules/cpu/src/runtime/runtime_function.cpp
 create mode 100644 modules/cpu/src/runtime/runtime_function.h
 create mode 100644 modules/cpu/src/runtime/runtime_module.cpp
 create mode 100644 modules/cpu/src/runtime/runtime_module.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 83e3f71db3..3ac570f4c9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -265,5 +265,5 @@ if(BUILD_TESTING)
 endif()
 
 # Modules
-#add_subdirectory(modules/k210)
+add_subdirectory(modules/cpu)
 #add_subdirectory(modules/vulkan)
diff --git a/modules/cpu/CMakeLists.txt b/modules/cpu/CMakeLists.txt
new file mode 100644
index 0000000000..2d7a213559
--- /dev/null
+++ b/modules/cpu/CMakeLists.txt
@@ -0,0 +1,56 @@
+cmake_minimum_required (VERSION 3.8)
+
+include_directories(include)
+#add_subdirectory(src/kernels)
+add_subdirectory(src/runtime)
+
+if (BUILDING_RUNTIME)
+    if (ENABLE_VULKAN_RUNTIME)
+        add_library(nncase_rt_modules_cpu STATIC ${SRCS})
+        target_include_directories(nncase_rt_modules_cpu PRIVATE include)
+        target_link_libraries(nncase_rt_modules_cpu PRIVATE runtime_cpu)
+        set_target_properties(nncase_rt_modules_cpu PROPERTIES
+                                                       OUTPUT_NAME "nncase.rt_modules.cpu")
+
+        install(DIRECTORY include/nncase/kernels
+            DESTINATION include/nncase
+            COMPONENT nncase-headers
+            FILES_MATCHING
+            PATTERN "*.def"
+            PATTERN "*.h"
+            PATTERN "*.hpp"
+            PATTERN "*.td"
+            PATTERN "*.inc"
+            PATTERN "LICENSE.TXT"
+            )
+
+        install(DIRECTORY include/nncase/runtime
+            DESTINATION include/nncase
+            COMPONENT nncase-headers
+            FILES_MATCHING
+            PATTERN "*.def"
+            PATTERN "*.h"
+            PATTERN "*.hpp"
+            PATTERN "*.td"
+            PATTERN "*.inc"
+            PATTERN "LICENSE.TXT"
+            )
+
+        install(TARGETS nncase_rt_modules_cpu EXPORT nncaseruntimeTargets
+            ARCHIVE DESTINATION lib
+            LIBRARY DESTINATION lib
+            RUNTIME DESTINATION bin
+            INCLUDES DESTINATION include
+        )
+
+        configure_file(${CMAKE_CURRENT_LIST_DIR}/cmake/nncase_rt_modules_cpuConfig.cmake.in nncase_rt_modules_cpuConfig.cmake @ONLY)
+        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/nncase_rt_modules_cpuConfig.cmake DESTINATION lib/cmake/nncaseruntime)
+    endif()
+else()
+    add_library(nncase_modules_cpu SHARED ${SRCS})
+    target_include_directories(nncase_modules_cpu PUBLIC include)
+    target_link_libraries(nncase_modules_cpu PRIVATE simulator_cpu nncasebase)
+    set_target_properties(nncase_modules_cpu PROPERTIES OUTPUT_NAME "nncase.modules.cpu")
+    install(TARGETS nncase_modules_cpu
+            COMPONENT nncase-runtime)
+endif()
diff --git a/modules/cpu/cmake/nncase_rt_modules_cpuConfig.cmake.in b/modules/cpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
new file mode 100644
index 0000000000..497d8eb3b3
--- /dev/null
+++ b/modules/cpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
@@ -0,0 +1 @@
+include(${CMAKE_CURRENT_LIST_DIR}/nncase_rt_modules_cpuTargets.cmake)
\ No newline at end of file
diff --git a/modules/cpu/include/nncase/runtime/cpu/compiler_defs.h b/modules/cpu/include/nncase/runtime/cpu/compiler_defs.h
new file mode 100644
index 0000000000..fa7dcceef0
--- /dev/null
+++ b/modules/cpu/include/nncase/runtime/cpu/compiler_defs.h
@@ -0,0 +1,28 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#include <nncase/compiler_defs.h>
+
+#if defined(_MSC_VER)
+#ifdef NNCASE_MODULES_CPU_DLL
+#define NNCASE_MODULES_CPU_API __declspec(dllexport)
+#elif NNCASE_SHARED_LIBS
+#define NNCASE_MODULES_CPU_API __declspec(dllimport)
+#else
+#define NNCASE_MODULES_CPU_API
+#endif
+#else
+#define NNCASE_MODULES_CPU_API __attribute__((visibility("default")))
+#endif
diff --git a/modules/cpu/include/nncase/runtime/cpu/runtime_module.h b/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
new file mode 100644
index 0000000000..5aecaa4aa7
--- /dev/null
+++ b/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
@@ -0,0 +1,29 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#include "compiler_defs.h"
+#include <nncase/runtime/runtime_module.h>
+
+BEGIN_NS_NNCASE_RT_MODULE(cpu)
+
+NNCASE_INLINE_VAR constexpr char DESCRIPTORS_SECTION_NAME[] = ".desc";
+
+NNCASE_INLINE_VAR constexpr module_kind_t cpu_module_type = to_module_kind("cpu");
+NNCASE_INLINE_VAR constexpr uint32_t cpu_module_version = 0;
+
+NNCASE_MODULES_CPU_API result<std::unique_ptr<runtime_module>>
+create_cpu_runtime_module();
+
+END_NS_NNCASE_RT_MODULE
diff --git a/modules/cpu/src/runtime/CMakeLists.txt b/modules/cpu/src/runtime/CMakeLists.txt
new file mode 100644
index 0000000000..fe8fc9236a
--- /dev/null
+++ b/modules/cpu/src/runtime/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required (VERSION 3.13)
+
+set(SRCS runtime_module.cpp
+         runtime_function.cpp)
+
+if (BUILDING_RUNTIME)
+    if (ENABLE_CPU_RUNTIME)
+        add_library(runtime_cpu OBJECT ${SRCS})
+        target_link_libraries(runtime_cpu PUBLIC nncaseruntime)
+        set_target_properties(runtime_cpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
+        install(TARGETS runtime_cpu EXPORT nncaseruntimeTargets)
+    endif()
+else()
+    add_library(simulator_cpu OBJECT ${SRCS})
+    target_link_libraries(simulator_cpu PUBLIC nncasebase nncaseruntime)
+    target_compile_definitions(simulator_cpu PUBLIC -DNNCASE_MODULES_CPU_DLL -DNNCASE_SIMULATOR)
+    set_target_properties(simulator_cpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
+endif()
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
new file mode 100644
index 0000000000..cdeec6a4ba
--- /dev/null
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -0,0 +1,52 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "runtime_function.h"
+#include <nncase/runtime/dbg.h>
+#include <nncase/runtime/runtime_loader.h>
+#include <nncase/runtime/runtime_op_utility.h>
+
+using namespace nncase;
+using namespace nncase::runtime;
+using namespace nncase::runtime::cpu;
+
+cpu_runtime_module &cpu_runtime_function::module() const noexcept {
+    return static_cast<cpu_runtime_module &>(runtime_function::module());
+}
+
+result<void> cpu_runtime_function::initialize_core(
+    runtime_function_init_context &context) noexcept {
+    text_ = context.module_init_context().section(".text").subspan(
+        context.header().entrypoint, context.header().text_size);
+
+    return ok();
+}
+
+result<value_t>
+cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
+                                  value_t return_value) noexcept {
+    // try_(preprocess_inputs());
+
+    // vk::SubmitInfo si({}, {}, cmd_buffer_, {});
+    // try_(vk::to_result(module().compute_queue().submit(si)));
+    // try_(vk::to_result(module().compute_queue().waitIdle()));
+    // try_(vk::to_result(module().device().waitIdle()));
+
+    // assert(buffer_refs_.empty());
+    // assert(buffer_copies_.empty());
+    // assert(buffer_barriers_.empty());
+
+    // try_(postprocess_outputs());
+    return ok(return_value);
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/runtime_function.h b/modules/cpu/src/runtime/runtime_function.h
new file mode 100644
index 0000000000..3504a46695
--- /dev/null
+++ b/modules/cpu/src/runtime/runtime_function.h
@@ -0,0 +1,37 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#include "runtime_module.h"
+#include <nncase/kernels/kernel_context.h>
+#include <nncase/runtime/runtime_function.h>
+
+BEGIN_NS_NNCASE_RT_MODULE(cpu)
+
+class cpu_runtime_function : public runtime_function {
+  public:
+    using runtime_function::runtime_function;
+
+    cpu_runtime_module &module() const noexcept;
+
+  protected:
+    result<void> initialize_core(runtime_function_init_context &context) noexcept override;
+    result<value_t> invoke_core(gsl::span<value_t> parameters,
+        value_t return_value) noexcept override;
+
+  private:
+    gsl::span<const gsl::byte> text_;
+};
+
+END_NS_NNCASE_RT_MODULE
diff --git a/modules/cpu/src/runtime/runtime_module.cpp b/modules/cpu/src/runtime/runtime_module.cpp
new file mode 100644
index 0000000000..8c30911df9
--- /dev/null
+++ b/modules/cpu/src/runtime/runtime_module.cpp
@@ -0,0 +1,70 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "runtime_module.h"
+#include "runtime_function.h"
+#include <nncase/runtime/dbg.h>
+#include <nncase/runtime/runtime_loader.h>
+#include <nncase/runtime/runtime_op_utility.h>
+
+using namespace nncase;
+using namespace nncase::runtime;
+using namespace nncase::runtime::cpu;
+
+result<void> cpu_runtime_module::initialize_before_functions(
+    runtime_module_init_context &context) noexcept {
+    if (!context.is_section_pinned())
+        return nncase::err(std::errc::bad_address);
+    // try_var(rdata_,
+    //         context.get_or_read_section(".rdata", rdata_storage_, true));
+    // try_var(text_, context.get_or_read_section(".text", text_storage_, true));
+
+    // auto descs =
+    //     context.section(DESCRIPTORS_SECTION_NAME).as_span<const uint32_t>();
+    // descriptor_sets_ = descs[0];
+    // descriptors_ = descs[1];
+    // shader_ = context.section(".shader");
+
+    // rdata_ = context.section(".rdata");
+    return ok();
+}
+
+result<std::unique_ptr<runtime_function>>
+cpu_runtime_module::create_function() noexcept {
+    std::unique_ptr<runtime_function> mod(new (std::nothrow)
+                                              cpu_runtime_function(*this));
+    if (mod)
+        return ok(std::move(mod));
+    return err(std::errc::not_enough_memory);
+}
+
+result<std::unique_ptr<runtime_module>> cpu::create_cpu_runtime_module() {
+    std::unique_ptr<runtime_module> mod(new (std::nothrow)
+                                            cpu_runtime_module());
+    if (mod)
+        return ok(std::move(mod));
+    return err(std::errc::not_enough_memory);
+}
+
+extern "C" {
+NNCASE_MODULES_CPU_API void
+RUNTIME_MODULE_ACTIVATOR_NAME(result<std::unique_ptr<runtime_module>> &result) {
+    result = create_cpu_runtime_module();
+}
+}
+
+#ifndef NNCASE_SIMULATOR
+runtime_registration nncase::runtime::builtin_runtimes[] = {
+    {cpu_module_type, RUNTIME_MODULE_ACTIVATOR_NAME}, {}};
+#endif
diff --git a/modules/cpu/src/runtime/runtime_module.h b/modules/cpu/src/runtime/runtime_module.h
new file mode 100644
index 0000000000..d179f9fd40
--- /dev/null
+++ b/modules/cpu/src/runtime/runtime_module.h
@@ -0,0 +1,38 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#include <nncase/runtime/cpu/runtime_module.h>
+
+BEGIN_NS_NNCASE_RT_MODULE(cpu)
+
+class cpu_runtime_module : public runtime_module {
+  public:
+    gsl::span<const gsl::byte> rdata_physical() noexcept { return rdata_; }
+    gsl::span<gsl::byte> data_physical() noexcept { return data_; }
+    gsl::span<const gsl::byte> text_physical() noexcept { return text_; }
+
+  protected:
+    result<void> initialize_before_functions(
+        runtime_module_init_context &context) noexcept override;
+    result<std::unique_ptr<runtime_function>>
+    create_function() noexcept override;
+
+  private:
+    gsl::span<gsl::byte> data_;
+    gsl::span<const gsl::byte> text_;
+    gsl::span<const gsl::byte> rdata_;
+};
+
+END_NS_NNCASE_RT_MODULE

From c95026167a7a9e0ba2ee47355fff9308b387e774 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 21 Jul 2023 19:38:20 +0800
Subject: [PATCH 009/308] fix build

---
 modules/cpu/src/runtime/runtime_function.cpp | 4 +---
 modules/cpu/src/runtime/runtime_function.h   | 2 +-
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index cdeec6a4ba..1ed0c0a3ed 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -26,9 +26,7 @@ cpu_runtime_module &cpu_runtime_function::module() const noexcept {
 }
 
 result<void> cpu_runtime_function::initialize_core(
-    runtime_function_init_context &context) noexcept {
-    text_ = context.module_init_context().section(".text").subspan(
-        context.header().entrypoint, context.header().text_size);
+    NNCASE_UNUSED runtime_function_init_context &context) noexcept {
 
     return ok();
 }
diff --git a/modules/cpu/src/runtime/runtime_function.h b/modules/cpu/src/runtime/runtime_function.h
index 3504a46695..b7554144b5 100644
--- a/modules/cpu/src/runtime/runtime_function.h
+++ b/modules/cpu/src/runtime/runtime_function.h
@@ -31,7 +31,7 @@ class cpu_runtime_function : public runtime_function {
         value_t return_value) noexcept override;
 
   private:
-    gsl::span<const gsl::byte> text_;
+    std::string name_;
 };
 
 END_NS_NNCASE_RT_MODULE

From 138527d0342f7ede01a78762a4fb6fe981717a18 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 21 Jul 2023 19:58:46 +0800
Subject: [PATCH 010/308] add cpu module

---
 .../CodeGen/LinkableFunction.cs                  |  4 ++--
 modules/cpu/CMakeLists.txt                       |  4 ++--
 .../include/nncase/runtime/cpu/runtime_module.h  |  2 +-
 modules/cpu/src/runtime/runtime_function.cpp     | 16 +++-------------
 modules/cpu/src/runtime/runtime_module.cpp       | 13 +++----------
 modules/cpu/src/runtime/runtime_module.h         |  3 +++
 .../Targets/UnitTestCPUTargetTiling.cs           |  6 +++++-
 7 files changed, 19 insertions(+), 29 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
index 4ad32bd353..ae49c39b3c 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
@@ -14,8 +14,8 @@ public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, FunctionCSourc
         PrimFunction = sourceFunction;
         FunctionCSource = funcCSource;
         Text = Array.Empty<byte>();
-        var desc = System.Text.Encoding.ASCII.GetBytes(sourceFunction.Name);
-        Sections = new LinkedSection[] { new(desc, ".desc", 0, 8, (uint)desc.Length) };
+        var name = System.Text.Encoding.ASCII.GetBytes(sourceFunction.Name);
+        Sections = new LinkedSection[] { new(name, ".name", 0, 8, (uint)name.Length) };
     }
 
     public uint Id { get; }
diff --git a/modules/cpu/CMakeLists.txt b/modules/cpu/CMakeLists.txt
index 2d7a213559..f030315513 100644
--- a/modules/cpu/CMakeLists.txt
+++ b/modules/cpu/CMakeLists.txt
@@ -5,7 +5,7 @@ include_directories(include)
 add_subdirectory(src/runtime)
 
 if (BUILDING_RUNTIME)
-    if (ENABLE_VULKAN_RUNTIME)
+    if (ENABLE_CPU_RUNTIME)
         add_library(nncase_rt_modules_cpu STATIC ${SRCS})
         target_include_directories(nncase_rt_modules_cpu PRIVATE include)
         target_link_libraries(nncase_rt_modules_cpu PRIVATE runtime_cpu)
@@ -50,7 +50,7 @@ else()
     add_library(nncase_modules_cpu SHARED ${SRCS})
     target_include_directories(nncase_modules_cpu PUBLIC include)
     target_link_libraries(nncase_modules_cpu PRIVATE simulator_cpu nncasebase)
-    set_target_properties(nncase_modules_cpu PROPERTIES OUTPUT_NAME "nncase.modules.cpu")
+    set_target_properties(nncase_modules_cpu PROPERTIES OUTPUT_NAME "nncase.simulator.cpu")
     install(TARGETS nncase_modules_cpu
             COMPONENT nncase-runtime)
 endif()
diff --git a/modules/cpu/include/nncase/runtime/cpu/runtime_module.h b/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
index 5aecaa4aa7..4642409eb2 100644
--- a/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
+++ b/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
@@ -18,7 +18,7 @@
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
-NNCASE_INLINE_VAR constexpr char DESCRIPTORS_SECTION_NAME[] = ".desc";
+NNCASE_INLINE_VAR constexpr char FUNCTION_NAME_SECTION_IDENTIFIER[] = ".name";
 
 NNCASE_INLINE_VAR constexpr module_kind_t cpu_module_type = to_module_kind("cpu");
 NNCASE_INLINE_VAR constexpr uint32_t cpu_module_version = 0;
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 1ed0c0a3ed..a268b68403 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -27,24 +27,14 @@ cpu_runtime_module &cpu_runtime_function::module() const noexcept {
 
 result<void> cpu_runtime_function::initialize_core(
     NNCASE_UNUSED runtime_function_init_context &context) noexcept {
-
+    try_var(name, context.section(FUNCTION_NAME_SECTION_IDENTIFIER));
+    name_ = std::string(name.as_span<const char>().data());
     return ok();
 }
 
 result<value_t>
 cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
                                   value_t return_value) noexcept {
-    // try_(preprocess_inputs());
-
-    // vk::SubmitInfo si({}, {}, cmd_buffer_, {});
-    // try_(vk::to_result(module().compute_queue().submit(si)));
-    // try_(vk::to_result(module().compute_queue().waitIdle()));
-    // try_(vk::to_result(module().device().waitIdle()));
-
-    // assert(buffer_refs_.empty());
-    // assert(buffer_copies_.empty());
-    // assert(buffer_barriers_.empty());
-
-    // try_(postprocess_outputs());
+    std::cout << "call " << name_ << std::endl;
     return ok(return_value);
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/runtime_module.cpp b/modules/cpu/src/runtime/runtime_module.cpp
index 8c30911df9..6e94bcf699 100644
--- a/modules/cpu/src/runtime/runtime_module.cpp
+++ b/modules/cpu/src/runtime/runtime_module.cpp
@@ -26,17 +26,10 @@ result<void> cpu_runtime_module::initialize_before_functions(
     runtime_module_init_context &context) noexcept {
     if (!context.is_section_pinned())
         return nncase::err(std::errc::bad_address);
-    // try_var(rdata_,
-    //         context.get_or_read_section(".rdata", rdata_storage_, true));
-    // try_var(text_, context.get_or_read_section(".text", text_storage_, true));
+    try_var(data_, context.get_or_read_section(".rdata", data_storage_, false));
+    try_var(rdata_,context.get_or_read_section(".rdata", rdata_storage_, true));
+    try_var(text_, context.get_or_read_section(".text", text_storage_, true));
 
-    // auto descs =
-    //     context.section(DESCRIPTORS_SECTION_NAME).as_span<const uint32_t>();
-    // descriptor_sets_ = descs[0];
-    // descriptors_ = descs[1];
-    // shader_ = context.section(".shader");
-
-    // rdata_ = context.section(".rdata");
     return ok();
 }
 
diff --git a/modules/cpu/src/runtime/runtime_module.h b/modules/cpu/src/runtime/runtime_module.h
index d179f9fd40..f672aeeab2 100644
--- a/modules/cpu/src/runtime/runtime_module.h
+++ b/modules/cpu/src/runtime/runtime_module.h
@@ -33,6 +33,9 @@ class cpu_runtime_module : public runtime_module {
     gsl::span<gsl::byte> data_;
     gsl::span<const gsl::byte> text_;
     gsl::span<const gsl::byte> rdata_;
+    host_buffer_t text_storage_;
+    host_buffer_t rdata_storage_;
+    host_buffer_t data_storage_;
 };
 
 END_NS_NNCASE_RT_MODULE
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 28ff7ccf07..376376f888 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -43,9 +43,13 @@ public async Task TestCpuUnary()
         var compiler = CompileSession.Compiler;
         compiler.ImportIRModule(module);
         await compiler.CompileAsync();
-        using (var fs = new MemoryStream())
+        using (var fs = Dumpper.OpenFile("test.kmodel"))
         {
             compiler.Gencode(fs);
         }
+        using (var fs = Dumpper.OpenFile("input_0.bin"))
+        {
+            fs.Write(IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 1, 2, 3, 4, 5 }).Evaluate().AsTensor().BytesBuffer);
+        }
     }
 }

From 941952f2235af8dbe66a934077f167ed70686ea1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 21 Jul 2023 20:08:24 +0800
Subject: [PATCH 011/308] fix cpu module init

---
 modules/cpu/src/runtime/runtime_module.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/cpu/src/runtime/runtime_module.cpp b/modules/cpu/src/runtime/runtime_module.cpp
index 6e94bcf699..c8dad680fd 100644
--- a/modules/cpu/src/runtime/runtime_module.cpp
+++ b/modules/cpu/src/runtime/runtime_module.cpp
@@ -26,7 +26,7 @@ result<void> cpu_runtime_module::initialize_before_functions(
     runtime_module_init_context &context) noexcept {
     if (!context.is_section_pinned())
         return nncase::err(std::errc::bad_address);
-    try_var(data_, context.get_or_read_section(".rdata", data_storage_, false));
+    try_var(data_, context.get_or_read_section(".data", data_storage_, false));
     try_var(rdata_,context.get_or_read_section(".rdata", rdata_storage_, true));
     try_var(text_, context.get_or_read_section(".text", text_storage_, true));
 

From 56efb3b6b599acb708d6008aa11c17e760aad375 Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Mon, 24 Jul 2023 02:20:46 +0000
Subject: [PATCH 012/308] Apply code-format changes

---
 .../CodeGen/CSourceBuiltn.cs                  |  7 +-
 .../CodeGen/CSourceConvertVisitor.cs          | 56 +++++++------
 .../CodeGen/CSourceExtensions.cs              |  7 +-
 .../CodeGen/CSourceUtilities.cs               | 12 ++-
 .../CodeGen/FunctionCSource.cs                | 83 ++++++++++---------
 .../CodeGen/LinkableModule.cs                 |  3 +-
 .../Passes/CPUFusionToTirPass.cs              |  2 +-
 .../Passes/Tile/CPUFusionGroupMutator.cs      |  1 -
 .../Passes/Tile/SingleCPUFusionConverter.cs   | 14 ++--
 .../nncase/runtime/cpu/runtime_module.h       |  3 +-
 modules/cpu/src/runtime/runtime_function.h    |  5 +-
 modules/cpu/src/runtime/runtime_module.cpp    |  3 +-
 src/Nncase.Core/Schedule/ScheduleTypes.cs     |  1 -
 src/Nncase.Core/TIR/MemSpan.cs                | 13 +--
 src/Nncase.Evaluator/TIR/Store.cs             |  1 -
 src/Nncase.Tests/Core/UnitTestTIR.cs          |  4 +-
 .../Targets/UnitTestCPUTargetTiling.cs        |  1 +
 17 files changed, 120 insertions(+), 96 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index adb7195e5f..45b5563f5f 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -1,11 +1,10 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 namespace Nncase.CodeGen.CPU;
 
 public static class CSourceBuiltn
 {
-
     public const string BufferType = "buffer_t";
 
     public const string BufferStruct = @"typedef struct buffer {
@@ -50,6 +49,4 @@ int strcmp(const char* s1,const char* s2) {{
 
 static nncase_mt_t *nncase_mt;
 ";
-
-
-}
\ No newline at end of file
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 7df0c005dc..ab4397910d 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
@@ -16,23 +16,6 @@
 
 namespace Nncase.CodeGen.CPU;
 
-/// <summary>
-/// the c symbol define.
-/// </summary>
-internal sealed class CSymbol
-{
-    public CSymbol(string type, string name)
-    {
-        Type = type;
-        Name = name;
-    }
-
-    public string Type { get; }
-    public string Name { get; }
-
-    public override string ToString() => $"{Type} {Name}";
-}
-
 internal struct IndentScope : IDisposable
 {
     private static readonly AsyncLocal<IndentWriter?> _writer = new AsyncLocal<IndentWriter?>();
@@ -71,12 +54,30 @@ public void Dispose()
     }
 }
 
+/// <summary>
+/// the c symbol define.
+/// </summary>
+internal sealed class CSymbol
+{
+    public CSymbol(string type, string name)
+    {
+        Type = type;
+        Name = name;
+    }
+
+    public string Type { get; }
+
+    public string Name { get; }
+
+    public override string ToString() => $"{Type} {Name}";
+}
 
 internal sealed class IndentWriter : StringWriter
 {
     public int Indent;
 
-    public IndentWriter(StringBuilder sb, int indent = 0) : base(sb)
+    public IndentWriter(StringBuilder sb, int indent = 0)
+        : base(sb)
     {
         Indent = indent;
     }
@@ -85,19 +86,20 @@ public void IndWrite(string? value)
     {
         for (int i = 0; i < Indent; i++)
         {
-            this.Write(' ');
+            Write(' ');
         }
-        this.Write(value);
+
+        Write(value);
     }
 }
 
 /// <summary>
-/// convert single prim function to c source
+/// convert single prim function to c source.
 /// </summary>
 internal sealed class CSourceConvertVisitor : ExprFunctor<CSymbol, Unit>
 {
-    private readonly StringBuilder _implBuilder;
     public readonly Dictionary<Expr, CSymbol> ExprMemo;
+    private readonly StringBuilder _implBuilder;
 
     public CSourceConvertVisitor()
     {
@@ -129,11 +131,13 @@ protected override CSymbol VisitPrimFunction(PrimFunction expr)
         {
             // 1. Function signature
             IndentScope.Writer.IndWrite($"{type} {{\n");
+
             // 2. Function body
             using (var _ = new IndentScope())
             {
                 Visit(expr.Body);
             }
+
             // 3. Function closing
             IndentScope.Writer.IndWrite("}\n");
         }
@@ -154,9 +158,9 @@ protected override CSymbol VisitCall(Call expr)
         var arguments = expr.Arguments.AsValueEnumerable().Select(Visit).ToArray();
         string type = expr.CheckedType switch
         {
-            TupleType x when x == TupleType.Void => "",
+            TupleType x when x == TupleType.Void => string.Empty,
             TensorType { IsScalar: true } x => x.DType.ToC(),
-            _ => throw new NotSupportedException()
+            _ => throw new NotSupportedException(),
         };
 
         string str;
@@ -190,6 +194,7 @@ protected override CSymbol VisitConst(Const expr)
         {
             return symbol;
         }
+
         string type;
         string str;
         if (expr is TensorConst { Value: Tensor { ElementType: PrimType ptype, Shape: { IsScalar: true } } scalar })
@@ -248,6 +253,7 @@ protected override CSymbol VisitFor(For expr)
             // 2. For Body
             Visit(expr.Body);
         }
+
         // 3. For closing
         IndentScope.Writer.IndWrite("}\n");
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index 63618df79e..e5b48ec442 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -1,7 +1,6 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
-
 namespace Nncase.CodeGen.CPU;
 
 /// <summary>
@@ -40,6 +39,6 @@ public static string ToC(this PrimType primType) =>
         BinaryOp.Sub => "-",
         BinaryOp.Mul => "*",
         BinaryOp.Div => "/",
-        _ => throw new NotSupportedException(binaryOp.ToString())
+        _ => throw new NotSupportedException(binaryOp.ToString()),
     };
-}
\ No newline at end of file
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
index be8d32cabd..7026825fa2 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
@@ -1,5 +1,9 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
 using Nncase.Diagnostics;
 using Nncase.IR.Math;
+
 namespace Nncase.CodeGen.CPU;
 
 internal static class CSourceUtilities
@@ -12,7 +16,7 @@ public static string ContertBinary(Binary binary, CSymbol[] arguments)
         switch (binary.BinaryOp)
         {
             case BinaryOp.Add or BinaryOp.Sub or BinaryOp.Mul or BinaryOp.Div:
-                str = ($"({lhs} {binary.BinaryOp.ToC()} {rhs})");
+                str = $"({lhs} {binary.BinaryOp.ToC()} {rhs})";
                 break;
             default:
                 throw new NotSupportedException();
@@ -28,13 +32,13 @@ internal static string ContertUnary(Unary op, CSymbol[] arguments)
         switch (op.UnaryOp)
         {
             case UnaryOp.Neg:
-                str = ($"!{input}");
+                str = $"!{input}";
                 break;
             default:
-                str = ($"nncase_mt->{arguments[0].Type}_{nameof(Unary).ToLower()}_{op.UnaryOp.ToString().ToLower()}{input}");
+                str = $"nncase_mt->{arguments[0].Type}_{nameof(Unary).ToLower()}_{op.UnaryOp.ToString().ToLower()}{input}";
                 break;
         }
 
         return str;
     }
-}
\ No newline at end of file
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
index c3a1e15066..b5f7ad2c86 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -1,7 +1,6 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
-
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -16,34 +15,40 @@
 
 namespace Nncase.CodeGen;
 
-internal sealed class FunctionCSource
-{
-    public FunctionCSource(string declaration, string implementation)
-    {
-        Declaration = declaration;
-        Implementation = implementation;
-    }
-
-    public string Declaration { get; }
-    public string Implementation { get; }
-}
-
-
 /// <summary>
 /// the csource code compiler.
 /// </summary>
 public class CSourceCompiler
 {
     /// <summary>
-    /// compiler exe name
+    /// compiler exe name.
     /// </summary>
-    string _exe = "", _arch = "", _ext = "";
+    private string _exe = string.Empty;
+    /// <summary>
+    /// compiler exe name.
+    /// </summary>
+    private string _arch = string.Empty;
+    /// <summary>
+    /// compiler exe name.
+    /// </summary>
+    private string _ext = string.Empty;
+
+    public CSourceCompiler()
+    {
+        PlatformSpecific();
+        ArchSpecific();
+    }
+
+    protected string Exe
+    {
+        get => _exe;
+    }
 
     /// <summary>
-    /// select current pattern's exe
+    /// select current pattern's exe.
     /// </summary>
     /// <exception cref="NotSupportedException"></exception>
-    void PlatformSpecific()
+    private void PlatformSpecific()
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
@@ -62,7 +67,7 @@ void PlatformSpecific()
         }
     }
 
-    void ArchSpecific()
+    private void ArchSpecific()
     {
         _arch = RuntimeInformation.OSArchitecture switch
         {
@@ -72,7 +77,7 @@ void ArchSpecific()
         };
     }
 
-    string ArgumentsSpecific(string sourcePath, string outPath)
+    private string ArgumentsSpecific(string sourcePath, string outPath)
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
@@ -88,12 +93,8 @@ string ArgumentsSpecific(string sourcePath, string outPath)
             var vcvardir = Path.Combine(vsdir, "..\\..\\VC\\Auxiliary\\Build\\vcvarsall.bat");
             return $"/C (\"{vcvardir}\" x64) && (cl /D_USRDLL /D_WINDLL \"{sourcePath}\" /MT /link /DLL /OUT:\"{outPath}\")";
         }
-        throw new System.ArgumentOutOfRangeException("Only Support Linux/Osx/Windows");
-    }
 
-    protected string Exe
-    {
-        get => _exe;
+        throw new System.ArgumentOutOfRangeException("Only Support Linux/Osx/Windows");
     }
 
     protected string Arch
@@ -106,18 +107,12 @@ protected string Ext
         get => _ext;
     }
 
-    public CSourceCompiler()
-    {
-        PlatformSpecific();
-        ArchSpecific();
-    }
-
     /// <summary>
-    /// compile the source txt, write to the out_path
+    /// compile the source txt, write to the out_path.
     /// </summary>
-    /// <param name="sourcePath"> c source code</param>
-    /// <param name="outPath"> out .so path </param>
-    /// <returns> outPath </returns>
+    /// <param name="sourcePath"> c source code.</param>
+    /// <param name="outPath"> out .so path. </param>
+    /// <returns> outPath. </returns>
     public string Compile(string sourcePath, string outPath)
     {
         var errMsg = new StringBuilder();
@@ -138,12 +133,26 @@ public string Compile(string sourcePath, string outPath)
                 }
             }
         }
+
         return outPath;
     }
 
     /// <summary>
     /// create the temp dll file and compile source
-    /// <see cref="Compile(string, string)"/>
+    /// <see cref="Compile(string, string)"/>.
     /// </summary>
     public string Compile(string sourcePath) => Compile(sourcePath, CodeGenUtil.GetTempFileName(Ext));
 }
+
+internal sealed class FunctionCSource
+{
+    public FunctionCSource(string declaration, string implementation)
+    {
+        Declaration = declaration;
+        Implementation = implementation;
+    }
+
+    public string Declaration { get; }
+
+    public string Implementation { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index 350460e5a2..13ec1b0779 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -40,6 +40,7 @@ public ILinkedModule Link(ILinkContext linkContext)
                     writer.Write(CSourceBuiltn.Header);
                 }
             }
+
             using (var fs = DumpScope.Current.OpenFile("cpuModule.c"))
             {
                 File.Open(csourcePath, FileMode.Open, FileAccess.Read).CopyTo(fs);
@@ -81,6 +82,7 @@ private string LinkCSources()
                     writer.WriteLine($"    {func.SourceFunction.Name}({string.Join(",", Enumerable.Range(0, func.PrimFunction.Parameters.Length).Select(i => $"buffers[{i}]"))}, nncase_mt, data, rdata);");
                     writer.WriteLine("  } else");
                 }
+
                 writer.WriteLine("  { }");
                 writer.WriteLine(CSourceBuiltn.MainEpilogue);
             }
@@ -94,5 +96,4 @@ private string CompileCSource(string sourcePath)
         var compiler = new CSourceCompiler();
         return compiler.Compile(sourcePath, Path.GetTempFileName());
     }
-
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs b/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
index 4afc56cb6f..293fd6a627 100644
--- a/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
+++ b/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
@@ -43,7 +43,7 @@ protected override Task<IRModule> RunCoreAsync(IRModule module, RunPassContext o
 
                 var post = (Function)rewriter.Rewrite(
                     func,
-                    new Mutators.IMergeRewriteRule[] { new CPUSameInputFusionMergeRule() }, 
+                    new Mutators.IMergeRewriteRule[] { new CPUSameInputFusionMergeRule() },
                     (rule, option) => new CPUFusionGroupMutator<MultiFusionChecker>(fusionCheckCache, _tileOptions, rule, option),
                     new() { AnalysisResults = analysis, MatchOptions = new Mutators.FusionGroupMutator.GroupedMatchOptions() });
 
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
index d11af85bb5..f1f9daab07 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
@@ -55,7 +55,6 @@ public CPUFusionGroupMutator(
     /// <inheritdoc/>
     public override bool MergedFusionCheckCallBack(Fusion mergedFusion, HashSet<Fusion> candidateFusions)
     {
-
         // var checker = (IFusionChecker)Activator.CreateInstance(typeof(T), new object[] { _tileOptions })!;
         // var ret = checker.Check(mergedFusion, PassOptions);
         // if (ret)
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index a2c932eb92..502b22c321 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -46,7 +46,7 @@ public ConvertVisitor(List<Expr> mainBody)
             _mainBody = mainBody;
         }
 
-        public Fusion VisitRootFusion => (Fusion)(VisitRoot!);
+        public Fusion VisitRootFusion => (Fusion)VisitRoot!;
 
         public IEnumerable<TIR.PhysicalBuffer> OutputBuffers => _buffersMap.Values.OfType<TIR.PhysicalBuffer>().Where(b => b.MemLocation == MemoryLocation.Output);
 
@@ -54,7 +54,7 @@ public ConvertVisitor(List<Expr> mainBody)
 
         protected override Unit DefaultVisitLeaf(Expr expr)
         {
-            return new();
+            return default(Unit);
         }
 
         protected override Unit VisitLeafCall(Call expr)
@@ -71,15 +71,16 @@ protected override Unit VisitLeafCall(Call expr)
                 default:
                     throw new NotSupportedException();
             }
-            return new();
+
+            return default(Unit);
         }
 
         private void GenerateUnary(Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
             var input = arguments[Unary.Input.Index];
             var loops = Enumerable.Range(0, input.Rank).Select(i => (T.ForLoop(out var loopVar, (0, input.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
-            var input_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + input.Strides[i] * loops[i].Item2);
-            var output_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + ret.Strides[i] * loops[i].Item2);
+            var input_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * loops[i].loopVar));
+            var output_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + (ret.Strides[i] * loops[i].loopVar));
             Expr stmt = T.Store(ret, output_index, IR.F.Math.Unary(unary.UnaryOp, T.Load(input, output_index)));
             var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
             _mainBody.Add(T.Block(nameof(Unary)).Body(final).Build());
@@ -101,6 +102,7 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
                         {
                             buffer = T.Buffer(c.CheckedDataType, MemoryLocation.Data, c.CheckedShape.ToValueArray().Select(i => (Expr)i).ToArray(), out _, name);
                         }
+
                         break;
                     case Var v:
                         buffer = T.PhysicalBuffer(v.CheckedDataType, MemoryLocation.Input, v.CheckedShape.ToValueArray(), out _, name);
@@ -111,8 +113,10 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
                     default:
                         throw new NotSupportedException();
                 }
+
                 _buffersMap.Add(expr, buffer);
             }
+
             return buffer;
         }
     }
diff --git a/modules/cpu/include/nncase/runtime/cpu/runtime_module.h b/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
index 4642409eb2..9c071f41b6 100644
--- a/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
+++ b/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
@@ -20,7 +20,8 @@ BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
 NNCASE_INLINE_VAR constexpr char FUNCTION_NAME_SECTION_IDENTIFIER[] = ".name";
 
-NNCASE_INLINE_VAR constexpr module_kind_t cpu_module_type = to_module_kind("cpu");
+NNCASE_INLINE_VAR constexpr module_kind_t cpu_module_type =
+    to_module_kind("cpu");
 NNCASE_INLINE_VAR constexpr uint32_t cpu_module_version = 0;
 
 NNCASE_MODULES_CPU_API result<std::unique_ptr<runtime_module>>
diff --git a/modules/cpu/src/runtime/runtime_function.h b/modules/cpu/src/runtime/runtime_function.h
index b7554144b5..e6a2580c7f 100644
--- a/modules/cpu/src/runtime/runtime_function.h
+++ b/modules/cpu/src/runtime/runtime_function.h
@@ -26,9 +26,10 @@ class cpu_runtime_function : public runtime_function {
     cpu_runtime_module &module() const noexcept;
 
   protected:
-    result<void> initialize_core(runtime_function_init_context &context) noexcept override;
+    result<void>
+    initialize_core(runtime_function_init_context &context) noexcept override;
     result<value_t> invoke_core(gsl::span<value_t> parameters,
-        value_t return_value) noexcept override;
+                                value_t return_value) noexcept override;
 
   private:
     std::string name_;
diff --git a/modules/cpu/src/runtime/runtime_module.cpp b/modules/cpu/src/runtime/runtime_module.cpp
index c8dad680fd..bf4481d159 100644
--- a/modules/cpu/src/runtime/runtime_module.cpp
+++ b/modules/cpu/src/runtime/runtime_module.cpp
@@ -27,7 +27,8 @@ result<void> cpu_runtime_module::initialize_before_functions(
     if (!context.is_section_pinned())
         return nncase::err(std::errc::bad_address);
     try_var(data_, context.get_or_read_section(".data", data_storage_, false));
-    try_var(rdata_,context.get_or_read_section(".rdata", rdata_storage_, true));
+    try_var(rdata_,
+            context.get_or_read_section(".rdata", rdata_storage_, true));
     try_var(text_, context.get_or_read_section(".text", text_storage_, true));
 
     return ok();
diff --git a/src/Nncase.Core/Schedule/ScheduleTypes.cs b/src/Nncase.Core/Schedule/ScheduleTypes.cs
index 9c2e47f8e2..f63e0467dc 100644
--- a/src/Nncase.Core/Schedule/ScheduleTypes.cs
+++ b/src/Nncase.Core/Schedule/ScheduleTypes.cs
@@ -10,7 +10,6 @@
 
 namespace Nncase.Schedule;
 
-
 /// <summary>
 /// the scheduler interface.
 /// </summary>
diff --git a/src/Nncase.Core/TIR/MemSpan.cs b/src/Nncase.Core/TIR/MemSpan.cs
index c360932c46..533e9fbb04 100644
--- a/src/Nncase.Core/TIR/MemSpan.cs
+++ b/src/Nncase.Core/TIR/MemSpan.cs
@@ -1,9 +1,11 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
 using Nncase;
 using Nncase.IR;
 
 namespace Nncase.TIR;
 
-
 /// <summary>
 /// the memory type.
 /// </summary>
@@ -52,12 +54,14 @@ public enum MemoryLocation : byte
 
 public sealed class MemSpan : Expr
 {
-    public MemSpan(Expr size, MemoryLocation location) : base(new[] { None.Default, size })
+    public MemSpan(Expr size, MemoryLocation location)
+        : base(new[] { None.Default, size })
     {
         Location = location;
     }
 
-    public MemSpan(Expr start, Expr size, MemoryLocation location) : base(new[] { start, size })
+    public MemSpan(Expr start, Expr size, MemoryLocation location)
+        : base(new[] { start, size })
     {
         Location = location;
     }
@@ -81,6 +85,5 @@ public MemSpan(Expr start, Expr size, MemoryLocation location) : base(new[] { st
     public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context)
         => functor.VisitMemSpan(this, context);
 
-
     public MemSpan With(Expr? start = null, Expr? size = null, MemoryLocation? location = null) => new(start ?? Start, size ?? Size, location ?? Location);
-}
\ No newline at end of file
+}
diff --git a/src/Nncase.Evaluator/TIR/Store.cs b/src/Nncase.Evaluator/TIR/Store.cs
index 573a5e8660..e0b6d5bcc7 100644
--- a/src/Nncase.Evaluator/TIR/Store.cs
+++ b/src/Nncase.Evaluator/TIR/Store.cs
@@ -33,7 +33,6 @@ public string Visit(IIRPrinterContext context, Store target, bool iLmode)
 
     private IRType Visit(Store target, TensorType handle, TensorType index, TensorType value)
     {
-        
         if (handle.DType != value.DType)
         {
             return new InvalidType($"You Can't Load The {value.DType} To {handle.DType}");
diff --git a/src/Nncase.Tests/Core/UnitTestTIR.cs b/src/Nncase.Tests/Core/UnitTestTIR.cs
index 0fce4d672d..9f3b78cf12 100644
--- a/src/Nncase.Tests/Core/UnitTestTIR.cs
+++ b/src/Nncase.Tests/Core/UnitTestTIR.cs
@@ -49,8 +49,8 @@ public void TestBufferStore()
     {
         Expr value = 42;
         var physicalBuffer = new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0);
-        var indices = new Expr[] { 0, 1 };
-        Call store = T.Store(physicalBuffer, 0, value);
+        _ = new Expr[] { 0, 1 };
+        _ = T.Store(physicalBuffer, 0, value);
     }
 
     [Fact]
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 376376f888..7156572dbf 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -47,6 +47,7 @@ public async Task TestCpuUnary()
         {
             compiler.Gencode(fs);
         }
+
         using (var fs = Dumpper.OpenFile("input_0.bin"))
         {
             fs.Write(IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 1, 2, 3, 4, 5 }).Evaluate().AsTensor().BytesBuffer);

From 6ace500bc82a0012677d29e8144bd21fac7947ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 24 Jul 2023 11:28:09 +0800
Subject: [PATCH 013/308] call cpu func by id

---
 modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs | 13 +------------
 .../Nncase.Modules.CPU/CodeGen/LinkableFunction.cs  |  3 +--
 .../Nncase.Modules.CPU/CodeGen/LinkableModule.cs    | 13 ++++++++-----
 modules/cpu/src/runtime/runtime_function.cpp        |  6 +++---
 modules/cpu/src/runtime/runtime_function.h          |  2 --
 src/Native/include/nncase/runtime/interpreter.h     |  1 +
 src/Native/include/nncase/runtime/runtime_module.h  |  2 ++
 src/Native/src/runtime/interpreter.cpp              | 11 +++++++++++
 src/Native/src/runtime/runtime_module.cpp           | 13 +++++++++++++
 9 files changed, 40 insertions(+), 24 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index 45b5563f5f..74fbfae3af 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -25,7 +25,7 @@ public static class CSourceBuiltn
 
     public const string FixedParameters = "nncase_mt_t* nncase_mt, void* data, void* rdata";
 
-    public const string MainPrologue = $@"void _start(char* name, buffer_t** buffers, {FixedParameters}) {{";
+    public const string MainPrologue = $@"void _start(size_t func_id, buffer_t** buffers, {FixedParameters}) {{";
 
     public const string MainEpilogue = @"}";
 
@@ -36,17 +36,6 @@ public static class CSourceBuiltn
 
 {BufferStruct}
 
-int strcmp(const char* s1,const char* s2) {{
-  while(*s1 && *s2) {{
-    if(*s1 != *s2) {{
-      break;
-    }}
-    s1++;
-    s2++; 
-  }}
-  return (*s1 - *s2) || (*s1 - '\0') || (*s2 - '\0'); 
-}}
-
 static nncase_mt_t *nncase_mt;
 ";
 }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
index ae49c39b3c..25f264df0c 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
@@ -14,8 +14,7 @@ public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, FunctionCSourc
         PrimFunction = sourceFunction;
         FunctionCSource = funcCSource;
         Text = Array.Empty<byte>();
-        var name = System.Text.Encoding.ASCII.GetBytes(sourceFunction.Name);
-        Sections = new LinkedSection[] { new(name, ".name", 0, 8, (uint)name.Length) };
+        Sections = new LinkedSection[] { };
     }
 
     public uint Id { get; }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index 13ec1b0779..89eb4d9b31 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -76,14 +76,17 @@ private string LinkCSources()
                 }
 
                 writer.WriteLine(CSourceBuiltn.MainPrologue);
+                writer.WriteLine($"  switch (func_id) {{");
+
                 foreach (var func in _functions)
                 {
-                    writer.WriteLine($"  if (strcmp(name,\"{func.SourceFunction.Name}\") == 0) {{");
-                    writer.WriteLine($"    {func.SourceFunction.Name}({string.Join(",", Enumerable.Range(0, func.PrimFunction.Parameters.Length).Select(i => $"buffers[{i}]"))}, nncase_mt, data, rdata);");
-                    writer.WriteLine("  } else");
+                    writer.WriteLine($"    case {func.Id}:");
+                    writer.WriteLine($"      {func.SourceFunction.Name}({string.Join(", ", Enumerable.Range(0, func.PrimFunction.Parameters.Length).Select(i => $"buffers[{i}]"))}, nncase_mt, data, rdata);");
+                    writer.WriteLine("    break;");
                 }
-
-                writer.WriteLine("  { }");
+                writer.WriteLine("    default: ");
+                writer.WriteLine("    break;");
+                writer.WriteLine("  }");
                 writer.WriteLine(CSourceBuiltn.MainEpilogue);
             }
         }
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index a268b68403..8de1ee7917 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -27,14 +27,14 @@ cpu_runtime_module &cpu_runtime_function::module() const noexcept {
 
 result<void> cpu_runtime_function::initialize_core(
     NNCASE_UNUSED runtime_function_init_context &context) noexcept {
-    try_var(name, context.section(FUNCTION_NAME_SECTION_IDENTIFIER));
-    name_ = std::string(name.as_span<const char>().data());
     return ok();
 }
 
 result<value_t>
 cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
                                   value_t return_value) noexcept {
-    std::cout << "call " << name_ << std::endl;
+                                    module().interp();
+    try_var(id, module().find_id_by_function(this));
+    std::cout << "call " << id << std::endl;
     return ok(return_value);
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/runtime_function.h b/modules/cpu/src/runtime/runtime_function.h
index e6a2580c7f..05d8eb099a 100644
--- a/modules/cpu/src/runtime/runtime_function.h
+++ b/modules/cpu/src/runtime/runtime_function.h
@@ -31,8 +31,6 @@ class cpu_runtime_function : public runtime_function {
     result<value_t> invoke_core(gsl::span<value_t> parameters,
                                 value_t return_value) noexcept override;
 
-  private:
-    std::string name_;
 };
 
 END_NS_NNCASE_RT_MODULE
diff --git a/src/Native/include/nncase/runtime/interpreter.h b/src/Native/include/nncase/runtime/interpreter.h
index fc91970657..a8f5814d34 100644
--- a/src/Native/include/nncase/runtime/interpreter.h
+++ b/src/Native/include/nncase/runtime/interpreter.h
@@ -73,6 +73,7 @@ class NNCASE_API interpreter {
 
     options_dict &options() noexcept;
     result<runtime_module *> find_module_by_id(size_t index) noexcept;
+    result<size_t> find_id_by_module(runtime_module *module) noexcept;
 
     /* V1 APIs */
 
diff --git a/src/Native/include/nncase/runtime/runtime_module.h b/src/Native/include/nncase/runtime/runtime_module.h
index 354d747cbf..444209016f 100644
--- a/src/Native/include/nncase/runtime/runtime_module.h
+++ b/src/Native/include/nncase/runtime/runtime_module.h
@@ -57,6 +57,8 @@ class NNCASE_API runtime_module {
     interpreter &interp() const noexcept { return *interp_; }
 
     result<runtime_function *> find_function_by_id(size_t index) noexcept;
+    
+    result<size_t> find_id_by_function(runtime_function * function) noexcept;
 
   protected:
     virtual result<void>
diff --git a/src/Native/src/runtime/interpreter.cpp b/src/Native/src/runtime/interpreter.cpp
index dc5839fb44..fe69b8a071 100644
--- a/src/Native/src/runtime/interpreter.cpp
+++ b/src/Native/src/runtime/interpreter.cpp
@@ -246,6 +246,17 @@ result<runtime_module *> interpreter::find_module_by_id(size_t index) noexcept {
     return ok(modules_[index].get());
 }
 
+result<size_t> interpreter::find_id_by_module(runtime_module *module) noexcept {
+    auto it = std::find_if(modules_.begin(), modules_.end(),
+                           [&module](const std::unique_ptr<runtime_module> &p) {
+                               return p.get() == module;
+                           });
+    if (it == modules_.end()) {
+        return err(std::errc::result_out_of_range);
+    }
+    return ok((it - modules_.begin()));
+}
+
 options_dict &interpreter::options() noexcept { return options_; }
 
 result<runtime_function *> interpreter::entry_function() noexcept {
diff --git a/src/Native/src/runtime/runtime_module.cpp b/src/Native/src/runtime/runtime_module.cpp
index 4b5d747bbd..66acaca61b 100644
--- a/src/Native/src/runtime/runtime_module.cpp
+++ b/src/Native/src/runtime/runtime_module.cpp
@@ -189,6 +189,19 @@ runtime_module::find_function_by_id(size_t index) noexcept {
     return ok(functions_[index].get());
 }
 
+result<size_t>
+runtime_module::find_id_by_function(runtime_function *function) noexcept {
+    auto it =
+        std::find_if(functions_.begin(), functions_.end(),
+                     [&function](const std::unique_ptr<runtime_function> &p) {
+                         return p.get() == function;
+                     });
+    if (it == functions_.end()) {
+        return err(std::errc::result_out_of_range);
+    }
+    return ok((it - functions_.begin()));
+}
+
 result<void> runtime_module::initialize_before_functions(
     NNCASE_UNUSED runtime_module_init_context &context) noexcept {
     return ok();

From 96fd3381c09a92b582ffcee318bfcd940c74e744 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Mon, 24 Jul 2023 03:31:56 +0000
Subject: [PATCH 014/308] Apply code-format changes

---
 .../Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs   |  2 +-
 .../Nncase.Modules.CPU/CodeGen/FunctionCSource.cs    | 12 +++++++-----
 .../Nncase.Modules.CPU/CodeGen/LinkableFunction.cs   |  2 +-
 modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs |  1 +
 .../Passes/Tile/SingleCPUFusionConverter.cs          |  4 ++--
 modules/cpu/src/runtime/runtime_function.cpp         |  2 +-
 modules/cpu/src/runtime/runtime_function.h           |  1 -
 src/Native/include/nncase/runtime/runtime_module.h   |  4 ++--
 src/Nncase.Core/TIR/MemSpan.cs                       |  2 +-
 9 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
index 7026825fa2..e7e479017b 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.Diagnostics;
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
index b5f7ad2c86..8b98277d30 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -24,10 +24,12 @@ public class CSourceCompiler
     /// compiler exe name.
     /// </summary>
     private string _exe = string.Empty;
+
     /// <summary>
     /// compiler exe name.
     /// </summary>
     private string _arch = string.Empty;
+
     /// <summary>
     /// compiler exe name.
     /// </summary>
@@ -44,6 +46,11 @@ protected string Exe
         get => _exe;
     }
 
+    protected string Arch
+    {
+        get => _arch;
+    }
+
     /// <summary>
     /// select current pattern's exe.
     /// </summary>
@@ -97,11 +104,6 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
         throw new System.ArgumentOutOfRangeException("Only Support Linux/Osx/Windows");
     }
 
-    protected string Arch
-    {
-        get => _arch;
-    }
-
     protected string Ext
     {
         get => _ext;
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
index 25f264df0c..37ca1f584f 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
@@ -14,7 +14,7 @@ public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, FunctionCSourc
         PrimFunction = sourceFunction;
         FunctionCSource = funcCSource;
         Text = Array.Empty<byte>();
-        Sections = new LinkedSection[] { };
+        Sections = Array.Empty<LinkedSection>();
     }
 
     public uint Id { get; }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index 89eb4d9b31..cfa27dc8b5 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -84,6 +84,7 @@ private string LinkCSources()
                     writer.WriteLine($"      {func.SourceFunction.Name}({string.Join(", ", Enumerable.Range(0, func.PrimFunction.Parameters.Length).Select(i => $"buffers[{i}]"))}, nncase_mt, data, rdata);");
                     writer.WriteLine("    break;");
                 }
+
                 writer.WriteLine("    default: ");
                 writer.WriteLine("    break;");
                 writer.WriteLine("  }");
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 502b22c321..1e54700651 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -54,7 +54,7 @@ public ConvertVisitor(List<Expr> mainBody)
 
         protected override Unit DefaultVisitLeaf(Expr expr)
         {
-            return default(Unit);
+            return default;
         }
 
         protected override Unit VisitLeafCall(Call expr)
@@ -72,7 +72,7 @@ protected override Unit VisitLeafCall(Call expr)
                     throw new NotSupportedException();
             }
 
-            return default(Unit);
+            return default;
         }
 
         private void GenerateUnary(Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 8de1ee7917..3f7cbe4156 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -33,7 +33,7 @@ result<void> cpu_runtime_function::initialize_core(
 result<value_t>
 cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
                                   value_t return_value) noexcept {
-                                    module().interp();
+    module().interp();
     try_var(id, module().find_id_by_function(this));
     std::cout << "call " << id << std::endl;
     return ok(return_value);
diff --git a/modules/cpu/src/runtime/runtime_function.h b/modules/cpu/src/runtime/runtime_function.h
index 05d8eb099a..79a524dfc1 100644
--- a/modules/cpu/src/runtime/runtime_function.h
+++ b/modules/cpu/src/runtime/runtime_function.h
@@ -30,7 +30,6 @@ class cpu_runtime_function : public runtime_function {
     initialize_core(runtime_function_init_context &context) noexcept override;
     result<value_t> invoke_core(gsl::span<value_t> parameters,
                                 value_t return_value) noexcept override;
-
 };
 
 END_NS_NNCASE_RT_MODULE
diff --git a/src/Native/include/nncase/runtime/runtime_module.h b/src/Native/include/nncase/runtime/runtime_module.h
index 444209016f..194dd3b1f7 100644
--- a/src/Native/include/nncase/runtime/runtime_module.h
+++ b/src/Native/include/nncase/runtime/runtime_module.h
@@ -57,8 +57,8 @@ class NNCASE_API runtime_module {
     interpreter &interp() const noexcept { return *interp_; }
 
     result<runtime_function *> find_function_by_id(size_t index) noexcept;
-    
-    result<size_t> find_id_by_function(runtime_function * function) noexcept;
+
+    result<size_t> find_id_by_function(runtime_function *function) noexcept;
 
   protected:
     virtual result<void>
diff --git a/src/Nncase.Core/TIR/MemSpan.cs b/src/Nncase.Core/TIR/MemSpan.cs
index 533e9fbb04..0ee5b4a215 100644
--- a/src/Nncase.Core/TIR/MemSpan.cs
+++ b/src/Nncase.Core/TIR/MemSpan.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase;

From dd6451e51f9f110c548cdce6d22d0d88e8ffb408 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 24 Jul 2023 16:14:39 +0800
Subject: [PATCH 015/308] add desc header

---
 .../CodeGen/FunctionBuilder.cs                | 88 ++++++++++++++++++-
 .../CodeGen/LinkableFunction.cs               |  5 +-
 .../nncase/runtime/cpu/runtime_module.h       |  2 -
 modules/cpu/src/runtime/runtime_function.cpp  | 59 +++++++++++++
 4 files changed, 148 insertions(+), 6 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
index 969fbcec47..7cd4df4f49 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
@@ -19,6 +19,43 @@ internal class FunctionBuilder : IDisposable
     private readonly BinaryWriter _textWriter;
     private readonly BinaryWriter _rdataWriter;
 
+    /// <summary>
+    /// NOTE sync with the k230 runtime function.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MemoryRange
+    {
+        public uint Start;
+        public uint Size;
+    }
+
+    /// <summary>
+    /// NOTE sync with the k230 runtime function.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    private unsafe struct DescHeader
+    {
+        /// <summary>
+        /// input pool size.
+        /// </summary>
+        public uint InputPoolSize;
+
+        /// <summary>
+        /// output pool size.
+        /// </summary>
+        public uint OutputPoolSize;
+
+        /// <summary>
+        /// input numbers.
+        /// </summary>
+        public uint Inputs;
+
+        /// <summary>
+        /// output numbers.
+        /// </summary>
+        public uint Outputs;
+    }
+
     public FunctionBuilder(uint id, BinaryWriter rdataWriter)
     {
         _id = id;
@@ -33,7 +70,54 @@ public unsafe LinkableFunction Build(TIR.PrimFunction function)
         visitor.Visit(function);
         var functionCSource = visitor.GetFunctionCSource();
 
-        // 2. write the rdata
+        // 2. write the desc
+        var descContent = new MemoryStream();
+        using (var descWriter = new BinaryWriter(descContent, Encoding.UTF8))
+        {
+            DescHeader header = new() { InputPoolSize = 0, OutputPoolSize = 0, Inputs = 0, Outputs = 0 };
+            long headerStart = descWriter.Position();
+            descWriter.Skip((ulong)sizeof(DescHeader));
+
+            foreach (var input in function.Parameters.AsValueEnumerable()
+                                .Where(buf => buf.MemLocation == TIR.MemoryLocation.Input))
+            {
+                header.Inputs++;
+                var rg = new MemoryRange { Start = checked((uint)input.Start), Size = checked((uint)input.Size) };
+                descWriter.Write(ref rg);
+                header.InputPoolSize = Math.Max(header.InputPoolSize, rg.Start + rg.Size);
+                descWriter.Write((uint)input.FixedDimensions.Length);
+                foreach (var dim in input.FixedDimensions)
+                {
+                    descWriter.Write((uint)dim);
+                }
+                foreach (var s in input.FixedStrides)
+                {
+                    descWriter.Write((uint)s);
+                }
+            }
+
+            foreach (var output in function.Parameters.AsValueEnumerable().Where(buf => buf.MemLocation == TIR.MemoryLocation.Output))
+            {
+                header.Outputs++;
+                var rg = new MemoryRange { Start = checked((uint)output.Start), Size = checked((uint)output.Size) };
+                descWriter.Write(ref rg);
+                header.OutputPoolSize = Math.Max(header.OutputPoolSize, rg.Start + rg.Size);
+                descWriter.Write((uint)output.FixedDimensions.Length);
+                foreach (var dim in output.FixedDimensions)
+                {
+                    descWriter.Write((uint)dim);
+                }
+                foreach (var s in output.FixedStrides)
+                {
+                    descWriter.Write((uint)s);
+                }
+            }
+
+            descWriter.Position(headerStart);
+            descWriter.Write(ref header);
+        }
+
+        // 3. write the rdata
         foreach (var buffer in function.SchedResult.Rdatas)
         {
             var bytes = buffer.Const!.Value.BytesBuffer;
@@ -46,7 +130,7 @@ public unsafe LinkableFunction Build(TIR.PrimFunction function)
             _rdataWriter.Write(bytes);
         }
 
-        return new LinkableFunction(_id, function, functionCSource);
+        return new LinkableFunction(_id, descContent.ToArray(), function, functionCSource);
     }
 
     public void Dispose()
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
index 37ca1f584f..8757cc2ccd 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
@@ -1,20 +1,21 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
+using System.Runtime.InteropServices;
 using Nncase.IR;
 
 namespace Nncase.CodeGen.CPU;
 
 internal sealed class LinkableFunction : ILinkableFunction
 {
-    public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, FunctionCSource funcCSource)
+    public LinkableFunction(uint id, byte[] descContents, TIR.PrimFunction sourceFunction, FunctionCSource funcCSource)
     {
         Id = id;
         SourceFunction = sourceFunction;
         PrimFunction = sourceFunction;
         FunctionCSource = funcCSource;
         Text = Array.Empty<byte>();
-        Sections = Array.Empty<LinkedSection>();
+        Sections = new ILinkedSection[] { new LinkedSection(descContents, ".desc", 0, 8, (uint)descContents.Length) };
     }
 
     public uint Id { get; }
diff --git a/modules/cpu/include/nncase/runtime/cpu/runtime_module.h b/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
index 9c071f41b6..487908008d 100644
--- a/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
+++ b/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
@@ -18,8 +18,6 @@
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
-NNCASE_INLINE_VAR constexpr char FUNCTION_NAME_SECTION_IDENTIFIER[] = ".name";
-
 NNCASE_INLINE_VAR constexpr module_kind_t cpu_module_type =
     to_module_kind("cpu");
 NNCASE_INLINE_VAR constexpr uint32_t cpu_module_version = 0;
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 3f7cbe4156..9934a6985c 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -21,12 +21,71 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace nncase::runtime::cpu;
 
+namespace {
+typedef struct memory_range {
+    uint32_t start;
+    uint32_t size;
+} memory_range_t;
+
+typedef struct desc_header {
+    uint32_t input_pool_size;
+
+    uint32_t output_pool_size;
+
+    uint32_t inputs;
+
+    uint32_t outputs;
+} desc_header_t;
+
+} // namespace
+
 cpu_runtime_module &cpu_runtime_function::module() const noexcept {
     return static_cast<cpu_runtime_module &>(runtime_function::module());
 }
 
 result<void> cpu_runtime_function::initialize_core(
     NNCASE_UNUSED runtime_function_init_context &context) noexcept {
+
+    try_(context.read_section(".desc", [this](auto sr, size_t) -> result<void> {
+        auto header = sr.template read<desc_header>();
+        if (parameters_size() != header.inputs + header.outputs)
+            return nncase::err(std::errc::invalid_argument);
+
+        for (uint32_t i = 0; i < header.inputs; i++) {
+            sr.template read<memory_range>();
+            auto rank = sr.template read<uint32_t>();
+            std::cout << "shape: ";
+            for (uint32_t j = 0; j < rank; j++) {
+                std::cout << sr.template read<uint32_t>() << ", ";
+            }
+            std::cout << std::endl;
+
+            std::cout << "stride: ";
+            for (uint32_t j = 0; j < rank; j++) {
+                std::cout << sr.template read<uint32_t>() << ", ";
+            }
+            std::cout << std::endl;
+        }
+
+        for (uint32_t i = 0; i < header.outputs; i++) {
+            sr.template read<memory_range>();
+            auto rank = sr.template read<uint32_t>();
+            std::cout << "shape: ";
+            for (uint32_t j = 0; j < rank; j++) {
+                std::cout << sr.template read<uint32_t>() << ", ";
+            }
+            std::cout << std::endl;
+
+            std::cout << "stride: ";
+            for (uint32_t j = 0; j < rank; j++) {
+                std::cout << sr.template read<uint32_t>() << ", ";
+            }
+            std::cout << std::endl;
+        }
+
+        return ok();
+    }));
+
     return ok();
 }
 

From e37b6a1c0372ab85ac71da8d958ed133dccdaccb Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Mon, 24 Jul 2023 08:18:12 +0000
Subject: [PATCH 016/308] Apply code-format changes

---
 modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
index 8b98277d30..73bcd2f605 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -51,6 +51,11 @@ protected string Arch
         get => _arch;
     }
 
+    protected string Ext
+    {
+        get => _ext;
+    }
+
     /// <summary>
     /// select current pattern's exe.
     /// </summary>
@@ -104,11 +109,6 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
         throw new System.ArgumentOutOfRangeException("Only Support Linux/Osx/Windows");
     }
 
-    protected string Ext
-    {
-        get => _ext;
-    }
-
     /// <summary>
     /// compile the source txt, write to the out_path.
     /// </summary>

From 834ab82250fe8c68fa642b56a6d629ff20c5c2de Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 24 Jul 2023 19:58:04 +0800
Subject: [PATCH 017/308] add elfloader

---
 .../CodeGen/CSourceBuiltn.cs                  |  28 +-
 .../CodeGen/FunctionCSource.cs                |   2 +-
 .../CodeGen/LinkableModule.cs                 |   4 +-
 modules/cpu/src/runtime/CMakeLists.txt        |   8 +-
 modules/cpu/src/runtime/cpu_common.h          |  71 +++
 modules/cpu/src/runtime/elf.h                 | 578 ++++++++++++++++++
 modules/cpu/src/runtime/elfarch.h             |  35 ++
 modules/cpu/src/runtime/elfload.cpp           | 269 ++++++++
 modules/cpu/src/runtime/elfload.h             |  99 +++
 modules/cpu/src/runtime/elfloader.cpp         |  40 ++
 modules/cpu/src/runtime/elfloader.h           |  62 ++
 modules/cpu/src/runtime/elfreloc_aarch64.cpp  |  67 ++
 modules/cpu/src/runtime/elfreloc_amd64.cpp    |  28 +
 modules/cpu/src/runtime/elfreloc_i386.cpp     |  28 +
 modules/cpu/src/runtime/elfreloc_riscv64.cpp  |  33 +
 modules/cpu/src/runtime/runtime_function.cpp  |  62 +-
 modules/cpu/src/runtime/runtime_function.h    |   8 +
 modules/cpu/src/runtime/runtime_module.cpp    |   8 +-
 18 files changed, 1414 insertions(+), 16 deletions(-)
 create mode 100644 modules/cpu/src/runtime/cpu_common.h
 create mode 100644 modules/cpu/src/runtime/elf.h
 create mode 100644 modules/cpu/src/runtime/elfarch.h
 create mode 100644 modules/cpu/src/runtime/elfload.cpp
 create mode 100644 modules/cpu/src/runtime/elfload.h
 create mode 100644 modules/cpu/src/runtime/elfloader.cpp
 create mode 100644 modules/cpu/src/runtime/elfloader.h
 create mode 100644 modules/cpu/src/runtime/elfreloc_aarch64.cpp
 create mode 100644 modules/cpu/src/runtime/elfreloc_amd64.cpp
 create mode 100644 modules/cpu/src/runtime/elfreloc_i386.cpp
 create mode 100644 modules/cpu/src/runtime/elfreloc_riscv64.cpp

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index 74fbfae3af..6eb0ae594d 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -10,13 +10,33 @@ public static class CSourceBuiltn
     public const string BufferStruct = @"typedef struct buffer {
     void *vaddr;
     size_t paddr;
-    int *shape;
-    int *stride;
-    int rank;
+    uint32_t *shape;
+    uint32_t *stride;
+    uint32_t rank;
 } buffer_t;";
 
     public const string MethodTable = @"typedef struct nncase_method_table {
-  float (*float_unary_asin)(float);
+    float (*float_unary_abs)(float);
+    float (*float_unary_acos)(float);
+    float (*float_unary_acosh)(float);
+    float (*float_unary_asin)(float);
+    float (*float_unary_asinh)(float);
+    float (*float_unary_ceil)(float);
+    float (*float_unary_cos)(float);
+    float (*float_unary_cosh)(float);
+    float (*float_unary_exp)(float);
+    float (*float_unary_floor)(float);
+    float (*float_unary_log)(float);
+    float (*float_unary_logical_not)(float);
+    float (*float_unary_neg)(float);
+    float (*float_unary_round)(float);
+    float (*float_unary_rsqrt)(float);
+    float (*float_unary_sign)(float);
+    float (*float_unary_sin)(float);
+    float (*float_unary_sinh)(float);
+    float (*float_unary_sqrt)(float);
+    float (*float_unary_square)(float);
+    float (*float_unary_tanh)(float);
 } nncase_mt_t;";
 
     public const string Include = @"#include <stdint.h>
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
index 73bcd2f605..cd5ff86d9d 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -93,7 +93,7 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
-            return $"{sourcePath} -fPIC -shared -march={Arch} -o {outPath}";
+            return $"{sourcePath} -nostdlib -static -no-pie -fPIC -march={Arch} -o {outPath}";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
         {
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index cfa27dc8b5..e2e53e6b19 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -58,7 +58,7 @@ public ILinkedModule Link(ILinkContext linkContext)
 
     private string LinkCSources()
     {
-        var path = Path.GetTempFileName();
+        var path = Path.GetTempFileName() + ".c";
         using (var fs = File.OpenWrite(path))
         {
             using (var writer = new StreamWriter(fs))
@@ -98,6 +98,6 @@ private string LinkCSources()
     private string CompileCSource(string sourcePath)
     {
         var compiler = new CSourceCompiler();
-        return compiler.Compile(sourcePath, Path.GetTempFileName());
+        return compiler.Compile(sourcePath, Path.GetTempFileName() + ".elf");
     }
 }
diff --git a/modules/cpu/src/runtime/CMakeLists.txt b/modules/cpu/src/runtime/CMakeLists.txt
index fe8fc9236a..ebba027d8d 100644
--- a/modules/cpu/src/runtime/CMakeLists.txt
+++ b/modules/cpu/src/runtime/CMakeLists.txt
@@ -1,7 +1,13 @@
 cmake_minimum_required (VERSION 3.13)
 
 set(SRCS runtime_module.cpp
-         runtime_function.cpp)
+         runtime_function.cpp
+         elfload.cpp
+         elfloader.cpp
+         elfreloc_aarch64.cpp
+         elfreloc_amd64.cpp
+         elfreloc_i386.cpp
+         elfreloc_riscv64.cpp)
 
 if (BUILDING_RUNTIME)
     if (ENABLE_CPU_RUNTIME)
diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
new file mode 100644
index 0000000000..70c22065b9
--- /dev/null
+++ b/modules/cpu/src/runtime/cpu_common.h
@@ -0,0 +1,71 @@
+#pragma once
+#include <functional>
+#include <math.h>
+#include <nncase/runtime/cpu/compiler_defs.h>
+#include <stddef.h>
+#include <stdint.h>
+
+BEGIN_NS_NNCASE_RT_MODULE(cpu)
+
+typedef struct nncase_method_table {
+    float (*float_unary_abs)(float);
+    float (*float_unary_acos)(float);
+    float (*float_unary_acosh)(float);
+    float (*float_unary_asin)(float);
+    float (*float_unary_asinh)(float);
+    float (*float_unary_ceil)(float);
+    float (*float_unary_cos)(float);
+    float (*float_unary_cosh)(float);
+    float (*float_unary_exp)(float);
+    float (*float_unary_floor)(float);
+    float (*float_unary_log)(float);
+    float (*float_unary_logical_not)(float);
+    float (*float_unary_neg)(float);
+    float (*float_unary_round)(float);
+    float (*float_unary_rsqrt)(float);
+    float (*float_unary_sign)(float);
+    float (*float_unary_sin)(float);
+    float (*float_unary_sinh)(float);
+    float (*float_unary_sqrt)(float);
+    float (*float_unary_square)(float);
+    float (*float_unary_tanh)(float);
+} nncase_mt_t;
+
+typedef struct buffer {
+    void *vaddr;
+    size_t paddr;
+    uint32_t *shape;
+    uint32_t *stride;
+    uint32_t rank;
+} buffer_t;
+
+inline float float_unary_logical_not(float x) { return !x; }
+inline float float_unary_neg(float x) { return std::negate<float>()(x); }
+inline float float_unary_rsqrt(float x) { return 1.f / sqrtf(x); }
+inline float float_unary_sign(float x) { return (0.f < x) - (x < 0.f); }
+inline float float_unary_square(float x) { return x * x; }
+
+[[maybe_unused]] static nncase_mt_t nncase_mt = {
+    .float_unary_abs = fabsf,
+    .float_unary_acos = acosf,
+    .float_unary_acosh = acoshf,
+    .float_unary_asin = asinf,
+    .float_unary_asinh = asinhf,
+    .float_unary_ceil = ceilf,
+    .float_unary_cos = cosf,
+    .float_unary_cosh = coshf,
+    .float_unary_exp = expf,
+    .float_unary_floor = floorf,
+    .float_unary_log = logf,
+    .float_unary_logical_not = &float_unary_logical_not,
+    .float_unary_neg = &float_unary_neg,
+    .float_unary_round = roundf,
+    .float_unary_rsqrt = &float_unary_rsqrt,
+    .float_unary_sign = &float_unary_sign,
+    .float_unary_sin = sinf,
+    .float_unary_sinh = sinhf,
+    .float_unary_sqrt = sqrtf,
+    .float_unary_square = &float_unary_square,
+    .float_unary_tanh = tanhf};
+
+END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/elf.h b/modules/cpu/src/runtime/elf.h
new file mode 100644
index 0000000000..027f99ad0c
--- /dev/null
+++ b/modules/cpu/src/runtime/elf.h
@@ -0,0 +1,578 @@
+/*    $OpenBSD: exec_elf.h,v 1.53 2014/01/03 03:00:39 guenther Exp $    */
+/*
+ * Copyright (c) 1995, 1996 Erik Theisen.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* imported sys/exec_elf.h from OpenBSD */
+
+#ifndef ELF_H
+#define ELF_H
+#include <stdint.h>
+
+typedef uint8_t     Elf_Byte;
+
+typedef uint32_t    Elf32_Addr;    /* Unsigned program address */
+typedef uint32_t    Elf32_Off;     /* Unsigned file offset */
+typedef int32_t     Elf32_Sword;   /* Signed large integer */
+typedef uint32_t    Elf32_Word;    /* Unsigned large integer */
+typedef uint16_t    Elf32_Half;    /* Unsigned medium integer */
+
+typedef uint64_t    Elf64_Addr;
+typedef uint64_t    Elf64_Off;
+typedef int32_t     Elf64_Shalf;
+
+#ifdef __alpha__
+typedef int64_t     Elf64_Sword;
+typedef uint64_t    Elf64_Word;
+#else
+typedef int32_t     Elf64_Sword;
+typedef uint32_t    Elf64_Word;
+#endif
+
+typedef int64_t     Elf64_Sxword;
+typedef uint64_t    Elf64_Xword;
+
+typedef uint32_t    Elf64_Half;
+typedef uint16_t    Elf64_Quarter;
+
+/*
+ * e_ident[] identification indexes
+ * See http://www.sco.com/developers/gabi/latest/ch4.eheader.html
+ */
+#define EI_MAG0        0        /* file ID */
+#define EI_MAG1        1        /* file ID */
+#define EI_MAG2        2        /* file ID */
+#define EI_MAG3        3        /* file ID */
+#define EI_CLASS       4        /* file class */
+#define EI_DATA        5        /* data encoding */
+#define EI_VERSION     6        /* ELF header version */
+#define EI_OSABI       7        /* OS/ABI ID */
+#define EI_ABIVERSION  8        /* ABI version */
+#define EI_PAD         9        /* start of pad bytes */
+#define EI_NIDENT     16        /* Size of e_ident[] */
+
+/* e_ident[] magic number */
+#define    ELFMAG0        0x7f       /* e_ident[EI_MAG0] */
+#define    ELFMAG1        'E'        /* e_ident[EI_MAG1] */
+#define    ELFMAG2        'L'        /* e_ident[EI_MAG2] */
+#define    ELFMAG3        'F'        /* e_ident[EI_MAG3] */
+#define    ELFMAG        "\177ELF"   /* magic */
+#define    SELFMAG        4          /* size of magic */
+
+/* e_ident[] file class */
+#define    ELFCLASSNONE    0        /* invalid */
+#define    ELFCLASS32    1          /* 32-bit objs */
+#define    ELFCLASS64    2          /* 64-bit objs */
+#define    ELFCLASSNUM    3         /* number of classes */
+
+/* e_ident[] data encoding */
+#define ELFDATANONE    0            /* invalid */
+#define ELFDATA2LSB    1            /* Little-Endian */
+#define ELFDATA2MSB    2            /* Big-Endian */
+#define ELFDATANUM     3            /* number of data encode defines */
+
+/* e_ident[] Operating System/ABI */
+#define ELFOSABI_SYSV        0    /* UNIX System V ABI */
+#define ELFOSABI_HPUX        1    /* HP-UX operating system */
+#define ELFOSABI_NETBSD      2    /* NetBSD */
+#define ELFOSABI_LINUX       3    /* GNU/Linux */
+#define ELFOSABI_HURD        4    /* GNU/Hurd */
+#define ELFOSABI_86OPEN      5    /* 86Open common IA32 ABI */
+#define ELFOSABI_SOLARIS     6    /* Solaris */
+#define ELFOSABI_MONTEREY    7    /* Monterey */
+#define ELFOSABI_IRIX        8    /* IRIX */
+#define ELFOSABI_FREEBSD     9    /* FreeBSD */
+#define ELFOSABI_TRU64       10   /* TRU64 UNIX */
+#define ELFOSABI_MODESTO     11   /* Novell Modesto */
+#define ELFOSABI_OPENBSD     12   /* OpenBSD */
+#define ELFOSABI_ARM         97   /* ARM */
+#define ELFOSABI_STANDALONE  255  /* Standalone (embedded) application */
+
+/* e_ident */
+#define IS_ELF(ehdr) ((ehdr).e_ident[EI_MAG0] == ELFMAG0 && \
+                      (ehdr).e_ident[EI_MAG1] == ELFMAG1 && \
+                      (ehdr).e_ident[EI_MAG2] == ELFMAG2 && \
+                      (ehdr).e_ident[EI_MAG3] == ELFMAG3)
+
+/* ELF Header */
+typedef struct {
+    unsigned char    e_ident[EI_NIDENT];     /* ELF Identification */
+    Elf32_Half       e_type;                 /* object file type */
+    Elf32_Half       e_machine;              /* machine */
+    Elf32_Word       e_version;              /* object file version */
+    Elf32_Addr       e_entry;                /* virtual entry point */
+    Elf32_Off        e_phoff;                /* program header table offset */
+    Elf32_Off        e_shoff;                /* section header table offset */
+    Elf32_Word       e_flags;                /* processor-specific flags */
+    Elf32_Half       e_ehsize;               /* ELF header size */
+    Elf32_Half       e_phentsize;            /* program header entry size */
+    Elf32_Half       e_phnum;                /* number of program header entries */
+    Elf32_Half       e_shentsize;            /* section header entry size */
+    Elf32_Half       e_shnum;                /* number of section header entries */
+    Elf32_Half       e_shstrndx;             /* section header table's "section
+                                                header string table" entry offset */
+} Elf32_Ehdr;
+
+typedef struct {
+    unsigned char    e_ident[EI_NIDENT];    /* Id bytes */
+    Elf64_Quarter    e_type;                /* file type */
+    Elf64_Quarter    e_machine;             /* machine type */
+    Elf64_Half       e_version;             /* version number */
+    Elf64_Addr       e_entry;               /* entry point */
+    Elf64_Off        e_phoff;               /* Program hdr offset */
+    Elf64_Off        e_shoff;               /* Section hdr offset */
+    Elf64_Half       e_flags;               /* Processor flags */
+    Elf64_Quarter    e_ehsize;              /* sizeof ehdr */
+    Elf64_Quarter    e_phentsize;           /* Program header entry size */
+    Elf64_Quarter    e_phnum;               /* Number of program headers */
+    Elf64_Quarter    e_shentsize;           /* Section header entry size */
+    Elf64_Quarter    e_shnum;               /* Number of section headers */
+    Elf64_Quarter    e_shstrndx;            /* String table index */
+} Elf64_Ehdr;
+
+/* e_type */
+#define ET_NONE        0        /* No file type */
+#define ET_REL         1        /* relocatable file */
+#define ET_EXEC        2        /* executable file */
+#define ET_DYN         3        /* shared object file */
+#define ET_CORE        4        /* core file */
+#define ET_NUM         5        /* number of types */
+#define ET_LOPROC      0xff00   /* reserved range for processor */
+#define ET_HIPROC      0xffff   /*  specific e_type */
+
+/* e_machine */
+#define EM_NONE        0        /* No Machine */
+#define EM_M32         1        /* AT&T WE 32100 */
+#define EM_SPARC       2        /* SPARC */
+#define EM_386         3        /* Intel 80386 */
+#define EM_68K         4        /* Motorola 68000 */
+#define EM_88K         5        /* Motorola 88000 */
+#define EM_486         6        /* Intel 80486 - unused? */
+#define EM_860         7        /* Intel 80860 */
+#define EM_MIPS        8        /* MIPS R3000 Big-Endian only */
+/*
+ * Don't know if EM_MIPS_RS4_BE,
+ * EM_SPARC64, EM_PARISC,
+ * or EM_PPC are ABI compliant
+ */
+#define EM_MIPS_RS4_BE 10        /* MIPS R4000 Big-Endian */
+#define EM_SPARC64     11        /* SPARC v9 64-bit unofficial */
+#define EM_PARISC      15        /* HPPA */
+#define EM_SPARC32PLUS 18        /* Enhanced instruction set SPARC */
+#define EM_PPC         20        /* PowerPC */
+#define EM_ARM         40        /* ARM AArch32 */
+#define EM_ALPHA       41        /* DEC ALPHA */
+#define EM_SH          42        /* Hitachi/Renesas Super-H */
+#define EM_SPARCV9     43        /* SPARC version 9 */
+#define EM_IA_64       50        /* Intel IA-64 Processor */
+#define EM_AMD64       62        /* AMD64 architecture */
+#define EM_VAX         75        /* DEC VAX */
+#define EM_AARCH64     183       /* ARM AArch64 */
+
+/* Non-standard */
+#define EM_ALPHA_EXP 0x9026 /* DEC ALPHA */
+
+#define EM_RISCV 243
+
+
+/* Version */
+#define EV_NONE        0        /* Invalid */
+#define EV_CURRENT     1        /* Current */
+#define EV_NUM         2        /* number of versions */
+
+/* Section Header */
+typedef struct {
+    Elf32_Word    sh_name;      /* name - index into section header
+                                 * string table section */
+    Elf32_Word    sh_type;      /* type */
+    Elf32_Word    sh_flags;     /* flags */
+    Elf32_Addr    sh_addr;      /* address */
+    Elf32_Off     sh_offset;    /* file offset */
+    Elf32_Word    sh_size;      /* section size */
+    Elf32_Word    sh_link;      /* section header table index link */
+    Elf32_Word    sh_info;      /* extra information */
+    Elf32_Word    sh_addralign; /* address alignment */
+    Elf32_Word    sh_entsize;   /* section entry size */
+} Elf32_Shdr;
+
+typedef struct {
+    Elf64_Half    sh_name;       /* section name */
+    Elf64_Half    sh_type;       /* section type */
+    Elf64_Xword   sh_flags;      /* section flags */
+    Elf64_Addr    sh_addr;       /* virtual address */
+    Elf64_Off     sh_offset;     /* file offset */
+    Elf64_Xword   sh_size;       /* section size */
+    Elf64_Half    sh_link;       /* link to another */
+    Elf64_Half    sh_info;       /* misc info */
+    Elf64_Xword   sh_addralign;  /* memory alignment */
+    Elf64_Xword   sh_entsize;    /* table entry size */
+} Elf64_Shdr;
+
+/* Special Section Indexes */
+#define SHN_UNDEF     0             /* undefined */
+#define SHN_LORESERVE 0xff00        /* lower bounds of reserved indexes */
+#define SHN_LOPROC    0xff00        /* reserved range for processor */
+#define SHN_HIPROC    0xff1f        /*   specific section indexes */
+#define SHN_ABS       0xfff1        /* absolute value */
+#define SHN_COMMON    0xfff2        /* common symbol */
+#define SHN_HIRESERVE 0xffff        /* upper bounds of reserved indexes */
+
+/* sh_type */
+#define SHT_NULL     0        /* inactive */
+#define SHT_PROGBITS 1        /* program defined information */
+#define SHT_SYMTAB   2        /* symbol table section */
+#define SHT_STRTAB   3        /* string table section */
+#define SHT_RELA     4        /* relocation section with addends*/
+#define SHT_HASH     5        /* symbol hash table section */
+#define SHT_DYNAMIC  6        /* dynamic section */
+#define SHT_NOTE     7        /* note section */
+#define SHT_NOBITS   8        /* no space section */
+#define SHT_REL      9        /* relation section without addends */
+#define SHT_SHLIB    10       /* reserved - purpose unknown */
+#define SHT_DYNSYM   11       /* dynamic symbol table section */
+#define SHT_NUM      12       /* number of section types */
+#define SHT_LOPROC   0x70000000    /* reserved range for processor */
+#define SHT_HIPROC   0x7fffffff    /*  specific section header types */
+#define SHT_LOUSER   0x80000000    /* reserved range for application */
+#define SHT_HIUSER   0xffffffff    /*  specific indexes */
+
+/* Section names */
+#define ELF_BSS         ".bss"        /* uninitialized data */
+#define ELF_DATA        ".data"       /* initialized data */
+#define ELF_DEBUG       ".debug"      /* debug */
+#define ELF_DYNAMIC     ".dynamic"    /* dynamic linking information */
+#define ELF_DYNSTR      ".dynstr"     /* dynamic string table */
+#define ELF_DYNSYM      ".dynsym"     /* dynamic symbol table */
+#define ELF_FINI        ".fini"       /* termination code */
+#define ELF_GOT         ".got"        /* global offset table */
+#define ELF_HASH        ".hash"       /* symbol hash table */
+#define ELF_INIT        ".init"       /* initialization code */
+#define ELF_REL_DATA    ".rel.data"   /* relocation data */
+#define ELF_REL_FINI    ".rel.fini"   /* relocation termination code */
+#define ELF_REL_INIT    ".rel.init"   /* relocation initialization code */
+#define ELF_REL_DYN     ".rel.dyn"    /* relocation dynamic link info */
+#define ELF_REL_RODATA  ".rel.rodata" /* relocation read-only data */
+#define ELF_REL_TEXT    ".rel.text"   /* relocation code */
+#define ELF_RODATA      ".rodata"     /* read-only data */
+#define ELF_SHSTRTAB    ".shstrtab"   /* section header string table */
+#define ELF_STRTAB      ".strtab"     /* string table */
+#define ELF_SYMTAB      ".symtab"     /* symbol table */
+#define ELF_TEXT        ".text"       /* code */
+
+
+/* Section Attribute Flags - sh_flags */
+#define SHF_WRITE        0x1           /* Writable */
+#define SHF_ALLOC        0x2           /* occupies memory */
+#define SHF_EXECINSTR    0x4           /* executable */
+#define SHF_TLS          0x400         /* thread local storage */
+#define SHF_MASKPROC     0xf0000000    /* reserved bits for processor
+                                        *  specific section attributes */
+
+/* Symbol Table Entry */
+typedef struct elf32_sym {
+    Elf32_Word    st_name;     /* name - index into string table */
+    Elf32_Addr    st_value;    /* symbol value */
+    Elf32_Word    st_size;     /* symbol size */
+    unsigned char st_info;     /* type and binding */
+    unsigned char st_other;    /* 0 - no defined meaning */
+    Elf32_Half    st_shndx;    /* section header index */
+} Elf32_Sym;
+
+typedef struct {
+    Elf64_Half    st_name;    /* Symbol name index in str table */
+    Elf_Byte      st_info;    /* type / binding attrs */
+    Elf_Byte      st_other;   /* unused */
+    Elf64_Quarter st_shndx;   /* section index of symbol */
+    Elf64_Xword   st_value;   /* value of symbol */
+    Elf64_Xword   st_size;    /* size of symbol */
+} Elf64_Sym;
+
+/* Symbol table index */
+#define STN_UNDEF    0        /* undefined */
+
+/* Extract symbol info - st_info */
+#define ELF32_ST_BIND(x)    ((x) >> 4)
+#define ELF32_ST_TYPE(x)    (((unsigned int) x) & 0xf)
+#define ELF32_ST_INFO(b,t)  (((b) << 4) + ((t) & 0xf))
+
+#define ELF64_ST_BIND(x)    ((x) >> 4)
+#define ELF64_ST_TYPE(x)    (((unsigned int) x) & 0xf)
+#define ELF64_ST_INFO(b,t)  (((b) << 4) + ((t) & 0xf))
+
+/* Symbol Binding - ELF32_ST_BIND - st_info */
+#define STB_LOCAL    0        /* Local symbol */
+#define STB_GLOBAL   1        /* Global symbol */
+#define STB_WEAK     2        /* like global - lower precedence */
+#define STB_NUM      3        /* number of symbol bindings */
+#define STB_LOPROC  13        /* reserved range for processor */
+#define STB_HIPROC  15        /*  specific symbol bindings */
+
+/* Symbol type - ELF32_ST_TYPE - st_info */
+#define STT_NOTYPE    0        /* not specified */
+#define STT_OBJECT    1        /* data object */
+#define STT_FUNC      2        /* function */
+#define STT_SECTION   3        /* section */
+#define STT_FILE      4        /* file */
+#define STT_TLS       6        /* thread local storage */
+#define STT_LOPROC    13       /* reserved range for processor */
+#define STT_HIPROC    15       /*  specific symbol types */
+
+/* Relocation entry with implicit addend */
+typedef struct {
+    Elf32_Addr    r_offset;    /* offset of relocation */
+    Elf32_Word    r_info;      /* symbol table index and type */
+} Elf32_Rel;
+
+/* Relocation entry with explicit addend */
+typedef struct {
+    Elf32_Addr    r_offset;    /* offset of relocation */
+    Elf32_Word    r_info;      /* symbol table index and type */
+    Elf32_Sword   r_addend;
+} Elf32_Rela;
+
+/* Extract relocation info - r_info */
+#define ELF32_R_SYM(i)         ((i) >> 8)
+#define ELF32_R_TYPE(i)        ((unsigned char) (i))
+#define ELF32_R_INFO(s,t)      (((s) << 8) + (unsigned char)(t))
+
+typedef struct {
+    Elf64_Xword    r_offset;    /* where to do it */
+    Elf64_Xword    r_info;      /* index & type of relocation */
+} Elf64_Rel;
+
+typedef struct {
+    Elf64_Xword    r_offset;    /* where to do it */
+    Elf64_Xword    r_info;      /* index & type of relocation */
+    Elf64_Sxword    r_addend;   /* adjustment value */
+} Elf64_Rela;
+
+#define    ELF64_R_SYM(info)    ((info) >> 32)
+#define    ELF64_R_TYPE(info)   ((info) & 0xFFFFFFFF)
+#define    ELF64_R_INFO(s,t)    (((s) << 32) + (__uint32_t)(t))
+
+#if defined(__mips64__) && defined(__MIPSEL__)
+/*
+ * The 64-bit MIPS ELF ABI uses a slightly different relocation format
+ * than the regular ELF ABI: the r_info field is split into several
+ * pieces (see gnu/usr.bin/binutils/include/elf/mips.h for details).
+ */
+#undef    ELF64_R_SYM
+#undef    ELF64_R_TYPE
+#undef    ELF64_R_INFO
+#define   ELF64_R_TYPE(info)   (swap32((info) >> 32))
+#define   ELF64_R_SYM(info)    ((info) & 0xFFFFFFFF)
+#define   ELF64_R_INFO(s,t)    (((__uint64_t)swap32(t) << 32) + (__uint32_t)(s))
+#endif /* __mips64__ && __MIPSEL__ */
+
+/* Program Header */
+typedef struct {
+    Elf32_Word    p_type;     /* segment type */
+    Elf32_Off     p_offset;   /* segment offset */
+    Elf32_Addr    p_vaddr;    /* virtual address of segment */
+    Elf32_Addr    p_paddr;    /* physical address - ignored? */
+    Elf32_Word    p_filesz;   /* number of bytes in file for seg. */
+    Elf32_Word    p_memsz;    /* number of bytes in mem. for seg. */
+    Elf32_Word    p_flags;    /* flags */
+    Elf32_Word    p_align;    /* memory alignment */
+} Elf32_Phdr;
+
+typedef struct {
+    Elf64_Half    p_type;     /* entry type */
+    Elf64_Half    p_flags;    /* flags */
+    Elf64_Off     p_offset;   /* offset */
+    Elf64_Addr    p_vaddr;    /* virtual address */
+    Elf64_Addr    p_paddr;    /* physical address */
+    Elf64_Xword   p_filesz;   /* file size */
+    Elf64_Xword   p_memsz;    /* memory size */
+    Elf64_Xword   p_align;    /* memory & file alignment */
+} Elf64_Phdr;
+
+/* Segment types - p_type */
+#define PT_NULL        0          /* unused */
+#define PT_LOAD        1          /* loadable segment */
+#define PT_DYNAMIC     2          /* dynamic linking section */
+#define PT_INTERP      3          /* the RTLD */
+#define PT_NOTE        4          /* auxiliary information */
+#define PT_SHLIB       5          /* reserved - purpose undefined */
+#define PT_PHDR        6          /* program header */
+#define PT_TLS         7          /* thread local storage */
+#define PT_LOOS        0x60000000 /* reserved range for OS */
+#define PT_HIOS        0x6fffffff /*  specific segment types */
+#define PT_LOPROC      0x70000000 /* reserved range for processor */
+#define PT_HIPROC      0x7fffffff /*  specific segment types */
+
+#define PT_OPENBSD_RANDOMIZE 0x65a3dbe6 /* fill with random data */
+#define PT_GANDR_KERNEL      0x67646b6c /* gdkl */
+
+
+/* Segment flags - p_flags */
+#define PF_X        0x1        /* Executable */
+#define PF_W        0x2        /* Writable */
+#define PF_R        0x4        /* Readable */
+#define PF_MASKPROC 0xf0000000    /* reserved bits for processor */
+                    /*  specific segment flags */
+
+/* Dynamic structure */
+typedef struct {
+    Elf32_Sword    d_tag;    /* controls meaning of d_val */
+    union {
+        Elf32_Word d_val;    /* Multiple meanings - see d_tag */
+        Elf32_Addr d_ptr;    /* program virtual address */
+    } d_un;
+} Elf32_Dyn;
+
+typedef struct {
+    Elf64_Xword     d_tag;   /* controls meaning of d_val */
+    union {
+        Elf64_Addr  d_ptr;
+        Elf64_Xword d_val;
+    } d_un;
+} Elf64_Dyn;
+
+/* Dynamic Array Tags - d_tag */
+#define DT_NULL        0        /* marks end of _DYNAMIC array */
+#define DT_NEEDED      1        /* string table offset of needed lib */
+#define DT_PLTRELSZ    2        /* size of relocation entries in PLT */
+#define DT_PLTGOT      3        /* address PLT/GOT */
+#define DT_HASH        4        /* address of symbol hash table */
+#define DT_STRTAB      5        /* address of string table */
+#define DT_SYMTAB      6        /* address of symbol table */
+#define DT_RELA        7        /* address of relocation table */
+#define DT_RELASZ      8        /* size of relocation table */
+#define DT_RELAENT     9        /* size of relocation entry */
+#define DT_STRSZ      10        /* size of string table */
+#define DT_SYMENT     11        /* size of symbol table entry */
+#define DT_INIT       12        /* address of initialization func. */
+#define DT_FINI       13        /* address of termination function */
+#define DT_SONAME     14        /* string table offset of shared obj */
+#define DT_RPATH      15        /* string table offset of library
+                                 * search path */
+#define DT_SYMBOLIC   16        /* start sym search in shared obj. */
+#define DT_REL        17        /* address of rel. tbl. w addends */
+#define DT_RELSZ      18        /* size of DT_REL relocation table */
+#define DT_RELENT     19        /* size of DT_REL relocation entry */
+#define DT_PLTREL     20        /* PLT referenced relocation entry */
+#define DT_DEBUG      21        /* bugger */
+#define DT_TEXTREL    22        /* Allow rel. mod. to unwritable seg */
+#define DT_JMPREL     23        /* add. of PLT's relocation entries */
+#define DT_BIND_NOW   24        /* Bind now regardless of env setting */
+#define DT_LOOS       0x6000000d    /* reserved range for OS */
+#define DT_HIOS       0x6ffff000    /*  specific dynamic array tags */
+#define DT_LOPROC     0x70000000    /* reserved range for processor */
+#define DT_HIPROC     0x7fffffff    /*  specific dynamic array tags */
+
+/* some other useful tags */
+#define DT_RELACOUNT  0x6ffffff9    /* if present, number of RELATIVE */
+#define DT_RELCOUNT   0x6ffffffa    /* relocs, which must come first */
+#define DT_FLAGS_1    0x6ffffffb
+
+/* Dynamic Flags - DT_FLAGS_1 .dynamic entry */
+#define DF_1_NOW       0x00000001
+#define DF_1_GLOBAL    0x00000002
+#define DF_1_GROUP     0x00000004
+#define DF_1_NODELETE  0x00000008
+#define DF_1_LOADFLTR  0x00000010
+#define DF_1_INITFIRST 0x00000020
+#define DF_1_NOOPEN    0x00000040
+#define DF_1_ORIGIN    0x00000080
+#define DF_1_DIRECT    0x00000100
+#define DF_1_TRANS     0x00000200
+#define DF_1_INTERPOSE 0x00000400
+#define DF_1_NODEFLIB  0x00000800
+#define DF_1_NODUMP    0x00001000
+#define DF_1_CONLFAT   0x00002000
+
+/* ld.so: number of low tags that are used saved internally (0 .. DT_NUM-1) */
+#define DT_NUM        (DT_JMPREL+1)
+
+/*
+ * Note Definitions
+ */
+typedef struct {
+    Elf32_Word namesz;
+    Elf32_Word descsz;
+    Elf32_Word type;
+} Elf32_Note;
+
+typedef struct {
+    Elf64_Half namesz;
+    Elf64_Half descsz;
+    Elf64_Half type;
+} Elf64_Note;
+
+#if defined(ELFSIZE) && (ELFSIZE == 32)
+#define Elf_Ehdr    Elf32_Ehdr
+#define Elf_Phdr    Elf32_Phdr
+#define Elf_Shdr    Elf32_Shdr
+#define Elf_Sym     Elf32_Sym
+#define Elf_Rel     Elf32_Rel
+#define Elf_RelA    Elf32_Rela
+#define Elf_Dyn     Elf32_Dyn
+#define Elf_Half    Elf32_Half
+#define Elf_Word    Elf32_Word
+#define Elf_Sword   Elf32_Sword
+#define Elf_Addr    Elf32_Addr
+#define Elf_Off     Elf32_Off
+#define Elf_Nhdr    Elf32_Nhdr
+#define Elf_Note    Elf32_Note
+
+#define ELF_R_SYM   ELF32_R_SYM
+#define ELF_R_TYPE  ELF32_R_TYPE
+#define ELF_R_INFO  ELF32_R_INFO
+#define ELFCLASS    ELFCLASS32
+
+#define ELF_ST_BIND ELF32_ST_BIND
+#define ELF_ST_TYPE ELF32_ST_TYPE
+#define ELF_ST_INFO ELF32_ST_INFO
+
+#elif defined(ELFSIZE) && (ELFSIZE == 64)
+
+#define Elf_Ehdr    Elf64_Ehdr
+#define Elf_Phdr    Elf64_Phdr
+#define Elf_Shdr    Elf64_Shdr
+#define Elf_Sym     Elf64_Sym
+#define Elf_Rel     Elf64_Rel
+#define Elf_RelA    Elf64_Rela
+#define Elf_Dyn     Elf64_Dyn
+#define Elf_Half    Elf64_Half
+#define Elf_Word    Elf64_Word
+#define Elf_Sword   Elf64_Sword
+#define Elf_Addr    Elf64_Addr
+#define Elf_Off     Elf64_Off
+#define Elf_Nhdr    Elf64_Nhdr
+#define Elf_Note    Elf64_Note
+
+#define ELF_R_SYM   ELF64_R_SYM
+#define ELF_R_TYPE  ELF64_R_TYPE
+#define ELF_R_INFO  ELF64_R_INFO
+#define ELFCLASS    ELFCLASS64
+
+#define ELF_ST_BIND ELF64_ST_BIND
+#define ELF_ST_TYPE ELF64_ST_TYPE
+#define ELF_ST_INFO ELF64_ST_INFO
+
+#endif
+
+#endif
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/elfarch.h b/modules/cpu/src/runtime/elfarch.h
new file mode 100644
index 0000000000..11f666c984
--- /dev/null
+++ b/modules/cpu/src/runtime/elfarch.h
@@ -0,0 +1,35 @@
+#ifndef ELFARCH_H
+#define ELFARCH_H
+
+#if defined(__i386__)
+#define EM_THIS EM_386
+#define EL_ARCH_USES_REL
+#elif defined(__amd64__)
+#define EM_THIS EM_AMD64
+#define EL_ARCH_USES_RELA
+#elif defined(__arm__)
+#define EM_THIS EM_ARM
+#elif defined(__aarch64__)
+#define EM_THIS EM_AARCH64
+#define EL_ARCH_USES_RELA
+#define EL_ARCH_USES_REL
+#elif defined(__riscv)
+#define EM_THIS EM_RISCV
+#define EL_ARCH_USES_RELA
+#else
+#error specify your ELF architecture
+#endif
+
+#if defined(__LP64__) || defined(__LLP64__)
+#define ELFSIZE 64
+#else
+#define ELFSIZE 32
+#endif
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define ELFDATATHIS ELFDATA2LSB
+#else
+#define ELFDATATHIS ELFDATA2MSB
+#endif
+
+#endif
diff --git a/modules/cpu/src/runtime/elfload.cpp b/modules/cpu/src/runtime/elfload.cpp
new file mode 100644
index 0000000000..b1670da065
--- /dev/null
+++ b/modules/cpu/src/runtime/elfload.cpp
@@ -0,0 +1,269 @@
+#include "elfload.h"
+#include <cstdio>
+#include <cstring>
+
+el_status el_pread(el_ctx *ctx, void *def, size_t nb, size_t offset)
+{
+    return ctx->pread(ctx, def, nb, offset) ? EL_OK : EL_EIO;
+}
+
+#define EL_PHOFF(ctx, num) (((ctx)->ehdr.e_phoff + (num) * (ctx)->ehdr.e_phentsize))
+
+el_status el_findphdr(el_ctx *ctx, Elf_Phdr *phdr, uint32_t type, unsigned *i)
+{
+    el_status rv = EL_OK;
+    for (; *i < ctx->ehdr.e_phnum; (*i)++) {
+        if ((rv = el_pread(ctx, phdr, sizeof *phdr, EL_PHOFF(ctx, *i))))
+            return rv;
+
+        if (phdr->p_type == type) {
+            return rv;
+        }
+    }
+
+    *i = -1;
+    return rv;
+}
+
+el_status el_init(el_ctx *ctx)
+{
+    el_status rv = EL_OK;
+    if ((rv = el_pread(ctx, &ctx->ehdr, sizeof ctx->ehdr, 0)))
+        return rv;
+
+    /* validate header */
+
+    if (!IS_ELF(ctx->ehdr))
+        return EL_NOTELF;
+
+
+    if (ctx->ehdr.e_ident[EI_CLASS] != ELFCLASS)
+        return EL_WRONGBITS;
+
+    if (ctx->ehdr.e_ident[EI_DATA] != ELFDATATHIS)
+        return EL_WRONGENDIAN;
+
+    if (ctx->ehdr.e_ident[EI_VERSION] != EV_CURRENT)
+        return EL_NOTELF;
+
+#if 0
+    /* gandr binaries use the STANDALONE ABI */
+    if (ctx->ehdr.e_ident[EI_OSABI] != ELFOSABI_STANDALONE)
+        return EL_WRONGOS;
+
+    /* G is for Gandr
+    if (ctx->ehdr.e_ident[EI_ABIVERSION] != 'G')
+        return EL_WRONGOS; */
+#endif
+
+    if (ctx->ehdr.e_type != ET_EXEC && ctx->ehdr.e_type != ET_DYN)
+        return EL_NOTEXEC;
+
+    if (ctx->ehdr.e_machine != EM_THIS)
+        return EL_WRONGARCH;
+
+    if (ctx->ehdr.e_version != EV_CURRENT)
+        return EL_NOTELF;
+
+    /* load phdrs */
+    Elf_Phdr ph;
+
+    /* iterate through, calculate extents */
+    ctx->base_load_paddr = ctx->base_load_vaddr = 0;
+    ctx->align = 1;
+    ctx->memsz = 0;
+
+    unsigned i = 0;
+    for(;;) {
+        if ((rv = el_findphdr(ctx, &ph, PT_LOAD, &i)))
+            return rv;
+
+        if (i == (unsigned) -1)
+            break;
+
+        Elf_Addr phend = ph.p_vaddr + ph.p_memsz;
+        if (phend > ctx->memsz)
+            ctx->memsz = phend;
+
+        if (ph.p_align > ctx->align)
+            ctx->align = ph.p_align;
+
+        i++;
+    }
+
+    if (ctx->ehdr.e_type == ET_DYN) {
+        i = 0;
+
+        if ((rv = el_findphdr(ctx, &ph, PT_DYNAMIC, &i)))
+            return rv;
+
+        if (i == (unsigned) -1)
+            return EL_NODYN;
+
+        ctx->dynoff  = ph.p_offset;
+        ctx->dynsize = ph.p_filesz;
+    } else {
+        ctx->dynoff  = 0;
+        ctx->dynsize = 0;
+    }
+
+    return rv;
+}
+
+/*
+typedef void* (*el_alloc_cb)(
+    el_ctx *ctx,
+    Elf_Addr phys,
+    Elf_Addr virt,
+    Elf_Addr size);
+*/
+
+el_status el_load(el_ctx *ctx, el_alloc_cb alloc)
+{
+    el_status rv = EL_OK;
+
+    /* address deltas */
+    Elf_Addr pdelta = ctx->base_load_paddr;
+    Elf_Addr vdelta = ctx->base_load_vaddr;
+
+    /* iterate paddrs */
+    Elf_Phdr ph;
+    unsigned i = 0;
+    for(;;) {
+        if ((rv = el_findphdr(ctx, &ph, PT_LOAD, &i)))
+            return rv;
+
+        if (i == (unsigned) -1)
+            break;
+
+        Elf_Addr pload = ph.p_paddr + pdelta;
+        Elf_Addr vload = ph.p_vaddr + vdelta;
+
+        /* allocate mem */
+        char *dest = (char *)alloc(ctx, pload, vload, ph.p_memsz);
+        if (!dest)
+            return EL_ENOMEM;
+
+        printf("Loading seg fileoff %lx, vaddr %lx to %lx\n",
+            ph.p_offset, ph.p_vaddr, (uintptr_t)dest);
+
+        /* read loaded portion */
+        if ((rv = el_pread(ctx, dest, ph.p_filesz, ph.p_offset)))
+            return rv;
+
+        /* zero mem-only portion */
+        memset(dest + ph.p_filesz, 0, ph.p_memsz - ph.p_filesz);
+
+        i++;
+    }
+
+    return rv;
+}
+
+el_status el_finddyn(el_ctx *ctx, Elf_Dyn *dyn, uint32_t tag)
+{
+    el_status rv = EL_OK;
+    size_t ndyn =  ctx->dynsize / sizeof(Elf_Dyn);
+
+    for(unsigned i = 0; i < ndyn; i++) {
+        if ((rv = el_pread(ctx, dyn, sizeof *dyn, ctx->dynoff + i * sizeof *dyn)))
+            return rv;
+
+        if (dyn->d_tag == tag)
+            return EL_OK;
+    }
+
+    dyn->d_tag = DT_NULL;
+    return EL_OK;
+}
+
+el_status el_findrelocs(el_ctx *ctx, el_relocinfo *ri, uint32_t type)
+{
+    el_status rv = EL_OK;
+
+    Elf_Dyn rel, relsz, relent;
+
+    if ((rv = el_finddyn(ctx, &rel, type)))
+        return rv;
+
+    if ((rv = el_finddyn(ctx, &relsz, type + 1)))
+        return rv;
+
+    if ((rv = el_finddyn(ctx, &relent, type + 2)))
+        return rv;
+
+    if (rel.d_tag == DT_NULL
+            || relsz.d_tag == DT_NULL
+            || relent.d_tag == DT_NULL) {
+        ri->entrysize = 0;
+        ri->tablesize = 0;
+        ri->tableoff  = 0;
+    } else {
+        ri->tableoff  = rel.d_un.d_ptr;
+        ri->tablesize = relsz.d_un.d_val;
+        ri->entrysize = relent.d_un.d_val;
+    }
+
+    return rv;
+}
+
+extern el_status el_applyrel(el_ctx *ctx, Elf_Rel *rel);
+extern el_status el_applyrela(el_ctx *ctx, Elf_RelA *rela);
+
+el_status el_relocate(el_ctx *ctx)
+{
+    el_status rv = EL_OK;
+
+    // not dynamic
+    if (ctx->ehdr.e_type != ET_DYN)
+        return EL_OK;
+
+    char *base = (char *) ctx->base_load_paddr;
+
+    el_relocinfo ri;
+#ifdef EL_ARCH_USES_REL
+    if ((rv = el_findrelocs(ctx, &ri, DT_REL)))
+        return rv;
+
+    if (ri.entrysize != sizeof(Elf_Rel) && ri.tablesize) {
+        EL_DEBUG("Relocation size %u doesn't match expected %u\n",
+            ri.entrysize, sizeof(Elf_Rel));
+        return EL_BADREL;
+    }
+
+    size_t relcnt = ri.tablesize / sizeof(Elf_Rel);
+    Elf_Rel *reltab = base + ri.tableoff;
+    for (size_t i = 0; i < relcnt; i++) {
+        if ((rv = el_applyrel(ctx, &reltab[i])))
+            return rv;
+    }
+#else
+    EL_DEBUG("Architecture doesn't use REL\n");
+#endif
+
+#ifdef EL_ARCH_USES_RELA
+    if ((rv = el_findrelocs(ctx, &ri, DT_RELA)))
+        return rv;
+
+    if (ri.entrysize != sizeof(Elf_RelA) && ri.tablesize) {
+        EL_DEBUG("Relocation size %u doesn't match expected %u\n",
+            ri.entrysize, sizeof(Elf_RelA));
+        return EL_BADREL;
+    }
+
+    size_t relacnt = ri.tablesize / sizeof(Elf_RelA);
+    Elf_RelA *relatab = (Elf_RelA *)(base + ri.tableoff);
+    for (size_t i = 0; i < relacnt; i++) {
+        if ((rv = el_applyrela(ctx, &relatab[i])))
+            return rv;
+    }
+#else
+    EL_DEBUG("Architecture doesn't use RELA\n");
+#endif
+
+#if !defined(EL_ARCH_USES_REL) && !defined(EL_ARCH_USES_RELA)
+    #error No relocation type defined!
+#endif
+
+    return rv;
+}
diff --git a/modules/cpu/src/runtime/elfload.h b/modules/cpu/src/runtime/elfload.h
new file mode 100644
index 0000000000..148b9b3a72
--- /dev/null
+++ b/modules/cpu/src/runtime/elfload.h
@@ -0,0 +1,99 @@
+#ifndef ELFLOAD_H
+#define ELFLOAD_H
+#include <stdbool.h>
+#include <stddef.h>
+#include "elfarch.h"
+#include "elf.h"
+
+#ifdef DEBUG
+#include <stdio.h>
+#define EL_DEBUG(...) printf(__VA_ARGS__)
+#else
+#define EL_DEBUG(...) do {} while(0)
+#endif
+
+typedef enum {
+    EL_OK         = 0,
+
+    EL_EIO,
+    EL_ENOMEM,
+
+    EL_NOTELF,
+    EL_WRONGBITS,
+    EL_WRONGENDIAN,
+    EL_WRONGARCH,
+    EL_WRONGOS,
+    EL_NOTEXEC,
+    EL_NODYN,
+    EL_BADREL,
+
+} el_status;
+
+typedef struct el_ctx {
+    bool (*pread)(struct el_ctx *ctx, void *dest, size_t nb, size_t offset);
+
+    /* base_load_* -> address we are actually going to load at
+     */
+    Elf_Addr
+        base_load_paddr,
+        base_load_vaddr;
+
+    /* size in memory of binary */
+    Elf_Addr memsz;
+
+    /* required alignment */
+    Elf_Addr align;
+
+    /* ELF header */
+    Elf_Ehdr  ehdr;
+
+    /* Offset of dynamic table (0 if not ET_DYN) */
+    Elf_Off  dynoff;
+    /* Size of dynamic table (0 if not ET_DYN) */
+    Elf_Addr dynsize;
+
+    void *elf;
+} el_ctx;
+
+el_status el_pread(el_ctx *ctx, void *def, size_t nb, size_t offset);
+
+el_status el_init(el_ctx *ctx);
+typedef void* (*el_alloc_cb)(
+    el_ctx *ctx,
+    Elf_Addr phys,
+    Elf_Addr virt,
+    Elf_Addr size);
+
+el_status el_load(el_ctx *ctx, el_alloc_cb alloccb);
+
+/* find the next phdr of type \p type, starting at \p *i.
+ * On success, returns EL_OK with *i set to the phdr number, and the phdr loaded
+ * in *phdr.
+ *
+ * If the end of the phdrs table was reached, *i is set to -1 and the contents
+ * of *phdr are undefined
+ */
+el_status el_findphdr(el_ctx *ctx, Elf_Phdr *phdr, uint32_t type, unsigned *i);
+
+/* Relocate the loaded executable */
+el_status el_relocate(el_ctx *ctx);
+
+/* find a dynamic table entry
+ * returns the entry on success, dyn->d_tag = DT_NULL on failure
+ */
+el_status el_finddyn(el_ctx *ctx, Elf_Dyn *dyn, uint32_t type);
+
+typedef struct {
+    Elf_Off  tableoff;
+    Elf_Addr tablesize;
+    Elf_Addr entrysize;
+} el_relocinfo;
+
+/* find all information regarding relocations of a specific type.
+ *
+ * pass DT_REL or DT_RELA for type
+ * sets ri->entrysize = 0 if not found
+ */
+el_status el_findrelocs(el_ctx *ctx, el_relocinfo *ri, uint32_t type);
+
+#endif
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/cpu/src/runtime/elfloader.cpp
new file mode 100644
index 0000000000..8bced71e14
--- /dev/null
+++ b/modules/cpu/src/runtime/elfloader.cpp
@@ -0,0 +1,40 @@
+#include "elfloader.h"
+
+using namespace nncase;
+using namespace nncase::runtime;
+using namespace nncase::runtime::cpu;
+
+int elfloader::invoke_elf(size_t id, buffer_t **buffers,
+                           nncase_mt_t *nncase_mt, void *data, void *rdata) {
+
+    check(el_init(&ctx_), "initialising");
+
+    // align to ctx.align
+    ptr_ = malloc(ctx_.memsz + ctx_.align);
+    buf_ = (void *)(((size_t)ptr_ + (ctx_.align - 1)) & ~(ctx_.align - 1));
+
+#if defined(__linux__)
+    if (mprotect(buf_, ctx_.memsz, PROT_READ | PROT_WRITE | PROT_EXEC)) {
+        perror("mprotect");
+        return 1;
+    }
+#endif
+
+    ctx_.base_load_vaddr = ctx_.base_load_paddr = (uintptr_t)buf_;
+
+    check(el_load(&ctx_, alloccb), "loading");
+    check(el_relocate(&ctx_), "relocating");
+
+    uintptr_t epaddr = ctx_.ehdr.e_entry + (uintptr_t)buf_;
+
+    entrypoint_t ep = (entrypoint_t)epaddr;
+
+    printf("Binary entrypoint is %" PRIxPTR "; invoking %p\n",
+           (uintptr_t)ctx_.ehdr.e_entry, (void *)epaddr);
+
+    ep(id, buffers, nncase_mt, data, rdata);
+
+    free(ptr_);
+
+    return 0;
+}
diff --git a/modules/cpu/src/runtime/elfloader.h b/modules/cpu/src/runtime/elfloader.h
new file mode 100644
index 0000000000..771a6b5f16
--- /dev/null
+++ b/modules/cpu/src/runtime/elfloader.h
@@ -0,0 +1,62 @@
+#pragma once
+#include "cpu_common.h"
+#include "elfload.h"
+#include <inttypes.h>
+#include <math.h>
+#include <nncase/runtime/cpu/compiler_defs.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(__linux__)
+#include <sys/mman.h>
+#endif
+
+BEGIN_NS_NNCASE_RT_MODULE(cpu)
+
+typedef void (*entrypoint_t)(size_t id, buffer_t **buffers,
+                             nncase_mt_t *nncase_mt, void *data, void *rdata);
+
+class elfloader {
+  public:
+    elfloader(char *elf) : elf_(elf) {
+        ctx_.pread = bpread;
+        ctx_.elf = elf;
+    }
+
+    // typedef void (*entrypoint_t)(float (*op_t)(float), float *, float *,
+    // int);
+
+    static bool bpread(el_ctx *ctx, void *dest, size_t nb, size_t offset) {
+        (void)ctx;
+
+        memcpy(dest, (char *)ctx->elf + offset, nb);
+
+        return true;
+    }
+
+    static void *alloccb(el_ctx *ctx, Elf_Addr phys, Elf_Addr virt,
+                         Elf_Addr size) {
+        (void)ctx;
+        (void)phys;
+        (void)size;
+        return (void *)virt;
+    }
+
+    static void check(el_status stat, const char *expln) {
+        if (stat) {
+            fprintf(stderr, "%s: error %d\n", expln, stat);
+            exit(1);
+        }
+    }
+
+    int invoke_elf(size_t id, buffer_t **buffers, nncase_mt_t *nncase_mt,
+                   void *data, void *rdata);
+
+  private:
+    void *ptr_;
+    void *buf_;
+    char *elf_;
+    el_ctx ctx_;
+};
+
+END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/elfreloc_aarch64.cpp b/modules/cpu/src/runtime/elfreloc_aarch64.cpp
new file mode 100644
index 0000000000..e8fd3f8ed7
--- /dev/null
+++ b/modules/cpu/src/runtime/elfreloc_aarch64.cpp
@@ -0,0 +1,67 @@
+#include "elfload.h"
+
+#if defined(__aarch64__)
+
+#define R_AARCH64_NONE     0
+#define R_AARCH64_RELATIVE 1027
+
+el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel)
+{
+    uintptr_t *p = (uintptr_t*) (rel->r_offset + ctx->base_load_paddr);
+    uint32_t type = ELF_R_TYPE(rel->r_info);
+    uint32_t sym  = ELF_R_SYM(rel->r_info);
+
+    switch (type) {
+        case R_AARCH64_NONE:
+            EL_DEBUG("R_AARCH64_NONE\n");
+            break;
+        case R_AARCH64_RELATIVE:
+            if (sym) {
+                EL_DEBUG("R_AARCH64_RELATIVE with symbol ref!\n");
+                return EL_BADREL;
+            }
+
+            EL_DEBUG("Applying R_AARCH64_RELATIVE reloc @%p\n", p);
+            *p = rel->r_addend + ctx->base_load_vaddr;
+            break;
+
+        default:
+            EL_DEBUG("Bad relocation %u\n", type);
+            return EL_BADREL;
+
+    }
+
+    return EL_OK;
+}
+
+el_status el_applyrel(el_ctx *ctx, Elf_Rel *rel)
+{
+    uintptr_t *p = (uintptr_t*) (rel->r_offset + ctx->base_load_paddr);
+    uint32_t type = ELF_R_TYPE(rel->r_info);
+    uint32_t sym  = ELF_R_SYM(rel->r_info);
+
+    switch (type) {
+        case R_AARCH64_NONE:
+            EL_DEBUG("R_AARCH64_NONE\n");
+            break;
+        case R_AARCH64_RELATIVE:
+            if (sym) {
+                EL_DEBUG("R_AARCH64_RELATIVE with symbol ref!\n");
+                return EL_BADREL;
+            }
+
+            EL_DEBUG("Applying R_AARCH64_RELATIVE reloc @%p\n", p);
+            *p += ctx->base_load_vaddr;
+            break;
+
+        default:
+            EL_DEBUG("Bad relocation %u\n", type);
+            return EL_BADREL;
+
+    }
+
+    return EL_OK;
+}
+
+
+#endif
diff --git a/modules/cpu/src/runtime/elfreloc_amd64.cpp b/modules/cpu/src/runtime/elfreloc_amd64.cpp
new file mode 100644
index 0000000000..8b32082ff3
--- /dev/null
+++ b/modules/cpu/src/runtime/elfreloc_amd64.cpp
@@ -0,0 +1,28 @@
+#include "elfload.h"
+
+#if defined(__amd64__)
+
+#define R_AMD64_NONE     0
+#define R_AMD64_RELATIVE 8
+
+el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel)
+{
+    uint64_t *p = (uint64_t*) (rel->r_offset + ctx->base_load_vaddr);
+    uint32_t type = ELF_R_TYPE(rel->r_info);
+
+    switch (type) {
+        case R_AMD64_NONE: break;
+        case R_AMD64_RELATIVE:
+            EL_DEBUG("Applying R_AMD64_RELATIVE reloc @%p\n", p);
+            *p = rel->r_addend + ctx->base_load_vaddr;
+            break;
+        default:
+            EL_DEBUG("Bad relocation %u\n", type);
+            return EL_BADREL;
+
+    }
+
+    return EL_OK;
+}
+
+#endif
diff --git a/modules/cpu/src/runtime/elfreloc_i386.cpp b/modules/cpu/src/runtime/elfreloc_i386.cpp
new file mode 100644
index 0000000000..fdf66e3d3f
--- /dev/null
+++ b/modules/cpu/src/runtime/elfreloc_i386.cpp
@@ -0,0 +1,28 @@
+#include "elfload.h"
+
+#if defined(__i386__)
+
+#define R_386_NONE     0
+#define R_386_RELATIVE 8
+
+el_status el_applyrel(el_ctx *ctx, Elf_Rel *rel)
+{
+    uint32_t *p = (uint32_t*) (rel->r_offset + ctx->base_load_vaddr);
+    uint32_t type = ELF_R_TYPE(rel->r_info);
+    uint32_t sym  = ELF_R_SYM(rel->r_info);
+
+    switch (type) {
+        case R_386_NONE: break;
+        case R_386_RELATIVE:
+            EL_DEBUG("Applying R_386_RELATIVE reloc @%p\n", p);
+            *p += ctx->base_load_vaddr;
+            break;
+        default:
+            EL_DEBUG("Bad relocation %u\n", type);
+            return EL_BADREL;
+    }
+
+    return EL_OK;
+}
+
+#endif
diff --git a/modules/cpu/src/runtime/elfreloc_riscv64.cpp b/modules/cpu/src/runtime/elfreloc_riscv64.cpp
new file mode 100644
index 0000000000..a4d99a64ef
--- /dev/null
+++ b/modules/cpu/src/runtime/elfreloc_riscv64.cpp
@@ -0,0 +1,33 @@
+#include "elfload.h"
+
+#if defined(__riscv)
+
+#define R_riscv64_NONE     0
+#define R_riscv64_RELATIVE 3
+#define R_riscv64_JUMP_SLOT 5
+
+el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel)
+{
+    uint64_t *p = (uint64_t*) (rel->r_offset + ctx->base_load_vaddr);
+    uint32_t type = ELF_R_TYPE(rel->r_info);
+    EL_DEBUG("rv\n");
+
+    switch (type) {
+        case R_riscv64_NONE: break;
+        case R_riscv64_RELATIVE:
+            EL_DEBUG("Applying R_riscv64_RELATIVE reloc @%p\n", p);
+            *p = rel->r_addend + ctx->base_load_vaddr;
+            break;
+        case R_riscv64_JUMP_SLOT:
+            EL_DEBUG("Applying R_riscv64_JUMP_SLOT reloc @%p\n", p);
+            break;
+        default:
+            EL_DEBUG("Bad relocation %u\n", type);
+            return EL_BADREL;
+
+    }
+
+    return EL_OK;
+}
+
+#endif
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 9934a6985c..2a6be1e344 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -13,9 +13,11 @@
  * limitations under the License.
  */
 #include "runtime_function.h"
+#include "elfloader.h"
 #include <nncase/runtime/dbg.h>
 #include <nncase/runtime/runtime_loader.h>
 #include <nncase/runtime/runtime_op_utility.h>
+#include <nncase/runtime/util.h>
 
 using namespace nncase;
 using namespace nncase::runtime;
@@ -54,33 +56,49 @@ result<void> cpu_runtime_function::initialize_core(
         for (uint32_t i = 0; i < header.inputs; i++) {
             sr.template read<memory_range>();
             auto rank = sr.template read<uint32_t>();
+            std::vector<uint32_t> shape(rank);
             std::cout << "shape: ";
             for (uint32_t j = 0; j < rank; j++) {
-                std::cout << sr.template read<uint32_t>() << ", ";
+                shape[j] = sr.template read<uint32_t>();
+                std::cout << shape[j] << ", ";
             }
             std::cout << std::endl;
 
+            std::vector<uint32_t> stride(rank);
             std::cout << "stride: ";
             for (uint32_t j = 0; j < rank; j++) {
-                std::cout << sr.template read<uint32_t>() << ", ";
+                stride[j] = sr.template read<uint32_t>();
+                std::cout << stride[j] << ", ";
             }
             std::cout << std::endl;
+
+            input_ranks_.emplace_back(rank);
+            input_shapes_.emplace_back(shape);
+            input_strides_.emplace_back(stride);
         }
 
         for (uint32_t i = 0; i < header.outputs; i++) {
             sr.template read<memory_range>();
             auto rank = sr.template read<uint32_t>();
+            std::vector<uint32_t> shape(rank);
             std::cout << "shape: ";
             for (uint32_t j = 0; j < rank; j++) {
-                std::cout << sr.template read<uint32_t>() << ", ";
+                shape[j] = sr.template read<uint32_t>();
+                std::cout << shape[j] << ", ";
             }
             std::cout << std::endl;
 
+            std::vector<uint32_t> stride(rank);
             std::cout << "stride: ";
             for (uint32_t j = 0; j < rank; j++) {
-                std::cout << sr.template read<uint32_t>() << ", ";
+                stride[j] = sr.template read<uint32_t>();
+                std::cout << stride[j] << ", ";
             }
             std::cout << std::endl;
+
+            output_ranks_.emplace_back(rank);
+            output_shapes_.emplace_back(shape);
+            output_strides_.emplace_back(stride);
         }
 
         return ok();
@@ -92,8 +110,42 @@ result<void> cpu_runtime_function::initialize_core(
 result<value_t>
 cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
                                   value_t return_value) noexcept {
-    module().interp();
     try_var(id, module().find_id_by_function(this));
     std::cout << "call " << id << std::endl;
+
+    std::vector<buffer_t *> buffers(input_ranks_.size() + output_ranks_.size());
+
+    // input buffer
+    for (uint32_t i = 0; i < input_ranks_.size(); i++) {
+        auto input_tensor = parameters[i].as<tensor>().expect(
+            "input " + std::to_string(i) + " is not a tensor");
+        try_var(input_span, get_input_span(input_tensor));
+        buffer_t *input_buffer =
+            new buffer_t(input_span.data(), 0, input_shapes_[i].data(),
+                         input_strides_[i].data(), input_ranks_[i]);
+        buffers[i] = input_buffer;
+    }
+
+    // output buffer
+    for (uint32_t i = 0; i < output_ranks_.size(); i++) {
+        auto output_tensor = parameters[i].as<tensor>().expect(
+            "output " + std::to_string(i) + " is not a tensor");
+        try_var(output_span, get_output_span(output_tensor));
+        buffer_t *output_buffer =
+            new buffer_t(output_span.data(), 0, output_shapes_[i].data(),
+                         output_strides_[i].data(), output_ranks_[i]);
+        buffers[input_ranks_.size() + i] = output_buffer;
+    }
+
+    auto elfloader_ = elfloader{(char *)module().text_physical().data()};
+    elfloader_.invoke_elf(id, buffers.data(), &nncase_mt, nullptr, nullptr);
+    for (int i = 0; i < 10; i++) {
+        printf("%f\n", ((float *)buffers[1]->vaddr)[i]);
+    }
+
+    for (int i = 0; i < buffers.size(); i++) {
+        delete buffers[i];
+    }
+
     return ok(return_value);
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/runtime_function.h b/modules/cpu/src/runtime/runtime_function.h
index 79a524dfc1..ba19300437 100644
--- a/modules/cpu/src/runtime/runtime_function.h
+++ b/modules/cpu/src/runtime/runtime_function.h
@@ -30,6 +30,14 @@ class cpu_runtime_function : public runtime_function {
     initialize_core(runtime_function_init_context &context) noexcept override;
     result<value_t> invoke_core(gsl::span<value_t> parameters,
                                 value_t return_value) noexcept override;
+
+  private:
+    std::vector<uint32_t> input_ranks_;
+    std::vector<std::vector<uint32_t>> input_shapes_;
+    std::vector<std::vector<uint32_t>> input_strides_;
+    std::vector<uint32_t> output_ranks_;
+    std::vector<std::vector<uint32_t>> output_shapes_;
+    std::vector<std::vector<uint32_t>> output_strides_;
 };
 
 END_NS_NNCASE_RT_MODULE
diff --git a/modules/cpu/src/runtime/runtime_module.cpp b/modules/cpu/src/runtime/runtime_module.cpp
index bf4481d159..810b51de4e 100644
--- a/modules/cpu/src/runtime/runtime_module.cpp
+++ b/modules/cpu/src/runtime/runtime_module.cpp
@@ -26,10 +26,12 @@ result<void> cpu_runtime_module::initialize_before_functions(
     runtime_module_init_context &context) noexcept {
     if (!context.is_section_pinned())
         return nncase::err(std::errc::bad_address);
-    try_var(data_, context.get_or_read_section(".data", data_storage_, false));
-    try_var(rdata_,
+    try_var(data, context.get_or_read_section(".data", data_storage_, false));
+    try_var(rdata,
             context.get_or_read_section(".rdata", rdata_storage_, true));
-    try_var(text_, context.get_or_read_section(".text", text_storage_, true));
+    try_var(text, context.get_or_read_section(".text", text_storage_, true));
+
+    text_ = text.as_span<const gsl::byte>();
 
     return ok();
 }

From 8a428c60c09ede898a0e399c30df60d9f9938ce7 Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Mon, 24 Jul 2023 12:00:55 +0000
Subject: [PATCH 018/308] Apply code-format changes

---
 .../CodeGen/FunctionCSource.cs                |  60 +-
 modules/cpu/src/runtime/elf.h                 | 749 +++++++++---------
 modules/cpu/src/runtime/elfload.cpp           |  71 +-
 modules/cpu/src/runtime/elfload.h             |  27 +-
 modules/cpu/src/runtime/elfloader.cpp         |   4 +-
 modules/cpu/src/runtime/elfreloc_aarch64.cpp  |  75 +-
 modules/cpu/src/runtime/elfreloc_amd64.cpp    |  25 +-
 modules/cpu/src/runtime/elfreloc_i386.cpp     |  26 +-
 modules/cpu/src/runtime/elfreloc_riscv64.cpp  |  31 +-
 modules/cpu/src/runtime/runtime_module.cpp    |   3 +-
 10 files changed, 526 insertions(+), 545 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
index cd5ff86d9d..e07152e4fc 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -56,6 +56,36 @@ protected string Ext
         get => _ext;
     }
 
+    /// <summary>
+    /// compile the source txt, write to the out_path.
+    /// </summary>
+    /// <param name="sourcePath"> c source code.</param>
+    /// <param name="outPath"> out .so path. </param>
+    /// <returns> outPath. </returns>
+    public string Compile(string sourcePath, string outPath)
+    {
+        var errMsg = new StringBuilder();
+        using (var errWriter = new StringWriter(errMsg))
+        {
+            using (var proc = new Process())
+            {
+                proc.StartInfo.FileName = Exe;
+                proc.StartInfo.Arguments = ArgumentsSpecific(sourcePath, outPath);
+                proc.StartInfo.RedirectStandardError = true;
+                proc.ErrorDataReceived += (sender, e) => errWriter.WriteLine(e.Data);
+                proc.Start();
+                proc.BeginErrorReadLine();
+                proc.WaitForExit();
+                if (proc.ExitCode != 0)
+                {
+                    throw new InvalidOperationException(errMsg.ToString());
+                }
+            }
+        }
+
+        return outPath;
+    }
+
     /// <summary>
     /// select current pattern's exe.
     /// </summary>
@@ -109,36 +139,6 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
         throw new System.ArgumentOutOfRangeException("Only Support Linux/Osx/Windows");
     }
 
-    /// <summary>
-    /// compile the source txt, write to the out_path.
-    /// </summary>
-    /// <param name="sourcePath"> c source code.</param>
-    /// <param name="outPath"> out .so path. </param>
-    /// <returns> outPath. </returns>
-    public string Compile(string sourcePath, string outPath)
-    {
-        var errMsg = new StringBuilder();
-        using (var errWriter = new StringWriter(errMsg))
-        {
-            using (var proc = new Process())
-            {
-                proc.StartInfo.FileName = Exe;
-                proc.StartInfo.Arguments = ArgumentsSpecific(sourcePath, outPath);
-                proc.StartInfo.RedirectStandardError = true;
-                proc.ErrorDataReceived += (sender, e) => errWriter.WriteLine(e.Data);
-                proc.Start();
-                proc.BeginErrorReadLine();
-                proc.WaitForExit();
-                if (proc.ExitCode != 0)
-                {
-                    throw new InvalidOperationException(errMsg.ToString());
-                }
-            }
-        }
-
-        return outPath;
-    }
-
     /// <summary>
     /// create the temp dll file and compile source
     /// <see cref="Compile(string, string)"/>.
diff --git a/modules/cpu/src/runtime/elf.h b/modules/cpu/src/runtime/elf.h
index 027f99ad0c..d7be196fa3 100644
--- a/modules/cpu/src/runtime/elf.h
+++ b/modules/cpu/src/runtime/elf.h
@@ -31,346 +31,345 @@
 #define ELF_H
 #include <stdint.h>
 
-typedef uint8_t     Elf_Byte;
+typedef uint8_t Elf_Byte;
 
-typedef uint32_t    Elf32_Addr;    /* Unsigned program address */
-typedef uint32_t    Elf32_Off;     /* Unsigned file offset */
-typedef int32_t     Elf32_Sword;   /* Signed large integer */
-typedef uint32_t    Elf32_Word;    /* Unsigned large integer */
-typedef uint16_t    Elf32_Half;    /* Unsigned medium integer */
+typedef uint32_t Elf32_Addr; /* Unsigned program address */
+typedef uint32_t Elf32_Off;  /* Unsigned file offset */
+typedef int32_t Elf32_Sword; /* Signed large integer */
+typedef uint32_t Elf32_Word; /* Unsigned large integer */
+typedef uint16_t Elf32_Half; /* Unsigned medium integer */
 
-typedef uint64_t    Elf64_Addr;
-typedef uint64_t    Elf64_Off;
-typedef int32_t     Elf64_Shalf;
+typedef uint64_t Elf64_Addr;
+typedef uint64_t Elf64_Off;
+typedef int32_t Elf64_Shalf;
 
 #ifdef __alpha__
-typedef int64_t     Elf64_Sword;
-typedef uint64_t    Elf64_Word;
+typedef int64_t Elf64_Sword;
+typedef uint64_t Elf64_Word;
 #else
-typedef int32_t     Elf64_Sword;
-typedef uint32_t    Elf64_Word;
+typedef int32_t Elf64_Sword;
+typedef uint32_t Elf64_Word;
 #endif
 
-typedef int64_t     Elf64_Sxword;
-typedef uint64_t    Elf64_Xword;
+typedef int64_t Elf64_Sxword;
+typedef uint64_t Elf64_Xword;
 
-typedef uint32_t    Elf64_Half;
-typedef uint16_t    Elf64_Quarter;
+typedef uint32_t Elf64_Half;
+typedef uint16_t Elf64_Quarter;
 
 /*
  * e_ident[] identification indexes
  * See http://www.sco.com/developers/gabi/latest/ch4.eheader.html
  */
-#define EI_MAG0        0        /* file ID */
-#define EI_MAG1        1        /* file ID */
-#define EI_MAG2        2        /* file ID */
-#define EI_MAG3        3        /* file ID */
-#define EI_CLASS       4        /* file class */
-#define EI_DATA        5        /* data encoding */
-#define EI_VERSION     6        /* ELF header version */
-#define EI_OSABI       7        /* OS/ABI ID */
-#define EI_ABIVERSION  8        /* ABI version */
-#define EI_PAD         9        /* start of pad bytes */
-#define EI_NIDENT     16        /* Size of e_ident[] */
+#define EI_MAG0 0       /* file ID */
+#define EI_MAG1 1       /* file ID */
+#define EI_MAG2 2       /* file ID */
+#define EI_MAG3 3       /* file ID */
+#define EI_CLASS 4      /* file class */
+#define EI_DATA 5       /* data encoding */
+#define EI_VERSION 6    /* ELF header version */
+#define EI_OSABI 7      /* OS/ABI ID */
+#define EI_ABIVERSION 8 /* ABI version */
+#define EI_PAD 9        /* start of pad bytes */
+#define EI_NIDENT 16    /* Size of e_ident[] */
 
 /* e_ident[] magic number */
-#define    ELFMAG0        0x7f       /* e_ident[EI_MAG0] */
-#define    ELFMAG1        'E'        /* e_ident[EI_MAG1] */
-#define    ELFMAG2        'L'        /* e_ident[EI_MAG2] */
-#define    ELFMAG3        'F'        /* e_ident[EI_MAG3] */
-#define    ELFMAG        "\177ELF"   /* magic */
-#define    SELFMAG        4          /* size of magic */
+#define ELFMAG0 0x7f     /* e_ident[EI_MAG0] */
+#define ELFMAG1 'E'      /* e_ident[EI_MAG1] */
+#define ELFMAG2 'L'      /* e_ident[EI_MAG2] */
+#define ELFMAG3 'F'      /* e_ident[EI_MAG3] */
+#define ELFMAG "\177ELF" /* magic */
+#define SELFMAG 4        /* size of magic */
 
 /* e_ident[] file class */
-#define    ELFCLASSNONE    0        /* invalid */
-#define    ELFCLASS32    1          /* 32-bit objs */
-#define    ELFCLASS64    2          /* 64-bit objs */
-#define    ELFCLASSNUM    3         /* number of classes */
+#define ELFCLASSNONE 0 /* invalid */
+#define ELFCLASS32 1   /* 32-bit objs */
+#define ELFCLASS64 2   /* 64-bit objs */
+#define ELFCLASSNUM 3  /* number of classes */
 
 /* e_ident[] data encoding */
-#define ELFDATANONE    0            /* invalid */
-#define ELFDATA2LSB    1            /* Little-Endian */
-#define ELFDATA2MSB    2            /* Big-Endian */
-#define ELFDATANUM     3            /* number of data encode defines */
+#define ELFDATANONE 0 /* invalid */
+#define ELFDATA2LSB 1 /* Little-Endian */
+#define ELFDATA2MSB 2 /* Big-Endian */
+#define ELFDATANUM 3  /* number of data encode defines */
 
 /* e_ident[] Operating System/ABI */
-#define ELFOSABI_SYSV        0    /* UNIX System V ABI */
-#define ELFOSABI_HPUX        1    /* HP-UX operating system */
-#define ELFOSABI_NETBSD      2    /* NetBSD */
-#define ELFOSABI_LINUX       3    /* GNU/Linux */
-#define ELFOSABI_HURD        4    /* GNU/Hurd */
-#define ELFOSABI_86OPEN      5    /* 86Open common IA32 ABI */
-#define ELFOSABI_SOLARIS     6    /* Solaris */
-#define ELFOSABI_MONTEREY    7    /* Monterey */
-#define ELFOSABI_IRIX        8    /* IRIX */
-#define ELFOSABI_FREEBSD     9    /* FreeBSD */
-#define ELFOSABI_TRU64       10   /* TRU64 UNIX */
-#define ELFOSABI_MODESTO     11   /* Novell Modesto */
-#define ELFOSABI_OPENBSD     12   /* OpenBSD */
-#define ELFOSABI_ARM         97   /* ARM */
-#define ELFOSABI_STANDALONE  255  /* Standalone (embedded) application */
+#define ELFOSABI_SYSV 0         /* UNIX System V ABI */
+#define ELFOSABI_HPUX 1         /* HP-UX operating system */
+#define ELFOSABI_NETBSD 2       /* NetBSD */
+#define ELFOSABI_LINUX 3        /* GNU/Linux */
+#define ELFOSABI_HURD 4         /* GNU/Hurd */
+#define ELFOSABI_86OPEN 5       /* 86Open common IA32 ABI */
+#define ELFOSABI_SOLARIS 6      /* Solaris */
+#define ELFOSABI_MONTEREY 7     /* Monterey */
+#define ELFOSABI_IRIX 8         /* IRIX */
+#define ELFOSABI_FREEBSD 9      /* FreeBSD */
+#define ELFOSABI_TRU64 10       /* TRU64 UNIX */
+#define ELFOSABI_MODESTO 11     /* Novell Modesto */
+#define ELFOSABI_OPENBSD 12     /* OpenBSD */
+#define ELFOSABI_ARM 97         /* ARM */
+#define ELFOSABI_STANDALONE 255 /* Standalone (embedded) application */
 
 /* e_ident */
-#define IS_ELF(ehdr) ((ehdr).e_ident[EI_MAG0] == ELFMAG0 && \
-                      (ehdr).e_ident[EI_MAG1] == ELFMAG1 && \
-                      (ehdr).e_ident[EI_MAG2] == ELFMAG2 && \
-                      (ehdr).e_ident[EI_MAG3] == ELFMAG3)
+#define IS_ELF(ehdr)                                                           \
+    ((ehdr).e_ident[EI_MAG0] == ELFMAG0 &&                                     \
+     (ehdr).e_ident[EI_MAG1] == ELFMAG1 &&                                     \
+     (ehdr).e_ident[EI_MAG2] == ELFMAG2 && (ehdr).e_ident[EI_MAG3] == ELFMAG3)
 
 /* ELF Header */
 typedef struct {
-    unsigned char    e_ident[EI_NIDENT];     /* ELF Identification */
-    Elf32_Half       e_type;                 /* object file type */
-    Elf32_Half       e_machine;              /* machine */
-    Elf32_Word       e_version;              /* object file version */
-    Elf32_Addr       e_entry;                /* virtual entry point */
-    Elf32_Off        e_phoff;                /* program header table offset */
-    Elf32_Off        e_shoff;                /* section header table offset */
-    Elf32_Word       e_flags;                /* processor-specific flags */
-    Elf32_Half       e_ehsize;               /* ELF header size */
-    Elf32_Half       e_phentsize;            /* program header entry size */
-    Elf32_Half       e_phnum;                /* number of program header entries */
-    Elf32_Half       e_shentsize;            /* section header entry size */
-    Elf32_Half       e_shnum;                /* number of section header entries */
-    Elf32_Half       e_shstrndx;             /* section header table's "section
-                                                header string table" entry offset */
+    unsigned char e_ident[EI_NIDENT]; /* ELF Identification */
+    Elf32_Half e_type;                /* object file type */
+    Elf32_Half e_machine;             /* machine */
+    Elf32_Word e_version;             /* object file version */
+    Elf32_Addr e_entry;               /* virtual entry point */
+    Elf32_Off e_phoff;                /* program header table offset */
+    Elf32_Off e_shoff;                /* section header table offset */
+    Elf32_Word e_flags;               /* processor-specific flags */
+    Elf32_Half e_ehsize;              /* ELF header size */
+    Elf32_Half e_phentsize;           /* program header entry size */
+    Elf32_Half e_phnum;               /* number of program header entries */
+    Elf32_Half e_shentsize;           /* section header entry size */
+    Elf32_Half e_shnum;               /* number of section header entries */
+    Elf32_Half e_shstrndx;            /* section header table's "section
+                                         header string table" entry offset */
 } Elf32_Ehdr;
 
 typedef struct {
-    unsigned char    e_ident[EI_NIDENT];    /* Id bytes */
-    Elf64_Quarter    e_type;                /* file type */
-    Elf64_Quarter    e_machine;             /* machine type */
-    Elf64_Half       e_version;             /* version number */
-    Elf64_Addr       e_entry;               /* entry point */
-    Elf64_Off        e_phoff;               /* Program hdr offset */
-    Elf64_Off        e_shoff;               /* Section hdr offset */
-    Elf64_Half       e_flags;               /* Processor flags */
-    Elf64_Quarter    e_ehsize;              /* sizeof ehdr */
-    Elf64_Quarter    e_phentsize;           /* Program header entry size */
-    Elf64_Quarter    e_phnum;               /* Number of program headers */
-    Elf64_Quarter    e_shentsize;           /* Section header entry size */
-    Elf64_Quarter    e_shnum;               /* Number of section headers */
-    Elf64_Quarter    e_shstrndx;            /* String table index */
+    unsigned char e_ident[EI_NIDENT]; /* Id bytes */
+    Elf64_Quarter e_type;             /* file type */
+    Elf64_Quarter e_machine;          /* machine type */
+    Elf64_Half e_version;             /* version number */
+    Elf64_Addr e_entry;               /* entry point */
+    Elf64_Off e_phoff;                /* Program hdr offset */
+    Elf64_Off e_shoff;                /* Section hdr offset */
+    Elf64_Half e_flags;               /* Processor flags */
+    Elf64_Quarter e_ehsize;           /* sizeof ehdr */
+    Elf64_Quarter e_phentsize;        /* Program header entry size */
+    Elf64_Quarter e_phnum;            /* Number of program headers */
+    Elf64_Quarter e_shentsize;        /* Section header entry size */
+    Elf64_Quarter e_shnum;            /* Number of section headers */
+    Elf64_Quarter e_shstrndx;         /* String table index */
 } Elf64_Ehdr;
 
 /* e_type */
-#define ET_NONE        0        /* No file type */
-#define ET_REL         1        /* relocatable file */
-#define ET_EXEC        2        /* executable file */
-#define ET_DYN         3        /* shared object file */
-#define ET_CORE        4        /* core file */
-#define ET_NUM         5        /* number of types */
-#define ET_LOPROC      0xff00   /* reserved range for processor */
-#define ET_HIPROC      0xffff   /*  specific e_type */
+#define ET_NONE 0        /* No file type */
+#define ET_REL 1         /* relocatable file */
+#define ET_EXEC 2        /* executable file */
+#define ET_DYN 3         /* shared object file */
+#define ET_CORE 4        /* core file */
+#define ET_NUM 5         /* number of types */
+#define ET_LOPROC 0xff00 /* reserved range for processor */
+#define ET_HIPROC 0xffff /*  specific e_type */
 
 /* e_machine */
-#define EM_NONE        0        /* No Machine */
-#define EM_M32         1        /* AT&T WE 32100 */
-#define EM_SPARC       2        /* SPARC */
-#define EM_386         3        /* Intel 80386 */
-#define EM_68K         4        /* Motorola 68000 */
-#define EM_88K         5        /* Motorola 88000 */
-#define EM_486         6        /* Intel 80486 - unused? */
-#define EM_860         7        /* Intel 80860 */
-#define EM_MIPS        8        /* MIPS R3000 Big-Endian only */
+#define EM_NONE 0  /* No Machine */
+#define EM_M32 1   /* AT&T WE 32100 */
+#define EM_SPARC 2 /* SPARC */
+#define EM_386 3   /* Intel 80386 */
+#define EM_68K 4   /* Motorola 68000 */
+#define EM_88K 5   /* Motorola 88000 */
+#define EM_486 6   /* Intel 80486 - unused? */
+#define EM_860 7   /* Intel 80860 */
+#define EM_MIPS 8  /* MIPS R3000 Big-Endian only */
 /*
  * Don't know if EM_MIPS_RS4_BE,
  * EM_SPARC64, EM_PARISC,
  * or EM_PPC are ABI compliant
  */
-#define EM_MIPS_RS4_BE 10        /* MIPS R4000 Big-Endian */
-#define EM_SPARC64     11        /* SPARC v9 64-bit unofficial */
-#define EM_PARISC      15        /* HPPA */
-#define EM_SPARC32PLUS 18        /* Enhanced instruction set SPARC */
-#define EM_PPC         20        /* PowerPC */
-#define EM_ARM         40        /* ARM AArch32 */
-#define EM_ALPHA       41        /* DEC ALPHA */
-#define EM_SH          42        /* Hitachi/Renesas Super-H */
-#define EM_SPARCV9     43        /* SPARC version 9 */
-#define EM_IA_64       50        /* Intel IA-64 Processor */
-#define EM_AMD64       62        /* AMD64 architecture */
-#define EM_VAX         75        /* DEC VAX */
-#define EM_AARCH64     183       /* ARM AArch64 */
+#define EM_MIPS_RS4_BE 10 /* MIPS R4000 Big-Endian */
+#define EM_SPARC64 11     /* SPARC v9 64-bit unofficial */
+#define EM_PARISC 15      /* HPPA */
+#define EM_SPARC32PLUS 18 /* Enhanced instruction set SPARC */
+#define EM_PPC 20         /* PowerPC */
+#define EM_ARM 40         /* ARM AArch32 */
+#define EM_ALPHA 41       /* DEC ALPHA */
+#define EM_SH 42          /* Hitachi/Renesas Super-H */
+#define EM_SPARCV9 43     /* SPARC version 9 */
+#define EM_IA_64 50       /* Intel IA-64 Processor */
+#define EM_AMD64 62       /* AMD64 architecture */
+#define EM_VAX 75         /* DEC VAX */
+#define EM_AARCH64 183    /* ARM AArch64 */
 
 /* Non-standard */
 #define EM_ALPHA_EXP 0x9026 /* DEC ALPHA */
 
 #define EM_RISCV 243
 
-
 /* Version */
-#define EV_NONE        0        /* Invalid */
-#define EV_CURRENT     1        /* Current */
-#define EV_NUM         2        /* number of versions */
+#define EV_NONE 0    /* Invalid */
+#define EV_CURRENT 1 /* Current */
+#define EV_NUM 2     /* number of versions */
 
 /* Section Header */
 typedef struct {
-    Elf32_Word    sh_name;      /* name - index into section header
-                                 * string table section */
-    Elf32_Word    sh_type;      /* type */
-    Elf32_Word    sh_flags;     /* flags */
-    Elf32_Addr    sh_addr;      /* address */
-    Elf32_Off     sh_offset;    /* file offset */
-    Elf32_Word    sh_size;      /* section size */
-    Elf32_Word    sh_link;      /* section header table index link */
-    Elf32_Word    sh_info;      /* extra information */
-    Elf32_Word    sh_addralign; /* address alignment */
-    Elf32_Word    sh_entsize;   /* section entry size */
+    Elf32_Word sh_name;      /* name - index into section header
+                              * string table section */
+    Elf32_Word sh_type;      /* type */
+    Elf32_Word sh_flags;     /* flags */
+    Elf32_Addr sh_addr;      /* address */
+    Elf32_Off sh_offset;     /* file offset */
+    Elf32_Word sh_size;      /* section size */
+    Elf32_Word sh_link;      /* section header table index link */
+    Elf32_Word sh_info;      /* extra information */
+    Elf32_Word sh_addralign; /* address alignment */
+    Elf32_Word sh_entsize;   /* section entry size */
 } Elf32_Shdr;
 
 typedef struct {
-    Elf64_Half    sh_name;       /* section name */
-    Elf64_Half    sh_type;       /* section type */
-    Elf64_Xword   sh_flags;      /* section flags */
-    Elf64_Addr    sh_addr;       /* virtual address */
-    Elf64_Off     sh_offset;     /* file offset */
-    Elf64_Xword   sh_size;       /* section size */
-    Elf64_Half    sh_link;       /* link to another */
-    Elf64_Half    sh_info;       /* misc info */
-    Elf64_Xword   sh_addralign;  /* memory alignment */
-    Elf64_Xword   sh_entsize;    /* table entry size */
+    Elf64_Half sh_name;       /* section name */
+    Elf64_Half sh_type;       /* section type */
+    Elf64_Xword sh_flags;     /* section flags */
+    Elf64_Addr sh_addr;       /* virtual address */
+    Elf64_Off sh_offset;      /* file offset */
+    Elf64_Xword sh_size;      /* section size */
+    Elf64_Half sh_link;       /* link to another */
+    Elf64_Half sh_info;       /* misc info */
+    Elf64_Xword sh_addralign; /* memory alignment */
+    Elf64_Xword sh_entsize;   /* table entry size */
 } Elf64_Shdr;
 
 /* Special Section Indexes */
-#define SHN_UNDEF     0             /* undefined */
-#define SHN_LORESERVE 0xff00        /* lower bounds of reserved indexes */
-#define SHN_LOPROC    0xff00        /* reserved range for processor */
-#define SHN_HIPROC    0xff1f        /*   specific section indexes */
-#define SHN_ABS       0xfff1        /* absolute value */
-#define SHN_COMMON    0xfff2        /* common symbol */
-#define SHN_HIRESERVE 0xffff        /* upper bounds of reserved indexes */
+#define SHN_UNDEF 0          /* undefined */
+#define SHN_LORESERVE 0xff00 /* lower bounds of reserved indexes */
+#define SHN_LOPROC 0xff00    /* reserved range for processor */
+#define SHN_HIPROC 0xff1f    /*   specific section indexes */
+#define SHN_ABS 0xfff1       /* absolute value */
+#define SHN_COMMON 0xfff2    /* common symbol */
+#define SHN_HIRESERVE 0xffff /* upper bounds of reserved indexes */
 
 /* sh_type */
-#define SHT_NULL     0        /* inactive */
+#define SHT_NULL 0            /* inactive */
 #define SHT_PROGBITS 1        /* program defined information */
-#define SHT_SYMTAB   2        /* symbol table section */
-#define SHT_STRTAB   3        /* string table section */
-#define SHT_RELA     4        /* relocation section with addends*/
-#define SHT_HASH     5        /* symbol hash table section */
-#define SHT_DYNAMIC  6        /* dynamic section */
-#define SHT_NOTE     7        /* note section */
-#define SHT_NOBITS   8        /* no space section */
-#define SHT_REL      9        /* relation section without addends */
-#define SHT_SHLIB    10       /* reserved - purpose unknown */
-#define SHT_DYNSYM   11       /* dynamic symbol table section */
-#define SHT_NUM      12       /* number of section types */
-#define SHT_LOPROC   0x70000000    /* reserved range for processor */
-#define SHT_HIPROC   0x7fffffff    /*  specific section header types */
-#define SHT_LOUSER   0x80000000    /* reserved range for application */
-#define SHT_HIUSER   0xffffffff    /*  specific indexes */
+#define SHT_SYMTAB 2          /* symbol table section */
+#define SHT_STRTAB 3          /* string table section */
+#define SHT_RELA 4            /* relocation section with addends*/
+#define SHT_HASH 5            /* symbol hash table section */
+#define SHT_DYNAMIC 6         /* dynamic section */
+#define SHT_NOTE 7            /* note section */
+#define SHT_NOBITS 8          /* no space section */
+#define SHT_REL 9             /* relation section without addends */
+#define SHT_SHLIB 10          /* reserved - purpose unknown */
+#define SHT_DYNSYM 11         /* dynamic symbol table section */
+#define SHT_NUM 12            /* number of section types */
+#define SHT_LOPROC 0x70000000 /* reserved range for processor */
+#define SHT_HIPROC 0x7fffffff /*  specific section header types */
+#define SHT_LOUSER 0x80000000 /* reserved range for application */
+#define SHT_HIUSER 0xffffffff /*  specific indexes */
 
 /* Section names */
-#define ELF_BSS         ".bss"        /* uninitialized data */
-#define ELF_DATA        ".data"       /* initialized data */
-#define ELF_DEBUG       ".debug"      /* debug */
-#define ELF_DYNAMIC     ".dynamic"    /* dynamic linking information */
-#define ELF_DYNSTR      ".dynstr"     /* dynamic string table */
-#define ELF_DYNSYM      ".dynsym"     /* dynamic symbol table */
-#define ELF_FINI        ".fini"       /* termination code */
-#define ELF_GOT         ".got"        /* global offset table */
-#define ELF_HASH        ".hash"       /* symbol hash table */
-#define ELF_INIT        ".init"       /* initialization code */
-#define ELF_REL_DATA    ".rel.data"   /* relocation data */
-#define ELF_REL_FINI    ".rel.fini"   /* relocation termination code */
-#define ELF_REL_INIT    ".rel.init"   /* relocation initialization code */
-#define ELF_REL_DYN     ".rel.dyn"    /* relocation dynamic link info */
-#define ELF_REL_RODATA  ".rel.rodata" /* relocation read-only data */
-#define ELF_REL_TEXT    ".rel.text"   /* relocation code */
-#define ELF_RODATA      ".rodata"     /* read-only data */
-#define ELF_SHSTRTAB    ".shstrtab"   /* section header string table */
-#define ELF_STRTAB      ".strtab"     /* string table */
-#define ELF_SYMTAB      ".symtab"     /* symbol table */
-#define ELF_TEXT        ".text"       /* code */
-
+#define ELF_BSS ".bss"               /* uninitialized data */
+#define ELF_DATA ".data"             /* initialized data */
+#define ELF_DEBUG ".debug"           /* debug */
+#define ELF_DYNAMIC ".dynamic"       /* dynamic linking information */
+#define ELF_DYNSTR ".dynstr"         /* dynamic string table */
+#define ELF_DYNSYM ".dynsym"         /* dynamic symbol table */
+#define ELF_FINI ".fini"             /* termination code */
+#define ELF_GOT ".got"               /* global offset table */
+#define ELF_HASH ".hash"             /* symbol hash table */
+#define ELF_INIT ".init"             /* initialization code */
+#define ELF_REL_DATA ".rel.data"     /* relocation data */
+#define ELF_REL_FINI ".rel.fini"     /* relocation termination code */
+#define ELF_REL_INIT ".rel.init"     /* relocation initialization code */
+#define ELF_REL_DYN ".rel.dyn"       /* relocation dynamic link info */
+#define ELF_REL_RODATA ".rel.rodata" /* relocation read-only data */
+#define ELF_REL_TEXT ".rel.text"     /* relocation code */
+#define ELF_RODATA ".rodata"         /* read-only data */
+#define ELF_SHSTRTAB ".shstrtab"     /* section header string table */
+#define ELF_STRTAB ".strtab"         /* string table */
+#define ELF_SYMTAB ".symtab"         /* symbol table */
+#define ELF_TEXT ".text"             /* code */
 
 /* Section Attribute Flags - sh_flags */
-#define SHF_WRITE        0x1           /* Writable */
-#define SHF_ALLOC        0x2           /* occupies memory */
-#define SHF_EXECINSTR    0x4           /* executable */
-#define SHF_TLS          0x400         /* thread local storage */
-#define SHF_MASKPROC     0xf0000000    /* reserved bits for processor
-                                        *  specific section attributes */
+#define SHF_WRITE 0x1     /* Writable */
+#define SHF_ALLOC 0x2     /* occupies memory */
+#define SHF_EXECINSTR 0x4 /* executable */
+#define SHF_TLS 0x400     /* thread local storage */
+#define SHF_MASKPROC                                                           \
+    0xf0000000 /* reserved bits for processor                                  \
+                *  specific section attributes */
 
 /* Symbol Table Entry */
 typedef struct elf32_sym {
-    Elf32_Word    st_name;     /* name - index into string table */
-    Elf32_Addr    st_value;    /* symbol value */
-    Elf32_Word    st_size;     /* symbol size */
-    unsigned char st_info;     /* type and binding */
-    unsigned char st_other;    /* 0 - no defined meaning */
-    Elf32_Half    st_shndx;    /* section header index */
+    Elf32_Word st_name;     /* name - index into string table */
+    Elf32_Addr st_value;    /* symbol value */
+    Elf32_Word st_size;     /* symbol size */
+    unsigned char st_info;  /* type and binding */
+    unsigned char st_other; /* 0 - no defined meaning */
+    Elf32_Half st_shndx;    /* section header index */
 } Elf32_Sym;
 
 typedef struct {
-    Elf64_Half    st_name;    /* Symbol name index in str table */
-    Elf_Byte      st_info;    /* type / binding attrs */
-    Elf_Byte      st_other;   /* unused */
-    Elf64_Quarter st_shndx;   /* section index of symbol */
-    Elf64_Xword   st_value;   /* value of symbol */
-    Elf64_Xword   st_size;    /* size of symbol */
+    Elf64_Half st_name;     /* Symbol name index in str table */
+    Elf_Byte st_info;       /* type / binding attrs */
+    Elf_Byte st_other;      /* unused */
+    Elf64_Quarter st_shndx; /* section index of symbol */
+    Elf64_Xword st_value;   /* value of symbol */
+    Elf64_Xword st_size;    /* size of symbol */
 } Elf64_Sym;
 
 /* Symbol table index */
-#define STN_UNDEF    0        /* undefined */
+#define STN_UNDEF 0 /* undefined */
 
 /* Extract symbol info - st_info */
-#define ELF32_ST_BIND(x)    ((x) >> 4)
-#define ELF32_ST_TYPE(x)    (((unsigned int) x) & 0xf)
-#define ELF32_ST_INFO(b,t)  (((b) << 4) + ((t) & 0xf))
+#define ELF32_ST_BIND(x) ((x) >> 4)
+#define ELF32_ST_TYPE(x) (((unsigned int)x) & 0xf)
+#define ELF32_ST_INFO(b, t) (((b) << 4) + ((t)&0xf))
 
-#define ELF64_ST_BIND(x)    ((x) >> 4)
-#define ELF64_ST_TYPE(x)    (((unsigned int) x) & 0xf)
-#define ELF64_ST_INFO(b,t)  (((b) << 4) + ((t) & 0xf))
+#define ELF64_ST_BIND(x) ((x) >> 4)
+#define ELF64_ST_TYPE(x) (((unsigned int)x) & 0xf)
+#define ELF64_ST_INFO(b, t) (((b) << 4) + ((t)&0xf))
 
 /* Symbol Binding - ELF32_ST_BIND - st_info */
-#define STB_LOCAL    0        /* Local symbol */
-#define STB_GLOBAL   1        /* Global symbol */
-#define STB_WEAK     2        /* like global - lower precedence */
-#define STB_NUM      3        /* number of symbol bindings */
-#define STB_LOPROC  13        /* reserved range for processor */
-#define STB_HIPROC  15        /*  specific symbol bindings */
+#define STB_LOCAL 0   /* Local symbol */
+#define STB_GLOBAL 1  /* Global symbol */
+#define STB_WEAK 2    /* like global - lower precedence */
+#define STB_NUM 3     /* number of symbol bindings */
+#define STB_LOPROC 13 /* reserved range for processor */
+#define STB_HIPROC 15 /*  specific symbol bindings */
 
 /* Symbol type - ELF32_ST_TYPE - st_info */
-#define STT_NOTYPE    0        /* not specified */
-#define STT_OBJECT    1        /* data object */
-#define STT_FUNC      2        /* function */
-#define STT_SECTION   3        /* section */
-#define STT_FILE      4        /* file */
-#define STT_TLS       6        /* thread local storage */
-#define STT_LOPROC    13       /* reserved range for processor */
-#define STT_HIPROC    15       /*  specific symbol types */
+#define STT_NOTYPE 0  /* not specified */
+#define STT_OBJECT 1  /* data object */
+#define STT_FUNC 2    /* function */
+#define STT_SECTION 3 /* section */
+#define STT_FILE 4    /* file */
+#define STT_TLS 6     /* thread local storage */
+#define STT_LOPROC 13 /* reserved range for processor */
+#define STT_HIPROC 15 /*  specific symbol types */
 
 /* Relocation entry with implicit addend */
 typedef struct {
-    Elf32_Addr    r_offset;    /* offset of relocation */
-    Elf32_Word    r_info;      /* symbol table index and type */
+    Elf32_Addr r_offset; /* offset of relocation */
+    Elf32_Word r_info;   /* symbol table index and type */
 } Elf32_Rel;
 
 /* Relocation entry with explicit addend */
 typedef struct {
-    Elf32_Addr    r_offset;    /* offset of relocation */
-    Elf32_Word    r_info;      /* symbol table index and type */
-    Elf32_Sword   r_addend;
+    Elf32_Addr r_offset; /* offset of relocation */
+    Elf32_Word r_info;   /* symbol table index and type */
+    Elf32_Sword r_addend;
 } Elf32_Rela;
 
 /* Extract relocation info - r_info */
-#define ELF32_R_SYM(i)         ((i) >> 8)
-#define ELF32_R_TYPE(i)        ((unsigned char) (i))
-#define ELF32_R_INFO(s,t)      (((s) << 8) + (unsigned char)(t))
+#define ELF32_R_SYM(i) ((i) >> 8)
+#define ELF32_R_TYPE(i) ((unsigned char)(i))
+#define ELF32_R_INFO(s, t) (((s) << 8) + (unsigned char)(t))
 
 typedef struct {
-    Elf64_Xword    r_offset;    /* where to do it */
-    Elf64_Xword    r_info;      /* index & type of relocation */
+    Elf64_Xword r_offset; /* where to do it */
+    Elf64_Xword r_info;   /* index & type of relocation */
 } Elf64_Rel;
 
 typedef struct {
-    Elf64_Xword    r_offset;    /* where to do it */
-    Elf64_Xword    r_info;      /* index & type of relocation */
-    Elf64_Sxword    r_addend;   /* adjustment value */
+    Elf64_Xword r_offset;  /* where to do it */
+    Elf64_Xword r_info;    /* index & type of relocation */
+    Elf64_Sxword r_addend; /* adjustment value */
 } Elf64_Rela;
 
-#define    ELF64_R_SYM(info)    ((info) >> 32)
-#define    ELF64_R_TYPE(info)   ((info) & 0xFFFFFFFF)
-#define    ELF64_R_INFO(s,t)    (((s) << 32) + (__uint32_t)(t))
+#define ELF64_R_SYM(info) ((info) >> 32)
+#define ELF64_R_TYPE(info) ((info)&0xFFFFFFFF)
+#define ELF64_R_INFO(s, t) (((s) << 32) + (__uint32_t)(t))
 
 #if defined(__mips64__) && defined(__MIPSEL__)
 /*
@@ -378,134 +377,134 @@ typedef struct {
  * than the regular ELF ABI: the r_info field is split into several
  * pieces (see gnu/usr.bin/binutils/include/elf/mips.h for details).
  */
-#undef    ELF64_R_SYM
-#undef    ELF64_R_TYPE
-#undef    ELF64_R_INFO
-#define   ELF64_R_TYPE(info)   (swap32((info) >> 32))
-#define   ELF64_R_SYM(info)    ((info) & 0xFFFFFFFF)
-#define   ELF64_R_INFO(s,t)    (((__uint64_t)swap32(t) << 32) + (__uint32_t)(s))
+#undef ELF64_R_SYM
+#undef ELF64_R_TYPE
+#undef ELF64_R_INFO
+#define ELF64_R_TYPE(info) (swap32((info) >> 32))
+#define ELF64_R_SYM(info) ((info)&0xFFFFFFFF)
+#define ELF64_R_INFO(s, t) (((__uint64_t)swap32(t) << 32) + (__uint32_t)(s))
 #endif /* __mips64__ && __MIPSEL__ */
 
 /* Program Header */
 typedef struct {
-    Elf32_Word    p_type;     /* segment type */
-    Elf32_Off     p_offset;   /* segment offset */
-    Elf32_Addr    p_vaddr;    /* virtual address of segment */
-    Elf32_Addr    p_paddr;    /* physical address - ignored? */
-    Elf32_Word    p_filesz;   /* number of bytes in file for seg. */
-    Elf32_Word    p_memsz;    /* number of bytes in mem. for seg. */
-    Elf32_Word    p_flags;    /* flags */
-    Elf32_Word    p_align;    /* memory alignment */
+    Elf32_Word p_type;   /* segment type */
+    Elf32_Off p_offset;  /* segment offset */
+    Elf32_Addr p_vaddr;  /* virtual address of segment */
+    Elf32_Addr p_paddr;  /* physical address - ignored? */
+    Elf32_Word p_filesz; /* number of bytes in file for seg. */
+    Elf32_Word p_memsz;  /* number of bytes in mem. for seg. */
+    Elf32_Word p_flags;  /* flags */
+    Elf32_Word p_align;  /* memory alignment */
 } Elf32_Phdr;
 
 typedef struct {
-    Elf64_Half    p_type;     /* entry type */
-    Elf64_Half    p_flags;    /* flags */
-    Elf64_Off     p_offset;   /* offset */
-    Elf64_Addr    p_vaddr;    /* virtual address */
-    Elf64_Addr    p_paddr;    /* physical address */
-    Elf64_Xword   p_filesz;   /* file size */
-    Elf64_Xword   p_memsz;    /* memory size */
-    Elf64_Xword   p_align;    /* memory & file alignment */
+    Elf64_Half p_type;    /* entry type */
+    Elf64_Half p_flags;   /* flags */
+    Elf64_Off p_offset;   /* offset */
+    Elf64_Addr p_vaddr;   /* virtual address */
+    Elf64_Addr p_paddr;   /* physical address */
+    Elf64_Xword p_filesz; /* file size */
+    Elf64_Xword p_memsz;  /* memory size */
+    Elf64_Xword p_align;  /* memory & file alignment */
 } Elf64_Phdr;
 
 /* Segment types - p_type */
-#define PT_NULL        0          /* unused */
-#define PT_LOAD        1          /* loadable segment */
-#define PT_DYNAMIC     2          /* dynamic linking section */
-#define PT_INTERP      3          /* the RTLD */
-#define PT_NOTE        4          /* auxiliary information */
-#define PT_SHLIB       5          /* reserved - purpose undefined */
-#define PT_PHDR        6          /* program header */
-#define PT_TLS         7          /* thread local storage */
-#define PT_LOOS        0x60000000 /* reserved range for OS */
-#define PT_HIOS        0x6fffffff /*  specific segment types */
-#define PT_LOPROC      0x70000000 /* reserved range for processor */
-#define PT_HIPROC      0x7fffffff /*  specific segment types */
+#define PT_NULL 0            /* unused */
+#define PT_LOAD 1            /* loadable segment */
+#define PT_DYNAMIC 2         /* dynamic linking section */
+#define PT_INTERP 3          /* the RTLD */
+#define PT_NOTE 4            /* auxiliary information */
+#define PT_SHLIB 5           /* reserved - purpose undefined */
+#define PT_PHDR 6            /* program header */
+#define PT_TLS 7             /* thread local storage */
+#define PT_LOOS 0x60000000   /* reserved range for OS */
+#define PT_HIOS 0x6fffffff   /*  specific segment types */
+#define PT_LOPROC 0x70000000 /* reserved range for processor */
+#define PT_HIPROC 0x7fffffff /*  specific segment types */
 
 #define PT_OPENBSD_RANDOMIZE 0x65a3dbe6 /* fill with random data */
-#define PT_GANDR_KERNEL      0x67646b6c /* gdkl */
-
+#define PT_GANDR_KERNEL 0x67646b6c      /* gdkl */
 
 /* Segment flags - p_flags */
-#define PF_X        0x1        /* Executable */
-#define PF_W        0x2        /* Writable */
-#define PF_R        0x4        /* Readable */
-#define PF_MASKPROC 0xf0000000    /* reserved bits for processor */
-                    /*  specific segment flags */
+#define PF_X 0x1               /* Executable */
+#define PF_W 0x2               /* Writable */
+#define PF_R 0x4               /* Readable */
+#define PF_MASKPROC 0xf0000000 /* reserved bits for processor */
+                               /*  specific segment flags */
 
 /* Dynamic structure */
 typedef struct {
-    Elf32_Sword    d_tag;    /* controls meaning of d_val */
+    Elf32_Sword d_tag; /* controls meaning of d_val */
     union {
-        Elf32_Word d_val;    /* Multiple meanings - see d_tag */
-        Elf32_Addr d_ptr;    /* program virtual address */
+        Elf32_Word d_val; /* Multiple meanings - see d_tag */
+        Elf32_Addr d_ptr; /* program virtual address */
     } d_un;
 } Elf32_Dyn;
 
 typedef struct {
-    Elf64_Xword     d_tag;   /* controls meaning of d_val */
+    Elf64_Xword d_tag; /* controls meaning of d_val */
     union {
-        Elf64_Addr  d_ptr;
+        Elf64_Addr d_ptr;
         Elf64_Xword d_val;
     } d_un;
 } Elf64_Dyn;
 
 /* Dynamic Array Tags - d_tag */
-#define DT_NULL        0        /* marks end of _DYNAMIC array */
-#define DT_NEEDED      1        /* string table offset of needed lib */
-#define DT_PLTRELSZ    2        /* size of relocation entries in PLT */
-#define DT_PLTGOT      3        /* address PLT/GOT */
-#define DT_HASH        4        /* address of symbol hash table */
-#define DT_STRTAB      5        /* address of string table */
-#define DT_SYMTAB      6        /* address of symbol table */
-#define DT_RELA        7        /* address of relocation table */
-#define DT_RELASZ      8        /* size of relocation table */
-#define DT_RELAENT     9        /* size of relocation entry */
-#define DT_STRSZ      10        /* size of string table */
-#define DT_SYMENT     11        /* size of symbol table entry */
-#define DT_INIT       12        /* address of initialization func. */
-#define DT_FINI       13        /* address of termination function */
-#define DT_SONAME     14        /* string table offset of shared obj */
-#define DT_RPATH      15        /* string table offset of library
-                                 * search path */
-#define DT_SYMBOLIC   16        /* start sym search in shared obj. */
-#define DT_REL        17        /* address of rel. tbl. w addends */
-#define DT_RELSZ      18        /* size of DT_REL relocation table */
-#define DT_RELENT     19        /* size of DT_REL relocation entry */
-#define DT_PLTREL     20        /* PLT referenced relocation entry */
-#define DT_DEBUG      21        /* bugger */
-#define DT_TEXTREL    22        /* Allow rel. mod. to unwritable seg */
-#define DT_JMPREL     23        /* add. of PLT's relocation entries */
-#define DT_BIND_NOW   24        /* Bind now regardless of env setting */
-#define DT_LOOS       0x6000000d    /* reserved range for OS */
-#define DT_HIOS       0x6ffff000    /*  specific dynamic array tags */
-#define DT_LOPROC     0x70000000    /* reserved range for processor */
-#define DT_HIPROC     0x7fffffff    /*  specific dynamic array tags */
+#define DT_NULL 0     /* marks end of _DYNAMIC array */
+#define DT_NEEDED 1   /* string table offset of needed lib */
+#define DT_PLTRELSZ 2 /* size of relocation entries in PLT */
+#define DT_PLTGOT 3   /* address PLT/GOT */
+#define DT_HASH 4     /* address of symbol hash table */
+#define DT_STRTAB 5   /* address of string table */
+#define DT_SYMTAB 6   /* address of symbol table */
+#define DT_RELA 7     /* address of relocation table */
+#define DT_RELASZ 8   /* size of relocation table */
+#define DT_RELAENT 9  /* size of relocation entry */
+#define DT_STRSZ 10   /* size of string table */
+#define DT_SYMENT 11  /* size of symbol table entry */
+#define DT_INIT 12    /* address of initialization func. */
+#define DT_FINI 13    /* address of termination function */
+#define DT_SONAME 14  /* string table offset of shared obj */
+#define DT_RPATH                                                               \
+    15                       /* string table offset of library                 \
+                              * search path */
+#define DT_SYMBOLIC 16       /* start sym search in shared obj. */
+#define DT_REL 17            /* address of rel. tbl. w addends */
+#define DT_RELSZ 18          /* size of DT_REL relocation table */
+#define DT_RELENT 19         /* size of DT_REL relocation entry */
+#define DT_PLTREL 20         /* PLT referenced relocation entry */
+#define DT_DEBUG 21          /* bugger */
+#define DT_TEXTREL 22        /* Allow rel. mod. to unwritable seg */
+#define DT_JMPREL 23         /* add. of PLT's relocation entries */
+#define DT_BIND_NOW 24       /* Bind now regardless of env setting */
+#define DT_LOOS 0x6000000d   /* reserved range for OS */
+#define DT_HIOS 0x6ffff000   /*  specific dynamic array tags */
+#define DT_LOPROC 0x70000000 /* reserved range for processor */
+#define DT_HIPROC 0x7fffffff /*  specific dynamic array tags */
 
 /* some other useful tags */
-#define DT_RELACOUNT  0x6ffffff9    /* if present, number of RELATIVE */
-#define DT_RELCOUNT   0x6ffffffa    /* relocs, which must come first */
-#define DT_FLAGS_1    0x6ffffffb
+#define DT_RELACOUNT 0x6ffffff9 /* if present, number of RELATIVE */
+#define DT_RELCOUNT 0x6ffffffa  /* relocs, which must come first */
+#define DT_FLAGS_1 0x6ffffffb
 
 /* Dynamic Flags - DT_FLAGS_1 .dynamic entry */
-#define DF_1_NOW       0x00000001
-#define DF_1_GLOBAL    0x00000002
-#define DF_1_GROUP     0x00000004
-#define DF_1_NODELETE  0x00000008
-#define DF_1_LOADFLTR  0x00000010
+#define DF_1_NOW 0x00000001
+#define DF_1_GLOBAL 0x00000002
+#define DF_1_GROUP 0x00000004
+#define DF_1_NODELETE 0x00000008
+#define DF_1_LOADFLTR 0x00000010
 #define DF_1_INITFIRST 0x00000020
-#define DF_1_NOOPEN    0x00000040
-#define DF_1_ORIGIN    0x00000080
-#define DF_1_DIRECT    0x00000100
-#define DF_1_TRANS     0x00000200
+#define DF_1_NOOPEN 0x00000040
+#define DF_1_ORIGIN 0x00000080
+#define DF_1_DIRECT 0x00000100
+#define DF_1_TRANS 0x00000200
 #define DF_1_INTERPOSE 0x00000400
-#define DF_1_NODEFLIB  0x00000800
-#define DF_1_NODUMP    0x00001000
-#define DF_1_CONLFAT   0x00002000
+#define DF_1_NODEFLIB 0x00000800
+#define DF_1_NODUMP 0x00001000
+#define DF_1_CONLFAT 0x00002000
 
 /* ld.so: number of low tags that are used saved internally (0 .. DT_NUM-1) */
-#define DT_NUM        (DT_JMPREL+1)
+#define DT_NUM (DT_JMPREL + 1)
 
 /*
  * Note Definitions
@@ -523,25 +522,25 @@ typedef struct {
 } Elf64_Note;
 
 #if defined(ELFSIZE) && (ELFSIZE == 32)
-#define Elf_Ehdr    Elf32_Ehdr
-#define Elf_Phdr    Elf32_Phdr
-#define Elf_Shdr    Elf32_Shdr
-#define Elf_Sym     Elf32_Sym
-#define Elf_Rel     Elf32_Rel
-#define Elf_RelA    Elf32_Rela
-#define Elf_Dyn     Elf32_Dyn
-#define Elf_Half    Elf32_Half
-#define Elf_Word    Elf32_Word
-#define Elf_Sword   Elf32_Sword
-#define Elf_Addr    Elf32_Addr
-#define Elf_Off     Elf32_Off
-#define Elf_Nhdr    Elf32_Nhdr
-#define Elf_Note    Elf32_Note
-
-#define ELF_R_SYM   ELF32_R_SYM
-#define ELF_R_TYPE  ELF32_R_TYPE
-#define ELF_R_INFO  ELF32_R_INFO
-#define ELFCLASS    ELFCLASS32
+#define Elf_Ehdr Elf32_Ehdr
+#define Elf_Phdr Elf32_Phdr
+#define Elf_Shdr Elf32_Shdr
+#define Elf_Sym Elf32_Sym
+#define Elf_Rel Elf32_Rel
+#define Elf_RelA Elf32_Rela
+#define Elf_Dyn Elf32_Dyn
+#define Elf_Half Elf32_Half
+#define Elf_Word Elf32_Word
+#define Elf_Sword Elf32_Sword
+#define Elf_Addr Elf32_Addr
+#define Elf_Off Elf32_Off
+#define Elf_Nhdr Elf32_Nhdr
+#define Elf_Note Elf32_Note
+
+#define ELF_R_SYM ELF32_R_SYM
+#define ELF_R_TYPE ELF32_R_TYPE
+#define ELF_R_INFO ELF32_R_INFO
+#define ELFCLASS ELFCLASS32
 
 #define ELF_ST_BIND ELF32_ST_BIND
 #define ELF_ST_TYPE ELF32_ST_TYPE
@@ -549,25 +548,25 @@ typedef struct {
 
 #elif defined(ELFSIZE) && (ELFSIZE == 64)
 
-#define Elf_Ehdr    Elf64_Ehdr
-#define Elf_Phdr    Elf64_Phdr
-#define Elf_Shdr    Elf64_Shdr
-#define Elf_Sym     Elf64_Sym
-#define Elf_Rel     Elf64_Rel
-#define Elf_RelA    Elf64_Rela
-#define Elf_Dyn     Elf64_Dyn
-#define Elf_Half    Elf64_Half
-#define Elf_Word    Elf64_Word
-#define Elf_Sword   Elf64_Sword
-#define Elf_Addr    Elf64_Addr
-#define Elf_Off     Elf64_Off
-#define Elf_Nhdr    Elf64_Nhdr
-#define Elf_Note    Elf64_Note
-
-#define ELF_R_SYM   ELF64_R_SYM
-#define ELF_R_TYPE  ELF64_R_TYPE
-#define ELF_R_INFO  ELF64_R_INFO
-#define ELFCLASS    ELFCLASS64
+#define Elf_Ehdr Elf64_Ehdr
+#define Elf_Phdr Elf64_Phdr
+#define Elf_Shdr Elf64_Shdr
+#define Elf_Sym Elf64_Sym
+#define Elf_Rel Elf64_Rel
+#define Elf_RelA Elf64_Rela
+#define Elf_Dyn Elf64_Dyn
+#define Elf_Half Elf64_Half
+#define Elf_Word Elf64_Word
+#define Elf_Sword Elf64_Sword
+#define Elf_Addr Elf64_Addr
+#define Elf_Off Elf64_Off
+#define Elf_Nhdr Elf64_Nhdr
+#define Elf_Note Elf64_Note
+
+#define ELF_R_SYM ELF64_R_SYM
+#define ELF_R_TYPE ELF64_R_TYPE
+#define ELF_R_INFO ELF64_R_INFO
+#define ELFCLASS ELFCLASS64
 
 #define ELF_ST_BIND ELF64_ST_BIND
 #define ELF_ST_TYPE ELF64_ST_TYPE
diff --git a/modules/cpu/src/runtime/elfload.cpp b/modules/cpu/src/runtime/elfload.cpp
index b1670da065..cb712edba5 100644
--- a/modules/cpu/src/runtime/elfload.cpp
+++ b/modules/cpu/src/runtime/elfload.cpp
@@ -2,15 +2,14 @@
 #include <cstdio>
 #include <cstring>
 
-el_status el_pread(el_ctx *ctx, void *def, size_t nb, size_t offset)
-{
+el_status el_pread(el_ctx *ctx, void *def, size_t nb, size_t offset) {
     return ctx->pread(ctx, def, nb, offset) ? EL_OK : EL_EIO;
 }
 
-#define EL_PHOFF(ctx, num) (((ctx)->ehdr.e_phoff + (num) * (ctx)->ehdr.e_phentsize))
+#define EL_PHOFF(ctx, num)                                                     \
+    (((ctx)->ehdr.e_phoff + (num) * (ctx)->ehdr.e_phentsize))
 
-el_status el_findphdr(el_ctx *ctx, Elf_Phdr *phdr, uint32_t type, unsigned *i)
-{
+el_status el_findphdr(el_ctx *ctx, Elf_Phdr *phdr, uint32_t type, unsigned *i) {
     el_status rv = EL_OK;
     for (; *i < ctx->ehdr.e_phnum; (*i)++) {
         if ((rv = el_pread(ctx, phdr, sizeof *phdr, EL_PHOFF(ctx, *i))))
@@ -25,8 +24,7 @@ el_status el_findphdr(el_ctx *ctx, Elf_Phdr *phdr, uint32_t type, unsigned *i)
     return rv;
 }
 
-el_status el_init(el_ctx *ctx)
-{
+el_status el_init(el_ctx *ctx) {
     el_status rv = EL_OK;
     if ((rv = el_pread(ctx, &ctx->ehdr, sizeof ctx->ehdr, 0)))
         return rv;
@@ -36,7 +34,6 @@ el_status el_init(el_ctx *ctx)
     if (!IS_ELF(ctx->ehdr))
         return EL_NOTELF;
 
-
     if (ctx->ehdr.e_ident[EI_CLASS] != ELFCLASS)
         return EL_WRONGBITS;
 
@@ -74,11 +71,11 @@ el_status el_init(el_ctx *ctx)
     ctx->memsz = 0;
 
     unsigned i = 0;
-    for(;;) {
+    for (;;) {
         if ((rv = el_findphdr(ctx, &ph, PT_LOAD, &i)))
             return rv;
 
-        if (i == (unsigned) -1)
+        if (i == (unsigned)-1)
             break;
 
         Elf_Addr phend = ph.p_vaddr + ph.p_memsz;
@@ -97,13 +94,13 @@ el_status el_init(el_ctx *ctx)
         if ((rv = el_findphdr(ctx, &ph, PT_DYNAMIC, &i)))
             return rv;
 
-        if (i == (unsigned) -1)
+        if (i == (unsigned)-1)
             return EL_NODYN;
 
-        ctx->dynoff  = ph.p_offset;
+        ctx->dynoff = ph.p_offset;
         ctx->dynsize = ph.p_filesz;
     } else {
-        ctx->dynoff  = 0;
+        ctx->dynoff = 0;
         ctx->dynsize = 0;
     }
 
@@ -118,8 +115,7 @@ typedef void* (*el_alloc_cb)(
     Elf_Addr size);
 */
 
-el_status el_load(el_ctx *ctx, el_alloc_cb alloc)
-{
+el_status el_load(el_ctx *ctx, el_alloc_cb alloc) {
     el_status rv = EL_OK;
 
     /* address deltas */
@@ -129,11 +125,11 @@ el_status el_load(el_ctx *ctx, el_alloc_cb alloc)
     /* iterate paddrs */
     Elf_Phdr ph;
     unsigned i = 0;
-    for(;;) {
+    for (;;) {
         if ((rv = el_findphdr(ctx, &ph, PT_LOAD, &i)))
             return rv;
 
-        if (i == (unsigned) -1)
+        if (i == (unsigned)-1)
             break;
 
         Elf_Addr pload = ph.p_paddr + pdelta;
@@ -144,8 +140,8 @@ el_status el_load(el_ctx *ctx, el_alloc_cb alloc)
         if (!dest)
             return EL_ENOMEM;
 
-        printf("Loading seg fileoff %lx, vaddr %lx to %lx\n",
-            ph.p_offset, ph.p_vaddr, (uintptr_t)dest);
+        printf("Loading seg fileoff %lx, vaddr %lx to %lx\n", ph.p_offset,
+               ph.p_vaddr, (uintptr_t)dest);
 
         /* read loaded portion */
         if ((rv = el_pread(ctx, dest, ph.p_filesz, ph.p_offset)))
@@ -160,13 +156,13 @@ el_status el_load(el_ctx *ctx, el_alloc_cb alloc)
     return rv;
 }
 
-el_status el_finddyn(el_ctx *ctx, Elf_Dyn *dyn, uint32_t tag)
-{
+el_status el_finddyn(el_ctx *ctx, Elf_Dyn *dyn, uint32_t tag) {
     el_status rv = EL_OK;
-    size_t ndyn =  ctx->dynsize / sizeof(Elf_Dyn);
+    size_t ndyn = ctx->dynsize / sizeof(Elf_Dyn);
 
-    for(unsigned i = 0; i < ndyn; i++) {
-        if ((rv = el_pread(ctx, dyn, sizeof *dyn, ctx->dynoff + i * sizeof *dyn)))
+    for (unsigned i = 0; i < ndyn; i++) {
+        if ((rv = el_pread(ctx, dyn, sizeof *dyn,
+                           ctx->dynoff + i * sizeof *dyn)))
             return rv;
 
         if (dyn->d_tag == tag)
@@ -177,8 +173,7 @@ el_status el_finddyn(el_ctx *ctx, Elf_Dyn *dyn, uint32_t tag)
     return EL_OK;
 }
 
-el_status el_findrelocs(el_ctx *ctx, el_relocinfo *ri, uint32_t type)
-{
+el_status el_findrelocs(el_ctx *ctx, el_relocinfo *ri, uint32_t type) {
     el_status rv = EL_OK;
 
     Elf_Dyn rel, relsz, relent;
@@ -192,14 +187,13 @@ el_status el_findrelocs(el_ctx *ctx, el_relocinfo *ri, uint32_t type)
     if ((rv = el_finddyn(ctx, &relent, type + 2)))
         return rv;
 
-    if (rel.d_tag == DT_NULL
-            || relsz.d_tag == DT_NULL
-            || relent.d_tag == DT_NULL) {
+    if (rel.d_tag == DT_NULL || relsz.d_tag == DT_NULL ||
+        relent.d_tag == DT_NULL) {
         ri->entrysize = 0;
         ri->tablesize = 0;
-        ri->tableoff  = 0;
+        ri->tableoff = 0;
     } else {
-        ri->tableoff  = rel.d_un.d_ptr;
+        ri->tableoff = rel.d_un.d_ptr;
         ri->tablesize = relsz.d_un.d_val;
         ri->entrysize = relent.d_un.d_val;
     }
@@ -210,15 +204,14 @@ el_status el_findrelocs(el_ctx *ctx, el_relocinfo *ri, uint32_t type)
 extern el_status el_applyrel(el_ctx *ctx, Elf_Rel *rel);
 extern el_status el_applyrela(el_ctx *ctx, Elf_RelA *rela);
 
-el_status el_relocate(el_ctx *ctx)
-{
+el_status el_relocate(el_ctx *ctx) {
     el_status rv = EL_OK;
 
     // not dynamic
     if (ctx->ehdr.e_type != ET_DYN)
         return EL_OK;
 
-    char *base = (char *) ctx->base_load_paddr;
+    char *base = (char *)ctx->base_load_paddr;
 
     el_relocinfo ri;
 #ifdef EL_ARCH_USES_REL
@@ -226,8 +219,8 @@ el_status el_relocate(el_ctx *ctx)
         return rv;
 
     if (ri.entrysize != sizeof(Elf_Rel) && ri.tablesize) {
-        EL_DEBUG("Relocation size %u doesn't match expected %u\n",
-            ri.entrysize, sizeof(Elf_Rel));
+        EL_DEBUG("Relocation size %u doesn't match expected %u\n", ri.entrysize,
+                 sizeof(Elf_Rel));
         return EL_BADREL;
     }
 
@@ -246,8 +239,8 @@ el_status el_relocate(el_ctx *ctx)
         return rv;
 
     if (ri.entrysize != sizeof(Elf_RelA) && ri.tablesize) {
-        EL_DEBUG("Relocation size %u doesn't match expected %u\n",
-            ri.entrysize, sizeof(Elf_RelA));
+        EL_DEBUG("Relocation size %u doesn't match expected %u\n", ri.entrysize,
+                 sizeof(Elf_RelA));
         return EL_BADREL;
     }
 
@@ -262,7 +255,7 @@ el_status el_relocate(el_ctx *ctx)
 #endif
 
 #if !defined(EL_ARCH_USES_REL) && !defined(EL_ARCH_USES_RELA)
-    #error No relocation type defined!
+#error No relocation type defined!
 #endif
 
     return rv;
diff --git a/modules/cpu/src/runtime/elfload.h b/modules/cpu/src/runtime/elfload.h
index 148b9b3a72..044fd5f967 100644
--- a/modules/cpu/src/runtime/elfload.h
+++ b/modules/cpu/src/runtime/elfload.h
@@ -1,19 +1,21 @@
 #ifndef ELFLOAD_H
 #define ELFLOAD_H
+#include "elf.h"
+#include "elfarch.h"
 #include <stdbool.h>
 #include <stddef.h>
-#include "elfarch.h"
-#include "elf.h"
 
 #ifdef DEBUG
 #include <stdio.h>
 #define EL_DEBUG(...) printf(__VA_ARGS__)
 #else
-#define EL_DEBUG(...) do {} while(0)
+#define EL_DEBUG(...)                                                          \
+    do {                                                                       \
+    } while (0)
 #endif
 
 typedef enum {
-    EL_OK         = 0,
+    EL_OK = 0,
 
     EL_EIO,
     EL_ENOMEM,
@@ -34,9 +36,7 @@ typedef struct el_ctx {
 
     /* base_load_* -> address we are actually going to load at
      */
-    Elf_Addr
-        base_load_paddr,
-        base_load_vaddr;
+    Elf_Addr base_load_paddr, base_load_vaddr;
 
     /* size in memory of binary */
     Elf_Addr memsz;
@@ -45,10 +45,10 @@ typedef struct el_ctx {
     Elf_Addr align;
 
     /* ELF header */
-    Elf_Ehdr  ehdr;
+    Elf_Ehdr ehdr;
 
     /* Offset of dynamic table (0 if not ET_DYN) */
-    Elf_Off  dynoff;
+    Elf_Off dynoff;
     /* Size of dynamic table (0 if not ET_DYN) */
     Elf_Addr dynsize;
 
@@ -58,11 +58,8 @@ typedef struct el_ctx {
 el_status el_pread(el_ctx *ctx, void *def, size_t nb, size_t offset);
 
 el_status el_init(el_ctx *ctx);
-typedef void* (*el_alloc_cb)(
-    el_ctx *ctx,
-    Elf_Addr phys,
-    Elf_Addr virt,
-    Elf_Addr size);
+typedef void *(*el_alloc_cb)(el_ctx *ctx, Elf_Addr phys, Elf_Addr virt,
+                             Elf_Addr size);
 
 el_status el_load(el_ctx *ctx, el_alloc_cb alloccb);
 
@@ -84,7 +81,7 @@ el_status el_relocate(el_ctx *ctx);
 el_status el_finddyn(el_ctx *ctx, Elf_Dyn *dyn, uint32_t type);
 
 typedef struct {
-    Elf_Off  tableoff;
+    Elf_Off tableoff;
     Elf_Addr tablesize;
     Elf_Addr entrysize;
 } el_relocinfo;
diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/cpu/src/runtime/elfloader.cpp
index 8bced71e14..f0c6571db1 100644
--- a/modules/cpu/src/runtime/elfloader.cpp
+++ b/modules/cpu/src/runtime/elfloader.cpp
@@ -4,8 +4,8 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace nncase::runtime::cpu;
 
-int elfloader::invoke_elf(size_t id, buffer_t **buffers,
-                           nncase_mt_t *nncase_mt, void *data, void *rdata) {
+int elfloader::invoke_elf(size_t id, buffer_t **buffers, nncase_mt_t *nncase_mt,
+                          void *data, void *rdata) {
 
     check(el_init(&ctx_), "initialising");
 
diff --git a/modules/cpu/src/runtime/elfreloc_aarch64.cpp b/modules/cpu/src/runtime/elfreloc_aarch64.cpp
index e8fd3f8ed7..58a5ad1753 100644
--- a/modules/cpu/src/runtime/elfreloc_aarch64.cpp
+++ b/modules/cpu/src/runtime/elfreloc_aarch64.cpp
@@ -2,66 +2,61 @@
 
 #if defined(__aarch64__)
 
-#define R_AARCH64_NONE     0
+#define R_AARCH64_NONE 0
 #define R_AARCH64_RELATIVE 1027
 
-el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel)
-{
-    uintptr_t *p = (uintptr_t*) (rel->r_offset + ctx->base_load_paddr);
+el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel) {
+    uintptr_t *p = (uintptr_t *)(rel->r_offset + ctx->base_load_paddr);
     uint32_t type = ELF_R_TYPE(rel->r_info);
-    uint32_t sym  = ELF_R_SYM(rel->r_info);
+    uint32_t sym = ELF_R_SYM(rel->r_info);
 
     switch (type) {
-        case R_AARCH64_NONE:
-            EL_DEBUG("R_AARCH64_NONE\n");
-            break;
-        case R_AARCH64_RELATIVE:
-            if (sym) {
-                EL_DEBUG("R_AARCH64_RELATIVE with symbol ref!\n");
-                return EL_BADREL;
-            }
-
-            EL_DEBUG("Applying R_AARCH64_RELATIVE reloc @%p\n", p);
-            *p = rel->r_addend + ctx->base_load_vaddr;
-            break;
-
-        default:
-            EL_DEBUG("Bad relocation %u\n", type);
+    case R_AARCH64_NONE:
+        EL_DEBUG("R_AARCH64_NONE\n");
+        break;
+    case R_AARCH64_RELATIVE:
+        if (sym) {
+            EL_DEBUG("R_AARCH64_RELATIVE with symbol ref!\n");
             return EL_BADREL;
+        }
 
+        EL_DEBUG("Applying R_AARCH64_RELATIVE reloc @%p\n", p);
+        *p = rel->r_addend + ctx->base_load_vaddr;
+        break;
+
+    default:
+        EL_DEBUG("Bad relocation %u\n", type);
+        return EL_BADREL;
     }
 
     return EL_OK;
 }
 
-el_status el_applyrel(el_ctx *ctx, Elf_Rel *rel)
-{
-    uintptr_t *p = (uintptr_t*) (rel->r_offset + ctx->base_load_paddr);
+el_status el_applyrel(el_ctx *ctx, Elf_Rel *rel) {
+    uintptr_t *p = (uintptr_t *)(rel->r_offset + ctx->base_load_paddr);
     uint32_t type = ELF_R_TYPE(rel->r_info);
-    uint32_t sym  = ELF_R_SYM(rel->r_info);
+    uint32_t sym = ELF_R_SYM(rel->r_info);
 
     switch (type) {
-        case R_AARCH64_NONE:
-            EL_DEBUG("R_AARCH64_NONE\n");
-            break;
-        case R_AARCH64_RELATIVE:
-            if (sym) {
-                EL_DEBUG("R_AARCH64_RELATIVE with symbol ref!\n");
-                return EL_BADREL;
-            }
-
-            EL_DEBUG("Applying R_AARCH64_RELATIVE reloc @%p\n", p);
-            *p += ctx->base_load_vaddr;
-            break;
-
-        default:
-            EL_DEBUG("Bad relocation %u\n", type);
+    case R_AARCH64_NONE:
+        EL_DEBUG("R_AARCH64_NONE\n");
+        break;
+    case R_AARCH64_RELATIVE:
+        if (sym) {
+            EL_DEBUG("R_AARCH64_RELATIVE with symbol ref!\n");
             return EL_BADREL;
+        }
+
+        EL_DEBUG("Applying R_AARCH64_RELATIVE reloc @%p\n", p);
+        *p += ctx->base_load_vaddr;
+        break;
 
+    default:
+        EL_DEBUG("Bad relocation %u\n", type);
+        return EL_BADREL;
     }
 
     return EL_OK;
 }
 
-
 #endif
diff --git a/modules/cpu/src/runtime/elfreloc_amd64.cpp b/modules/cpu/src/runtime/elfreloc_amd64.cpp
index 8b32082ff3..98e638ae44 100644
--- a/modules/cpu/src/runtime/elfreloc_amd64.cpp
+++ b/modules/cpu/src/runtime/elfreloc_amd64.cpp
@@ -2,24 +2,23 @@
 
 #if defined(__amd64__)
 
-#define R_AMD64_NONE     0
+#define R_AMD64_NONE 0
 #define R_AMD64_RELATIVE 8
 
-el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel)
-{
-    uint64_t *p = (uint64_t*) (rel->r_offset + ctx->base_load_vaddr);
+el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel) {
+    uint64_t *p = (uint64_t *)(rel->r_offset + ctx->base_load_vaddr);
     uint32_t type = ELF_R_TYPE(rel->r_info);
 
     switch (type) {
-        case R_AMD64_NONE: break;
-        case R_AMD64_RELATIVE:
-            EL_DEBUG("Applying R_AMD64_RELATIVE reloc @%p\n", p);
-            *p = rel->r_addend + ctx->base_load_vaddr;
-            break;
-        default:
-            EL_DEBUG("Bad relocation %u\n", type);
-            return EL_BADREL;
-
+    case R_AMD64_NONE:
+        break;
+    case R_AMD64_RELATIVE:
+        EL_DEBUG("Applying R_AMD64_RELATIVE reloc @%p\n", p);
+        *p = rel->r_addend + ctx->base_load_vaddr;
+        break;
+    default:
+        EL_DEBUG("Bad relocation %u\n", type);
+        return EL_BADREL;
     }
 
     return EL_OK;
diff --git a/modules/cpu/src/runtime/elfreloc_i386.cpp b/modules/cpu/src/runtime/elfreloc_i386.cpp
index fdf66e3d3f..2373ab036c 100644
--- a/modules/cpu/src/runtime/elfreloc_i386.cpp
+++ b/modules/cpu/src/runtime/elfreloc_i386.cpp
@@ -2,24 +2,24 @@
 
 #if defined(__i386__)
 
-#define R_386_NONE     0
+#define R_386_NONE 0
 #define R_386_RELATIVE 8
 
-el_status el_applyrel(el_ctx *ctx, Elf_Rel *rel)
-{
-    uint32_t *p = (uint32_t*) (rel->r_offset + ctx->base_load_vaddr);
+el_status el_applyrel(el_ctx *ctx, Elf_Rel *rel) {
+    uint32_t *p = (uint32_t *)(rel->r_offset + ctx->base_load_vaddr);
     uint32_t type = ELF_R_TYPE(rel->r_info);
-    uint32_t sym  = ELF_R_SYM(rel->r_info);
+    uint32_t sym = ELF_R_SYM(rel->r_info);
 
     switch (type) {
-        case R_386_NONE: break;
-        case R_386_RELATIVE:
-            EL_DEBUG("Applying R_386_RELATIVE reloc @%p\n", p);
-            *p += ctx->base_load_vaddr;
-            break;
-        default:
-            EL_DEBUG("Bad relocation %u\n", type);
-            return EL_BADREL;
+    case R_386_NONE:
+        break;
+    case R_386_RELATIVE:
+        EL_DEBUG("Applying R_386_RELATIVE reloc @%p\n", p);
+        *p += ctx->base_load_vaddr;
+        break;
+    default:
+        EL_DEBUG("Bad relocation %u\n", type);
+        return EL_BADREL;
     }
 
     return EL_OK;
diff --git a/modules/cpu/src/runtime/elfreloc_riscv64.cpp b/modules/cpu/src/runtime/elfreloc_riscv64.cpp
index a4d99a64ef..487361da2c 100644
--- a/modules/cpu/src/runtime/elfreloc_riscv64.cpp
+++ b/modules/cpu/src/runtime/elfreloc_riscv64.cpp
@@ -2,29 +2,28 @@
 
 #if defined(__riscv)
 
-#define R_riscv64_NONE     0
+#define R_riscv64_NONE 0
 #define R_riscv64_RELATIVE 3
 #define R_riscv64_JUMP_SLOT 5
 
-el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel)
-{
-    uint64_t *p = (uint64_t*) (rel->r_offset + ctx->base_load_vaddr);
+el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel) {
+    uint64_t *p = (uint64_t *)(rel->r_offset + ctx->base_load_vaddr);
     uint32_t type = ELF_R_TYPE(rel->r_info);
     EL_DEBUG("rv\n");
 
     switch (type) {
-        case R_riscv64_NONE: break;
-        case R_riscv64_RELATIVE:
-            EL_DEBUG("Applying R_riscv64_RELATIVE reloc @%p\n", p);
-            *p = rel->r_addend + ctx->base_load_vaddr;
-            break;
-        case R_riscv64_JUMP_SLOT:
-            EL_DEBUG("Applying R_riscv64_JUMP_SLOT reloc @%p\n", p);
-            break;
-        default:
-            EL_DEBUG("Bad relocation %u\n", type);
-            return EL_BADREL;
-
+    case R_riscv64_NONE:
+        break;
+    case R_riscv64_RELATIVE:
+        EL_DEBUG("Applying R_riscv64_RELATIVE reloc @%p\n", p);
+        *p = rel->r_addend + ctx->base_load_vaddr;
+        break;
+    case R_riscv64_JUMP_SLOT:
+        EL_DEBUG("Applying R_riscv64_JUMP_SLOT reloc @%p\n", p);
+        break;
+    default:
+        EL_DEBUG("Bad relocation %u\n", type);
+        return EL_BADREL;
     }
 
     return EL_OK;
diff --git a/modules/cpu/src/runtime/runtime_module.cpp b/modules/cpu/src/runtime/runtime_module.cpp
index 810b51de4e..1bdd121f9c 100644
--- a/modules/cpu/src/runtime/runtime_module.cpp
+++ b/modules/cpu/src/runtime/runtime_module.cpp
@@ -27,8 +27,7 @@ result<void> cpu_runtime_module::initialize_before_functions(
     if (!context.is_section_pinned())
         return nncase::err(std::errc::bad_address);
     try_var(data, context.get_or_read_section(".data", data_storage_, false));
-    try_var(rdata,
-            context.get_or_read_section(".rdata", rdata_storage_, true));
+    try_var(rdata, context.get_or_read_section(".rdata", rdata_storage_, true));
     try_var(text, context.get_or_read_section(".text", text_storage_, true));
 
     text_ = text.as_span<const gsl::byte>();

From 092df591f9352a2394100a3d44f87e24be97d04d Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Tue, 25 Jul 2023 01:57:36 +0000
Subject: [PATCH 019/308] Apply code-format changes

---
 .../Nncase.Modules.CPU/CodeGen/FunctionCSource.cs    | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
index e07152e4fc..347ff76d36 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -86,6 +86,12 @@ public string Compile(string sourcePath, string outPath)
         return outPath;
     }
 
+    /// <summary>
+    /// create the temp dll file and compile source
+    /// <see cref="Compile(string, string)"/>.
+    /// </summary>
+    public string Compile(string sourcePath) => Compile(sourcePath, CodeGenUtil.GetTempFileName(Ext));
+
     /// <summary>
     /// select current pattern's exe.
     /// </summary>
@@ -138,12 +144,6 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
 
         throw new System.ArgumentOutOfRangeException("Only Support Linux/Osx/Windows");
     }
-
-    /// <summary>
-    /// create the temp dll file and compile source
-    /// <see cref="Compile(string, string)"/>.
-    /// </summary>
-    public string Compile(string sourcePath) => Compile(sourcePath, CodeGenUtil.GetTempFileName(Ext));
 }
 
 internal sealed class FunctionCSource

From 19546c076c87bdcb8f25f4577d69fb9d3a52e9c0 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 25 Jul 2023 10:00:25 +0800
Subject: [PATCH 020/308] fix elfloader build

---
 modules/cpu/src/runtime/elf.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/modules/cpu/src/runtime/elf.h b/modules/cpu/src/runtime/elf.h
index d7be196fa3..04cbf49893 100644
--- a/modules/cpu/src/runtime/elf.h
+++ b/modules/cpu/src/runtime/elf.h
@@ -30,6 +30,7 @@
 #ifndef ELF_H
 #define ELF_H
 #include <stdint.h>
+#include "elfarch.h"
 
 typedef uint8_t Elf_Byte;
 

From e8956e6986eca9770c1ead538fd6fc831280924d Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 25 Jul 2023 10:02:28 +0800
Subject: [PATCH 021/308] disable launch_debugger

---
 python/nncase/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/nncase/__init__.py b/python/nncase/__init__.py
index f58942ce25..8653d3b301 100644
--- a/python/nncase/__init__.py
+++ b/python/nncase/__init__.py
@@ -44,7 +44,7 @@ def _initialize():
 
 
 _initialize()
-_nncase.launch_debugger()
+# _nncase.launch_debugger()
 
 
 class ImportOptions:

From 1db8052db303f429081c40ca57cf7c35803f14f9 Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Tue, 25 Jul 2023 02:06:13 +0000
Subject: [PATCH 022/308] Apply code-format changes

---
 modules/cpu/src/runtime/elf.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/cpu/src/runtime/elf.h b/modules/cpu/src/runtime/elf.h
index 04cbf49893..4db5998b3a 100644
--- a/modules/cpu/src/runtime/elf.h
+++ b/modules/cpu/src/runtime/elf.h
@@ -29,8 +29,8 @@
 
 #ifndef ELF_H
 #define ELF_H
-#include <stdint.h>
 #include "elfarch.h"
+#include <stdint.h>
 
 typedef uint8_t Elf_Byte;
 

From a726a93d25c5a7ea77214c566f1f89ae8326e314 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 25 Jul 2023 10:53:46 +0800
Subject: [PATCH 023/308] update csource dump

---
 modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs | 12 ++++++++----
 modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs  |  2 +-
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index e2e53e6b19..946cfd4afa 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
+using System.IO;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -18,11 +19,13 @@ internal sealed class LinkableModule : ILinkableModule
     private readonly byte[] _rdata;
 
     private readonly IReadOnlyList<LinkableFunction> _functions;
+    private readonly CompileOptions _options;
 
-    public LinkableModule(byte[] rdata, IReadOnlyList<LinkableFunction> functions)
+    public LinkableModule(byte[] rdata, IReadOnlyList<LinkableFunction> functions, CompileOptions options)
     {
         _rdata = rdata;
         _functions = functions;
+        _options = options;
     }
 
     public ILinkedModule Link(ILinkContext linkContext)
@@ -31,9 +34,10 @@ public ILinkedModule Link(ILinkContext linkContext)
         var elfPath = CompileCSource(csourcePath);
         var text = File.ReadAllBytes(elfPath);
 
-        if (DumpScope.Current.IsEnabled(DumpFlags.CodeGen))
+        if (_options.DumpFlags.HasFlag(DumpFlags.CodeGen))
         {
-            using (var fs = DumpScope.Current.OpenFile("cpuModule.h"))
+            var dumpPath = _options.DumpDir;
+            using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.h"), FileMode.Create))
             {
                 using (var writer = new StreamWriter(fs))
                 {
@@ -41,7 +45,7 @@ public ILinkedModule Link(ILinkContext linkContext)
                 }
             }
 
-            using (var fs = DumpScope.Current.OpenFile("cpuModule.c"))
+            using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.c"), FileMode.Create))
             {
                 File.Open(csourcePath, FileMode.Open, FileAccess.Read).CopyTo(fs);
             }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
index c68b7b16da..36dd625463 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
@@ -32,7 +32,7 @@ public ILinkableModule Build(IReadOnlyList<BaseFunction> functions)
         var linkableFunctions = functions.OfType<TIR.PrimFunction>().Select((f, i) => new FunctionBuilder((uint)i, _rdataWriter).Build(f)).ToArray();
         _rdataWriter.Flush();
 
-        return new LinkableModule(_rdataContent.ToArray(), linkableFunctions);
+        return new LinkableModule(_rdataContent.ToArray(), linkableFunctions, CompileOptions);
     }
 
     public void Dispose() => ((IDisposable)_rdataContent).Dispose();

From 11f469196b1cbff2a22e5d7e70842d14b29ac7ae Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 25 Jul 2023 12:04:24 +0800
Subject: [PATCH 024/308] fix cpu runtime function

---
 .../Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs   |  3 ---
 modules/cpu/src/runtime/cpu_common.h                 | 10 +++++-----
 modules/cpu/src/runtime/runtime_function.cpp         |  6 +++---
 modules/cpu/src/runtime/runtime_module.cpp           | 12 +++++-------
 4 files changed, 13 insertions(+), 18 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
index e7e479017b..7b2d6e09bc 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
@@ -31,9 +31,6 @@ internal static string ContertUnary(Unary op, CSymbol[] arguments)
         string str;
         switch (op.UnaryOp)
         {
-            case UnaryOp.Neg:
-                str = $"!{input}";
-                break;
             default:
                 str = $"nncase_mt->{arguments[0].Type}_{nameof(Unary).ToLower()}_{op.UnaryOp.ToString().ToLower()}{input}";
                 break;
diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
index 70c22065b9..72ace7cd89 100644
--- a/modules/cpu/src/runtime/cpu_common.h
+++ b/modules/cpu/src/runtime/cpu_common.h
@@ -57,15 +57,15 @@ inline float float_unary_square(float x) { return x * x; }
     .float_unary_exp = expf,
     .float_unary_floor = floorf,
     .float_unary_log = logf,
-    .float_unary_logical_not = &float_unary_logical_not,
-    .float_unary_neg = &float_unary_neg,
+    .float_unary_logical_not = float_unary_logical_not,
+    .float_unary_neg = float_unary_neg,
     .float_unary_round = roundf,
-    .float_unary_rsqrt = &float_unary_rsqrt,
-    .float_unary_sign = &float_unary_sign,
+    .float_unary_rsqrt = float_unary_rsqrt,
+    .float_unary_sign = float_unary_sign,
     .float_unary_sin = sinf,
     .float_unary_sinh = sinhf,
     .float_unary_sqrt = sqrtf,
-    .float_unary_square = &float_unary_square,
+    .float_unary_square = float_unary_square,
     .float_unary_tanh = tanhf};
 
 END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 2a6be1e344..a128173364 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -109,7 +109,7 @@ result<void> cpu_runtime_function::initialize_core(
 
 result<value_t>
 cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
-                                  value_t return_value) noexcept {
+                                NNCASE_UNUSED value_t return_value) noexcept {
     try_var(id, module().find_id_by_function(this));
     std::cout << "call " << id << std::endl;
 
@@ -128,7 +128,7 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
 
     // output buffer
     for (uint32_t i = 0; i < output_ranks_.size(); i++) {
-        auto output_tensor = parameters[i].as<tensor>().expect(
+        auto output_tensor = parameters[input_ranks_.size() + i].as<tensor>().expect(
             "output " + std::to_string(i) + " is not a tensor");
         try_var(output_span, get_output_span(output_tensor));
         buffer_t *output_buffer =
@@ -147,5 +147,5 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
         delete buffers[i];
     }
 
-    return ok(return_value);
+    return ok<value_t>(tuple(std::in_place));
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/runtime_module.cpp b/modules/cpu/src/runtime/runtime_module.cpp
index 1bdd121f9c..4bfc2fff11 100644
--- a/modules/cpu/src/runtime/runtime_module.cpp
+++ b/modules/cpu/src/runtime/runtime_module.cpp
@@ -24,13 +24,11 @@ using namespace nncase::runtime::cpu;
 
 result<void> cpu_runtime_module::initialize_before_functions(
     runtime_module_init_context &context) noexcept {
-    if (!context.is_section_pinned())
-        return nncase::err(std::errc::bad_address);
-    try_var(data, context.get_or_read_section(".data", data_storage_, false));
-    try_var(rdata, context.get_or_read_section(".rdata", rdata_storage_, true));
-    try_var(text, context.get_or_read_section(".text", text_storage_, true));
-
-    text_ = text.as_span<const gsl::byte>();
+    // if (!context.is_section_pinned())
+    //     return nncase::err(std::errc::bad_address);
+    // try_var(data, context.get_or_read_section(".data", data_storage_, false));
+    // try_var(rdata, context.get_or_read_section(".rdata", rdata_storage_, true));
+    try_set(text_, context.get_or_read_section(".text", text_storage_, true));
 
     return ok();
 }

From b438407bd62e59a79fa2e9e8a0a907837bd658eb Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Tue, 25 Jul 2023 04:07:23 +0000
Subject: [PATCH 025/308] Apply code-format changes

---
 modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs | 2 +-
 modules/cpu/src/runtime/runtime_function.cpp         | 7 ++++---
 modules/cpu/src/runtime/runtime_module.cpp           | 5 +++--
 3 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index 946cfd4afa..f668f441b4 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -2,8 +2,8 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
-using System.IO;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index a128173364..f786c92a20 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -109,7 +109,7 @@ result<void> cpu_runtime_function::initialize_core(
 
 result<value_t>
 cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
-                                NNCASE_UNUSED value_t return_value) noexcept {
+                                  NNCASE_UNUSED value_t return_value) noexcept {
     try_var(id, module().find_id_by_function(this));
     std::cout << "call " << id << std::endl;
 
@@ -128,8 +128,9 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
 
     // output buffer
     for (uint32_t i = 0; i < output_ranks_.size(); i++) {
-        auto output_tensor = parameters[input_ranks_.size() + i].as<tensor>().expect(
-            "output " + std::to_string(i) + " is not a tensor");
+        auto output_tensor =
+            parameters[input_ranks_.size() + i].as<tensor>().expect(
+                "output " + std::to_string(i) + " is not a tensor");
         try_var(output_span, get_output_span(output_tensor));
         buffer_t *output_buffer =
             new buffer_t(output_span.data(), 0, output_shapes_[i].data(),
diff --git a/modules/cpu/src/runtime/runtime_module.cpp b/modules/cpu/src/runtime/runtime_module.cpp
index 4bfc2fff11..0b1b2efbe8 100644
--- a/modules/cpu/src/runtime/runtime_module.cpp
+++ b/modules/cpu/src/runtime/runtime_module.cpp
@@ -26,8 +26,9 @@ result<void> cpu_runtime_module::initialize_before_functions(
     runtime_module_init_context &context) noexcept {
     // if (!context.is_section_pinned())
     //     return nncase::err(std::errc::bad_address);
-    // try_var(data, context.get_or_read_section(".data", data_storage_, false));
-    // try_var(rdata, context.get_or_read_section(".rdata", rdata_storage_, true));
+    // try_var(data, context.get_or_read_section(".data", data_storage_,
+    // false)); try_var(rdata, context.get_or_read_section(".rdata",
+    // rdata_storage_, true));
     try_set(text_, context.get_or_read_section(".text", text_storage_, true));
 
     return ok();

From 893b73dd7c4f0166728e990f1d0b1d23b8127d2c Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 25 Jul 2023 13:44:36 +0800
Subject: [PATCH 026/308] fix warnings

---
 .../CodeGen/CSourceConvertVisitor.cs          | 48 +++++++++----------
 .../CodeGen/CSourceUtilities.cs               |  3 +-
 .../CodeGen/FunctionCSource.cs                |  4 +-
 3 files changed, 28 insertions(+), 27 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index ab4397910d..5dc9cec026 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -74,14 +74,14 @@ public CSymbol(string type, string name)
 
 internal sealed class IndentWriter : StringWriter
 {
-    public int Indent;
-
     public IndentWriter(StringBuilder sb, int indent = 0)
         : base(sb)
     {
         Indent = indent;
     }
 
+    public int Indent { get; set; }
+
     public void IndWrite(string? value)
     {
         for (int i = 0; i < Indent; i++)
@@ -98,24 +98,24 @@ public void IndWrite(string? value)
 /// </summary>
 internal sealed class CSourceConvertVisitor : ExprFunctor<CSymbol, Unit>
 {
-    public readonly Dictionary<Expr, CSymbol> ExprMemo;
+    private readonly Dictionary<Expr, CSymbol> _exprMemo;
     private readonly StringBuilder _implBuilder;
 
     public CSourceConvertVisitor()
     {
         _implBuilder = new StringBuilder();
-        ExprMemo = new(ReferenceEqualityComparer.Instance);
+        _exprMemo = new(ReferenceEqualityComparer.Instance);
     }
 
     public FunctionCSource GetFunctionCSource()
     {
-        return new(ExprMemo[VisitRoot!].Type + ";", _implBuilder.ToString());
+        return new(_exprMemo[VisitRoot!].Type + ";", _implBuilder.ToString());
     }
 
     /// <inheritdoc/>
     protected override CSymbol VisitPrimFunction(PrimFunction expr)
     {
-        if (ExprMemo.TryGetValue(expr, out var symbol))
+        if (_exprMemo.TryGetValue(expr, out var symbol))
         {
             return symbol;
         }
@@ -133,7 +133,7 @@ protected override CSymbol VisitPrimFunction(PrimFunction expr)
             IndentScope.Writer.IndWrite($"{type} {{\n");
 
             // 2. Function body
-            using (var _ = new IndentScope())
+            using (_ = new IndentScope())
             {
                 Visit(expr.Body);
             }
@@ -143,14 +143,14 @@ protected override CSymbol VisitPrimFunction(PrimFunction expr)
         }
 
         symbol = new(type, new(expr.Name));
-        ExprMemo.Add(expr, symbol);
+        _exprMemo.Add(expr, symbol);
         return symbol;
     }
 
     /// <inheritdoc/>
     protected override CSymbol VisitCall(Call expr)
     {
-        if (ExprMemo.TryGetValue(expr, out var symbol))
+        if (_exprMemo.TryGetValue(expr, out var symbol))
         {
             return symbol;
         }
@@ -183,14 +183,14 @@ protected override CSymbol VisitCall(Call expr)
         }
 
         symbol = new(type, str);
-        ExprMemo.Add(expr, symbol);
+        _exprMemo.Add(expr, symbol);
         return symbol;
     }
 
     /// <inheritdoc/>
     protected override CSymbol VisitConst(Const expr)
     {
-        if (ExprMemo.TryGetValue(expr, out var symbol))
+        if (_exprMemo.TryGetValue(expr, out var symbol))
         {
             return symbol;
         }
@@ -215,14 +215,14 @@ protected override CSymbol VisitConst(Const expr)
         }
 
         symbol = new(type, str);
-        ExprMemo.Add(expr, symbol);
+        _exprMemo.Add(expr, symbol);
         return symbol;
     }
 
     /// <inheritdoc/>
     protected override CSymbol VisitVar(Var expr)
     {
-        if (ExprMemo.TryGetValue(expr, out var symbol))
+        if (_exprMemo.TryGetValue(expr, out var symbol))
         {
             return symbol;
         }
@@ -233,14 +233,14 @@ protected override CSymbol VisitVar(Var expr)
         }
 
         symbol = new(ttype.DType.ToC(), new($"{expr.Name}_{expr.GlobalVarIndex}"));
-        ExprMemo.Add(expr, symbol);
+        _exprMemo.Add(expr, symbol);
         return symbol;
     }
 
     /// <inheritdoc/>
     protected override CSymbol VisitFor(For expr)
     {
-        if (ExprMemo.TryGetValue(expr, out var symbol))
+        if (_exprMemo.TryGetValue(expr, out var symbol))
         {
             return symbol;
         }
@@ -258,14 +258,14 @@ protected override CSymbol VisitFor(For expr)
         IndentScope.Writer.IndWrite("}\n");
 
         symbol = new(string.Empty, string.Empty);
-        ExprMemo.Add(expr, symbol);
+        _exprMemo.Add(expr, symbol);
         return symbol;
     }
 
     /// <inheritdoc/>
     protected override CSymbol VisitSequential(Sequential expr)
     {
-        if (ExprMemo.TryGetValue(expr, out var symbol))
+        if (_exprMemo.TryGetValue(expr, out var symbol))
         {
             return symbol;
         }
@@ -284,26 +284,26 @@ protected override CSymbol VisitSequential(Sequential expr)
         }
 
         symbol = new(string.Empty, string.Empty);
-        ExprMemo.Add(expr, symbol);
+        _exprMemo.Add(expr, symbol);
         return symbol;
     }
 
     /// <inheritdoc/>
     protected override CSymbol VisitIfThenElse(IfThenElse expr)
     {
-        if (ExprMemo.TryGetValue(expr, out var symbol))
+        if (_exprMemo.TryGetValue(expr, out var symbol))
         {
             return symbol;
         }
 
         IndentScope.Writer.IndWrite($"if({Visit(expr.Condition).Name}) {{\n");
-        using (var _ = new IndentScope())
+        using (_ = new IndentScope())
         {
             Visit(expr.Then);
         }
 
         IndentScope.Writer.IndWrite("} else {\n");
-        using (var _ = new IndentScope())
+        using (_ = new IndentScope())
         {
             Visit(expr.Else);
         }
@@ -311,19 +311,19 @@ protected override CSymbol VisitIfThenElse(IfThenElse expr)
         IndentScope.Writer.IndWrite("}\n");
 
         symbol = new(string.Empty, string.Empty);
-        ExprMemo.Add(expr, symbol);
+        _exprMemo.Add(expr, symbol);
         return symbol;
     }
 
     protected override CSymbol VisitPhysicalBuffer(PhysicalBuffer expr)
     {
-        if (ExprMemo.TryGetValue(expr, out var symbol))
+        if (_exprMemo.TryGetValue(expr, out var symbol))
         {
             return symbol;
         }
 
         symbol = new(CSourceBuiltn.BufferType + "*", expr.Name);
-        ExprMemo.Add(expr, symbol);
+        _exprMemo.Add(expr, symbol);
         return symbol;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
index 7b2d6e09bc..359ba4c3e9 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
+using System.Globalization;
 using Nncase.Diagnostics;
 using Nncase.IR.Math;
 
@@ -32,7 +33,7 @@ internal static string ContertUnary(Unary op, CSymbol[] arguments)
         switch (op.UnaryOp)
         {
             default:
-                str = $"nncase_mt->{arguments[0].Type}_{nameof(Unary).ToLower()}_{op.UnaryOp.ToString().ToLower()}{input}";
+                str = $"nncase_mt->{arguments[0].Type}_{nameof(Unary).ToLower(CultureInfo.CurrentCulture)}_{op.UnaryOp.ToString().ToLower(CultureInfo.CurrentCulture)}{input}";
                 break;
         }
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
index 347ff76d36..456d23649d 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -95,7 +95,7 @@ public string Compile(string sourcePath, string outPath)
     /// <summary>
     /// select current pattern's exe.
     /// </summary>
-    /// <exception cref="NotSupportedException"></exception>
+    /// <exception cref="NotSupportedException">NotSupportedException.</exception>
     private void PlatformSpecific()
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
@@ -142,7 +142,7 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
             return $"/C (\"{vcvardir}\" x64) && (cl /D_USRDLL /D_WINDLL \"{sourcePath}\" /MT /link /DLL /OUT:\"{outPath}\")";
         }
 
-        throw new System.ArgumentOutOfRangeException("Only Support Linux/Osx/Windows");
+        throw new System.NotSupportedException("Only Support Linux/Osx/Windows");
     }
 }
 

From 25c4fc296fd53a94480de676b5ca14d1c7c2aa5a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 25 Jul 2023 15:26:58 +0800
Subject: [PATCH 027/308] fix bug

---
 .../CodeGen/CSourceBuiltn.cs                  |   2 -
 .../CodeGen/CSourceCompiler.cs                | 152 ++++++++++++++++++
 .../CodeGen/FunctionCSource.cs                | 131 ---------------
 .../CodeGen/LinkableModule.cs                 |  15 +-
 .../Passes/Rules/LowerUnary.cs                |   2 +-
 .../Nncase.Modules.CPU/Targets/CPUTarget.cs   |   2 +-
 modules/cpu/src/runtime/elfload.cpp           |   6 +-
 modules/cpu/src/runtime/elfloader.h           |   3 +-
 modules/cpu/src/runtime/runtime_function.cpp  |   8 +-
 9 files changed, 174 insertions(+), 147 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index 6eb0ae594d..13b55dbb34 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -55,7 +55,5 @@ public static class CSourceBuiltn
 {MethodTable}
 
 {BufferStruct}
-
-static nncase_mt_t *nncase_mt;
 ";
 }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
new file mode 100644
index 0000000000..9d34d5763a
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
@@ -0,0 +1,152 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using Nncase.IR;
+using Nncase.Schedule;
+using Nncase.TIR;
+
+namespace Nncase.CodeGen;
+
+/// <summary>
+/// the csource code compiler.
+/// </summary>
+public class CSourceCompiler
+{
+    /// <summary>
+    /// compiler exe name.
+    /// </summary>
+    private string _exe = string.Empty;
+
+    /// <summary>
+    /// compiler exe name.
+    /// </summary>
+    private string _arch = string.Empty;
+
+    /// <summary>
+    /// compiler exe name.
+    /// </summary>
+    private string _ext = string.Empty;
+
+    public CSourceCompiler()
+    {
+        PlatformSpecific();
+        ArchSpecific();
+    }
+
+    protected string Exe
+    {
+        get => _exe;
+    }
+
+    protected string Arch
+    {
+        get => _arch;
+    }
+
+    protected string Ext
+    {
+        get => _ext;
+    }
+
+    /// <summary>
+    /// compile the source txt, write to the out_path.
+    /// </summary>
+    /// <param name="sourcePath"> c source code.</param>
+    /// <param name="outPath"> out .so path. </param>
+    /// <returns> outPath. </returns>
+    public string Compile(string sourcePath, string outPath)
+    {
+        var errMsg = new StringBuilder();
+        using (var errWriter = new StringWriter(errMsg))
+        {
+            using (var proc = new Process())
+            {
+                proc.StartInfo.FileName = Exe;
+                proc.StartInfo.Arguments = ArgumentsSpecific(sourcePath, outPath);
+                proc.StartInfo.RedirectStandardError = true;
+                proc.ErrorDataReceived += (sender, e) => errWriter.WriteLine(e.Data);
+                proc.Start();
+                proc.BeginErrorReadLine();
+                proc.WaitForExit();
+                if (proc.ExitCode != 0)
+                {
+                    throw new InvalidOperationException(errMsg.ToString());
+                }
+            }
+        }
+
+        return outPath;
+    }
+
+    /// <summary>
+    /// create the temp dll file and compile source
+    /// <see cref="Compile(string, string)"/>.
+    /// </summary>
+    public string Compile(string sourcePath) => Compile(sourcePath, CodeGenUtil.GetTempFileName(Ext));
+
+    /// <summary>
+    /// select current pattern's exe.
+    /// </summary>
+    /// <exception cref="NotSupportedException">NotSupportedException.</exception>
+    private void PlatformSpecific()
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+        {
+            _exe = "gcc";
+            _ext = "so";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            _exe = "clang";
+            _ext = "dylib";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            _exe = "cmd";
+            _ext = "dll";
+        }
+
+        if (System.Environment.GetEnvironmentVariable("NNCASE_CPU_COMPILER") is string exe)
+        {
+            _exe = exe;
+        }
+    }
+
+    private void ArchSpecific()
+    {
+        _arch = RuntimeInformation.OSArchitecture switch
+        {
+            Architecture.X64 => RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "x86-64" : "x86_64",
+            Architecture.Arm64 => "arm64",
+            _ => throw new NotSupportedException(RuntimeInformation.OSArchitecture.ToString()),
+        };
+    }
+
+    private string ArgumentsSpecific(string sourcePath, string outPath)
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+        {
+            return $"{sourcePath} -nostdlib -static -no-pie -fPIC -march={Arch} -o {outPath}";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            return $"{sourcePath} -nostdlib -static -nopie -fPIC -arch {Arch} -o {outPath} -e__start";
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            var vsdir = Environment.GetEnvironmentVariable("VSAPPIDDIR") ?? throw new InvalidOperationException("Cannot find vs");
+            var vcvardir = Path.Combine(vsdir, "..\\..\\VC\\Auxiliary\\Build\\vcvarsall.bat");
+            return $"/C (\"{vcvardir}\" x64) && (cl /D_USRDLL /D_WINDLL \"{sourcePath}\" /MT /link /DLL /OUT:\"{outPath}\")";
+        }
+
+        throw new System.NotSupportedException("Only Support Linux/Osx/Windows");
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
index 456d23649d..d08db57507 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -15,137 +15,6 @@
 
 namespace Nncase.CodeGen;
 
-/// <summary>
-/// the csource code compiler.
-/// </summary>
-public class CSourceCompiler
-{
-    /// <summary>
-    /// compiler exe name.
-    /// </summary>
-    private string _exe = string.Empty;
-
-    /// <summary>
-    /// compiler exe name.
-    /// </summary>
-    private string _arch = string.Empty;
-
-    /// <summary>
-    /// compiler exe name.
-    /// </summary>
-    private string _ext = string.Empty;
-
-    public CSourceCompiler()
-    {
-        PlatformSpecific();
-        ArchSpecific();
-    }
-
-    protected string Exe
-    {
-        get => _exe;
-    }
-
-    protected string Arch
-    {
-        get => _arch;
-    }
-
-    protected string Ext
-    {
-        get => _ext;
-    }
-
-    /// <summary>
-    /// compile the source txt, write to the out_path.
-    /// </summary>
-    /// <param name="sourcePath"> c source code.</param>
-    /// <param name="outPath"> out .so path. </param>
-    /// <returns> outPath. </returns>
-    public string Compile(string sourcePath, string outPath)
-    {
-        var errMsg = new StringBuilder();
-        using (var errWriter = new StringWriter(errMsg))
-        {
-            using (var proc = new Process())
-            {
-                proc.StartInfo.FileName = Exe;
-                proc.StartInfo.Arguments = ArgumentsSpecific(sourcePath, outPath);
-                proc.StartInfo.RedirectStandardError = true;
-                proc.ErrorDataReceived += (sender, e) => errWriter.WriteLine(e.Data);
-                proc.Start();
-                proc.BeginErrorReadLine();
-                proc.WaitForExit();
-                if (proc.ExitCode != 0)
-                {
-                    throw new InvalidOperationException(errMsg.ToString());
-                }
-            }
-        }
-
-        return outPath;
-    }
-
-    /// <summary>
-    /// create the temp dll file and compile source
-    /// <see cref="Compile(string, string)"/>.
-    /// </summary>
-    public string Compile(string sourcePath) => Compile(sourcePath, CodeGenUtil.GetTempFileName(Ext));
-
-    /// <summary>
-    /// select current pattern's exe.
-    /// </summary>
-    /// <exception cref="NotSupportedException">NotSupportedException.</exception>
-    private void PlatformSpecific()
-    {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-        {
-            _exe = "gcc";
-            _ext = "so";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-        {
-            _exe = "clang";
-            _ext = "dylib";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-        {
-            _exe = "cmd";
-            _ext = "dll";
-        }
-    }
-
-    private void ArchSpecific()
-    {
-        _arch = RuntimeInformation.OSArchitecture switch
-        {
-            Architecture.X64 => RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "x86-64" : "x86_64",
-            Architecture.Arm64 => "arm64",
-            _ => throw new NotSupportedException(RuntimeInformation.OSArchitecture.ToString()),
-        };
-    }
-
-    private string ArgumentsSpecific(string sourcePath, string outPath)
-    {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-        {
-            return $"{sourcePath} -nostdlib -static -no-pie -fPIC -march={Arch} -o {outPath}";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-        {
-            return $"{sourcePath} -fPIC -shared -arch {Arch} -o {outPath}";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-        {
-            var vsdir = Environment.GetEnvironmentVariable("VSAPPIDDIR") ?? throw new InvalidOperationException("Cannot find vs");
-            var vcvardir = Path.Combine(vsdir, "..\\..\\VC\\Auxiliary\\Build\\vcvarsall.bat");
-            return $"/C (\"{vcvardir}\" x64) && (cl /D_USRDLL /D_WINDLL \"{sourcePath}\" /MT /link /DLL /OUT:\"{outPath}\")";
-        }
-
-        throw new System.NotSupportedException("Only Support Linux/Osx/Windows");
-    }
-}
-
 internal sealed class FunctionCSource
 {
     public FunctionCSource(string declaration, string implementation)
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index f668f441b4..ad46c59d0b 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -31,9 +31,6 @@ public LinkableModule(byte[] rdata, IReadOnlyList<LinkableFunction> functions, C
     public ILinkedModule Link(ILinkContext linkContext)
     {
         var csourcePath = LinkCSources();
-        var elfPath = CompileCSource(csourcePath);
-        var text = File.ReadAllBytes(elfPath);
-
         if (_options.DumpFlags.HasFlag(DumpFlags.CodeGen))
         {
             var dumpPath = _options.DumpDir;
@@ -51,6 +48,18 @@ public ILinkedModule Link(ILinkContext linkContext)
             }
         }
 
+        var elfPath = CompileCSource(csourcePath);
+        var text = File.ReadAllBytes(elfPath);
+
+        if (_options.DumpFlags.HasFlag(DumpFlags.CodeGen))
+        {
+            var dumpPath = _options.DumpDir;
+            using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.elf"), FileMode.Create))
+            {
+                fs.Write(text);
+            }
+        }
+
         var linkedFunctions = new List<LinkedFunction>();
         foreach (var func in _functions)
         {
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs b/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs
index f0cbd5a862..a6182d5c27 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs
@@ -24,7 +24,7 @@ public partial class LowerUnary : RewriteRule<Pattern>
     public override Pattern Pattern { get; } = IsUnary(
       target_name: "unary",
       _ => true,
-      IsWildcard("input"));
+      IsWildcard("input") with { TypePattern = IsFloat() });
 
     private Expr GetReplace(Unary unary, Expr input)
     {
diff --git a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
index 3f9c2bc9cc..5978d15620 100644
--- a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
@@ -41,7 +41,7 @@ public void RegisterTargetInDependentPass(IPassManager passManager, CompileOptio
     /// <inheritdoc/>
     public void RegisterTargetDependentPass(IPassManager passManager, CompileOptions options)
     {
-        passManager.AddWithName<EGraphRulesPass>("LowerIR").Configure(p =>
+        passManager.AddWithName<DataflowPass>("LowerIR").Configure(p =>
         {
             p.Add<LowerUnary>();
         });
diff --git a/modules/cpu/src/runtime/elfload.cpp b/modules/cpu/src/runtime/elfload.cpp
index cb712edba5..8a03d6c93c 100644
--- a/modules/cpu/src/runtime/elfload.cpp
+++ b/modules/cpu/src/runtime/elfload.cpp
@@ -140,8 +140,8 @@ el_status el_load(el_ctx *ctx, el_alloc_cb alloc) {
         if (!dest)
             return EL_ENOMEM;
 
-        printf("Loading seg fileoff %lx, vaddr %lx to %lx\n", ph.p_offset,
-               ph.p_vaddr, (uintptr_t)dest);
+        // printf("Loading seg fileoff %lx, vaddr %lx to %lx\n", ph.p_offset,
+              //  ph.p_vaddr, (uintptr_t)dest);
 
         /* read loaded portion */
         if ((rv = el_pread(ctx, dest, ph.p_filesz, ph.p_offset)))
@@ -225,7 +225,7 @@ el_status el_relocate(el_ctx *ctx) {
     }
 
     size_t relcnt = ri.tablesize / sizeof(Elf_Rel);
-    Elf_Rel *reltab = base + ri.tableoff;
+    Elf_Rel *reltab = (Elf_Rel *)(base + ri.tableoff);
     for (size_t i = 0; i < relcnt; i++) {
         if ((rv = el_applyrel(ctx, &reltab[i])))
             return rv;
diff --git a/modules/cpu/src/runtime/elfloader.h b/modules/cpu/src/runtime/elfloader.h
index 771a6b5f16..bdc0c5039e 100644
--- a/modules/cpu/src/runtime/elfloader.h
+++ b/modules/cpu/src/runtime/elfloader.h
@@ -18,7 +18,7 @@ typedef void (*entrypoint_t)(size_t id, buffer_t **buffers,
 
 class elfloader {
   public:
-    elfloader(char *elf) : elf_(elf) {
+    elfloader(char *elf) {
         ctx_.pread = bpread;
         ctx_.elf = elf;
     }
@@ -55,7 +55,6 @@ class elfloader {
   private:
     void *ptr_;
     void *buf_;
-    char *elf_;
     el_ctx ctx_;
 };
 
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index f786c92a20..61afac5746 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -121,8 +121,8 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
             "input " + std::to_string(i) + " is not a tensor");
         try_var(input_span, get_input_span(input_tensor));
         buffer_t *input_buffer =
-            new buffer_t(input_span.data(), 0, input_shapes_[i].data(),
-                         input_strides_[i].data(), input_ranks_[i]);
+            new buffer_t{input_span.data(), 0, input_shapes_[i].data(),
+                         input_strides_[i].data(), input_ranks_[i]};
         buffers[i] = input_buffer;
     }
 
@@ -133,8 +133,8 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
                 "output " + std::to_string(i) + " is not a tensor");
         try_var(output_span, get_output_span(output_tensor));
         buffer_t *output_buffer =
-            new buffer_t(output_span.data(), 0, output_shapes_[i].data(),
-                         output_strides_[i].data(), output_ranks_[i]);
+            new buffer_t{output_span.data(), 0, output_shapes_[i].data(),
+                         output_strides_[i].data(), output_ranks_[i]};
         buffers[input_ranks_.size() + i] = output_buffer;
     }
 

From 79e010a9b0f85ddcf83fd6e91efbc950a4f5ed09 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Tue, 25 Jul 2023 07:29:57 +0000
Subject: [PATCH 028/308] Apply code-format changes

---
 modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs | 2 +-
 modules/cpu/src/runtime/elfload.cpp                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
index 9d34d5763a..6ab53936fc 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
diff --git a/modules/cpu/src/runtime/elfload.cpp b/modules/cpu/src/runtime/elfload.cpp
index 8a03d6c93c..23e4b355e9 100644
--- a/modules/cpu/src/runtime/elfload.cpp
+++ b/modules/cpu/src/runtime/elfload.cpp
@@ -141,7 +141,7 @@ el_status el_load(el_ctx *ctx, el_alloc_cb alloc) {
             return EL_ENOMEM;
 
         // printf("Loading seg fileoff %lx, vaddr %lx to %lx\n", ph.p_offset,
-              //  ph.p_vaddr, (uintptr_t)dest);
+        //  ph.p_vaddr, (uintptr_t)dest);
 
         /* read loaded portion */
         if ((rv = el_pread(ctx, dest, ph.p_filesz, ph.p_offset)))

From ebe45fd4555762832b96f9b5d1956b01b272bade Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 25 Jul 2023 15:52:50 +0800
Subject: [PATCH 029/308] add bianry method table

---
 .../CodeGen/CSourceBuiltn.cs                  |  38 ++++++-
 modules/cpu/src/runtime/cpu_common.h          | 102 +++++++++++++++++-
 2 files changed, 138 insertions(+), 2 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index 13b55dbb34..269e8e5492 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -16,6 +16,7 @@ public static class CSourceBuiltn
 } buffer_t;";
 
     public const string MethodTable = @"typedef struct nncase_method_table {
+    // float unary
     float (*float_unary_abs)(float);
     float (*float_unary_acos)(float);
     float (*float_unary_acosh)(float);
@@ -37,9 +38,44 @@ public static class CSourceBuiltn
     float (*float_unary_sqrt)(float);
     float (*float_unary_square)(float);
     float (*float_unary_tanh)(float);
+    // float bianry
+    float (*float_binary_add)(float, float);
+    float (*float_binary_sub)(float, float);
+    float (*float_binary_mul)(float, float);
+    float (*float_binary_div)(float, float);
+    float (*float_binary_min)(float, float);
+    float (*float_binary_max)(float, float);
+    float (*float_binary_pow)(float, float);
+    float (*float_binary_logical_and)(float, float);
+    float (*float_binary_mod)(float, float);
+    // int32 bianry
+    int32_t (*int32_binary_add)(int32_t, int32_t);
+    int32_t (*int32_binary_sub)(int32_t, int32_t);
+    int32_t (*int32_binary_mul)(int32_t, int32_t);
+    int32_t (*int32_binary_div)(int32_t, int32_t);
+    int32_t (*int32_binary_min)(int32_t, int32_t);
+    int32_t (*int32_binary_max)(int32_t, int32_t);
+    int32_t (*int32_binary_pow)(int32_t, int32_t);
+    int32_t (*int32_binary_logical_and)(int32_t, int32_t);
+    int32_t (*int32_binary_mod)(int32_t, int32_t);
+    // int64 bianry
+    int64_t (*int64_binary_add)(int64_t, int64_t);
+    int64_t (*int64_binary_sub)(int64_t, int64_t);
+    int64_t (*int64_binary_mul)(int64_t, int64_t);
+    int64_t (*int64_binary_div)(int64_t, int64_t);
+    int64_t (*int64_binary_min)(int64_t, int64_t);
+    int64_t (*int64_binary_max)(int64_t, int64_t);
+    int64_t (*int64_binary_pow)(int64_t, int64_t);
+    int64_t (*int64_binary_logical_and)(int64_t, int64_t);
+    int64_t (*int64_binary_mod)(int64_t, int64_t);
+    // bool binary
+    bool (*bool_binary_and)(bool, bool);
+    bool (*bool_binary_or)(bool, bool);
+    bool (*bool_binary_xor)(bool, bool);
 } nncase_mt_t;";
 
-    public const string Include = @"#include <stdint.h>
+    public const string Include = @"#include <stdbool.h>
+#include <stdint.h>
 #include <stddef.h>
 ";
 
diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
index 72ace7cd89..047ea7ce31 100644
--- a/modules/cpu/src/runtime/cpu_common.h
+++ b/modules/cpu/src/runtime/cpu_common.h
@@ -2,12 +2,14 @@
 #include <functional>
 #include <math.h>
 #include <nncase/runtime/cpu/compiler_defs.h>
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
 typedef struct nncase_method_table {
+    // float unary
     float (*float_unary_abs)(float);
     float (*float_unary_acos)(float);
     float (*float_unary_acosh)(float);
@@ -29,6 +31,40 @@ typedef struct nncase_method_table {
     float (*float_unary_sqrt)(float);
     float (*float_unary_square)(float);
     float (*float_unary_tanh)(float);
+    // float bianry
+    float (*float_binary_add)(float, float);
+    float (*float_binary_sub)(float, float);
+    float (*float_binary_mul)(float, float);
+    float (*float_binary_div)(float, float);
+    float (*float_binary_min)(float, float);
+    float (*float_binary_max)(float, float);
+    float (*float_binary_pow)(float, float);
+    float (*float_binary_logical_and)(float, float);
+    float (*float_binary_mod)(float, float);
+    // int32 bianry
+    int32_t (*int32_binary_add)(int32_t, int32_t);
+    int32_t (*int32_binary_sub)(int32_t, int32_t);
+    int32_t (*int32_binary_mul)(int32_t, int32_t);
+    int32_t (*int32_binary_div)(int32_t, int32_t);
+    int32_t (*int32_binary_min)(int32_t, int32_t);
+    int32_t (*int32_binary_max)(int32_t, int32_t);
+    int32_t (*int32_binary_pow)(int32_t, int32_t);
+    int32_t (*int32_binary_logical_and)(int32_t, int32_t);
+    int32_t (*int32_binary_mod)(int32_t, int32_t);
+    // int64 bianry
+    int64_t (*int64_binary_add)(int64_t, int64_t);
+    int64_t (*int64_binary_sub)(int64_t, int64_t);
+    int64_t (*int64_binary_mul)(int64_t, int64_t);
+    int64_t (*int64_binary_div)(int64_t, int64_t);
+    int64_t (*int64_binary_min)(int64_t, int64_t);
+    int64_t (*int64_binary_max)(int64_t, int64_t);
+    int64_t (*int64_binary_pow)(int64_t, int64_t);
+    int64_t (*int64_binary_logical_and)(int64_t, int64_t);
+    int64_t (*int64_binary_mod)(int64_t, int64_t);
+    // bool binary
+    bool (*bool_binary_and)(bool, bool);
+    bool (*bool_binary_or)(bool, bool);
+    bool (*bool_binary_xor)(bool, bool);
 } nncase_mt_t;
 
 typedef struct buffer {
@@ -45,6 +81,40 @@ inline float float_unary_rsqrt(float x) { return 1.f / sqrtf(x); }
 inline float float_unary_sign(float x) { return (0.f < x) - (x < 0.f); }
 inline float float_unary_square(float x) { return x * x; }
 
+inline float float_binary_add(float x, float y) { return x + y; }
+inline float float_binary_sub(float x, float y) { return x - y; }
+inline float float_binary_mul(float x, float y) { return x * y; }
+inline float float_binary_div(float x, float y) { return x / y; }
+inline float float_binary_min(float x, float y) { return std::min(x, y); }
+inline float float_binary_max(float x, float y) { return std::max(x, y); }
+inline float float_binary_pow(float x, float y) { return powf(x, y); }
+inline float float_binary_logical_and(float x, float y) { return x && y; }
+inline float float_binary_mod(float x, float y) { return fmod(x, y); }
+
+inline int32_t int32_binary_add(int32_t x, int32_t y) { return x + y; }
+inline int32_t int32_binary_sub(int32_t x, int32_t y) { return x - y; }
+inline int32_t int32_binary_mul(int32_t x, int32_t y) { return x * y; }
+inline int32_t int32_binary_div(int32_t x, int32_t y) { return x / y; }
+inline int32_t int32_binary_min(int32_t x, int32_t y) { return std::min(x, y); }
+inline int32_t int32_binary_max(int32_t x, int32_t y) { return std::max(x, y); }
+inline int32_t int32_binary_pow(int32_t x, int32_t y) { return std::pow(x, y); }
+inline int32_t int32_binary_logical_and(int32_t x, int32_t y) { return x && y; }
+inline int32_t int32_binary_mod(int32_t x, int32_t y) { return x % y; }
+
+inline int64_t int64_binary_add(int64_t x, int64_t y) { return x + y; }
+inline int64_t int64_binary_sub(int64_t x, int64_t y) { return x - y; }
+inline int64_t int64_binary_mul(int64_t x, int64_t y) { return x * y; }
+inline int64_t int64_binary_div(int64_t x, int64_t y) { return x / y; }
+inline int64_t int64_binary_min(int64_t x, int64_t y) { return std::min(x, y); }
+inline int64_t int64_binary_max(int64_t x, int64_t y) { return std::max(x, y); }
+inline int64_t int64_binary_pow(int64_t x, int64_t y) { return std::pow(x, y); }
+inline int64_t int64_binary_logical_and(int64_t x, int64_t y) { return x && y; }
+inline int64_t int64_binary_mod(int64_t x, int64_t y) { return x % y; }
+
+inline bool bool_binary_logical_and(bool x, bool y) { return x && y; }
+inline bool bool_binary_logical_or(bool x, bool y) { return x || y; }
+inline bool bool_binary_logical_xor(bool x, bool y) { return x ^ y; }
+
 [[maybe_unused]] static nncase_mt_t nncase_mt = {
     .float_unary_abs = fabsf,
     .float_unary_acos = acosf,
@@ -66,6 +136,36 @@ inline float float_unary_square(float x) { return x * x; }
     .float_unary_sinh = sinhf,
     .float_unary_sqrt = sqrtf,
     .float_unary_square = float_unary_square,
-    .float_unary_tanh = tanhf};
+    .float_unary_tanh = tanhf,
+    .float_binary_add = float_binary_add,
+    .float_binary_sub = float_binary_sub,
+    .float_binary_mul = float_binary_mul,
+    .float_binary_div = float_binary_div,
+    .float_binary_min = float_binary_min,
+    .float_binary_max = float_binary_max,
+    .float_binary_pow = float_binary_pow,
+    .float_binary_logical_and = float_binary_logical_and,
+    .float_binary_mod = float_binary_mod,
+    .int32_binary_add = int32_binary_add,
+    .int32_binary_sub = int32_binary_sub,
+    .int32_binary_mul = int32_binary_mul,
+    .int32_binary_div = int32_binary_div,
+    .int32_binary_min = int32_binary_min,
+    .int32_binary_max = int32_binary_max,
+    .int32_binary_pow = int32_binary_pow,
+    .int32_binary_logical_and = int32_binary_logical_and,
+    .int32_binary_mod = int32_binary_mod,
+    .int64_binary_add = int64_binary_add,
+    .int64_binary_sub = int64_binary_sub,
+    .int64_binary_mul = int64_binary_mul,
+    .int64_binary_div = int64_binary_div,
+    .int64_binary_min = int64_binary_min,
+    .int64_binary_max = int64_binary_max,
+    .int64_binary_pow = int64_binary_pow,
+    .int64_binary_logical_and = int64_binary_logical_and,
+    .int64_binary_mod = int64_binary_mod,
+    .bool_binary_and = bool_binary_logical_and,
+    .bool_binary_or = bool_binary_logical_or,
+    .bool_binary_xor = bool_binary_logical_xor};
 
 END_NS_NNCASE_RT_MODULE
\ No newline at end of file

From 8b7b8ca3b03f02bd2a896c3ef42efd28ca8874a9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 25 Jul 2023 16:41:20 +0800
Subject: [PATCH 030/308] change make fusion

---
 .../Passes/Rules/LowerMatMul.cs               | 34 ++++++++++++++++++
 .../Passes/Rules/MakeFusion.cs                | 35 ++++++++++---------
 .../Nncase.Modules.CPU/Targets/CPUTarget.cs   |  1 +
 3 files changed, 54 insertions(+), 16 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs b/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs
new file mode 100644
index 0000000000..81b0c5a3c3
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs
@@ -0,0 +1,34 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.Math;
+using Nncase.PatternMatch;
+
+using static Nncase.IR.F.CPU;
+using static Nncase.IR.TypePatternUtility;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.Utility;
+
+namespace Nncase.Passes.Rules;
+
+[RuleGenerator]
+public partial class LowerMatMul : RewriteRule<Pattern>
+{
+    /// <inheritdoc/>
+    public override Pattern Pattern { get; } = IsMatMul(
+      target_name: "matmul",
+      _ => true,
+      IsWildcard("inputA") with { TypePattern = IsFloat() },
+      IsWildcard("inputB") with { TypePattern = IsFloat() });
+
+    private Expr GetReplace(MatMul matmul, Expr inputA, Expr inputB)
+    {
+        return CPUKernel(matmul, inputA, inputB);
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
index d7644bf2b5..29d10bd7ad 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
@@ -18,26 +18,29 @@
 namespace Nncase.Passes.Rules;
 
 [RuleGenerator]
-internal partial class CPUSingleInputFusion<T> : FusionMaker
-    where T : Op
+internal sealed partial class CPUFusion : FusionMaker
 {
     public override string ModuleKind { get; } = CPUTarget.Kind;
 
-    public override Pattern Pattern { get; } = IsCallWildcard(
-            "call",
-            IsOp<T>("op"),
-            IsWildcard("input"));
+    public override Pattern Pattern => IsCallWildcard("call", IsOp<CPUKernelOp>("op"));
 
-    private Call? GetReplace(Call call, IReadOnlyList<Expr> callParams, Op op, Expr input)
+    private Call? GetReplace(Call call, CPUKernelOp op, IReadOnlyList<Expr> callParams)
     {
-        var newInput = new Var(input.CheckedType!);
-        var newCall = ReplaceCallParams(op, callParams, (input, newInput));
-        var fusion = new Call(new Fusion(FullName, ModuleKind, newCall, new[] { newInput }), input);
-        return fusion;
-    }
-}
+        var newInputs = new List<Expr>();
+        for (int i = 0; i < callParams.Count; i++)
+        {
+            if (callParams[i] is (Call or Var))
+            {
+                newInputs.Add(new Var(callParams[i].CheckedType!));
+            }
+            else
+            {
+                newInputs.Add(callParams[i]);
+            }
+        }
 
-internal sealed class CPUFusion : CPUSingleInputFusion<CPUKernelOp>
-{
-    public override string Name => nameof(CPUFusion);
+        var newCall = new Call(op, newInputs.ToArray());
+        var callFusion = new Call(new Fusion(FullName, ModuleKind, newCall, newInputs.OfType<Var>().ToArray()), newInputs.Select((e, i) => (e, i)).Where(p => p.e is Var).Select(p => callParams[p.i]).ToArray());
+        return callFusion;
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
index 5978d15620..01cf36f618 100644
--- a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
@@ -44,6 +44,7 @@ public void RegisterTargetDependentPass(IPassManager passManager, CompileOptions
         passManager.AddWithName<DataflowPass>("LowerIR").Configure(p =>
         {
             p.Add<LowerUnary>();
+            p.Add<LowerMatMul>();
         });
     }
 

From a251e59287eaff78f969d41cea6d9f1fc889a5dc Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Tue, 25 Jul 2023 08:44:21 +0000
Subject: [PATCH 031/308] Apply code-format changes

---
 modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs | 2 +-
 modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs b/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs
index 81b0c5a3c3..d23b542ff9 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
index 29d10bd7ad..d372d36037 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
@@ -29,7 +29,7 @@ internal sealed partial class CPUFusion : FusionMaker
         var newInputs = new List<Expr>();
         for (int i = 0; i < callParams.Count; i++)
         {
-            if (callParams[i] is (Call or Var))
+            if (callParams[i] is Call or Var)
             {
                 newInputs.Add(new Var(callParams[i].CheckedType!));
             }

From e6894e3faf05a46a0e4c0047f600496c58c2ae33 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 25 Jul 2023 16:45:45 +0800
Subject: [PATCH 032/308] add cpu binary lower

---
 .../Passes/Rules/LowerBinary.cs               | 40 +++++++++++++++++++
 .../Nncase.Modules.CPU/Targets/CPUTarget.cs   |  1 +
 2 files changed, 41 insertions(+)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/LowerBinary.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/LowerBinary.cs b/modules/Nncase.Modules.CPU/Passes/Rules/LowerBinary.cs
new file mode 100644
index 0000000000..ef1c431f99
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/LowerBinary.cs
@@ -0,0 +1,40 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.Math;
+using Nncase.PatternMatch;
+
+using static Nncase.IR.F.CPU;
+using static Nncase.IR.TypePatternUtility;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.Utility;
+
+namespace Nncase.Passes.Rules;
+
+[RuleGenerator]
+public partial class LowerBinary : RewriteRule<Pattern>
+{
+    /// <inheritdoc/>
+    public override Pattern Pattern { get; } = IsBinary(
+      target_name: "binary",
+      _ => true,
+      IsWildcard("lhs") with { TypePattern = IsFloat() },
+	  IsWildcard("rhs") with { TypePattern = IsFloat() }
+	  );
+
+    private Expr? GetReplace(Binary binary, Expr lhs, Expr rhs)
+    {
+		if (lhs.CheckedShape.Rank != rhs.CheckedShape.Rank)
+		{
+            return null;
+        }
+		
+        return CPUKernel(binary, lhs, rhs);
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
index 01cf36f618..1b3504f305 100644
--- a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
@@ -43,6 +43,7 @@ public void RegisterTargetDependentPass(IPassManager passManager, CompileOptions
     {
         passManager.AddWithName<DataflowPass>("LowerIR").Configure(p =>
         {
+            p.Add<LowerBinary>();
             p.Add<LowerUnary>();
             p.Add<LowerMatMul>();
         });

From 1ce70232c830871a8119fa5bd0bcc1f02da1f24f Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Tue, 25 Jul 2023 08:48:38 +0000
Subject: [PATCH 033/308] Apply code-format changes

---
 modules/Nncase.Modules.CPU/Passes/Rules/LowerBinary.cs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/LowerBinary.cs b/modules/Nncase.Modules.CPU/Passes/Rules/LowerBinary.cs
index ef1c431f99..ffef820490 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/LowerBinary.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/LowerBinary.cs
@@ -25,16 +25,15 @@ public partial class LowerBinary : RewriteRule<Pattern>
       target_name: "binary",
       _ => true,
       IsWildcard("lhs") with { TypePattern = IsFloat() },
-	  IsWildcard("rhs") with { TypePattern = IsFloat() }
-	  );
+      IsWildcard("rhs") with { TypePattern = IsFloat() });
 
     private Expr? GetReplace(Binary binary, Expr lhs, Expr rhs)
     {
-		if (lhs.CheckedShape.Rank != rhs.CheckedShape.Rank)
-		{
+        if (lhs.CheckedShape.Rank != rhs.CheckedShape.Rank)
+        {
             return null;
         }
-		
+
         return CPUKernel(binary, lhs, rhs);
     }
 }

From bf162feadf0fb02c461a19cc7410c4927f56d4b4 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 25 Jul 2023 16:51:57 +0800
Subject: [PATCH 034/308] draft binary to tir

---
 .../Passes/Tile/SingleCPUFusionConverter.cs   | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 1e54700651..c7818713ec 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -68,6 +68,9 @@ protected override Unit VisitLeafCall(Call expr)
                 case Unary unary:
                     GenerateUnary(unary, arguments, ret);
                     break;
+                case Binary binary:
+                    GenerateBinary(binary, arguments, ret, expr);
+                    break;                    
                 default:
                     throw new NotSupportedException();
             }
@@ -86,6 +89,30 @@ private void GenerateUnary(Unary unary, ReadOnlySpan<Buffer> arguments, Buffer r
             _mainBody.Add(T.Block(nameof(Unary)).Body(final).Build());
         }
 
+        private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffer ret, Call call)
+        {
+            var lhs = call[Binary.Lhs];
+            var rhs = call[Binary.Rhs];
+            var lhsBuffer = arguments[Binary.Lhs.Index];
+            var rhsBuffer = arguments[Binary.Rhs.Index];
+
+            var outShape = call.CheckedShape.ToValueArray();
+            var lhsShape = Enumerable.Repeat(1, outShape.Length).ToArray();
+            Array.Copy(lhs.CheckedShape.ToValueArray(), 0, lhsShape, lhsShape.Length - lhs.CheckedShape.Rank, lhs.CheckedShape.Rank);
+            var rhsShape = Enumerable.Repeat(1, outShape.Length).ToArray();
+            Array.Copy(rhs.CheckedShape.ToValueArray(), 0, rhsShape, rhsShape.Length - rhs.CheckedShape.Rank, rhs.CheckedShape.Rank);
+
+            var lhsScale = outShape.Zip(lhsShape).Select(s => s.First / s.Second).ToArray();
+            var rhsScale = outShape.Zip(rhsShape).Select(s => s.First / s.Second).ToArray();
+
+            var loops = Enumerable.Range(0, outShape.Length).Select(i => (T.ForLoop(out var loopVar, (0, outShape[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
+            var input_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * loops[i].loopVar));
+            var output_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + (ret.Strides[i] * loops[i].loopVar));
+            Expr stmt = T.Store(ret, output_index, IR.F.Math.Unary(unary.UnaryOp, T.Load(input, output_index)));
+            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
+            _mainBody.Add(T.Block(nameof(Unary)).Body(final).Build());
+        }
+
         private TIR.Buffer TryAllocateBuffer(Expr expr)
         {
             var name = $"buffer_{_buffersMap.Keys.Count}";

From 58af7d5f4b9f04632ef46087c9ed98d244f574b5 Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Tue, 25 Jul 2023 08:54:57 +0000
Subject: [PATCH 035/308] Apply code-format changes

---
 .../Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index c7818713ec..4c3aa9045e 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -70,7 +70,7 @@ protected override Unit VisitLeafCall(Call expr)
                     break;
                 case Binary binary:
                     GenerateBinary(binary, arguments, ret, expr);
-                    break;                    
+                    break;
                 default:
                     throw new NotSupportedException();
             }

From 852c7ac5d698f9fdae08b840259018d78c6332de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 25 Jul 2023 19:13:00 +0800
Subject: [PATCH 036/308] remove buffer load/store

---
 src/Nncase.Core/IR/Buffers/BufferLoad.cs      | 22 ++++++++
 src/Nncase.Core/IR/Buffers/BufferStore.cs     | 24 +++++++++
 src/Nncase.Core/IR/ExprCloner.g.cs            | 19 -------
 src/Nncase.Core/IR/ExprFunctor.g.cs           | 24 ---------
 src/Nncase.Core/IR/ExprRewriter.g.cs          | 38 -------------
 src/Nncase.Core/IR/ExprVisitor.g.cs           | 54 -------------------
 src/Nncase.Core/TIR/BufferLoad.cs             | 40 --------------
 src/Nncase.Core/TIR/BufferStore.cs            | 47 ----------------
 src/Nncase.Core/TIR/Script.cs                 | 16 ++++++
 .../Diagnostics/ScriptPrintVisitor.cs         | 28 ----------
 src/Nncase.Evaluator/Buffer.cs                |  9 ----
 src/Nncase.Evaluator/Buffers/BufferLoad.cs    | 41 ++++++++++++++
 src/Nncase.Evaluator/Buffers/BufferStore.cs   | 47 ++++++++++++++++
 src/Nncase.Evaluator/TIR/Store.cs             |  2 -
 src/Nncase.Evaluator/TypeInferenceVisitor.cs  | 48 -----------------
 15 files changed, 150 insertions(+), 309 deletions(-)
 create mode 100644 src/Nncase.Core/IR/Buffers/BufferLoad.cs
 create mode 100644 src/Nncase.Core/IR/Buffers/BufferStore.cs
 delete mode 100644 src/Nncase.Core/TIR/BufferLoad.cs
 delete mode 100644 src/Nncase.Core/TIR/BufferStore.cs
 delete mode 100644 src/Nncase.Evaluator/Buffer.cs
 create mode 100644 src/Nncase.Evaluator/Buffers/BufferLoad.cs
 create mode 100644 src/Nncase.Evaluator/Buffers/BufferStore.cs

diff --git a/src/Nncase.Core/IR/Buffers/BufferLoad.cs b/src/Nncase.Core/IR/Buffers/BufferLoad.cs
new file mode 100644
index 0000000000..4885197c3f
--- /dev/null
+++ b/src/Nncase.Core/IR/Buffers/BufferLoad.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR.Tensors;
+using Nncase.PatternMatch;
+using static Nncase.IR.TypePatternUtility;
+
+namespace Nncase.IR.Buffers;
+
+/// <summary>
+/// BufferIndexOf expression.
+/// </summary>
+[PatternFunctionalGenerator]
+public sealed partial class BufferLoad : Op
+{
+    /// <summary>
+    /// Get the input parameter.
+    /// </summary>
+    public static readonly ParameterInfo Input = new(typeof(BufferLoad), 0, "input", IsTensor());
+    
+    public static readonly ParameterInfo Indices = new(typeof(BufferLoad), 1, "indices", IsTuple());
+}
diff --git a/src/Nncase.Core/IR/Buffers/BufferStore.cs b/src/Nncase.Core/IR/Buffers/BufferStore.cs
new file mode 100644
index 0000000000..04f57d594b
--- /dev/null
+++ b/src/Nncase.Core/IR/Buffers/BufferStore.cs
@@ -0,0 +1,24 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR.Tensors;
+using Nncase.PatternMatch;
+using static Nncase.IR.TypePatternUtility;
+
+namespace Nncase.IR.Buffers;
+
+/// <summary>
+/// BufferIndexOf expression.
+/// </summary>
+[PatternFunctionalGenerator]
+public sealed partial class BufferStore : Op
+{
+    /// <summary>
+    /// Get the input parameter.
+    /// </summary>
+    public static readonly ParameterInfo Input = new(typeof(BufferStore), 0, "input", IsTensor());
+
+    public static readonly ParameterInfo Indices = new(typeof(BufferStore), 1, "indices", IsTuple());
+
+    public static readonly ParameterInfo Value = new(typeof(BufferStore), 2, "value", IsTensor());
+}
diff --git a/src/Nncase.Core/IR/ExprCloner.g.cs b/src/Nncase.Core/IR/ExprCloner.g.cs
index 78d5d2bda4..7357f7f78b 100644
--- a/src/Nncase.Core/IR/ExprCloner.g.cs
+++ b/src/Nncase.Core/IR/ExprCloner.g.cs
@@ -157,15 +157,6 @@ protected override Expr VisitLeafPhysicalBuffer(TIR.PhysicalBuffer expr, TContex
         );
     }
 
-    /// <inheritdoc />
-    protected override Expr VisitLeafBufferLoad(TIR.BufferLoad expr, TContext context)
-    {
-        return expr.With(
-            buffer: Clone(expr.Buffer, context),
-            indices: CloneArray(expr.Indices, context)
-        );
-    }
-
     /// <inheritdoc />
     protected override Expr VisitLeafBufferRegion(TIR.BufferRegion expr, TContext context)
     {
@@ -175,16 +166,6 @@ protected override Expr VisitLeafBufferRegion(TIR.BufferRegion expr, TContext co
         );
     }
 
-    /// <inheritdoc />
-    protected override Expr VisitLeafBufferStore(TIR.BufferStore expr, TContext context)
-    {
-        return expr.With(
-            buffer: Clone(expr.Buffer, context),
-            indices: CloneArray(expr.Indices, context),
-            value: Clone(expr.Value, context)
-        );
-    }
-
     /// <inheritdoc />
     protected override Expr VisitLeafFor(TIR.For expr, TContext context)
     {
diff --git a/src/Nncase.Core/IR/ExprFunctor.g.cs b/src/Nncase.Core/IR/ExprFunctor.g.cs
index 57e1ef86d5..f6ff8fd928 100644
--- a/src/Nncase.Core/IR/ExprFunctor.g.cs
+++ b/src/Nncase.Core/IR/ExprFunctor.g.cs
@@ -104,21 +104,11 @@ public partial class ExprFunctor<TExprResult, TTypeResult, TContext>
     /// </summary>
     internal protected virtual TExprResult VisitPhysicalBuffer(TIR.PhysicalBuffer expr, TContext context) => VisitBuffer(expr, context);
 
-    /// <summary>
-    /// Visit <see cref="TIR.BufferLoad"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitBufferLoad(TIR.BufferLoad expr, TContext context) => DefaultVisit(expr, context);
-
     /// <summary>
     /// Visit <see cref="TIR.BufferRegion"/>.
     /// </summary>
     internal protected virtual TExprResult VisitBufferRegion(TIR.BufferRegion expr, TContext context) => DefaultVisit(expr, context);
 
-    /// <summary>
-    /// Visit <see cref="TIR.BufferStore"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitBufferStore(TIR.BufferStore expr, TContext context) => DefaultVisit(expr, context);
-
     /// <summary>
     /// Visit <see cref="TIR.For"/>.
     /// </summary>
@@ -289,13 +279,6 @@ public partial class ExprFunctor<TExprResult, TTypeResult>
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitPhysicalBuffer(TIR.PhysicalBuffer expr, Unit context) => VisitPhysicalBuffer(expr);
     /// <summary>
-    /// Visit <see cref="TIR.BufferLoad"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitBufferLoad(TIR.BufferLoad expr) => base.VisitBufferLoad(expr, default);
-    
-    /// <inheritdoc/>
-    internal protected sealed override TExprResult VisitBufferLoad(TIR.BufferLoad expr, Unit context) => VisitBufferLoad(expr);
-    /// <summary>
     /// Visit <see cref="TIR.BufferRegion"/>.
     /// </summary>
     internal protected virtual TExprResult VisitBufferRegion(TIR.BufferRegion expr) => base.VisitBufferRegion(expr, default);
@@ -303,13 +286,6 @@ public partial class ExprFunctor<TExprResult, TTypeResult>
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitBufferRegion(TIR.BufferRegion expr, Unit context) => VisitBufferRegion(expr);
     /// <summary>
-    /// Visit <see cref="TIR.BufferStore"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitBufferStore(TIR.BufferStore expr) => base.VisitBufferStore(expr, default);
-    
-    /// <inheritdoc/>
-    internal protected sealed override TExprResult VisitBufferStore(TIR.BufferStore expr, Unit context) => VisitBufferStore(expr);
-    /// <summary>
     /// Visit <see cref="TIR.For"/>.
     /// </summary>
     internal protected virtual TExprResult VisitFor(TIR.For expr) => base.VisitFor(expr, default);
diff --git a/src/Nncase.Core/IR/ExprRewriter.g.cs b/src/Nncase.Core/IR/ExprRewriter.g.cs
index 2f0b6c1233..6695315197 100644
--- a/src/Nncase.Core/IR/ExprRewriter.g.cs
+++ b/src/Nncase.Core/IR/ExprRewriter.g.cs
@@ -122,24 +122,12 @@ protected sealed override Expr VisitLeafPhysicalBuffer(TIR.PhysicalBuffer expr,
         return RewriteLeafPhysicalBuffer(expr, context);
     }
 
-    /// <inheritdoc/>
-    protected sealed override Expr VisitLeafBufferLoad(TIR.BufferLoad expr, TContext context)
-    {
-        return RewriteLeafBufferLoad(expr, context);
-    }
-
     /// <inheritdoc/>
     protected sealed override Expr VisitLeafBufferRegion(TIR.BufferRegion expr, TContext context)
     {
         return RewriteLeafBufferRegion(expr, context);
     }
 
-    /// <inheritdoc/>
-    protected sealed override Expr VisitLeafBufferStore(TIR.BufferStore expr, TContext context)
-    {
-        return RewriteLeafBufferStore(expr, context);
-    }
-
     /// <inheritdoc/>
     protected sealed override Expr VisitLeafFor(TIR.For expr, TContext context)
     {
@@ -272,21 +260,11 @@ protected sealed override Expr VisitLeafIterVar(TIR.IterVar expr, TContext conte
     /// </summary>
     protected virtual Expr RewriteLeafPhysicalBuffer(TIR.PhysicalBuffer expr, TContext context) => RewriteLeafBuffer(expr, context);
 
-    /// <summary>
-    /// Rewrite leaf <see cref="TIR.BufferLoad"/>.
-    /// </summary>
-    protected virtual Expr RewriteLeafBufferLoad(TIR.BufferLoad expr, TContext context) => DefaultRewriteLeaf(expr, context);
-
     /// <summary>
     /// Rewrite leaf <see cref="TIR.BufferRegion"/>.
     /// </summary>
     protected virtual Expr RewriteLeafBufferRegion(TIR.BufferRegion expr, TContext context) => DefaultRewriteLeaf(expr, context);
 
-    /// <summary>
-    /// Rewrite leaf <see cref="TIR.BufferStore"/>.
-    /// </summary>
-    protected virtual Expr RewriteLeafBufferStore(TIR.BufferStore expr, TContext context) => DefaultRewriteLeaf(expr, context);
-
     /// <summary>
     /// Rewrite leaf <see cref="TIR.For"/>.
     /// </summary>
@@ -474,14 +452,6 @@ public partial class ExprRewriter
     /// <inheritdoc />
     protected sealed override Expr RewriteLeafPhysicalBuffer(TIR.PhysicalBuffer expr, Unit context) => RewriteLeafPhysicalBuffer(expr);
 
-    /// <summary>
-    /// Rewrite leaf <see cref="TIR.BufferLoad"/>.
-    /// </summary>
-    protected virtual Expr RewriteLeafBufferLoad(TIR.BufferLoad expr) => DefaultRewriteLeaf(expr);
-
-    /// <inheritdoc />
-    protected sealed override Expr RewriteLeafBufferLoad(TIR.BufferLoad expr, Unit context) => RewriteLeafBufferLoad(expr);
-
     /// <summary>
     /// Rewrite leaf <see cref="TIR.BufferRegion"/>.
     /// </summary>
@@ -490,14 +460,6 @@ public partial class ExprRewriter
     /// <inheritdoc />
     protected sealed override Expr RewriteLeafBufferRegion(TIR.BufferRegion expr, Unit context) => RewriteLeafBufferRegion(expr);
 
-    /// <summary>
-    /// Rewrite leaf <see cref="TIR.BufferStore"/>.
-    /// </summary>
-    protected virtual Expr RewriteLeafBufferStore(TIR.BufferStore expr) => DefaultRewriteLeaf(expr);
-
-    /// <inheritdoc />
-    protected sealed override Expr RewriteLeafBufferStore(TIR.BufferStore expr, Unit context) => RewriteLeafBufferStore(expr);
-
     /// <summary>
     /// Rewrite leaf <see cref="TIR.For"/>.
     /// </summary>
diff --git a/src/Nncase.Core/IR/ExprVisitor.g.cs b/src/Nncase.Core/IR/ExprVisitor.g.cs
index 5e5a609a6a..c56e4f5aa7 100644
--- a/src/Nncase.Core/IR/ExprVisitor.g.cs
+++ b/src/Nncase.Core/IR/ExprVisitor.g.cs
@@ -131,13 +131,6 @@ protected internal override TExprResult VisitPhysicalBuffer(TIR.PhysicalBuffer e
         return VisitLeafPhysicalBuffer(expr, context);
     }
 
-    /// <inheritdoc />
-    protected internal override TExprResult VisitBufferLoad(TIR.BufferLoad expr, TContext context)
-    {
-        VisitOperands(expr, context);
-        return VisitLeafBufferLoad(expr, context);
-    }
-
     /// <inheritdoc />
     protected internal override TExprResult VisitBufferRegion(TIR.BufferRegion expr, TContext context)
     {
@@ -145,13 +138,6 @@ protected internal override TExprResult VisitBufferRegion(TIR.BufferRegion expr,
         return VisitLeafBufferRegion(expr, context);
     }
 
-    /// <inheritdoc />
-    protected internal override TExprResult VisitBufferStore(TIR.BufferStore expr, TContext context)
-    {
-        VisitOperands(expr, context);
-        return VisitLeafBufferStore(expr, context);
-    }
-
     /// <inheritdoc />
     protected internal override TExprResult VisitFor(TIR.For expr, TContext context)
     {
@@ -302,21 +288,11 @@ protected internal override TExprResult VisitMemSpan(TIR.MemSpan expr, TContext
     /// </summary>
     protected virtual TExprResult VisitLeafPhysicalBuffer(TIR.PhysicalBuffer expr, TContext context) => VisitLeafBuffer(expr, context);
 
-    /// <summary>
-    /// Visit leaf <see cref="TIR.BufferLoad"/>.
-    /// </summary>
-    protected virtual TExprResult VisitLeafBufferLoad(TIR.BufferLoad expr, TContext context) => DefaultVisitLeaf(expr, context);
-
     /// <summary>
     /// Visit leaf <see cref="TIR.BufferRegion"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafBufferRegion(TIR.BufferRegion expr, TContext context) => DefaultVisitLeaf(expr, context);
 
-    /// <summary>
-    /// Visit leaf <see cref="TIR.BufferStore"/>.
-    /// </summary>
-    protected virtual TExprResult VisitLeafBufferStore(TIR.BufferStore expr, TContext context) => DefaultVisitLeaf(expr, context);
-
     /// <summary>
     /// Visit leaf <see cref="TIR.For"/>.
     /// </summary>
@@ -467,13 +443,6 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitPhysicalBuffer(TIR.PhysicalBuffer expr, Unit context) => VisitPhysicalBuffer(expr);
     /// <summary>
-    /// Visit <see cref="TIR.BufferLoad"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitBufferLoad(TIR.BufferLoad expr) => base.VisitBufferLoad(expr, default);
-
-    /// <inheritdoc/>
-    internal protected sealed override TExprResult VisitBufferLoad(TIR.BufferLoad expr, Unit context) => VisitBufferLoad(expr);
-    /// <summary>
     /// Visit <see cref="TIR.BufferRegion"/>.
     /// </summary>
     internal protected virtual TExprResult VisitBufferRegion(TIR.BufferRegion expr) => base.VisitBufferRegion(expr, default);
@@ -481,13 +450,6 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitBufferRegion(TIR.BufferRegion expr, Unit context) => VisitBufferRegion(expr);
     /// <summary>
-    /// Visit <see cref="TIR.BufferStore"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitBufferStore(TIR.BufferStore expr) => base.VisitBufferStore(expr, default);
-
-    /// <inheritdoc/>
-    internal protected sealed override TExprResult VisitBufferStore(TIR.BufferStore expr, Unit context) => VisitBufferStore(expr);
-    /// <summary>
     /// Visit <see cref="TIR.For"/>.
     /// </summary>
     internal protected virtual TExprResult VisitFor(TIR.For expr) => base.VisitFor(expr, default);
@@ -688,14 +650,6 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafPhysicalBuffer(TIR.PhysicalBuffer expr, Unit context) => VisitLeafPhysicalBuffer(expr);
 
-    /// <summary>
-    /// Visit leaf <see cref="TIR.BufferLoad"/>.
-    /// </summary>
-    protected virtual TExprResult VisitLeafBufferLoad(TIR.BufferLoad expr) => base.VisitLeafBufferLoad(expr, default);
-
-    /// <inheritdoc/>
-    protected sealed override TExprResult VisitLeafBufferLoad(TIR.BufferLoad expr, Unit context) => VisitLeafBufferLoad(expr);
-
     /// <summary>
     /// Visit leaf <see cref="TIR.BufferRegion"/>.
     /// </summary>
@@ -704,14 +658,6 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafBufferRegion(TIR.BufferRegion expr, Unit context) => VisitLeafBufferRegion(expr);
 
-    /// <summary>
-    /// Visit leaf <see cref="TIR.BufferStore"/>.
-    /// </summary>
-    protected virtual TExprResult VisitLeafBufferStore(TIR.BufferStore expr) => base.VisitLeafBufferStore(expr, default);
-
-    /// <inheritdoc/>
-    protected sealed override TExprResult VisitLeafBufferStore(TIR.BufferStore expr, Unit context) => VisitLeafBufferStore(expr);
-
     /// <summary>
     /// Visit leaf <see cref="TIR.For"/>.
     /// </summary>
diff --git a/src/Nncase.Core/TIR/BufferLoad.cs b/src/Nncase.Core/TIR/BufferLoad.cs
deleted file mode 100644
index 86081624dd..0000000000
--- a/src/Nncase.Core/TIR/BufferLoad.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-using Nncase.Utilities;
-
-namespace Nncase.TIR;
-
-/// <summary>
-/// Buffer load node.
-/// </summary>
-public sealed class BufferLoad : Expr
-{
-    public BufferLoad(PhysicalBuffer buffer, ReadOnlySpan<Expr> indices)
-        : base(ArrayUtility.Concat(buffer, indices))
-    {
-    }
-
-    /// <summary>
-    /// Gets the buffer to be loaded.
-    /// </summary>
-    public PhysicalBuffer Buffer => (PhysicalBuffer)Operands[0];
-
-    /// <summary>
-    /// Gets the buffer indices.
-    /// </summary>
-    public ReadOnlySpan<Expr> Indices => Operands.Slice(1);
-
-    /// <inheritdoc/>
-    public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context)
-        => functor.VisitBufferLoad(this, context);
-
-    public BufferLoad With(PhysicalBuffer? buffer = null, Expr[]? indices = null)
-        => new BufferLoad(buffer ?? Buffer, indices ?? Indices);
-}
diff --git a/src/Nncase.Core/TIR/BufferStore.cs b/src/Nncase.Core/TIR/BufferStore.cs
deleted file mode 100644
index 56d6a9df4d..0000000000
--- a/src/Nncase.Core/TIR/BufferStore.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-
-namespace Nncase.TIR;
-
-/// <summary>
-/// Buffer store node.
-/// </summary>
-public sealed class BufferStore : Expr
-{
-    private readonly int _indicesCount;
-
-    public BufferStore(PhysicalBuffer buffer, ReadOnlySpan<Expr> indices, Expr value)
-        : base(new Expr[] { buffer }.Concat(indices.ToArray()).Append(value).ToArray())
-    {
-        _indicesCount = indices.Length;
-    }
-
-    /// <summary>
-    /// Gets the buffer.
-    /// </summary>
-    public PhysicalBuffer Buffer => (PhysicalBuffer)Operands[0];
-
-    /// <summary>
-    /// Gets the value we to be stored.
-    /// </summary>
-    public ReadOnlySpan<Expr> Indices => Operands[1.._indicesCount];
-
-    /// <summary>
-    /// Gets the indices location to be stored.
-    /// </summary>
-    public Expr Value => Operands[_indicesCount + 1];
-
-    /// <inheritdoc/>
-    public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context)
-        => functor.VisitBufferStore(this, context);
-
-    public BufferStore With(PhysicalBuffer? buffer = null, Expr[]? indices = null, Expr? value = null)
-        => new BufferStore(buffer ?? Buffer, indices ?? Indices, value ?? Value);
-}
diff --git a/src/Nncase.Core/TIR/Script.cs b/src/Nncase.Core/TIR/Script.cs
index 8f640a0419..fd89d8661a 100644
--- a/src/Nncase.Core/TIR/Script.cs
+++ b/src/Nncase.Core/TIR/Script.cs
@@ -313,4 +313,20 @@ public static Call Emit<T>(out T value, Func<T> creator)
         value = creator();
         return Nop();
     }
+
+    /// <summary>
+    /// buffer load.
+    /// </summary>
+    /// <param name="buffer"> buffer. </param>
+    /// <param name="indices"> indices. </param>
+    /// <returns> call bufferload. </returns>
+    public static Call BufferLoad(TIR.Buffer buffer, params Expr[] indices) => new Call(new IR.Buffers.BufferLoad(), buffer, new IR.Tuple(indices));
+
+    /// <summary>
+    /// buffer store.
+    /// </summary>
+    /// <param name="buffer">buffer.</param>
+    /// <param name="indicesAndValue">indices and value.</param>
+    /// <returns>buffer store.</returns>
+    public static Call BufferStore(TIR.Buffer buffer, params Expr[] indicesAndValue) => new Call(new IR.Buffers.BufferLoad(), buffer, new IR.Tuple(indicesAndValue[..^1]), indicesAndValue[^1]);
 }
diff --git a/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs b/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
index 21047b326d..9dae59bd85 100644
--- a/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
@@ -481,34 +481,6 @@ protected override IPrintSymbol VisitBlock(Block expr)
         return doc;
     }
 
-    /// <inheritdoc/>
-    protected override IPrintSymbol VisitBufferLoad(BufferLoad expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var doc))
-        {
-            return doc;
-        }
-
-        _scope.Push();
-        _scope.Append($"{expr.Buffer.Name}[{string.Join(", ", expr.Indices.ToArray().Select(Visit))}]");
-        doc = new(_scope.Pop());
-        return doc;
-    }
-
-    /// <inheritdoc/>
-    protected override IPrintSymbol VisitBufferStore(BufferStore expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var doc))
-        {
-            return doc;
-        }
-
-        _scope.Push();
-        _scope.Append($"{expr.Buffer.Name}[{string.Join(", ", expr.Indices.ToArray().Select(Visit))}] = {Visit(expr.Value)}");
-        doc = new(_scope.Pop());
-        return doc;
-    }
-
     /// <inheritdoc/>
     protected override IPrintSymbol VisitIterVar(IterVar expr)
     {
diff --git a/src/Nncase.Evaluator/Buffer.cs b/src/Nncase.Evaluator/Buffer.cs
deleted file mode 100644
index 079cdaecce..0000000000
--- a/src/Nncase.Evaluator/Buffer.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-namespace Nncase.Evaluator.TIR
-{
-    public class Buffer
-    {
-    }
-}
diff --git a/src/Nncase.Evaluator/Buffers/BufferLoad.cs b/src/Nncase.Evaluator/Buffers/BufferLoad.cs
new file mode 100644
index 0000000000..0069028c32
--- /dev/null
+++ b/src/Nncase.Evaluator/Buffers/BufferLoad.cs
@@ -0,0 +1,41 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.Buffers;
+
+namespace Nncase.Evaluator.Buffers;
+
+/// <summary>
+/// Evaluator for BufferOf.
+/// </summary>
+[TypeInferGenerator]
+public partial class BufferLoadEvaluator : ITypeInferencer<BufferLoad>, IOpPrinter<BufferLoad>
+{
+    public string Visit(IIRPrinterContext context, BufferLoad target, bool iLmode)
+    {
+        if (iLmode)
+        {
+            throw new System.NotSupportedException();
+        }
+        return $"{context.GetArgument(target, BufferLoad.Input)}[{context.GetArgument(target, BufferLoad.Indices)}]";
+    }
+
+    private IRType Visit(TensorType input, TupleType indices)
+    {
+        if (indices.Count != input.Shape.Rank)
+        {
+            return new InvalidType($"the input buffer rank {input.Shape.Rank} != indices.Count {indices.Count}");
+        }
+
+        foreach (var item in indices)
+        {
+            if (item is not TensorType { IsScalar: true, DType: var dtype } || dtype != DataTypes.Int32)
+            {
+                return new InvalidType("indices is not int32 type!");
+            }
+        }
+
+        return TensorType.Scalar(input.DType);
+    }
+}
diff --git a/src/Nncase.Evaluator/Buffers/BufferStore.cs b/src/Nncase.Evaluator/Buffers/BufferStore.cs
new file mode 100644
index 0000000000..2d0020486b
--- /dev/null
+++ b/src/Nncase.Evaluator/Buffers/BufferStore.cs
@@ -0,0 +1,47 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.Buffers;
+
+namespace Nncase.Evaluator.Buffers;
+
+/// <summary>
+/// Evaluator for BufferOf.
+/// </summary>
+[TypeInferGenerator]
+public partial class BufferStoreEvaluator : ITypeInferencer<BufferStore>, IOpPrinter<BufferStore>
+{
+    public string Visit(IIRPrinterContext context, BufferStore target, bool iLmode)
+    {
+        if (iLmode)
+        {
+            throw new System.NotSupportedException();
+        }
+
+        return $"{context.GetArgument(target, BufferStore.Input)}[{context.GetArgument(target, BufferStore.Indices)}] = {context.GetArgument(target, BufferStore.Value)}";
+    }
+
+    private IRType Visit(TensorType input, TupleType indices, TensorType value)
+    {
+        if (indices.Count != input.Shape.Rank)
+        {
+            return new InvalidType($"the input buffer rank {input.Shape.Rank} != indices.Count {indices.Count}");
+        }
+
+        foreach (var item in indices)
+        {
+            if (item is not TensorType { IsScalar: true, DType: var dtype } || dtype != DataTypes.Int32)
+            {
+                return new InvalidType("indices is not int32 type!");
+            }
+        }
+
+        if (!value.IsScalar || input.DType != value.DType)
+        {
+            return new InvalidType("value can't store!");
+        }
+
+        return TupleType.Void;
+    }
+}
diff --git a/src/Nncase.Evaluator/TIR/Store.cs b/src/Nncase.Evaluator/TIR/Store.cs
index e0b6d5bcc7..9a1d6d6cda 100644
--- a/src/Nncase.Evaluator/TIR/Store.cs
+++ b/src/Nncase.Evaluator/TIR/Store.cs
@@ -27,8 +27,6 @@ public string Visit(IIRPrinterContext context, Store target, bool iLmode)
         _ = context.GetArgument(target, Store.Value);
         var index = context.GetArgument(target, Store.Index);
         return $"{handle}[{index}] = {index}";
-
-        throw new System.NotImplementedException();
     }
 
     private IRType Visit(Store target, TensorType handle, TensorType index, TensorType value)
diff --git a/src/Nncase.Evaluator/TypeInferenceVisitor.cs b/src/Nncase.Evaluator/TypeInferenceVisitor.cs
index 208d085058..c0f9f28f55 100644
--- a/src/Nncase.Evaluator/TypeInferenceVisitor.cs
+++ b/src/Nncase.Evaluator/TypeInferenceVisitor.cs
@@ -52,28 +52,6 @@ protected override IRType VisitLeafBlock(Block expr)
         return TupleType.Void;
     }
 
-    /// <inheritdoc/>
-    protected override IRType VisitLeafBufferLoad(BufferLoad expr)
-    {
-        IRType type;
-        VerifySubField(expr, expr.Buffer, TypePatternUtility.IsPointer());
-        for (int i = 0; i < expr.Indices.Length; i++)
-        {
-            VerifySubField(expr, expr.Indices[i], TypePatternUtility.IsIntegralScalar(), $"BufferLoad.Indices[{i}]");
-        }
-
-        if (expr.Buffer.CheckedType is TensorType { IsScalar: true, DType: PointerType { ElemType: PrimType pointedType } })
-        {
-            type = TensorType.Scalar(pointedType);
-        }
-        else
-        {
-            type = new InvalidType($"Can't load from {expr.Buffer.CheckedType}");
-        }
-
-        return type;
-    }
-
     /// <inheritdoc/>
     protected override IRType VisitLeafBufferRegion(BufferRegion expr)
     {
@@ -90,32 +68,6 @@ protected override IRType VisitLeafBufferRegion(BufferRegion expr)
         return type;
     }
 
-    /// <inheritdoc/>
-    protected override IRType VisitLeafBufferStore(BufferStore expr)
-    {
-        VerifySubField(expr, expr.Buffer, TypePatternUtility.IsPointer());
-        for (int i = 0; i < expr.Indices.Length; i++)
-        {
-            VerifySubField(expr, expr.Indices[i], TypePatternUtility.IsIntegralScalar(), $"BufferStore.Indices[{i}]");
-        }
-
-        VerifySubField(expr, expr.Value, TypePatternUtility.IsScalar());
-
-        IRType type;
-        if (expr.Value.CheckedType is TensorType { IsScalar: true, DType: PrimType valueType } &&
-            expr.Buffer.CheckedType is TensorType { IsScalar: true, DType: PointerType { ElemType: PrimType pointedType } }
-            && valueType == pointedType)
-        {
-            type = TupleType.Void;
-        }
-        else
-        {
-            type = new InvalidType($"Can't store {expr.Value.CheckedType} to {expr.Buffer.CheckedType}");
-        }
-
-        return type;
-    }
-
     /// <inheritdoc/>
     protected override IRType VisitLeafCall(Call expr)
     {

From 8dbe2279f0bbf9235bb990d665ecea739572f1f5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 25 Jul 2023 19:53:17 +0800
Subject: [PATCH 037/308] update tiling

---
 .../Passes/Tile/SingleCPUFusionConverter.cs   | 12 ++---
 .../Nncase.Modules.CPU/Targets/CPUTarget.cs   |  2 +
 src/Nncase.Core/IR/Buffers/BufferLoad.cs      | 10 +++-
 src/Nncase.Core/IR/Buffers/BufferStore.cs     | 13 ++++-
 .../Passes/Mutators/FlattenBuffer.cs          | 35 ++++++------
 .../Passes/Mutators/FoldMathCall.cs           | 30 -----------
 src/Nncase.Core/Passes/Mutators/Mutator.cs    |  6 ---
 .../SubstituteVarAndCollectOpaqueBlock.cs     | 54 -------------------
 src/Nncase.Core/TIR/Scheduler.cs              | 19 +++----
 src/Nncase.Core/TIR/Script.cs                 |  7 +--
 src/Nncase.Evaluator/Buffers/BufferLoad.cs    |  1 +
 src/Nncase.Evaluator/Buffers/BufferModule.cs  |  2 +
 src/Nncase.Tests/Core/UnitTestMutator.cs      |  2 -
 13 files changed, 61 insertions(+), 132 deletions(-)
 delete mode 100644 src/Nncase.Core/Passes/Mutators/FoldMathCall.cs
 delete mode 100644 src/Nncase.Core/Passes/Mutators/SubstituteVarAndCollectOpaqueBlock.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 4c3aa9045e..5301794aaf 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -82,9 +82,8 @@ private void GenerateUnary(Unary unary, ReadOnlySpan<Buffer> arguments, Buffer r
         {
             var input = arguments[Unary.Input.Index];
             var loops = Enumerable.Range(0, input.Rank).Select(i => (T.ForLoop(out var loopVar, (0, input.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
-            var input_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * loops[i].loopVar));
-            var output_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + (ret.Strides[i] * loops[i].loopVar));
-            Expr stmt = T.Store(ret, output_index, IR.F.Math.Unary(unary.UnaryOp, T.Load(input, output_index)));
+            var loopVars = loops.Select(f => f.loopVar).ToArray();
+            Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Unary(unary.UnaryOp, T.BufferLoad(input, loopVars)));
             var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
             _mainBody.Add(T.Block(nameof(Unary)).Body(final).Build());
         }
@@ -106,11 +105,8 @@ private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffe
             var rhsScale = outShape.Zip(rhsShape).Select(s => s.First / s.Second).ToArray();
 
             var loops = Enumerable.Range(0, outShape.Length).Select(i => (T.ForLoop(out var loopVar, (0, outShape[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
-            var input_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * loops[i].loopVar));
-            var output_index = Enumerable.Range(0, input.Rank).Aggregate((Expr)0, (acc, i) => acc + (ret.Strides[i] * loops[i].loopVar));
-            Expr stmt = T.Store(ret, output_index, IR.F.Math.Unary(unary.UnaryOp, T.Load(input, output_index)));
-            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-            _mainBody.Add(T.Block(nameof(Unary)).Body(final).Build());
+            // var ?final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
+            // _mainBody.Add(T.Block(nameof(Unary)).Body(final).Build());
         }
 
         private TIR.Buffer TryAllocateBuffer(Expr expr)
diff --git a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
index 1b3504f305..b3fe833906 100644
--- a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
@@ -87,7 +87,9 @@ public void RegisterTargetDependentAfterQuantPass(IPassManager passManager, Comp
         passManager.Add<PrimFuncPass>().Configure(p =>
         {
             p.Add<Passes.Mutators.UnFoldBlock>();
+            p.Add<Passes.Mutators.FlattenBuffer>();
             p.Add<Passes.Mutators.FlattenSequential>();
+            p.Add<Passes.Mutators.FoldConstCall>();
         });
     }
 
diff --git a/src/Nncase.Core/IR/Buffers/BufferLoad.cs b/src/Nncase.Core/IR/Buffers/BufferLoad.cs
index 4885197c3f..882282a073 100644
--- a/src/Nncase.Core/IR/Buffers/BufferLoad.cs
+++ b/src/Nncase.Core/IR/Buffers/BufferLoad.cs
@@ -8,7 +8,7 @@
 namespace Nncase.IR.Buffers;
 
 /// <summary>
-/// BufferIndexOf expression.
+/// BufferLoad expression.
 /// </summary>
 [PatternFunctionalGenerator]
 public sealed partial class BufferLoad : Op
@@ -17,6 +17,12 @@ public sealed partial class BufferLoad : Op
     /// Get the input parameter.
     /// </summary>
     public static readonly ParameterInfo Input = new(typeof(BufferLoad), 0, "input", IsTensor());
-    
+
+    /// <summary>
+    /// Get the indices.
+    /// </summary>
     public static readonly ParameterInfo Indices = new(typeof(BufferLoad), 1, "indices", IsTuple());
+
+    /// <inheritdoc/>
+    public override bool CanFoldConstCall => false;
 }
diff --git a/src/Nncase.Core/IR/Buffers/BufferStore.cs b/src/Nncase.Core/IR/Buffers/BufferStore.cs
index 04f57d594b..b8402d10e3 100644
--- a/src/Nncase.Core/IR/Buffers/BufferStore.cs
+++ b/src/Nncase.Core/IR/Buffers/BufferStore.cs
@@ -8,7 +8,7 @@
 namespace Nncase.IR.Buffers;
 
 /// <summary>
-/// BufferIndexOf expression.
+/// BufferStore op.
 /// </summary>
 [PatternFunctionalGenerator]
 public sealed partial class BufferStore : Op
@@ -18,7 +18,16 @@ public sealed partial class BufferStore : Op
     /// </summary>
     public static readonly ParameterInfo Input = new(typeof(BufferStore), 0, "input", IsTensor());
 
+    /// <summary>
+    /// Get the indices parameter.
+    /// </summary>
     public static readonly ParameterInfo Indices = new(typeof(BufferStore), 1, "indices", IsTuple());
 
-    public static readonly ParameterInfo Value = new(typeof(BufferStore), 2, "value", IsTensor());
+    /// <summary>
+    /// Get the value parameter.
+    /// </summary>
+    public static readonly ParameterInfo Value = new(typeof(BufferStore), 2, "value", IsScalar());
+
+    /// <inheritdoc/>
+    public override bool CanFoldConstCall => false;
 }
diff --git a/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs b/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
index a0431cdd68..a941477030 100644
--- a/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
+++ b/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
@@ -12,35 +12,38 @@
 namespace Nncase.Passes.Mutators;
 
 /// <summary>
-/// Flatten the multi-dimensional BufferLoad and BufferStore to single dimensional Load/Store. Also remove Block to ensure that the flattened TIR can not be scheduled again.
+/// Flatten the multi-dimensional BufferLoad and BufferStore to single dimensional Load/Store.
 /// </summary>
 public sealed class FlattenBuffer : ExprRewriter
 {
     /// <inheritdoc/>
     protected override Expr RewriteLeafBlock(Block expr)
     {
-        if (!expr.IterVars.IsEmpty)
+        // TODO: put the unfold block into this.
+        if (expr.Predicate is TensorConst tc && tc.Value.ToScalar<bool>() == true)
         {
-            throw new InvalidOperationException("Non-opaque blocks are not allowed in FlattenBuffer. Please call pass ConvertBlocksToOpaque before.");
+            return expr.Body;
         }
 
-        // 1. Visit the body
-        var predicate = expr.Predicate;
-        if (predicate is TensorConst { Value: { Length: 1 } t }
-            && t.ToScalar<bool>())
+        return T.Nop();
+    }
+
+    /// <inheritdoc/>
+    protected override Expr RewriteLeafCall(Call expr)
+    {
+        if (expr.Target is IR.Buffers.BufferLoad)
         {
-            return expr.Body;
+            var indices = (IR.Tuple)expr[IR.Buffers.BufferLoad.Indices];
+            var input = (TIR.Buffer)expr[IR.Buffers.BufferLoad.Input];
+            return T.Load(input, Enumerable.Range(0, indices.Count).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * indices[i])));
         }
-        else
+        else if (expr.Target is IR.Buffers.BufferStore)
         {
-            return new IfThenElse(predicate, expr.Body);
+            var indices = (IR.Tuple)expr[IR.Buffers.BufferStore.Indices];
+            var input = (TIR.Buffer)expr[IR.Buffers.BufferStore.Input];
+            return T.Store(input, Enumerable.Range(0, indices.Count).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * indices[i])), expr[IR.Buffers.BufferStore.Value]);
         }
 
-        // Step 3. Handle allocations in reverse order
-        // TODO add the alloc buffers.
-        // for (size_t i = new_block->alloc_buffers.size(); i > 0; --i) {
-        //   const Buffer& buffer = new_block->alloc_buffers[i - 1];
-        //   body = MakeAllocStmt(buffer, std::move(body));
-        // }
+        return expr;
     }
 }
diff --git a/src/Nncase.Core/Passes/Mutators/FoldMathCall.cs b/src/Nncase.Core/Passes/Mutators/FoldMathCall.cs
deleted file mode 100644
index af25604454..0000000000
--- a/src/Nncase.Core/Passes/Mutators/FoldMathCall.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.Reactive;
-using NetFabric.Hyperlinq;
-using Nncase.Evaluator;
-using Nncase.IR;
-using Nncase.Passes;
-
-namespace Nncase.Passes.Mutators;
-
-/// <summary>
-/// fold math calc operator.
-/// </summary>
-public sealed class FoldMathCall : ExprRewriter
-{
-    /// <inheritdoc/>
-    protected override Expr RewriteLeafCall(Call expr)
-    {
-        if (expr.Target is Op op && op.GetType().Namespace is string @namespace
-          && @namespace.StartsWith("Nncase.IR.Math"))
-        {
-            return expr.Arguments.AsValueEnumerable().All(x => x is Const)
-                ? Const.FromValue(CompilerServices.Evaluate(expr))
-                : expr;
-        }
-
-        return expr;
-    }
-}
diff --git a/src/Nncase.Core/Passes/Mutators/Mutator.cs b/src/Nncase.Core/Passes/Mutators/Mutator.cs
index 1392ff7726..1f2587d5d0 100644
--- a/src/Nncase.Core/Passes/Mutators/Mutator.cs
+++ b/src/Nncase.Core/Passes/Mutators/Mutator.cs
@@ -50,10 +50,4 @@ public static class Mutator
     /// </summary>
     /// <returns>RemoveNop.</returns>
     public static Func<ExprRewriter> RemoveNop() => () => new Mutators.RemoveNop();
-
-    /// <summary>
-    /// fold math calc operator.
-    /// </summary>
-    /// <returns>FoldMathCall.</returns>
-    public static Func<ExprRewriter> FoldMathCall() => () => new Mutators.FoldMathCall();
 }
diff --git a/src/Nncase.Core/Passes/Mutators/SubstituteVarAndCollectOpaqueBlock.cs b/src/Nncase.Core/Passes/Mutators/SubstituteVarAndCollectOpaqueBlock.cs
deleted file mode 100644
index da6daf3ed2..0000000000
--- a/src/Nncase.Core/Passes/Mutators/SubstituteVarAndCollectOpaqueBlock.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reactive;
-using Nncase.IR;
-using Nncase.TIR;
-
-namespace Nncase.Passes.Mutators;
-
-/// <summary>
-/// Substitute vars and collect the reuse mapping of opaque blocks.
-/// </summary>
-public sealed class SubstituteVarAndCollectOpaqueBlock : ExprRewriter
-{
-    private readonly Func<Var, Expr?> _varMapper;
-    private readonly Dictionary<Block, Block> _opaqueBlocks;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="SubstituteVarAndCollectOpaqueBlock"/> class.
-    /// <see cref="SubstituteVarAndCollectOpaqueBlock"/>.
-    /// </summary>
-    public SubstituteVarAndCollectOpaqueBlock(
-        Func<Var, Expr?> varMaper,
-        Dictionary<Block, Block> opaque_blocks)
-    {
-        _varMapper = varMaper;
-        _opaqueBlocks = opaque_blocks;
-    }
-
-    /// <inheritdoc/>
-    protected override Expr RewriteLeafVar(Var expr)
-    {
-        if (_varMapper(expr) is Expr replace)
-        {
-            return replace;
-        }
-
-        return expr;
-    }
-
-    protected override Expr RewriteLeafBlock(Block expr)
-    {
-        var replace = (Block)base.RewriteLeafBlock(expr);
-        if (replace.IterVars.IsEmpty)
-        {
-            _opaqueBlocks.Add(expr, replace);
-        }
-
-        return replace;
-    }
-}
diff --git a/src/Nncase.Core/TIR/Scheduler.cs b/src/Nncase.Core/TIR/Scheduler.cs
index 214bd983f6..eb660d3dac 100644
--- a/src/Nncase.Core/TIR/Scheduler.cs
+++ b/src/Nncase.Core/TIR/Scheduler.cs
@@ -101,16 +101,17 @@ public For[] Split(For loop, params Expr[] factors)
 
         // Step 3. create new for loop.
         var nFor = new For[factors.Length];
-        nbody = (Sequential)new Passes.Mutators.SubstituteVarAndCollectOpaqueBlock(v => v == loop.LoopVar ? substitute : v, opaque_block_reuse).Rewrite(nbody);
-        for (int i = factors.Length - 1; i >= 0; i--)
-        {
-            var @for = new For(newloopVars[i], (0, factors[i]), LoopMode.Serial, nbody);
-            nbody = T.Sequential(@for);
-            nFor[i] = @for;
-        }
 
-        // Setp 4. update the function
-        Entry = (Function)new Passes.Mutators.Substitutor(expr => object.ReferenceEquals(expr, loop) ? nFor[0] : null).Rewrite(Entry);
+        // nbody = (Sequential)new Passes.Mutators.SubstituteVarAndCollectOpaqueBlock(v => v == loop.LoopVar ? substitute : v, opaque_block_reuse).Rewrite(nbody);
+        // for (int i = factors.Length - 1; i >= 0; i--)
+        // {
+        //     var @for = new For(newloopVars[i], (0, factors[i]), LoopMode.Serial, nbody);
+        //     nbody = T.Sequential(@for);
+        //     nFor[i] = @for;
+        // }
+
+        // // Setp 4. update the function
+        // Entry = (Function)new Passes.Mutators.Substitutor(expr => object.ReferenceEquals(expr, loop) ? nFor[0] : null).Rewrite(Entry);
         return nFor;
     }
 
diff --git a/src/Nncase.Core/TIR/Script.cs b/src/Nncase.Core/TIR/Script.cs
index fd89d8661a..c9f4a77f72 100644
--- a/src/Nncase.Core/TIR/Script.cs
+++ b/src/Nncase.Core/TIR/Script.cs
@@ -326,7 +326,8 @@ public static Call Emit<T>(out T value, Func<T> creator)
     /// buffer store.
     /// </summary>
     /// <param name="buffer">buffer.</param>
-    /// <param name="indicesAndValue">indices and value.</param>
-    /// <returns>buffer store.</returns>
-    public static Call BufferStore(TIR.Buffer buffer, params Expr[] indicesAndValue) => new Call(new IR.Buffers.BufferLoad(), buffer, new IR.Tuple(indicesAndValue[..^1]), indicesAndValue[^1]);
+    /// <param name="indices">indices.</param>
+    /// <param name="value">value.</param>
+    /// <returns> call bufferstore.</returns>
+    public static Call BufferStore(TIR.Buffer buffer, Expr[] indices, Expr value) => new Call(new IR.Buffers.BufferStore(), buffer, new IR.Tuple(indices), value);
 }
diff --git a/src/Nncase.Evaluator/Buffers/BufferLoad.cs b/src/Nncase.Evaluator/Buffers/BufferLoad.cs
index 0069028c32..210227c555 100644
--- a/src/Nncase.Evaluator/Buffers/BufferLoad.cs
+++ b/src/Nncase.Evaluator/Buffers/BufferLoad.cs
@@ -18,6 +18,7 @@ public string Visit(IIRPrinterContext context, BufferLoad target, bool iLmode)
         {
             throw new System.NotSupportedException();
         }
+
         return $"{context.GetArgument(target, BufferLoad.Input)}[{context.GetArgument(target, BufferLoad.Indices)}]";
     }
 
diff --git a/src/Nncase.Evaluator/Buffers/BufferModule.cs b/src/Nncase.Evaluator/Buffers/BufferModule.cs
index 4547718379..0954206679 100644
--- a/src/Nncase.Evaluator/Buffers/BufferModule.cs
+++ b/src/Nncase.Evaluator/Buffers/BufferModule.cs
@@ -20,5 +20,7 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<StrideOfEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<AllocateEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<UninitializedEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<BufferLoadEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<BufferStoreEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/src/Nncase.Tests/Core/UnitTestMutator.cs b/src/Nncase.Tests/Core/UnitTestMutator.cs
index b08f089911..b8c7d7d587 100644
--- a/src/Nncase.Tests/Core/UnitTestMutator.cs
+++ b/src/Nncase.Tests/Core/UnitTestMutator.cs
@@ -29,7 +29,5 @@ public void TestMutator()
         var removeNop = Mutator.RemoveNop().Invoke();
         Assert.Equal(new Passes.Mutators.RemoveNop().IsMutated, removeNop.IsMutated);
 
-        var foldMathCall = Mutator.FoldMathCall().Invoke();
-        Assert.Equal(new Passes.Mutators.FoldMathCall().IsMutated, foldMathCall.IsMutated);
     }
 }

From f664e3685264981bc2f720164dcd4f439cf8c103 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Tue, 25 Jul 2023 11:56:00 +0000
Subject: [PATCH 038/308] Apply code-format changes

---
 .../Passes/Tile/SingleCPUFusionConverter.cs            |  1 +
 src/Nncase.Core/IR/Buffers/BufferLoad.cs               |  2 +-
 src/Nncase.Core/IR/Buffers/BufferStore.cs              |  2 +-
 src/Nncase.Core/TIR/Scheduler.cs                       | 10 +++++++---
 src/Nncase.Evaluator/Buffers/BufferLoad.cs             |  2 +-
 src/Nncase.Evaluator/Buffers/BufferStore.cs            |  2 +-
 src/Nncase.Tests/Core/UnitTestMutator.cs               |  1 -
 7 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 5301794aaf..aa7c827ded 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -105,6 +105,7 @@ private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffe
             var rhsScale = outShape.Zip(rhsShape).Select(s => s.First / s.Second).ToArray();
 
             var loops = Enumerable.Range(0, outShape.Length).Select(i => (T.ForLoop(out var loopVar, (0, outShape[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
+
             // var ?final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
             // _mainBody.Add(T.Block(nameof(Unary)).Body(final).Build());
         }
diff --git a/src/Nncase.Core/IR/Buffers/BufferLoad.cs b/src/Nncase.Core/IR/Buffers/BufferLoad.cs
index 882282a073..dbf3427b6e 100644
--- a/src/Nncase.Core/IR/Buffers/BufferLoad.cs
+++ b/src/Nncase.Core/IR/Buffers/BufferLoad.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR.Tensors;
diff --git a/src/Nncase.Core/IR/Buffers/BufferStore.cs b/src/Nncase.Core/IR/Buffers/BufferStore.cs
index b8402d10e3..2d8e86cad8 100644
--- a/src/Nncase.Core/IR/Buffers/BufferStore.cs
+++ b/src/Nncase.Core/IR/Buffers/BufferStore.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR.Tensors;
diff --git a/src/Nncase.Core/TIR/Scheduler.cs b/src/Nncase.Core/TIR/Scheduler.cs
index eb660d3dac..30e9552c04 100644
--- a/src/Nncase.Core/TIR/Scheduler.cs
+++ b/src/Nncase.Core/TIR/Scheduler.cs
@@ -87,7 +87,10 @@ public For[] Split(For loop, params Expr[] factors)
         } // TODO add assert total == (loop.Dom.Max - loop.Dom.Min)
 
         // Step 2. Replace all occurrences of the original loop var with new variables
-        Expr total = 1, substitute = 0;
+        _ = 1;
+
+        // Step 2. Replace all occurrences of the original loop var with new variables
+        Expr substitute = 0;
         var newloopVars = new Var[factors.Length];
         foreach (var i in Enumerable.Range(0, factors.Length))
         {
@@ -96,8 +99,9 @@ public For[] Split(For loop, params Expr[] factors)
             newloopVars[i] = loopVar;
         }
 
-        Dictionary<Block, Block> opaque_block_reuse = new(); // TODO the opaque_block_reuse for what?
-        Sequential nbody = loop.Body;
+        _ = new
+        Dictionary<Block, Block>(); // TODO the opaque_block_reuse for what?
+        _ = loop.Body;
 
         // Step 3. create new for loop.
         var nFor = new For[factors.Length];
diff --git a/src/Nncase.Evaluator/Buffers/BufferLoad.cs b/src/Nncase.Evaluator/Buffers/BufferLoad.cs
index 210227c555..78bab2e920 100644
--- a/src/Nncase.Evaluator/Buffers/BufferLoad.cs
+++ b/src/Nncase.Evaluator/Buffers/BufferLoad.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
diff --git a/src/Nncase.Evaluator/Buffers/BufferStore.cs b/src/Nncase.Evaluator/Buffers/BufferStore.cs
index 2d0020486b..81a833f79e 100644
--- a/src/Nncase.Evaluator/Buffers/BufferStore.cs
+++ b/src/Nncase.Evaluator/Buffers/BufferStore.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
diff --git a/src/Nncase.Tests/Core/UnitTestMutator.cs b/src/Nncase.Tests/Core/UnitTestMutator.cs
index b8c7d7d587..83d99fbb60 100644
--- a/src/Nncase.Tests/Core/UnitTestMutator.cs
+++ b/src/Nncase.Tests/Core/UnitTestMutator.cs
@@ -28,6 +28,5 @@ public void TestMutator()
 
         var removeNop = Mutator.RemoveNop().Invoke();
         Assert.Equal(new Passes.Mutators.RemoveNop().IsMutated, removeNop.IsMutated);
-
     }
 }

From 240d195f063eb5ca6445d7f43ac201df934e2100 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 25 Jul 2023 20:05:48 +0800
Subject: [PATCH 039/308] add matmul cpu kernel

---
 .../Passes/Tile/SingleCPUFusionConverter.cs   | 22 +++++++++++++++++++
 .../Targets/UnitTestCPUTargetTiling.cs        | 22 +++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index aa7c827ded..e1bd589c40 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -71,6 +71,9 @@ protected override Unit VisitLeafCall(Call expr)
                 case Binary binary:
                     GenerateBinary(binary, arguments, ret, expr);
                     break;
+                case MatMul matmul:
+                    GenerateMatMul(arguments, ret, expr);
+                    break;
                 default:
                     throw new NotSupportedException();
             }
@@ -78,6 +81,25 @@ protected override Unit VisitLeafCall(Call expr)
             return default;
         }
 
+        private void GenerateMatMul(Buffer[] arguments, Buffer ret, Call expr)
+        {
+            var lhs = arguments[0];
+            var rhs = arguments[1];
+
+            // [m,k] @ [k, n]
+            var body = T.Block(nameof(MatMul)).Body(
+                T.Serial(out var m, (0, lhs.Dimensions[0])).Body(
+                    T.Serial(out var n, (0, rhs.Dimensions[1])).Body(
+                        T.Serial(out var k, (0, lhs.Dimensions[1])).Body(
+                            T.BufferStore(ret, new[] { m, n }, T.BufferLoad(ret, m, n) + (T.BufferLoad(lhs, m, k) * T.BufferLoad(rhs, k, n)))
+                        )
+                    )
+                )
+            );
+
+            _mainBody.Add(body.Build());
+        }
+
         private void GenerateUnary(Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
             var input = arguments[Unary.Input.Index];
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 7156572dbf..47a62e510b 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -53,4 +53,26 @@ public async Task TestCpuUnary()
             fs.Write(IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 1, 2, 3, 4, 5 }).Evaluate().AsTensor().BytesBuffer);
         }
     }
+
+    [Fact]
+    public async Task TestCpuMatMul()
+    {
+        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, new[] { 3, 4 }));
+        var rhs = new Var("rhs", new TensorType(DataTypes.Float32, new[] { 4, 6 }));
+        var main = new Function("main", IR.F.Tensors.MatMul(lhs, rhs), new[] { lhs, rhs });
+        var module = new IR.IRModule(main);
+
+        var compiler = CompileSession.Compiler;
+        compiler.ImportIRModule(module);
+        await compiler.CompileAsync();
+        using (var fs = Dumpper.OpenFile("test.kmodel"))
+        {
+            compiler.Gencode(fs);
+        }
+
+        using (var fs = Dumpper.OpenFile("input_0.bin"))
+        {
+            fs.Write(IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 1, 2, 3, 4, 5 }).Evaluate().AsTensor().BytesBuffer);
+        }
+    }
 }

From 55cb1054c1b025d1a978368db98f71a74e174fff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 25 Jul 2023 20:06:55 +0800
Subject: [PATCH 040/308] fix warning

---
 .../Passes/Tile/SingleCPUFusionConverter.cs                 | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index e1bd589c40..7263c6a55f 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -91,11 +91,7 @@ private void GenerateMatMul(Buffer[] arguments, Buffer ret, Call expr)
                 T.Serial(out var m, (0, lhs.Dimensions[0])).Body(
                     T.Serial(out var n, (0, rhs.Dimensions[1])).Body(
                         T.Serial(out var k, (0, lhs.Dimensions[1])).Body(
-                            T.BufferStore(ret, new[] { m, n }, T.BufferLoad(ret, m, n) + (T.BufferLoad(lhs, m, k) * T.BufferLoad(rhs, k, n)))
-                        )
-                    )
-                )
-            );
+                            T.BufferStore(ret, new[] { m, n }, T.BufferLoad(ret, m, n) + (T.BufferLoad(lhs, m, k) * T.BufferLoad(rhs, k, n)))))));
 
             _mainBody.Add(body.Build());
         }

From a71ad51a7428e02600a29fc8e4f9c5d3a42b5360 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Wed, 26 Jul 2023 13:30:50 +0800
Subject: [PATCH 041/308] update matmul tiling

---
 .../Passes/Rules/LowerMatMul.cs                  |  9 +++++++--
 .../Passes/Rules/MakeFusion.cs                   |  2 +-
 .../Passes/Tile/SingleCPUFusionConverter.cs      | 16 ++++++++++------
 src/Nncase.Passes/Rules/Neutral/FusionMaker.cs   |  4 +++-
 .../Targets/UnitTestCPUTargetTiling.cs           |  5 +++--
 5 files changed, 24 insertions(+), 12 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs b/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs
index d23b542ff9..a087945bbf 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs
@@ -27,8 +27,13 @@ public partial class LowerMatMul : RewriteRule<Pattern>
       IsWildcard("inputA") with { TypePattern = IsFloat() },
       IsWildcard("inputB") with { TypePattern = IsFloat() });
 
-    private Expr GetReplace(MatMul matmul, Expr inputA, Expr inputB)
+    private Expr? GetReplace(MatMul matmul, Expr inputA, Expr inputB)
     {
-        return CPUKernel(matmul, inputA, inputB);
+        if (inputA.CheckedShape.Rank == inputB.CheckedShape.Rank && inputA.CheckedShape.Zip(inputB.CheckedShape).SkipLast(2).All(d => d.First == d.Second))
+        {
+            return CPUKernel(matmul, inputA, inputB);
+        }
+
+        return null;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
index d372d36037..54e6eb725f 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
@@ -40,7 +40,7 @@ internal sealed partial class CPUFusion : FusionMaker
         }
 
         var newCall = new Call(op, newInputs.ToArray());
-        var callFusion = new Call(new Fusion(FullName, ModuleKind, newCall, newInputs.OfType<Var>().ToArray()), newInputs.Select((e, i) => (e, i)).Where(p => p.e is Var).Select(p => callParams[p.i]).ToArray());
+        var callFusion = new Call(new Fusion($"{op.Target.GetType().Name}_{Count}", ModuleKind, newCall, newInputs.OfType<Var>().ToArray()), newInputs.Select((e, i) => (e, i)).Where(p => p.e is Var).Select(p => callParams[p.i]).ToArray());
         return callFusion;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 7263c6a55f..a399410337 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -86,13 +86,17 @@ private void GenerateMatMul(Buffer[] arguments, Buffer ret, Call expr)
             var lhs = arguments[0];
             var rhs = arguments[1];
 
-            // [m,k] @ [k, n]
-            var body = T.Block(nameof(MatMul)).Body(
-                T.Serial(out var m, (0, lhs.Dimensions[0])).Body(
-                    T.Serial(out var n, (0, rhs.Dimensions[1])).Body(
-                        T.Serial(out var k, (0, lhs.Dimensions[1])).Body(
-                            T.BufferStore(ret, new[] { m, n }, T.BufferLoad(ret, m, n) + (T.BufferLoad(lhs, m, k) * T.BufferLoad(rhs, k, n)))))));
+            var loops = Enumerable.Range(0, lhs.Rank - 2).Select(i => (T.ForLoop(out var loopVar, (0, lhs.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
+            var loopVars = loops.Select(f => f.loopVar).ToArray();
+            var stmt = T.Serial(out var m, (0, lhs.Dimensions[0])).Body(
+                T.Serial(out var n, (0, rhs.Dimensions[1])).Body(
+                    T.Serial(out var k, (0, lhs.Dimensions[1])).Body(
+                        T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), T.BufferLoad(ret, loopVars.Concat(new[] { m, n }).ToArray()) + (T.BufferLoad(lhs, loopVars.Concat(new[] { m, k }).ToArray()) * T.BufferLoad(rhs, loopVars.Concat(new[] { k, n }).ToArray())))))).
+                Build();
+            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
 
+            // [m,k] @ [k, n]
+            var body = T.Block(nameof(MatMul)).Body(final);
             _mainBody.Add(body.Build());
         }
 
diff --git a/src/Nncase.Passes/Rules/Neutral/FusionMaker.cs b/src/Nncase.Passes/Rules/Neutral/FusionMaker.cs
index 8e371dded0..7d64ddd81f 100644
--- a/src/Nncase.Passes/Rules/Neutral/FusionMaker.cs
+++ b/src/Nncase.Passes/Rules/Neutral/FusionMaker.cs
@@ -24,11 +24,13 @@ public abstract class FusionMaker : RewriteRule<Pattern>
 {
     private int _count;
 
+    public int Count { get => _count++; }
+
     public virtual string Name { get; } = "FusionMaker";
 
     public virtual string ModuleKind { get; } = "StackVM";
 
-    public string FullName => $"{Name}_{_count++}";
+    public string FullName => $"{Name}_{Count}";
 }
 
 /// <summary>
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 47a62e510b..b1cca37c84 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -58,8 +58,9 @@ public async Task TestCpuUnary()
     public async Task TestCpuMatMul()
     {
         var lhs = new Var("lhs", new TensorType(DataTypes.Float32, new[] { 3, 4 }));
-        var rhs = new Var("rhs", new TensorType(DataTypes.Float32, new[] { 4, 6 }));
-        var main = new Function("main", IR.F.Tensors.MatMul(lhs, rhs), new[] { lhs, rhs });
+        var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, new[] { 4, 6 });
+        //new Var("rhs", new TensorType(DataTypes.Float32, new[] { 4, 6 }));
+        var main = new Function("main", IR.F.Tensors.MatMul(lhs, rhs), new[] { lhs });
         var module = new IR.IRModule(main);
 
         var compiler = CompileSession.Compiler;

From 31c479130d98f005a5e66311b14f01517bf111c1 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 26 Jul 2023 14:11:46 +0800
Subject: [PATCH 042/308] cpu binary to tir

---
 .../Passes/Tile/SingleCPUFusionConverter.cs        | 14 +++++++++-----
 modules/cpu/src/runtime/runtime_function.cpp       |  3 ---
 .../Targets/UnitTestCPUTargetTiling.cs             |  3 ++-
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index a399410337..468db5dc19 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -90,6 +90,7 @@ private void GenerateMatMul(Buffer[] arguments, Buffer ret, Call expr)
             var loopVars = loops.Select(f => f.loopVar).ToArray();
             var stmt = T.Serial(out var m, (0, lhs.Dimensions[0])).Body(
                 T.Serial(out var n, (0, rhs.Dimensions[1])).Body(
+                    T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), 0f),
                     T.Serial(out var k, (0, lhs.Dimensions[1])).Body(
                         T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), T.BufferLoad(ret, loopVars.Concat(new[] { m, n }).ToArray()) + (T.BufferLoad(lhs, loopVars.Concat(new[] { m, k }).ToArray()) * T.BufferLoad(rhs, loopVars.Concat(new[] { k, n }).ToArray())))))).
                 Build();
@@ -112,8 +113,8 @@ private void GenerateUnary(Unary unary, ReadOnlySpan<Buffer> arguments, Buffer r
 
         private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffer ret, Call call)
         {
-            var lhs = call[Binary.Lhs];
-            var rhs = call[Binary.Rhs];
+            var lhs = call.Arguments[Binary.Lhs.Index];
+            var rhs = call.Arguments[Binary.Rhs.Index];
             var lhsBuffer = arguments[Binary.Lhs.Index];
             var rhsBuffer = arguments[Binary.Rhs.Index];
 
@@ -127,9 +128,12 @@ private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffe
             var rhsScale = outShape.Zip(rhsShape).Select(s => s.First / s.Second).ToArray();
 
             var loops = Enumerable.Range(0, outShape.Length).Select(i => (T.ForLoop(out var loopVar, (0, outShape[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
-
-            // var ?final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-            // _mainBody.Add(T.Block(nameof(Unary)).Body(final).Build());
+            var loopVars = loops.Select(f => f.loopVar).ToArray();
+            var lhsLoopVars = loopVars.Zip(lhsScale).Select(v => v.First / v.Second).ToArray();
+            var rhsLoopVars = loopVars.Zip(rhsScale).Select(v => v.First / v.Second).ToArray();
+            Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Binary(binary.BinaryOp, T.BufferLoad(lhsBuffer, lhsLoopVars), T.BufferLoad(rhsBuffer, rhsLoopVars)));
+            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
+            _mainBody.Add(T.Block(nameof(Binary)).Body(final).Build());
         }
 
         private TIR.Buffer TryAllocateBuffer(Expr expr)
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 61afac5746..74345772a7 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -140,9 +140,6 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
 
     auto elfloader_ = elfloader{(char *)module().text_physical().data()};
     elfloader_.invoke_elf(id, buffers.data(), &nncase_mt, nullptr, nullptr);
-    for (int i = 0; i < 10; i++) {
-        printf("%f\n", ((float *)buffers[1]->vaddr)[i]);
-    }
 
     for (int i = 0; i < buffers.size(); i++) {
         delete buffers[i];
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index b1cca37c84..f3a897f37d 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -59,7 +59,8 @@ public async Task TestCpuMatMul()
     {
         var lhs = new Var("lhs", new TensorType(DataTypes.Float32, new[] { 3, 4 }));
         var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, new[] { 4, 6 });
-        //new Var("rhs", new TensorType(DataTypes.Float32, new[] { 4, 6 }));
+
+        // new Var("rhs", new TensorType(DataTypes.Float32, new[] { 4, 6 }));
         var main = new Function("main", IR.F.Tensors.MatMul(lhs, rhs), new[] { lhs });
         var module = new IR.IRModule(main);
 

From 4d93b0e409731efb275696c187478d3b30da4bf3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 26 Jul 2023 15:40:28 +0800
Subject: [PATCH 043/308] add buffer schedule

---
 .../CodeGen/CSourceConvertVisitor.cs          | 14 +++++
 .../Passes/Tile/SingleCPUFusionConverter.cs   |  7 +--
 .../Nncase.Modules.CPU/Targets/CPUTarget.cs   |  8 +++
 modules/cpu/src/runtime/cpu_common.h          |  8 +++
 modules/cpu/src/runtime/runtime_function.cpp  |  3 +-
 modules/cpu/src/runtime/runtime_module.cpp    |  4 +-
 src/Nncase.Core/IR/Buffers/MatchBuffer.cs     | 21 ++++++++
 .../Passes/Mutators/FoldBufferSlot.cs         | 51 +++++++++++++++++++
 src/Nncase.Core/TIR/Script.cs                 |  2 +
 src/Nncase.Evaluator/Buffers/BufferModule.cs  |  1 +
 src/Nncase.Evaluator/Buffers/MatchBuffer.cs   | 29 +++++++++++
 11 files changed, 141 insertions(+), 7 deletions(-)
 create mode 100644 src/Nncase.Core/IR/Buffers/MatchBuffer.cs
 create mode 100644 src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs
 create mode 100644 src/Nncase.Evaluator/Buffers/MatchBuffer.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 5dc9cec026..9b6b358525 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -178,6 +178,20 @@ protected override CSymbol VisitCall(Call expr)
             case Load:
                 str = $"((({type} *){arguments[0].Name}->vaddr)[{arguments[1].Name}])";
                 break;
+            case IR.Buffers.MatchBuffer op:
+                var n = arguments[0].Name;
+                var pb = (TIR.PhysicalBuffer)expr[IR.Buffers.MatchBuffer.Input];
+                var ind = new String(Enumerable.Repeat<char>(' ', IndentScope.Writer.Indent).ToArray());
+                str = $@"uint32_t _{n}_shape[] = {{ {string.Join(", ", pb.FixedDimensions.ToArray())} }};
+{ind}uint32_t _{n}_stride[] = {{ {string.Join(", ", pb.FixedStrides.ToArray())} }};
+{ind}buffer_t _{n} = {{
+{ind}{ind}.vaddr = ((uint8_t*) rdata + {pb.Start}),
+{ind}{ind}.paddr = 0,
+{ind}{ind}.shape = _{n}_shape,
+{ind}{ind}.stride = _{n}_stride,
+{ind}{ind}.rank = {pb.FixedDimensions.Length} }};
+{ind}buffer_t *{n} = &_{n}";
+                break;
             default:
                 throw new NotSupportedException();
         }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 468db5dc19..cc05e9396b 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -95,9 +95,10 @@ private void GenerateMatMul(Buffer[] arguments, Buffer ret, Call expr)
                         T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), T.BufferLoad(ret, loopVars.Concat(new[] { m, n }).ToArray()) + (T.BufferLoad(lhs, loopVars.Concat(new[] { m, k }).ToArray()) * T.BufferLoad(rhs, loopVars.Concat(new[] { k, n }).ToArray())))))).
                 Build();
             var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-
             // [m,k] @ [k, n]
-            var body = T.Block(nameof(MatMul)).Body(final);
+            var body = T.Block(nameof(MatMul)).Body(
+                T.Sequential(arguments.OfType<PhysicalBuffer>().Where(p => p.Const != null).Select(b => T.MatchBuffer(b)).ToArray()),
+                final);
             _mainBody.Add(body.Build());
         }
 
@@ -158,7 +159,7 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
                         buffer = T.PhysicalBuffer(v.CheckedDataType, MemoryLocation.Input, v.CheckedShape.ToValueArray(), out _, name);
                         break;
                     case TensorConst c:
-                        buffer = T.PhysicalBuffer(c.Value.ElementType, MemoryLocation.Rdata, c.Value.Dimensions, out _, name);
+                        buffer = T.ConstBuffer(c, out _, name);
                         break;
                     default:
                         throw new NotSupportedException();
diff --git a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
index b3fe833906..1e2657ab3b 100644
--- a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
@@ -91,6 +91,14 @@ public void RegisterTargetDependentAfterQuantPass(IPassManager passManager, Comp
             p.Add<Passes.Mutators.FlattenSequential>();
             p.Add<Passes.Mutators.FoldConstCall>();
         });
+
+        passManager.AddWithName<DDrBufferSchdeulePass>("DDrBufferSchdeule");
+
+        passManager.AddWithName<PrimFuncPass>("InstStage").Configure(p =>
+        {
+            p.Add<Passes.Mutators.FoldConstCall>();
+            p.Add<Passes.Mutators.FoldBufferSlot>(); // 折叠自定义op
+        });
     }
 
     public void RegisterTargetDependentBeforeCodeGen(IPassManager passManager, CompileOptions options)
diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
index 047ea7ce31..d51e1775aa 100644
--- a/modules/cpu/src/runtime/cpu_common.h
+++ b/modules/cpu/src/runtime/cpu_common.h
@@ -97,7 +97,11 @@ inline int32_t int32_binary_mul(int32_t x, int32_t y) { return x * y; }
 inline int32_t int32_binary_div(int32_t x, int32_t y) { return x / y; }
 inline int32_t int32_binary_min(int32_t x, int32_t y) { return std::min(x, y); }
 inline int32_t int32_binary_max(int32_t x, int32_t y) { return std::max(x, y); }
+#if defined (__arm64__)  && defined (__APPLE__)   
+inline int32_t int32_binary_pow(int32_t x, int32_t y) { return (int32_t)pow(x, y); }
+#else
 inline int32_t int32_binary_pow(int32_t x, int32_t y) { return std::pow(x, y); }
+#endif
 inline int32_t int32_binary_logical_and(int32_t x, int32_t y) { return x && y; }
 inline int32_t int32_binary_mod(int32_t x, int32_t y) { return x % y; }
 
@@ -107,7 +111,11 @@ inline int64_t int64_binary_mul(int64_t x, int64_t y) { return x * y; }
 inline int64_t int64_binary_div(int64_t x, int64_t y) { return x / y; }
 inline int64_t int64_binary_min(int64_t x, int64_t y) { return std::min(x, y); }
 inline int64_t int64_binary_max(int64_t x, int64_t y) { return std::max(x, y); }
+#if defined (__arm64__)  && defined (__APPLE__)   
+inline int64_t int64_binary_pow(int64_t x, int64_t y) { return (int64_t)pow(x, y); }
+#else
 inline int64_t int64_binary_pow(int64_t x, int64_t y) { return std::pow(x, y); }
+#endif
 inline int64_t int64_binary_logical_and(int64_t x, int64_t y) { return x && y; }
 inline int64_t int64_binary_mod(int64_t x, int64_t y) { return x % y; }
 
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 74345772a7..f5cc272b88 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -139,8 +139,7 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
     }
 
     auto elfloader_ = elfloader{(char *)module().text_physical().data()};
-    elfloader_.invoke_elf(id, buffers.data(), &nncase_mt, nullptr, nullptr);
-
+    elfloader_.invoke_elf(id, buffers.data(), &nncase_mt, nullptr, (void *)module().rdata_physical().data());
     for (int i = 0; i < buffers.size(); i++) {
         delete buffers[i];
     }
diff --git a/modules/cpu/src/runtime/runtime_module.cpp b/modules/cpu/src/runtime/runtime_module.cpp
index 0b1b2efbe8..6e44d1fd3b 100644
--- a/modules/cpu/src/runtime/runtime_module.cpp
+++ b/modules/cpu/src/runtime/runtime_module.cpp
@@ -27,8 +27,8 @@ result<void> cpu_runtime_module::initialize_before_functions(
     // if (!context.is_section_pinned())
     //     return nncase::err(std::errc::bad_address);
     // try_var(data, context.get_or_read_section(".data", data_storage_,
-    // false)); try_var(rdata, context.get_or_read_section(".rdata",
-    // rdata_storage_, true));
+    // false)); 
+    try_set(rdata_, context.get_or_read_section(".rdata", rdata_storage_, true));
     try_set(text_, context.get_or_read_section(".text", text_storage_, true));
 
     return ok();
diff --git a/src/Nncase.Core/IR/Buffers/MatchBuffer.cs b/src/Nncase.Core/IR/Buffers/MatchBuffer.cs
new file mode 100644
index 0000000000..0904ed7267
--- /dev/null
+++ b/src/Nncase.Core/IR/Buffers/MatchBuffer.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR.Tensors;
+using Nncase.PatternMatch;
+using static Nncase.IR.TypePatternUtility;
+
+namespace Nncase.IR.Buffers;
+
+/// <summary>
+/// MatchBuffer op.
+/// todo maybe need united matchbuffer and allocatebuffer
+/// </summary>
+[PatternFunctionalGenerator]
+public sealed partial class MatchBuffer : Op
+{
+    public static readonly ParameterInfo Input = new(typeof(MatchBuffer), 0, "input", IsTensor());
+
+    /// <inheritdoc/>
+    public override bool CanFoldConstCall => false;
+}
diff --git a/src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs b/src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs
new file mode 100644
index 0000000000..d96dfd968d
--- /dev/null
+++ b/src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs
@@ -0,0 +1,51 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Reactive;
+using Nncase.Evaluator;
+using Nncase.IR;
+using Nncase.Passes;
+using Nncase.TIR;
+
+namespace Nncase.Passes.Mutators;
+
+/// <summary>
+/// remove buffer BaseMentOf/DDrOf/MmuOF.
+/// </summary>
+public sealed class FoldBufferSlot : ExprRewriter
+{
+    protected internal override Expr VisitPrimFunction(TIR.PrimFunction expr, Unit context)
+    {
+        if (expr.SchedResult.IsScheduled == true)
+        {
+            return base.VisitPrimFunction(expr, context);
+        }
+
+        return expr;
+    }
+
+    protected override Expr RewriteLeafCall(Call expr)
+    {
+        if (expr.Target is IR.Buffers.BaseMentOf)
+        {
+            var locate = ((TIR.PhysicalBuffer)expr.Arguments[0]).MemLocation;
+            return locate switch
+            {
+                MemoryLocation.Input => 0,
+                MemoryLocation.Output => 1,
+                MemoryLocation.Rdata => 2,
+                MemoryLocation.Data => 3,
+                _ => throw new ArgumentOutOfRangeException($"You Can't Assgin The BaseMent For {locate}!"),
+            };
+        }
+        else if (expr.Target is IR.Buffers.DDrOf)
+        {
+            if (expr.Arguments[0] is TIR.PhysicalBuffer buf)
+            {
+                return buf.Start;
+            }
+        }
+
+        return expr;
+    }
+}
diff --git a/src/Nncase.Core/TIR/Script.cs b/src/Nncase.Core/TIR/Script.cs
index c9f4a77f72..ad1b71f0bf 100644
--- a/src/Nncase.Core/TIR/Script.cs
+++ b/src/Nncase.Core/TIR/Script.cs
@@ -330,4 +330,6 @@ public static Call Emit<T>(out T value, Func<T> creator)
     /// <param name="value">value.</param>
     /// <returns> call bufferstore.</returns>
     public static Call BufferStore(TIR.Buffer buffer, Expr[] indices, Expr value) => new Call(new IR.Buffers.BufferStore(), buffer, new IR.Tuple(indices), value);
+
+    public static Call MatchBuffer(TIR.Buffer buffer) => new Call(new IR.Buffers.MatchBuffer(), buffer);
 }
diff --git a/src/Nncase.Evaluator/Buffers/BufferModule.cs b/src/Nncase.Evaluator/Buffers/BufferModule.cs
index 0954206679..a2512b6f13 100644
--- a/src/Nncase.Evaluator/Buffers/BufferModule.cs
+++ b/src/Nncase.Evaluator/Buffers/BufferModule.cs
@@ -22,5 +22,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<UninitializedEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<BufferLoadEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<BufferStoreEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<MatchBufferEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/src/Nncase.Evaluator/Buffers/MatchBuffer.cs b/src/Nncase.Evaluator/Buffers/MatchBuffer.cs
new file mode 100644
index 0000000000..7a806fdd61
--- /dev/null
+++ b/src/Nncase.Evaluator/Buffers/MatchBuffer.cs
@@ -0,0 +1,29 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.Buffers;
+
+namespace Nncase.Evaluator.Buffers;
+
+/// <summary>
+/// Evaluator for BufferOf.
+/// </summary>
+[TypeInferGenerator]
+public partial class MatchBufferEvaluator : ITypeInferencer<MatchBuffer>, IOpPrinter<MatchBuffer>
+{
+    public string Visit(IIRPrinterContext context, MatchBuffer target, bool iLmode)
+    {
+        if (iLmode)
+        {
+            throw new System.NotSupportedException();
+        }
+
+        return $"Matched {context.GetArgument(target, MatchBuffer.Input)}";
+    }
+
+    private IRType Visit()
+    {
+        return TupleType.Void;
+    }
+}

From 02fbf2fee6e1d34c19c4facd6d95eef4aff5287f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 26 Jul 2023 15:42:05 +0800
Subject: [PATCH 044/308] format

---
 modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs   | 2 +-
 .../Passes/Tile/SingleCPUFusionConverter.cs                   | 1 +
 src/Nncase.Core/IR/Buffers/MatchBuffer.cs                     | 4 ++--
 src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs             | 2 +-
 src/Nncase.Evaluator/Buffers/MatchBuffer.cs                   | 2 +-
 5 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 9b6b358525..d75f80cced 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -181,7 +181,7 @@ protected override CSymbol VisitCall(Call expr)
             case IR.Buffers.MatchBuffer op:
                 var n = arguments[0].Name;
                 var pb = (TIR.PhysicalBuffer)expr[IR.Buffers.MatchBuffer.Input];
-                var ind = new String(Enumerable.Repeat<char>(' ', IndentScope.Writer.Indent).ToArray());
+                var ind = new string(Enumerable.Repeat<char>(' ', IndentScope.Writer.Indent).ToArray());
                 str = $@"uint32_t _{n}_shape[] = {{ {string.Join(", ", pb.FixedDimensions.ToArray())} }};
 {ind}uint32_t _{n}_stride[] = {{ {string.Join(", ", pb.FixedStrides.ToArray())} }};
 {ind}buffer_t _{n} = {{
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index cc05e9396b..267a5a484d 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -95,6 +95,7 @@ private void GenerateMatMul(Buffer[] arguments, Buffer ret, Call expr)
                         T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), T.BufferLoad(ret, loopVars.Concat(new[] { m, n }).ToArray()) + (T.BufferLoad(lhs, loopVars.Concat(new[] { m, k }).ToArray()) * T.BufferLoad(rhs, loopVars.Concat(new[] { k, n }).ToArray())))))).
                 Build();
             var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
+
             // [m,k] @ [k, n]
             var body = T.Block(nameof(MatMul)).Body(
                 T.Sequential(arguments.OfType<PhysicalBuffer>().Where(p => p.Const != null).Select(b => T.MatchBuffer(b)).ToArray()),
diff --git a/src/Nncase.Core/IR/Buffers/MatchBuffer.cs b/src/Nncase.Core/IR/Buffers/MatchBuffer.cs
index 0904ed7267..3cafa7f595 100644
--- a/src/Nncase.Core/IR/Buffers/MatchBuffer.cs
+++ b/src/Nncase.Core/IR/Buffers/MatchBuffer.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR.Tensors;
@@ -9,7 +9,7 @@ namespace Nncase.IR.Buffers;
 
 /// <summary>
 /// MatchBuffer op.
-/// todo maybe need united matchbuffer and allocatebuffer
+/// todo maybe need united matchbuffer and allocatebuffer.
 /// </summary>
 [PatternFunctionalGenerator]
 public sealed partial class MatchBuffer : Op
diff --git a/src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs b/src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs
index d96dfd968d..4bc48af9d1 100644
--- a/src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs
+++ b/src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System.Reactive;
diff --git a/src/Nncase.Evaluator/Buffers/MatchBuffer.cs b/src/Nncase.Evaluator/Buffers/MatchBuffer.cs
index 7a806fdd61..7a8122d2ae 100644
--- a/src/Nncase.Evaluator/Buffers/MatchBuffer.cs
+++ b/src/Nncase.Evaluator/Buffers/MatchBuffer.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;

From 9fa866bdd6d95aa5116649f401979106d70aadba Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 26 Jul 2023 16:25:22 +0800
Subject: [PATCH 045/308] update cpu tir

---
 .../Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs |  2 +-
 .../Nncase.Modules.CPU/CodeGen/LinkedModule.cs    |  2 +-
 .../Passes/Tile/SingleCPUFusionConverter.cs       | 15 +++++++++------
 modules/cpu/src/runtime/elfloader.cpp             |  2 +-
 modules/cpu/src/runtime/elfloader.h               |  4 ++--
 modules/cpu/src/runtime/runtime_function.cpp      |  2 +-
 6 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
index 6ab53936fc..d59e244f92 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
@@ -134,7 +134,7 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
-            return $"{sourcePath} -nostdlib -static -no-pie -fPIC -march={Arch} -o {outPath}";
+            return $"{sourcePath} -nostdlib -static -no-pie -fPIC -fno-stack-protector -march={Arch} -o {outPath}";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
         {
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
index 8a300e55bf..c32350936f 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
@@ -15,7 +15,7 @@ internal sealed class LinkedModule : ILinkedModule
     public LinkedModule(IReadOnlyList<ILinkedFunction> functions, byte[] text, byte[] rdata)
     {
         Functions = functions;
-        Sections = new[] { new LinkedSection(text, ".text", 0, 8, (uint)text.Length) };
+        Sections = new[] { new LinkedSection(text, ".text", 0, 8, (uint)text.Length), new LinkedSection(rdata, ".rdata", 0, 8, (uint)rdata.Length) };
     }
 
     public string ModuleKind => Targets.CPUTarget.Kind;
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 267a5a484d..2cf09245c1 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -81,24 +81,24 @@ protected override Unit VisitLeafCall(Call expr)
             return default;
         }
 
-        private void GenerateMatMul(Buffer[] arguments, Buffer ret, Call expr)
+        private void GenerateMatMul(ReadOnlySpan<Buffer> arguments, Buffer ret, Call expr)
         {
             var lhs = arguments[0];
             var rhs = arguments[1];
 
             var loops = Enumerable.Range(0, lhs.Rank - 2).Select(i => (T.ForLoop(out var loopVar, (0, lhs.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
             var loopVars = loops.Select(f => f.loopVar).ToArray();
-            var stmt = T.Serial(out var m, (0, lhs.Dimensions[0])).Body(
-                T.Serial(out var n, (0, rhs.Dimensions[1])).Body(
+            var stmt = T.Serial(out var m, (0, lhs.Dimensions[^2])).Body(
+                T.Serial(out var n, (0, rhs.Dimensions[^1])).Body(
                     T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), 0f),
-                    T.Serial(out var k, (0, lhs.Dimensions[1])).Body(
+                    T.Serial(out var k, (0, lhs.Dimensions[^1])).Body(
                         T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), T.BufferLoad(ret, loopVars.Concat(new[] { m, n }).ToArray()) + (T.BufferLoad(lhs, loopVars.Concat(new[] { m, k }).ToArray()) * T.BufferLoad(rhs, loopVars.Concat(new[] { k, n }).ToArray())))))).
                 Build();
             var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
 
             // [m,k] @ [k, n]
             var body = T.Block(nameof(MatMul)).Body(
-                T.Sequential(arguments.OfType<PhysicalBuffer>().Where(p => p.Const != null).Select(b => T.MatchBuffer(b)).ToArray()),
+                T.Sequential(arguments.ToArray().OfType<PhysicalBuffer>().Where(p => p.Const != null).Select(b => T.MatchBuffer(b)).ToArray()),
                 final);
             _mainBody.Add(body.Build());
         }
@@ -135,7 +135,10 @@ private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffe
             var rhsLoopVars = loopVars.Zip(rhsScale).Select(v => v.First / v.Second).ToArray();
             Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Binary(binary.BinaryOp, T.BufferLoad(lhsBuffer, lhsLoopVars), T.BufferLoad(rhsBuffer, rhsLoopVars)));
             var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-            _mainBody.Add(T.Block(nameof(Binary)).Body(final).Build());
+            var body = T.Block(nameof(Binary)).Body(
+                T.Sequential(arguments.ToArray().OfType<PhysicalBuffer>().Where(p => p.Const != null).Select(b => T.MatchBuffer(b)).ToArray()),
+                final);
+            _mainBody.Add(body.Build());
         }
 
         private TIR.Buffer TryAllocateBuffer(Expr expr)
diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/cpu/src/runtime/elfloader.cpp
index f0c6571db1..f20063b9d5 100644
--- a/modules/cpu/src/runtime/elfloader.cpp
+++ b/modules/cpu/src/runtime/elfloader.cpp
@@ -5,7 +5,7 @@ using namespace nncase::runtime;
 using namespace nncase::runtime::cpu;
 
 int elfloader::invoke_elf(size_t id, buffer_t **buffers, nncase_mt_t *nncase_mt,
-                          void *data, void *rdata) {
+                          void *data, const void *rdata) {
 
     check(el_init(&ctx_), "initialising");
 
diff --git a/modules/cpu/src/runtime/elfloader.h b/modules/cpu/src/runtime/elfloader.h
index bdc0c5039e..7a0aa36f00 100644
--- a/modules/cpu/src/runtime/elfloader.h
+++ b/modules/cpu/src/runtime/elfloader.h
@@ -14,7 +14,7 @@
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
 typedef void (*entrypoint_t)(size_t id, buffer_t **buffers,
-                             nncase_mt_t *nncase_mt, void *data, void *rdata);
+                             nncase_mt_t *nncase_mt, void *data, const void *rdata);
 
 class elfloader {
   public:
@@ -50,7 +50,7 @@ class elfloader {
     }
 
     int invoke_elf(size_t id, buffer_t **buffers, nncase_mt_t *nncase_mt,
-                   void *data, void *rdata);
+                   void *data, const void *rdata);
 
   private:
     void *ptr_;
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index f5cc272b88..422fd23e59 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -139,7 +139,7 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
     }
 
     auto elfloader_ = elfloader{(char *)module().text_physical().data()};
-    elfloader_.invoke_elf(id, buffers.data(), &nncase_mt, nullptr, (void *)module().rdata_physical().data());
+    elfloader_.invoke_elf(id, buffers.data(), &nncase_mt, nullptr, (const void *)module().rdata_physical().data());
     for (int i = 0; i < buffers.size(); i++) {
         delete buffers[i];
     }

From 5429c6bcb1a92d71b4f8f0bbf89b945f9f063e02 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 27 Jul 2023 13:37:13 +0800
Subject: [PATCH 046/308] refactor buffer

---
 src/Nncase.Core/TIR/Buffer.cs | 219 +++-------------------------------
 1 file changed, 18 insertions(+), 201 deletions(-)

diff --git a/src/Nncase.Core/TIR/Buffer.cs b/src/Nncase.Core/TIR/Buffer.cs
index 9289d1afec..80f86c4f21 100644
--- a/src/Nncase.Core/TIR/Buffer.cs
+++ b/src/Nncase.Core/TIR/Buffer.cs
@@ -267,233 +267,50 @@ public SelectedRange Slice(Segment1D segment)
 /// <summary>
 /// buffer.
 /// </summary>
-public abstract class Buffer : Expr
+public sealed class Buffer : Expr
 {
-    public Buffer(string name, DataType elemType, MemoryLocation memoryLocation, Expr[] operands)
-        : base(operands.ToArray())
+    private static int _globalVarIndex;
+
+    public Buffer(string name, DataType elemType, MemSpan memSpan, Expr[] dimensions, Expr[] strides)
+        : base(new[] { memSpan }.Concat(dimensions).Concat(strides))
     {
         Name = name;
         ElemType = elemType;
-        MemLocation = memoryLocation;
+        Rank = dimensions.Length;
+        GlobalVarIndex = Interlocked.Increment(ref _globalVarIndex);
     }
 
     public string Name { get; }
 
     public DataType ElemType { get; }
 
-    public MemoryLocation MemLocation { get; }
-
-    /// <summary>
-    /// Gets if this buffer from the constant !.
-    /// </summary>
-    public TensorConst? Const { get; init; }
-
     /// <summary>
     /// Gets rank of the tensor: number of dimensions.
     /// </summary>
-    public abstract int Rank { get; }
+    public int Rank { get; }
 
     /// <summary>
-    /// Gets the strides.
-    /// <remarks>
-    /// This Strides is by elements not by bytes!
-    /// </remarks>
+    /// Gets the global var index.
     /// </summary>
-    public abstract ReadOnlySpan<Expr> Strides { get; }
+    public int GlobalVarIndex { get; }
 
     /// <summary>
     /// Gets the shape.
     /// </summary>
-    public abstract ReadOnlySpan<Expr> Dimensions { get; }
-
-    /// <inheritdoc/>
-    public override bool Equals(object? obj)
-    {
-        if (obj is not Buffer other)
-        {
-            return false;
-        }
-
-        if (Const is not null && !Const.Equals(other.Const))
-        {
-            return false;
-        }
-
-        return string.Equals(Name, other.Name, StringComparison.Ordinal) &&
-                ElemType.Equals(other.ElemType) &&
-                MemLocation.Equals(other.MemLocation) &&
-                Rank.Equals(other.Rank) &&
-                base.Equals(obj);
-    }
-}
-
-/// <summary>
-/// the logical buffer.
-/// </summary>
-public sealed class LogicalBuffer : Buffer
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="LogicalBuffer"/> class.
-    /// create from the IRType.
-    /// </summary>
-    /// <param name="name">the name.</param>
-    /// <param name="location">the location.</param>
-    /// <param name="elemType">prim type.</param>
-    /// <param name="dimensions">the shape.</param>
-    /// <param name="strides">the strides.</param>
-    public LogicalBuffer(string name, DataType elemType, MemoryLocation location, ReadOnlySpan<Expr> dimensions, ReadOnlySpan<Expr> strides)
-        : base(name, elemType, location, ArrayUtility.Concat(dimensions, strides))
-    {
-        Rank = dimensions.Length;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="LogicalBuffer"/> class.
-    /// <see cref="LogicalBuffer"/>.
-    /// </summary>
-    public LogicalBuffer(string name, MemoryLocation location, TensorConst tensor)
-        : this(name, tensor.Value.ElementType, location, ArrayUtility.ToExprArray(tensor.Value.Dimensions), ArrayUtility.ToExprArray(tensor.Value.Strides))
-    {
-        Const = tensor;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="LogicalBuffer"/> class.
-    /// <seealso cref="LogicalBuffer"/>
-    /// </summary>
-    public LogicalBuffer(string name, DataType elemType, MemoryLocation location, ReadOnlySpan<Expr> dimensions)
-        : this(name, elemType, location, dimensions, TensorUtilities.GetStrides(dimensions))
-    {
-    }
-
-    /// <summary>
-    /// Gets get the total length.
-    /// </summary>
-    public Expr Length => TensorUtilities.GetProduct(Dimensions);
+    public MemSpan MemSpan => (MemSpan)Operands[0];
 
     /// <summary>
     /// Gets the shape.
     /// </summary>
-    public override ReadOnlySpan<Expr> Dimensions => Operands[0..Rank];
+    public ReadOnlySpan<Expr> Dimensions => Operands[1..(1 + Rank)];
 
     /// <summary>
     /// Gets the strides.
+    /// <remarks>
+    /// This Strides is by elements not by bytes!
+    /// </remarks>
     /// </summary>
-    public override ReadOnlySpan<Expr> Strides => Operands[Rank..];
-
-    /// <inheritdoc/>
-    public override int Rank { get; }
-
-    /// <inheritdoc/>
-    public override string ToString()
-    {
-        return $"LogicalBuffer({Name}, {ElemType}, {nameof(MemLocation)})";
-    }
-
-    /// <inheritdoc/>
-    public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context)
-        => functor.VisitLogicalBuffer(this, context);
-
-    public LogicalBuffer With(string? name = null, DataType? elemType = null, MemoryLocation? location = null, Expr[]? dimensions = null, Expr[]? strides = null)
-        => new LogicalBuffer(name ?? Name, elemType ?? ElemType, location ?? MemLocation, dimensions ?? Dimensions, strides ?? Strides) { Const = Const };
-}
-
-/// <summary>
-/// the physical buffer.
-/// </summary>
-public sealed class PhysicalBuffer : Buffer
-{
-    private readonly int[] _fixedDimensions;
-    private readonly int[] _fixedStrides;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="PhysicalBuffer"/> class.
-    /// ctor for physical buffer.
-    /// </summary>
-    public PhysicalBuffer(string name, DataType elemType, MemoryLocation location, ReadOnlySpan<int> dimensions, ReadOnlySpan<int> strides, int start, int size)
-        : base(name, elemType, location, Array.Empty<Expr>())
-    {
-        Start = start;
-        Size = size;
-        _fixedDimensions = dimensions.ToArray();
-        _fixedStrides = strides.ToArray();
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="PhysicalBuffer"/> class.
-    /// <see cref="PhysicalBuffer"/>.
-    /// </summary>
-    public PhysicalBuffer(string name, DataType elemType, MemoryLocation location, ReadOnlySpan<int> dimensions, int start, int size)
-        : this(name, elemType, location, dimensions, TensorUtilities.GetStrides(dimensions), start, size)
-    {
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="PhysicalBuffer"/> class.
-    /// <see cref="PhysicalBuffer"/>.
-    /// </summary>
-    public PhysicalBuffer(string name, MemoryLocation location, TensorConst tensor, int start, int size)
-        : this(name, tensor.Value.ElementType, location, tensor.Value.Dimensions, tensor.Value.Strides, start, size)
-    {
-        Const = tensor;
-    }
-
-    /// <summary>
-    /// Gets fixed dimensions.
-    /// </summary>
-    public ReadOnlySpan<int> FixedDimensions => _fixedDimensions;
-
-    /// <summary>
-    /// Gets fixed strides.
-    /// </summary>
-    public ReadOnlySpan<int> FixedStrides => _fixedStrides;
-
-    /// <summary>
-    /// Gets or sets start.
-    /// </summary>
-    public int Start { get; set; }
-
-    /// <summary>
-    /// Gets total size in bytes.
-    /// </summary>
-    public int Size { get; init; }
-
-    /// <summary>
-    /// Gets dimensions.
-    /// </summary>
-    public override ReadOnlySpan<Expr> Dimensions => ArrayUtility.ToExprArray(FixedDimensions);
-
-    /// <summary>
-    /// Gets strides.
-    /// </summary>
-    public override ReadOnlySpan<Expr> Strides => ArrayUtility.ToExprArray(FixedStrides);
-
-    /// <summary>
-    /// Gets shape.
-    /// </summary>
-    public Shape Shape => new Shape(FixedDimensions);
-
-    /// <inheritdoc/>
-    public override int Rank => FixedDimensions.Length;
-
-    /// <inheritdoc/>
-    public override string ToString()
-    {
-        return $"PhysicalBuffer({Name}, {ElemType}, {nameof(MemLocation)})";
-    }
-
-    /// <inheritdoc/>
-    public override bool Equals(object? obj)
-    {
-        return base.Equals(obj) && obj is PhysicalBuffer other &&
-          FixedDimensions.SequenceEqual(other.FixedDimensions) &&
-          FixedStrides.SequenceEqual(other.FixedStrides);
-    }
+    public ReadOnlySpan<Expr> Strides => Operands[(1 + Rank)..(1 + Rank + Rank)];
 
-    /// <inheritdoc/>
-    public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context)
-        => functor.VisitPhysicalBuffer(this, context);
-
-    public PhysicalBuffer With(string? name = null, DataType? elemType = null, MemoryLocation? location = null, int[]? dimensions = null, int[]? strides = null, int? start = null, int? size = null)
-        => new PhysicalBuffer(name ?? Name, elemType ?? ElemType, location ?? MemLocation, dimensions ?? FixedDimensions, strides ?? FixedStrides, start ?? Start, size ?? Size) { Const = Const };
-}
+    public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context) => throw new NotImplementedException();
+}
\ No newline at end of file

From 4b5361388e77bcaa9866b11efba05c42b20348e3 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Fri, 28 Jul 2023 16:32:41 +0800
Subject: [PATCH 047/308] fix build

---
 .../CodeGen/CSourceConvertVisitor.cs          |  22 +--
 .../CodeGen/CSourceExtensions.cs              |   1 -
 .../CodeGen/FunctionBuilder.cs                |  97 ++++-----
 .../Passes/Tile/CPUFusionGroupMutator.cs      |   2 +-
 .../Passes/Tile/SingleCPUFusionConverter.cs   |  25 ++-
 src/Nncase.Core/FunctionCollector.cs          |   2 +-
 src/Nncase.Core/IR/ExprCloner.g.cs            |  28 +--
 src/Nncase.Core/IR/ExprFunctor.cs             |  10 +
 src/Nncase.Core/IR/ExprFunctor.g.cs           |  48 ++---
 src/Nncase.Core/IR/ExprRewriter.g.cs          |  69 ++-----
 src/Nncase.Core/IR/ExprVisitor.g.cs           | 187 ++++++------------
 src/Nncase.Core/IR/IRList.csv                 |   7 +-
 src/Nncase.Core/IR/TypeFunctor.cs             |   8 +
 .../Passes/Mutators/FoldBufferSlot.cs         |   4 +-
 .../Passes/Mutators/UnRollLoopSequential.cs   |   5 +-
 src/Nncase.Core/Schedule/ScheduleTypes.cs     |   4 +-
 src/Nncase.Core/TIR/Buffer.cs                 |  15 +-
 src/Nncase.Core/TIR/MemSpan.cs                |  21 +-
 src/Nncase.Core/TIR/PrimFunction.cs           |  12 +-
 src/Nncase.Core/TIR/Script.cs                 |  53 +++--
 .../Diagnostics/ScriptPrintVisitor.cs         |  24 ++-
 src/Nncase.Evaluator/TypeInferenceVisitor.cs  |  43 ++--
 src/Nncase.Passes/DDrBufferSchdeulePass.cs    | 168 +++++++---------
 .../Rules/Neutral/PrimFuncMergeRule.cs        |   2 +
 src/Nncase.Tests/Core/UnitTestExpression.cs   |  12 +-
 .../Core/UnitTestStringUtility.cs             |   6 +-
 src/Nncase.Tests/Core/UnitTestTIR.cs          |  34 +---
 .../Diagnostics/UnitTestDumpper.cs            |   2 +-
 .../Evaluator/UnitTestEvaluator.cs            |   2 +-
 .../TIR/PrimFunc/IDataFlowPrimFuncCase.cs     |  15 +-
 .../TIR/PrimFunc/UnitTestPrimFuncMerge.cs     |  10 +-
 src/Nncase.Tests/TIR/UnitTestMutators.cs      |  24 +--
 .../Transform/UnitTestPassManager.cs          |  12 +-
 .../Transform/UnitTestSubstitutor.cs          |  12 +-
 34 files changed, 421 insertions(+), 565 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index d75f80cced..9e71b76ea6 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -180,16 +180,16 @@ protected override CSymbol VisitCall(Call expr)
                 break;
             case IR.Buffers.MatchBuffer op:
                 var n = arguments[0].Name;
-                var pb = (TIR.PhysicalBuffer)expr[IR.Buffers.MatchBuffer.Input];
+                var pb = (TIR.Buffer)expr[IR.Buffers.MatchBuffer.Input];
                 var ind = new string(Enumerable.Repeat<char>(' ', IndentScope.Writer.Indent).ToArray());
-                str = $@"uint32_t _{n}_shape[] = {{ {string.Join(", ", pb.FixedDimensions.ToArray())} }};
-{ind}uint32_t _{n}_stride[] = {{ {string.Join(", ", pb.FixedStrides.ToArray())} }};
+                str = $@"uint32_t _{n}_shape[] = {{ {string.Join(", ", pb.Dimensions.AsValueEnumerable().Select(e => Visit(e).Name).ToArray())} }};
+{ind}uint32_t _{n}_stride[] = {{ {string.Join(", ", pb.Strides.AsValueEnumerable().Select(e => Visit(e).Name).ToArray())} }};
 {ind}buffer_t _{n} = {{
-{ind}{ind}.vaddr = ((uint8_t*) rdata + {pb.Start}),
+{ind}{ind}.vaddr = ((uint8_t*) rdata + {Visit(pb.MemSpan.Start).Name}),
 {ind}{ind}.paddr = 0,
 {ind}{ind}.shape = _{n}_shape,
 {ind}{ind}.stride = _{n}_stride,
-{ind}{ind}.rank = {pb.FixedDimensions.Length} }};
+{ind}{ind}.rank = {pb.Dimensions.Length} }};
 {ind}buffer_t *{n} = &_{n}";
                 break;
             default:
@@ -328,16 +328,4 @@ protected override CSymbol VisitIfThenElse(IfThenElse expr)
         _exprMemo.Add(expr, symbol);
         return symbol;
     }
-
-    protected override CSymbol VisitPhysicalBuffer(PhysicalBuffer expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        symbol = new(CSourceBuiltn.BufferType + "*", expr.Name);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
 }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index e5b48ec442..9ba7ff5656 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -29,7 +29,6 @@ public static string ToC(this PrimType primType) =>
     public static string ToC(this DataType dataType) => dataType switch
     {
         PrimType ptype => ptype.ToC(),
-        PointerType { ElemType: PrimType etype } => etype.ToC() + "*",
         _ => throw new NotSupportedException(dataType.ToString()),
     };
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
index 7cd4df4f49..a571294a75 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
@@ -72,61 +72,62 @@ public unsafe LinkableFunction Build(TIR.PrimFunction function)
 
         // 2. write the desc
         var descContent = new MemoryStream();
-        using (var descWriter = new BinaryWriter(descContent, Encoding.UTF8))
-        {
-            DescHeader header = new() { InputPoolSize = 0, OutputPoolSize = 0, Inputs = 0, Outputs = 0 };
-            long headerStart = descWriter.Position();
-            descWriter.Skip((ulong)sizeof(DescHeader));
-
-            foreach (var input in function.Parameters.AsValueEnumerable()
-                                .Where(buf => buf.MemLocation == TIR.MemoryLocation.Input))
-            {
-                header.Inputs++;
-                var rg = new MemoryRange { Start = checked((uint)input.Start), Size = checked((uint)input.Size) };
-                descWriter.Write(ref rg);
-                header.InputPoolSize = Math.Max(header.InputPoolSize, rg.Start + rg.Size);
-                descWriter.Write((uint)input.FixedDimensions.Length);
-                foreach (var dim in input.FixedDimensions)
-                {
-                    descWriter.Write((uint)dim);
-                }
-                foreach (var s in input.FixedStrides)
-                {
-                    descWriter.Write((uint)s);
-                }
-            }
-
-            foreach (var output in function.Parameters.AsValueEnumerable().Where(buf => buf.MemLocation == TIR.MemoryLocation.Output))
-            {
-                header.Outputs++;
-                var rg = new MemoryRange { Start = checked((uint)output.Start), Size = checked((uint)output.Size) };
-                descWriter.Write(ref rg);
-                header.OutputPoolSize = Math.Max(header.OutputPoolSize, rg.Start + rg.Size);
-                descWriter.Write((uint)output.FixedDimensions.Length);
-                foreach (var dim in output.FixedDimensions)
-                {
-                    descWriter.Write((uint)dim);
-                }
-                foreach (var s in output.FixedStrides)
-                {
-                    descWriter.Write((uint)s);
-                }
-            }
-
-            descWriter.Position(headerStart);
-            descWriter.Write(ref header);
-        }
+        // using (var descWriter = new BinaryWriter(descContent, Encoding.UTF8))
+        // {
+        //     DescHeader header = new() { InputPoolSize = 0, OutputPoolSize = 0, Inputs = 0, Outputs = 0 };
+        //     long headerStart = descWriter.Position();
+        //     descWriter.Skip((ulong)sizeof(DescHeader));
+
+        //     foreach (var input in function.Parameters.AsValueEnumerable()
+        //                         .Where(buf => buf.MemLocation == TIR.MemoryLocation.Input))
+        //     {
+        //         header.Inputs++;
+        //         var rg = new MemoryRange { Start = checked((uint)input.Start), Size = checked((uint)input.Size) };
+        //         descWriter.Write(ref rg);
+        //         header.InputPoolSize = Math.Max(header.InputPoolSize, rg.Start + rg.Size);
+        //         descWriter.Write((uint)input.FixedDimensions.Length);
+        //         foreach (var dim in input.FixedDimensions)
+        //         {
+        //             descWriter.Write((uint)dim);
+        //         }
+        //         foreach (var s in input.FixedStrides)
+        //         {
+        //             descWriter.Write((uint)s);
+        //         }
+        //     }
+
+        //     foreach (var output in function.Parameters.AsValueEnumerable().Where(buf => buf.MemLocation == TIR.MemoryLocation.Output))
+        //     {
+        //         header.Outputs++;
+        //         var rg = new MemoryRange { Start = checked((uint)output.Start), Size = checked((uint)output.Size) };
+        //         descWriter.Write(ref rg);
+        //         header.OutputPoolSize = Math.Max(header.OutputPoolSize, rg.Start + rg.Size);
+        //         descWriter.Write((uint)output.FixedDimensions.Length);
+        //         foreach (var dim in output.FixedDimensions)
+        //         {
+        //             descWriter.Write((uint)dim);
+        //         }
+        //         foreach (var s in output.FixedStrides)
+        //         {
+        //             descWriter.Write((uint)s);
+        //         }
+        //     }
+
+        //     descWriter.Position(headerStart);
+        //     descWriter.Write(ref header);
+        // }
 
         // 3. write the rdata
-        foreach (var buffer in function.SchedResult.Rdatas)
+        foreach (var (@const, range) in function.SchedResult.Rdatas)
         {
-            var bytes = buffer.Const!.Value.BytesBuffer;
-            if ((uint)bytes.Length != buffer.Size)
+            var bytes = ((TensorConst)@const).Value.BytesBuffer;
+            var size = range.End.Value - range.Start.Value;
+            if ((uint)bytes.Length != size)
             {
                 throw new InvalidDataException("The Buffer Szie Not Equal!");
             }
 
-            _rdataWriter.Position((uint)buffer.Start);
+            _rdataWriter.Position((uint)size);
             _rdataWriter.Write(bytes);
         }
 
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
index f1f9daab07..e0d361a6da 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
@@ -129,7 +129,7 @@ protected override Expr RewriteLeafCall(Call expr)
                 int param_count = 0;
                 foreach (var b in prim_func.Parameters)
                 {
-                    if (b.MemLocation == TIR.MemoryLocation.Input)
+                    if (b.MemSpan.Location == TIR.MemoryLocation.Input)
                     {
                         if (is_input)
                         {
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 2cf09245c1..bd45b072ca 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -48,9 +48,9 @@ public ConvertVisitor(List<Expr> mainBody)
 
         public Fusion VisitRootFusion => (Fusion)VisitRoot!;
 
-        public IEnumerable<TIR.PhysicalBuffer> OutputBuffers => _buffersMap.Values.OfType<TIR.PhysicalBuffer>().Where(b => b.MemLocation == MemoryLocation.Output);
+        public IEnumerable<TIR.Buffer> OutputBuffers => _buffersMap.Values.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Output));
 
-        public IEnumerable<TIR.PhysicalBuffer> InputBuffers => _buffersMap.Values.OfType<TIR.PhysicalBuffer>().Where(b => b.MemLocation == MemoryLocation.Input);
+        public IEnumerable<TIR.Buffer> InputBuffers => _buffersMap.Values.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Input));
 
         protected override Unit DefaultVisitLeaf(Expr expr)
         {
@@ -98,7 +98,9 @@ private void GenerateMatMul(ReadOnlySpan<Buffer> arguments, Buffer ret, Call exp
 
             // [m,k] @ [k, n]
             var body = T.Block(nameof(MatMul)).Body(
-                T.Sequential(arguments.ToArray().OfType<PhysicalBuffer>().Where(p => p.Const != null).Select(b => T.MatchBuffer(b)).ToArray()),
+                T.MatchBuffer(arguments[0]),
+                T.MatchBuffer(arguments[1]),
+                T.MatchBuffer(ret),
                 final);
             _mainBody.Add(body.Build());
         }
@@ -110,7 +112,10 @@ private void GenerateUnary(Unary unary, ReadOnlySpan<Buffer> arguments, Buffer r
             var loopVars = loops.Select(f => f.loopVar).ToArray();
             Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Unary(unary.UnaryOp, T.BufferLoad(input, loopVars)));
             var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-            _mainBody.Add(T.Block(nameof(Unary)).Body(final).Build());
+            _mainBody.Add(T.Block(nameof(Unary)).Body(
+                T.MatchBuffer(arguments[0]),
+                T.MatchBuffer(ret),
+                final).Build());
         }
 
         private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffer ret, Call call)
@@ -136,7 +141,9 @@ private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffe
             Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Binary(binary.BinaryOp, T.BufferLoad(lhsBuffer, lhsLoopVars), T.BufferLoad(rhsBuffer, rhsLoopVars)));
             var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
             var body = T.Block(nameof(Binary)).Body(
-                T.Sequential(arguments.ToArray().OfType<PhysicalBuffer>().Where(p => p.Const != null).Select(b => T.MatchBuffer(b)).ToArray()),
+                T.MatchBuffer(arguments[0]),
+                T.MatchBuffer(arguments[1]),
+                T.MatchBuffer(ret),
                 final);
             _mainBody.Add(body.Build());
         }
@@ -151,19 +158,19 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
                     case Call c:
                         if (ReferenceEquals(c, VisitRootFusion.Body))
                         {
-                            buffer = T.PhysicalBuffer(c.CheckedDataType, MemoryLocation.Output, c.CheckedShape.ToValueArray(), out _, name);
+                            buffer = T.AttachBuffer((TensorType)c.CheckedType, MemoryLocation.Output, out _, out _, name);
                         }
                         else
                         {
-                            buffer = T.Buffer(c.CheckedDataType, MemoryLocation.Data, c.CheckedShape.ToValueArray().Select(i => (Expr)i).ToArray(), out _, name);
+                            buffer = T.CreateBuffer((TensorType)c.CheckedDataType, MemoryLocation.Data, out _, name);
                         }
 
                         break;
                     case Var v:
-                        buffer = T.PhysicalBuffer(v.CheckedDataType, MemoryLocation.Input, v.CheckedShape.ToValueArray(), out _, name);
+                        buffer = T.AttachBuffer((TensorType)v.CheckedType, MemoryLocation.Input, out _, out _, name);
                         break;
                     case TensorConst c:
-                        buffer = T.ConstBuffer(c, out _, name);
+                        buffer = T.AttachBuffer(c, out _, name);
                         break;
                     default:
                         throw new NotSupportedException();
diff --git a/src/Nncase.Core/FunctionCollector.cs b/src/Nncase.Core/FunctionCollector.cs
index 9ed2a8bca7..12655d25a1 100644
--- a/src/Nncase.Core/FunctionCollector.cs
+++ b/src/Nncase.Core/FunctionCollector.cs
@@ -17,7 +17,7 @@ public FunctionCollector()
 
         public HashSet<Function> Functions => _functions;
 
-        protected override int VisitLeafFunction(Function expr, Unit context)
+        protected override int VisitLeafFunction(Function expr)
         {
             _functions.Add(expr);
             return 0;
diff --git a/src/Nncase.Core/IR/ExprCloner.g.cs b/src/Nncase.Core/IR/ExprCloner.g.cs
index 7357f7f78b..855ff4e22e 100644
--- a/src/Nncase.Core/IR/ExprCloner.g.cs
+++ b/src/Nncase.Core/IR/ExprCloner.g.cs
@@ -1,4 +1,3 @@
-
 //---------------------------------------------------------------------------------------------------
 // <auto-generated>
 //    This code was generated by T4 template.
@@ -57,8 +56,7 @@ protected override Expr VisitLeafIf(If expr, TContext context)
         return expr.With(
             condition: Clone(expr.Condition, context),
             then: Clone(expr.Then, context),
-            @else: Clone(expr.Else, context),
-            paramList: expr.ParamList.Select(p => Clone(p, context)).ToArray()
+            @else: Clone(expr.Else, context)
         );
     }
 
@@ -141,22 +139,6 @@ protected override Expr VisitLeafBlock(TIR.Block expr, TContext context)
         );
     }
 
-    /// <inheritdoc />
-    protected override Expr VisitLeafLogicalBuffer(TIR.LogicalBuffer expr, TContext context)
-    {
-        return expr.With(
-            dimensions: CloneArray(expr.Dimensions, context),
-            strides: CloneArray(expr.Strides, context)
-        );
-    }
-
-    /// <inheritdoc />
-    protected override Expr VisitLeafPhysicalBuffer(TIR.PhysicalBuffer expr, TContext context)
-    {
-        return expr.With(
-        );
-    }
-
     /// <inheritdoc />
     protected override Expr VisitLeafBufferRegion(TIR.BufferRegion expr, TContext context)
     {
@@ -237,12 +219,4 @@ protected override Expr VisitLeafIterVar(TIR.IterVar expr, TContext context)
         );
     }
 
-    /// <inheritdoc />
-    protected override Expr VisitLeafMemSpan(TIR.MemSpan expr, TContext context)
-    {
-        return expr.With(
-            start: Clone(expr.Start, context),
-            size: Clone(expr.Size, context)
-        );
-    }
 }
diff --git a/src/Nncase.Core/IR/ExprFunctor.cs b/src/Nncase.Core/IR/ExprFunctor.cs
index 4462f8d2cc..0fd8bc9ed9 100644
--- a/src/Nncase.Core/IR/ExprFunctor.cs
+++ b/src/Nncase.Core/IR/ExprFunctor.cs
@@ -102,6 +102,13 @@ public partial class ExprFunctor<TExprResult, TTypeResult> : ExprFunctor<TExprRe
     /// <returns>Result.</returns>
     public virtual TTypeResult VisitType(TensorType type) => base.VisitType(type, default);
 
+    /// <summary>
+    /// Visit point type.
+    /// </summary>
+    /// <param name="type">pointer type.</param>
+    /// <returns>Result.</returns>
+    public virtual TTypeResult VisitType(PointerType type) => base.VisitType(type, default);
+
     /// <summary>
     /// Visit tuple type.
     /// </summary>
@@ -135,6 +142,9 @@ public partial class ExprFunctor<TExprResult, TTypeResult> : ExprFunctor<TExprRe
     /// <inheritdoc/>
     public sealed override TTypeResult VisitType(TensorType type, Unit context) => VisitType(type);
 
+    /// <inheritdoc/>
+    public sealed override TTypeResult VisitType(PointerType type, Unit context) => VisitType(type);
+
     /// <inheritdoc/>
     public sealed override TTypeResult VisitType(TupleType type, Unit context) => VisitType(type);
 
diff --git a/src/Nncase.Core/IR/ExprFunctor.g.cs b/src/Nncase.Core/IR/ExprFunctor.g.cs
index f6ff8fd928..188aad4659 100644
--- a/src/Nncase.Core/IR/ExprFunctor.g.cs
+++ b/src/Nncase.Core/IR/ExprFunctor.g.cs
@@ -1,4 +1,3 @@
-
 //---------------------------------------------------------------------------------------------------
 // <auto-generated>
 //    This code was generated by T4 template.
@@ -79,6 +78,11 @@ public partial class ExprFunctor<TExprResult, TTypeResult, TContext>
     /// </summary>
     internal protected virtual TExprResult VisitTupleConst(TupleConst expr, TContext context) => VisitConst(expr, context);
 
+    /// <summary>
+    /// Visit <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    internal protected virtual TExprResult VisitMemSpan(TIR.MemSpan expr, TContext context) => DefaultVisit(expr, context);
+
     /// <summary>
     /// Visit <see cref="Var"/>.
     /// </summary>
@@ -94,16 +98,6 @@ public partial class ExprFunctor<TExprResult, TTypeResult, TContext>
     /// </summary>
     internal protected virtual TExprResult VisitBuffer(TIR.Buffer expr, TContext context) => DefaultVisit(expr, context);
 
-    /// <summary>
-    /// Visit <see cref="TIR.LogicalBuffer"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitLogicalBuffer(TIR.LogicalBuffer expr, TContext context) => VisitBuffer(expr, context);
-
-    /// <summary>
-    /// Visit <see cref="TIR.PhysicalBuffer"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitPhysicalBuffer(TIR.PhysicalBuffer expr, TContext context) => VisitBuffer(expr, context);
-
     /// <summary>
     /// Visit <see cref="TIR.BufferRegion"/>.
     /// </summary>
@@ -144,10 +138,6 @@ public partial class ExprFunctor<TExprResult, TTypeResult, TContext>
     /// </summary>
     internal protected virtual TExprResult VisitIterVar(TIR.IterVar expr, TContext context) => DefaultVisit(expr, context);
 
-    /// <summary>
-    /// Visit <see cref="TIR.MemSpan"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitMemSpan(TIR.MemSpan expr, TContext context) => DefaultVisit(expr, context);
 }
 
 public partial class ExprFunctor<TExprResult, TTypeResult>
@@ -244,6 +234,13 @@ public partial class ExprFunctor<TExprResult, TTypeResult>
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitTupleConst(TupleConst expr, Unit context) => VisitTupleConst(expr);
     /// <summary>
+    /// Visit <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    internal protected virtual TExprResult VisitMemSpan(TIR.MemSpan expr) => base.VisitMemSpan(expr, default);
+    
+    /// <inheritdoc/>
+    internal protected sealed override TExprResult VisitMemSpan(TIR.MemSpan expr, Unit context) => VisitMemSpan(expr);
+    /// <summary>
     /// Visit <see cref="Var"/>.
     /// </summary>
     internal protected virtual TExprResult VisitVar(Var expr) => base.VisitVar(expr, default);
@@ -265,20 +262,6 @@ public partial class ExprFunctor<TExprResult, TTypeResult>
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitBuffer(TIR.Buffer expr, Unit context) => VisitBuffer(expr);
     /// <summary>
-    /// Visit <see cref="TIR.LogicalBuffer"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitLogicalBuffer(TIR.LogicalBuffer expr) => base.VisitLogicalBuffer(expr, default);
-    
-    /// <inheritdoc/>
-    internal protected sealed override TExprResult VisitLogicalBuffer(TIR.LogicalBuffer expr, Unit context) => VisitLogicalBuffer(expr);
-    /// <summary>
-    /// Visit <see cref="TIR.PhysicalBuffer"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitPhysicalBuffer(TIR.PhysicalBuffer expr) => base.VisitPhysicalBuffer(expr, default);
-    
-    /// <inheritdoc/>
-    internal protected sealed override TExprResult VisitPhysicalBuffer(TIR.PhysicalBuffer expr, Unit context) => VisitPhysicalBuffer(expr);
-    /// <summary>
     /// Visit <see cref="TIR.BufferRegion"/>.
     /// </summary>
     internal protected virtual TExprResult VisitBufferRegion(TIR.BufferRegion expr) => base.VisitBufferRegion(expr, default);
@@ -334,11 +317,4 @@ public partial class ExprFunctor<TExprResult, TTypeResult>
     
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitIterVar(TIR.IterVar expr, Unit context) => VisitIterVar(expr);
-    /// <summary>
-    /// Visit <see cref="TIR.MemSpan"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitMemSpan(TIR.MemSpan expr) => base.VisitMemSpan(expr, default);
-
-    /// <inheritdoc/>
-    internal protected sealed override TExprResult VisitMemSpan(TIR.MemSpan expr, Unit context) => VisitMemSpan(expr);
 }
diff --git a/src/Nncase.Core/IR/ExprRewriter.g.cs b/src/Nncase.Core/IR/ExprRewriter.g.cs
index 6695315197..b842c110f1 100644
--- a/src/Nncase.Core/IR/ExprRewriter.g.cs
+++ b/src/Nncase.Core/IR/ExprRewriter.g.cs
@@ -1,4 +1,3 @@
-
 //---------------------------------------------------------------------------------------------------
 // <auto-generated>
 //    This code was generated by T4 template.
@@ -92,6 +91,12 @@ protected sealed override Expr VisitLeafTupleConst(TupleConst expr, TContext con
         return RewriteLeafTupleConst(expr, context);
     }
 
+    /// <inheritdoc/>
+    protected sealed override Expr VisitLeafMemSpan(TIR.MemSpan expr, TContext context)
+    {
+        return RewriteLeafMemSpan(expr, context);
+    }
+
     /// <inheritdoc/>
     protected sealed override Expr VisitLeafVar(Var expr, TContext context)
     {
@@ -110,18 +115,6 @@ protected sealed override Expr VisitLeafBuffer(TIR.Buffer expr, TContext context
         return RewriteLeafBuffer(expr, context);
     }
 
-    /// <inheritdoc/>
-    protected sealed override Expr VisitLeafLogicalBuffer(TIR.LogicalBuffer expr, TContext context)
-    {
-        return RewriteLeafLogicalBuffer(expr, context);
-    }
-
-    /// <inheritdoc/>
-    protected sealed override Expr VisitLeafPhysicalBuffer(TIR.PhysicalBuffer expr, TContext context)
-    {
-        return RewriteLeafPhysicalBuffer(expr, context);
-    }
-
     /// <inheritdoc/>
     protected sealed override Expr VisitLeafBufferRegion(TIR.BufferRegion expr, TContext context)
     {
@@ -235,6 +228,11 @@ protected sealed override Expr VisitLeafIterVar(TIR.IterVar expr, TContext conte
     /// </summary>
     protected virtual Expr RewriteLeafTupleConst(TupleConst expr, TContext context) => RewriteLeafConst(expr, context);
 
+    /// <summary>
+    /// Rewrite leaf <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    protected virtual Expr RewriteLeafMemSpan(TIR.MemSpan expr, TContext context) => DefaultRewriteLeaf(expr, context);
+
     /// <summary>
     /// Rewrite leaf <see cref="Var"/>.
     /// </summary>
@@ -250,16 +248,6 @@ protected sealed override Expr VisitLeafIterVar(TIR.IterVar expr, TContext conte
     /// </summary>
     protected virtual Expr RewriteLeafBuffer(TIR.Buffer expr, TContext context) => DefaultRewriteLeaf(expr, context);
 
-    /// <summary>
-    /// Rewrite leaf <see cref="TIR.LogicalBuffer"/>.
-    /// </summary>
-    protected virtual Expr RewriteLeafLogicalBuffer(TIR.LogicalBuffer expr, TContext context) => RewriteLeafBuffer(expr, context);
-
-    /// <summary>
-    /// Rewrite leaf <see cref="TIR.PhysicalBuffer"/>.
-    /// </summary>
-    protected virtual Expr RewriteLeafPhysicalBuffer(TIR.PhysicalBuffer expr, TContext context) => RewriteLeafBuffer(expr, context);
-
     /// <summary>
     /// Rewrite leaf <see cref="TIR.BufferRegion"/>.
     /// </summary>
@@ -300,10 +288,6 @@ protected sealed override Expr VisitLeafIterVar(TIR.IterVar expr, TContext conte
     /// </summary>
     protected virtual Expr RewriteLeafIterVar(TIR.IterVar expr, TContext context) => DefaultRewriteLeaf(expr, context);
 
-    /// <summary>
-    /// Rewrite leaf <see cref="TIR.MemSpan"/>.
-    /// </summary>
-    protected virtual Expr RewriteLeafMemSpan(TIR.MemSpan expr, TContext context) => DefaultRewriteLeaf(expr, context);
 }
 
 public partial class ExprRewriter
@@ -412,6 +396,14 @@ public partial class ExprRewriter
     /// <inheritdoc />
     protected sealed override Expr RewriteLeafTupleConst(TupleConst expr, Unit context) => RewriteLeafTupleConst(expr);
 
+    /// <summary>
+    /// Rewrite leaf <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    protected virtual Expr RewriteLeafMemSpan(TIR.MemSpan expr) => DefaultRewriteLeaf(expr);
+
+    /// <inheritdoc />
+    protected sealed override Expr RewriteLeafMemSpan(TIR.MemSpan expr, Unit context) => RewriteLeafMemSpan(expr);
+
     /// <summary>
     /// Rewrite leaf <see cref="Var"/>.
     /// </summary>
@@ -436,22 +428,6 @@ public partial class ExprRewriter
     /// <inheritdoc />
     protected sealed override Expr RewriteLeafBuffer(TIR.Buffer expr, Unit context) => RewriteLeafBuffer(expr);
 
-    /// <summary>
-    /// Rewrite leaf <see cref="TIR.LogicalBuffer"/>.
-    /// </summary>
-    protected virtual Expr RewriteLeafLogicalBuffer(TIR.LogicalBuffer expr) => RewriteLeafBuffer(expr);
-
-    /// <inheritdoc />
-    protected sealed override Expr RewriteLeafLogicalBuffer(TIR.LogicalBuffer expr, Unit context) => RewriteLeafLogicalBuffer(expr);
-
-    /// <summary>
-    /// Rewrite leaf <see cref="TIR.PhysicalBuffer"/>.
-    /// </summary>
-    protected virtual Expr RewriteLeafPhysicalBuffer(TIR.PhysicalBuffer expr) => RewriteLeafBuffer(expr);
-
-    /// <inheritdoc />
-    protected sealed override Expr RewriteLeafPhysicalBuffer(TIR.PhysicalBuffer expr, Unit context) => RewriteLeafPhysicalBuffer(expr);
-
     /// <summary>
     /// Rewrite leaf <see cref="TIR.BufferRegion"/>.
     /// </summary>
@@ -516,11 +492,4 @@ public partial class ExprRewriter
     /// <inheritdoc />
     protected sealed override Expr RewriteLeafIterVar(TIR.IterVar expr, Unit context) => RewriteLeafIterVar(expr);
 
-    /// <summary>
-    /// Rewrite leaf <see cref="TIR.MemSpan"/>.
-    /// </summary>
-    protected virtual Expr RewriteLeafMemSpan(TIR.MemSpan expr) => DefaultRewriteLeaf(expr);
-
-    /// <inheritdoc />
-    protected sealed override Expr RewriteLeafMemSpan(TIR.MemSpan expr, Unit context) => RewriteLeafMemSpan(expr);
 }
diff --git a/src/Nncase.Core/IR/ExprVisitor.g.cs b/src/Nncase.Core/IR/ExprVisitor.g.cs
index c56e4f5aa7..75dc5ab13d 100644
--- a/src/Nncase.Core/IR/ExprVisitor.g.cs
+++ b/src/Nncase.Core/IR/ExprVisitor.g.cs
@@ -1,4 +1,3 @@
-
 //---------------------------------------------------------------------------------------------------
 // <auto-generated>
 //    This code was generated by T4 template.
@@ -117,20 +116,6 @@ protected internal override TExprResult VisitBlock(TIR.Block expr, TContext cont
         return VisitLeafBlock(expr, context);
     }
 
-    /// <inheritdoc />
-    protected internal override TExprResult VisitLogicalBuffer(TIR.LogicalBuffer expr, TContext context)
-    {
-        VisitOperands(expr, context);
-        return VisitLeafLogicalBuffer(expr, context);
-    }
-
-    /// <inheritdoc />
-    protected internal override TExprResult VisitPhysicalBuffer(TIR.PhysicalBuffer expr, TContext context)
-    {
-        VisitOperands(expr, context);
-        return VisitLeafPhysicalBuffer(expr, context);
-    }
-
     /// <inheritdoc />
     protected internal override TExprResult VisitBufferRegion(TIR.BufferRegion expr, TContext context)
     {
@@ -191,13 +176,6 @@ protected internal override TExprResult VisitIterVar(TIR.IterVar expr, TContext
         return VisitLeafIterVar(expr, context);
     }
 
-    /// <inheritdoc />
-    protected internal override TExprResult VisitMemSpan(TIR.MemSpan expr, TContext context)
-    {
-        VisitOperands(expr, context);
-        return VisitLeafMemSpan(expr, context);
-    }
-
     /// <summary>
     /// Visit leaf <see cref="BaseFunction"/>.
     /// </summary>
@@ -263,6 +241,11 @@ protected internal override TExprResult VisitMemSpan(TIR.MemSpan expr, TContext
     /// </summary>
     protected virtual TExprResult VisitLeafTupleConst(TupleConst expr, TContext context) => VisitLeafConst(expr, context);
 
+    /// <summary>
+    /// Visit leaf <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    protected virtual TExprResult VisitLeafMemSpan(TIR.MemSpan expr, TContext context) => DefaultVisitLeaf(expr, context);
+
     /// <summary>
     /// Visit leaf <see cref="Var"/>.
     /// </summary>
@@ -278,16 +261,6 @@ protected internal override TExprResult VisitMemSpan(TIR.MemSpan expr, TContext
     /// </summary>
     protected virtual TExprResult VisitLeafBuffer(TIR.Buffer expr, TContext context) => DefaultVisitLeaf(expr, context);
 
-    /// <summary>
-    /// Visit leaf <see cref="TIR.LogicalBuffer"/>.
-    /// </summary>
-    protected virtual TExprResult VisitLeafLogicalBuffer(TIR.LogicalBuffer expr, TContext context) => VisitLeafBuffer(expr, context);
-
-    /// <summary>
-    /// Visit leaf <see cref="TIR.PhysicalBuffer"/>.
-    /// </summary>
-    protected virtual TExprResult VisitLeafPhysicalBuffer(TIR.PhysicalBuffer expr, TContext context) => VisitLeafBuffer(expr, context);
-
     /// <summary>
     /// Visit leaf <see cref="TIR.BufferRegion"/>.
     /// </summary>
@@ -328,11 +301,6 @@ protected internal override TExprResult VisitMemSpan(TIR.MemSpan expr, TContext
     /// </summary>
     protected virtual TExprResult VisitLeafIterVar(TIR.IterVar expr, TContext context) => DefaultVisitLeaf(expr, context);
 
-    /// <summary>
-    /// Visit leaf <see cref="TIR.MemSpan"/>.
-    /// </summary>
-    protected virtual TExprResult VisitLeafMemSpan(TIR.MemSpan expr, TContext context) => DefaultVisitLeaf(expr, context);
-
 }
 
 public partial class ExprVisitor<TExprResult, TTypeResult>
@@ -341,176 +309,154 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit <see cref="Call"/>.
     /// </summary>
     internal protected virtual TExprResult VisitCall(Call expr) => base.VisitCall(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitCall(Call expr, Unit context) => VisitCall(expr);
     /// <summary>
     /// Visit <see cref="Function"/>.
     /// </summary>
     internal protected virtual TExprResult VisitFunction(Function expr) => base.VisitFunction(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitFunction(Function expr, Unit context) => VisitFunction(expr);
     /// <summary>
     /// Visit <see cref="Fusion"/>.
     /// </summary>
     internal protected virtual TExprResult VisitFusion(Fusion expr) => base.VisitFusion(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitFusion(Fusion expr, Unit context) => VisitFusion(expr);
     /// <summary>
     /// Visit <see cref="If"/>.
     /// </summary>
     internal protected virtual TExprResult VisitIf(If expr) => base.VisitIf(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitIf(If expr, Unit context) => VisitIf(expr);
     /// <summary>
     /// Visit <see cref="Marker"/>.
     /// </summary>
     internal protected virtual TExprResult VisitMarker(Marker expr) => base.VisitMarker(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitMarker(Marker expr, Unit context) => VisitMarker(expr);
     /// <summary>
     /// Visit <see cref="None"/>.
     /// </summary>
     internal protected virtual TExprResult VisitNone(None expr) => base.VisitNone(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitNone(None expr, Unit context) => VisitNone(expr);
     /// <summary>
     /// Visit <see cref="Op"/>.
     /// </summary>
     internal protected virtual TExprResult VisitOp(Op expr) => base.VisitOp(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitOp(Op expr, Unit context) => VisitOp(expr);
     /// <summary>
     /// Visit <see cref="PrimFunctionWrapper"/>.
     /// </summary>
     internal protected virtual TExprResult VisitPrimFunctionWrapper(PrimFunctionWrapper expr) => base.VisitPrimFunctionWrapper(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitPrimFunctionWrapper(PrimFunctionWrapper expr, Unit context) => VisitPrimFunctionWrapper(expr);
     /// <summary>
     /// Visit <see cref="TensorConst"/>.
     /// </summary>
     internal protected virtual TExprResult VisitTensorConst(TensorConst expr) => base.VisitTensorConst(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitTensorConst(TensorConst expr, Unit context) => VisitTensorConst(expr);
     /// <summary>
     /// Visit <see cref="IR.Tuple"/>.
     /// </summary>
     internal protected virtual TExprResult VisitTuple(IR.Tuple expr) => base.VisitTuple(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitTuple(IR.Tuple expr, Unit context) => VisitTuple(expr);
     /// <summary>
     /// Visit <see cref="TupleConst"/>.
     /// </summary>
     internal protected virtual TExprResult VisitTupleConst(TupleConst expr) => base.VisitTupleConst(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitTupleConst(TupleConst expr, Unit context) => VisitTupleConst(expr);
     /// <summary>
     /// Visit <see cref="Var"/>.
     /// </summary>
     internal protected virtual TExprResult VisitVar(Var expr) => base.VisitVar(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitVar(Var expr, Unit context) => VisitVar(expr);
     /// <summary>
     /// Visit <see cref="TIR.Block"/>.
     /// </summary>
     internal protected virtual TExprResult VisitBlock(TIR.Block expr) => base.VisitBlock(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitBlock(TIR.Block expr, Unit context) => VisitBlock(expr);
     /// <summary>
-    /// Visit <see cref="TIR.LogicalBuffer"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitLogicalBuffer(TIR.LogicalBuffer expr) => base.VisitLogicalBuffer(expr, default);
-
-    /// <inheritdoc/>
-    internal protected sealed override TExprResult VisitLogicalBuffer(TIR.LogicalBuffer expr, Unit context) => VisitLogicalBuffer(expr);
-    /// <summary>
-    /// Visit <see cref="TIR.PhysicalBuffer"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitPhysicalBuffer(TIR.PhysicalBuffer expr) => base.VisitPhysicalBuffer(expr, default);
-
-    /// <inheritdoc/>
-    internal protected sealed override TExprResult VisitPhysicalBuffer(TIR.PhysicalBuffer expr, Unit context) => VisitPhysicalBuffer(expr);
-    /// <summary>
     /// Visit <see cref="TIR.BufferRegion"/>.
     /// </summary>
     internal protected virtual TExprResult VisitBufferRegion(TIR.BufferRegion expr) => base.VisitBufferRegion(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitBufferRegion(TIR.BufferRegion expr, Unit context) => VisitBufferRegion(expr);
     /// <summary>
     /// Visit <see cref="TIR.For"/>.
     /// </summary>
     internal protected virtual TExprResult VisitFor(TIR.For expr) => base.VisitFor(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitFor(TIR.For expr, Unit context) => VisitFor(expr);
     /// <summary>
     /// Visit <see cref="TIR.IfThenElse"/>.
     /// </summary>
     internal protected virtual TExprResult VisitIfThenElse(TIR.IfThenElse expr) => base.VisitIfThenElse(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitIfThenElse(TIR.IfThenElse expr, Unit context) => VisitIfThenElse(expr);
     /// <summary>
     /// Visit <see cref="TIR.Let"/>.
     /// </summary>
     internal protected virtual TExprResult VisitLet(TIR.Let expr) => base.VisitLet(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitLet(TIR.Let expr, Unit context) => VisitLet(expr);
     /// <summary>
     /// Visit <see cref="TIR.PrimFunction"/>.
     /// </summary>
     internal protected virtual TExprResult VisitPrimFunction(TIR.PrimFunction expr) => base.VisitPrimFunction(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitPrimFunction(TIR.PrimFunction expr, Unit context) => VisitPrimFunction(expr);
     /// <summary>
     /// Visit <see cref="TIR.Sequential"/>.
     /// </summary>
     internal protected virtual TExprResult VisitSequential(TIR.Sequential expr) => base.VisitSequential(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitSequential(TIR.Sequential expr, Unit context) => VisitSequential(expr);
     /// <summary>
     /// Visit <see cref="TIR.Range"/>.
     /// </summary>
     internal protected virtual TExprResult VisitRange(TIR.Range expr) => base.VisitRange(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitRange(TIR.Range expr, Unit context) => VisitRange(expr);
     /// <summary>
     /// Visit <see cref="TIR.IterVar"/>.
     /// </summary>
     internal protected virtual TExprResult VisitIterVar(TIR.IterVar expr) => base.VisitIterVar(expr, default);
-
+    
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitIterVar(TIR.IterVar expr, Unit context) => VisitIterVar(expr);
-    /// <summary>
-    /// Visit <see cref="TIR.IterVar"/>.
-    /// </summary>
-    internal protected virtual TExprResult VisitMemSpan(TIR.MemSpan expr) => base.VisitMemSpan(expr, default);
-
-    /// <inheritdoc/>
-    internal protected sealed override TExprResult VisitMemSpan(TIR.MemSpan expr, Unit context) => VisitMemSpan(expr);
-
     /// <summary>
     /// Visit leaf <see cref="BaseFunction"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafBaseFunction(BaseFunction expr) => base.VisitLeafBaseFunction(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafBaseFunction(BaseFunction expr, Unit context) => VisitLeafBaseFunction(expr);
 
@@ -518,7 +464,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="Call"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafCall(Call expr) => base.VisitLeafCall(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafCall(Call expr, Unit context) => VisitLeafCall(expr);
 
@@ -526,7 +472,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="Const"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafConst(Const expr) => base.VisitLeafConst(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafConst(Const expr, Unit context) => VisitLeafConst(expr);
 
@@ -534,15 +480,15 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="Function"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafFunction(Function expr) => base.VisitLeafFunction(expr, default);
-
+    
     /// <inheritdoc/>
-    protected override TExprResult VisitLeafFunction(Function expr, Unit context) => VisitLeafFunction(expr);
+    protected sealed override TExprResult VisitLeafFunction(Function expr, Unit context) => VisitLeafFunction(expr);
 
     /// <summary>
     /// Visit leaf <see cref="Fusion"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafFusion(Fusion expr) => base.VisitLeafFusion(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafFusion(Fusion expr, Unit context) => VisitLeafFusion(expr);
 
@@ -550,7 +496,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="If"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafIf(If expr) => base.VisitLeafIf(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafIf(If expr, Unit context) => VisitLeafIf(expr);
 
@@ -558,7 +504,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="Marker"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafMarker(Marker expr) => base.VisitLeafMarker(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafMarker(Marker expr, Unit context) => VisitLeafMarker(expr);
 
@@ -566,7 +512,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="None"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafNone(None expr) => base.VisitLeafNone(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafNone(None expr, Unit context) => VisitLeafNone(expr);
 
@@ -574,7 +520,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="Op"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafOp(Op expr) => base.VisitLeafOp(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafOp(Op expr, Unit context) => VisitLeafOp(expr);
 
@@ -582,7 +528,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="PrimFunctionWrapper"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafPrimFunctionWrapper(PrimFunctionWrapper expr) => base.VisitLeafPrimFunctionWrapper(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafPrimFunctionWrapper(PrimFunctionWrapper expr, Unit context) => VisitLeafPrimFunctionWrapper(expr);
 
@@ -590,7 +536,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="TensorConst"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafTensorConst(TensorConst expr) => base.VisitLeafTensorConst(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafTensorConst(TensorConst expr, Unit context) => VisitLeafTensorConst(expr);
 
@@ -598,7 +544,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="IR.Tuple"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafTuple(IR.Tuple expr) => base.VisitLeafTuple(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafTuple(IR.Tuple expr, Unit context) => VisitLeafTuple(expr);
 
@@ -606,15 +552,23 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="TupleConst"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafTupleConst(TupleConst expr) => base.VisitLeafTupleConst(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafTupleConst(TupleConst expr, Unit context) => VisitLeafTupleConst(expr);
 
+    /// <summary>
+    /// Visit leaf <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    protected virtual TExprResult VisitLeafMemSpan(TIR.MemSpan expr) => base.VisitLeafMemSpan(expr, default);
+    
+    /// <inheritdoc/>
+    protected sealed override TExprResult VisitLeafMemSpan(TIR.MemSpan expr, Unit context) => VisitLeafMemSpan(expr);
+
     /// <summary>
     /// Visit leaf <see cref="Var"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafVar(Var expr) => base.VisitLeafVar(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafVar(Var expr, Unit context) => VisitLeafVar(expr);
 
@@ -622,7 +576,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="TIR.Block"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafBlock(TIR.Block expr) => base.VisitLeafBlock(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafBlock(TIR.Block expr, Unit context) => VisitLeafBlock(expr);
 
@@ -630,31 +584,15 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="TIR.Buffer"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafBuffer(TIR.Buffer expr) => base.VisitLeafBuffer(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafBuffer(TIR.Buffer expr, Unit context) => VisitLeafBuffer(expr);
 
-    /// <summary>
-    /// Visit leaf <see cref="TIR.LogicalBuffer"/>.
-    /// </summary>
-    protected virtual TExprResult VisitLeafLogicalBuffer(TIR.LogicalBuffer expr) => base.VisitLeafLogicalBuffer(expr, default);
-
-    /// <inheritdoc/>
-    protected sealed override TExprResult VisitLeafLogicalBuffer(TIR.LogicalBuffer expr, Unit context) => VisitLeafLogicalBuffer(expr);
-
-    /// <summary>
-    /// Visit leaf <see cref="TIR.PhysicalBuffer"/>.
-    /// </summary>
-    protected virtual TExprResult VisitLeafPhysicalBuffer(TIR.PhysicalBuffer expr) => base.VisitLeafPhysicalBuffer(expr, default);
-
-    /// <inheritdoc/>
-    protected sealed override TExprResult VisitLeafPhysicalBuffer(TIR.PhysicalBuffer expr, Unit context) => VisitLeafPhysicalBuffer(expr);
-
     /// <summary>
     /// Visit leaf <see cref="TIR.BufferRegion"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafBufferRegion(TIR.BufferRegion expr) => base.VisitLeafBufferRegion(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafBufferRegion(TIR.BufferRegion expr, Unit context) => VisitLeafBufferRegion(expr);
 
@@ -662,7 +600,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="TIR.For"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafFor(TIR.For expr) => base.VisitLeafFor(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafFor(TIR.For expr, Unit context) => VisitLeafFor(expr);
 
@@ -670,7 +608,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="TIR.IfThenElse"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafIfThenElse(TIR.IfThenElse expr) => base.VisitLeafIfThenElse(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafIfThenElse(TIR.IfThenElse expr, Unit context) => VisitLeafIfThenElse(expr);
 
@@ -678,7 +616,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="TIR.Let"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafLet(TIR.Let expr) => base.VisitLeafLet(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafLet(TIR.Let expr, Unit context) => VisitLeafLet(expr);
 
@@ -686,7 +624,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="TIR.PrimFunction"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafPrimFunction(TIR.PrimFunction expr) => base.VisitLeafPrimFunction(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafPrimFunction(TIR.PrimFunction expr, Unit context) => VisitLeafPrimFunction(expr);
 
@@ -694,7 +632,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="TIR.Sequential"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafSequential(TIR.Sequential expr) => base.VisitLeafSequential(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafSequential(TIR.Sequential expr, Unit context) => VisitLeafSequential(expr);
 
@@ -702,7 +640,7 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="TIR.Range"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafRange(TIR.Range expr) => base.VisitLeafRange(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafRange(TIR.Range expr, Unit context) => VisitLeafRange(expr);
 
@@ -710,15 +648,8 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// Visit leaf <see cref="TIR.IterVar"/>.
     /// </summary>
     protected virtual TExprResult VisitLeafIterVar(TIR.IterVar expr) => base.VisitLeafIterVar(expr, default);
-
+    
     /// <inheritdoc/>
     protected sealed override TExprResult VisitLeafIterVar(TIR.IterVar expr, Unit context) => VisitLeafIterVar(expr);
 
-    /// <summary>
-    /// Visit leaf <see cref="TIR.MemSpan"/>.
-    /// </summary>
-    protected virtual TExprResult VisitLeafMemSpan(TIR.MemSpan expr) => base.VisitLeafMemSpan(expr, default);
-
-    /// <inheritdoc/>
-    protected sealed override TExprResult VisitLeafMemSpan(TIR.MemSpan expr, Unit context) => VisitLeafMemSpan(expr);
 }
diff --git a/src/Nncase.Core/IR/IRList.csv b/src/Nncase.Core/IR/IRList.csv
index 5ae3c89d18..8a1e2ed2f1 100644
--- a/src/Nncase.Core/IR/IRList.csv
+++ b/src/Nncase.Core/IR/IRList.csv
@@ -11,14 +11,11 @@ PrimFunctionWrapper,true,true,BaseFunction,,Target
 TensorConst,true,false,Const,,
 Tuple,true,false,Default,IR.,@Fields
 TupleConst,true,false,Const,,
+MemSpan,false,false,Default,TIR.,Start;Size;
 Var,true,false,Default,,
 Block,true,false,Default,TIR.,Body;InitBody;@IterVars;@Reads;@Writes;@AllocBuffers;Predicate
-Buffer,false,false,Default,TIR.,
-LogicalBuffer,true,false,Buffer,TIR.,@Dimensions;@Strides
-PhysicalBuffer,true,false,Buffer,TIR.,
-BufferLoad,true,false,Default,TIR.,Buffer;@Indices
+Buffer,false,false,Default,TIR.,MemSpan;@Dimensions;@Strides
 BufferRegion,true,false,Default,TIR.,Buffer;@Region
-BufferStore,true,false,Default,TIR.,Buffer;@Indices;Value
 For,true,false,Default,TIR.,LoopVar;Domain;Body
 IfThenElse,true,false,Default,TIR.,Condition;Then;Else
 Let,true,false,Default,TIR.,Var;Expression;Body
diff --git a/src/Nncase.Core/IR/TypeFunctor.cs b/src/Nncase.Core/IR/TypeFunctor.cs
index 453cfa257a..d63f56c101 100644
--- a/src/Nncase.Core/IR/TypeFunctor.cs
+++ b/src/Nncase.Core/IR/TypeFunctor.cs
@@ -68,6 +68,14 @@ public virtual TResult VisitType(IRType type, TContext context)
     /// <returns>Result.</returns>
     public virtual TResult VisitType(TensorType type, TContext context) => DefaultVisitType(type, context);
 
+    /// <summary>
+    /// Visit pointer type.
+    /// </summary>
+    /// <param name="type">Pointer type.</param>
+    /// <param name="context">Context.</param>
+    /// <returns>Result.</returns>
+    public virtual TResult VisitType(PointerType type, TContext context) => DefaultVisitType(type, context);
+
     /// <summary>
     /// Visit tuple type.
     /// </summary>
diff --git a/src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs b/src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs
index 4bc48af9d1..018183c5d7 100644
--- a/src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs
+++ b/src/Nncase.Core/Passes/Mutators/FoldBufferSlot.cs
@@ -28,7 +28,7 @@ protected override Expr RewriteLeafCall(Call expr)
     {
         if (expr.Target is IR.Buffers.BaseMentOf)
         {
-            var locate = ((TIR.PhysicalBuffer)expr.Arguments[0]).MemLocation;
+            var locate = ((TIR.MemSpan)expr.Arguments[0]).Location;
             return locate switch
             {
                 MemoryLocation.Input => 0,
@@ -40,7 +40,7 @@ protected override Expr RewriteLeafCall(Call expr)
         }
         else if (expr.Target is IR.Buffers.DDrOf)
         {
-            if (expr.Arguments[0] is TIR.PhysicalBuffer buf)
+            if (expr.Arguments[0] is TIR.MemSpan buf)
             {
                 return buf.Start;
             }
diff --git a/src/Nncase.Core/Passes/Mutators/UnRollLoopSequential.cs b/src/Nncase.Core/Passes/Mutators/UnRollLoopSequential.cs
index e0a043cc64..0bb934f02a 100644
--- a/src/Nncase.Core/Passes/Mutators/UnRollLoopSequential.cs
+++ b/src/Nncase.Core/Passes/Mutators/UnRollLoopSequential.cs
@@ -144,8 +144,6 @@ public LoopBodyCloner(IReadOnlyDictionary<Var, TensorConst> vmap, Dictionary<Typ
             }
         }
 
-        protected override Expr VisitLeafPhysicalBuffer(PhysicalBuffer expr, Unit context) => expr;
-
         protected override Expr VisitLeafVar(Var expr, Unit context)
         {
             if (_vmap.TryGetValue(expr, out var result))
@@ -189,9 +187,10 @@ protected override Expr VisitLeafRange(TIR.Range expr, Unit context)
             return CSE(expr.With(start: Clone(expr.Start, context), stop: Clone(expr.Stop, context), step: Clone(expr.Step, context)));
         }
 
-        protected override Expr VisitLeafLogicalBuffer(LogicalBuffer expr, Unit context)
+        protected override Expr VisitLeafBuffer(TIR.Buffer expr, Unit context)
         {
             return expr.With(
+                memSpan: Clone<MemSpan>(expr.MemSpan, context),
                 dimensions: CloneArray(expr.Dimensions, context).Select(e => CSE(e)).ToArray(),
                 strides: CloneArray(expr.Strides, context));
         }
diff --git a/src/Nncase.Core/Schedule/ScheduleTypes.cs b/src/Nncase.Core/Schedule/ScheduleTypes.cs
index f63e0467dc..8661109f22 100644
--- a/src/Nncase.Core/Schedule/ScheduleTypes.cs
+++ b/src/Nncase.Core/Schedule/ScheduleTypes.cs
@@ -215,7 +215,7 @@ public SchedFunctionResult()
     /// <summary>
     /// Gets the buffer allocation.
     /// </summary>
-    public HashSet<TIR.PhysicalBuffer> Rdatas { get; }
+    public Dictionary<IR.Const, System.Range> Rdatas { get; }
 
     /// <summary>
     /// Gets or sets the data section length.
@@ -250,7 +250,7 @@ public override bool Equals(object? obj)
             return true;
         }
 
-        return EqualityComparer<HashSet<TIR.PhysicalBuffer>>.Default.Equals(Rdatas, result.Rdatas) &&
+        return EqualityComparer<Dictionary<IR.Const, System.Range>>.Default.Equals(Rdatas, result.Rdatas) &&
                EqualityComparer<int>.Default.Equals(DataUsage, result.DataUsage);
     }
 
diff --git a/src/Nncase.Core/TIR/Buffer.cs b/src/Nncase.Core/TIR/Buffer.cs
index 80f86c4f21..cc5c5f1155 100644
--- a/src/Nncase.Core/TIR/Buffer.cs
+++ b/src/Nncase.Core/TIR/Buffer.cs
@@ -269,15 +269,12 @@ public SelectedRange Slice(Segment1D segment)
 /// </summary>
 public sealed class Buffer : Expr
 {
-    private static int _globalVarIndex;
-
     public Buffer(string name, DataType elemType, MemSpan memSpan, Expr[] dimensions, Expr[] strides)
         : base(new[] { memSpan }.Concat(dimensions).Concat(strides))
     {
         Name = name;
         ElemType = elemType;
         Rank = dimensions.Length;
-        GlobalVarIndex = Interlocked.Increment(ref _globalVarIndex);
     }
 
     public string Name { get; }
@@ -289,11 +286,6 @@ public Buffer(string name, DataType elemType, MemSpan memSpan, Expr[] dimensions
     /// </summary>
     public int Rank { get; }
 
-    /// <summary>
-    /// Gets the global var index.
-    /// </summary>
-    public int GlobalVarIndex { get; }
-
     /// <summary>
     /// Gets the shape.
     /// </summary>
@@ -312,5 +304,8 @@ public Buffer(string name, DataType elemType, MemSpan memSpan, Expr[] dimensions
     /// </summary>
     public ReadOnlySpan<Expr> Strides => Operands[(1 + Rank)..(1 + Rank + Rank)];
 
-    public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context) => throw new NotImplementedException();
-}
\ No newline at end of file
+    public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context) => functor.VisitBuffer(this, context);
+
+    public Buffer With(MemSpan? memSpan = null, Expr[]? dimensions = null, Expr[]? strides = null)
+        => new Buffer(Name, ElemType, memSpan ?? MemSpan, dimensions ?? Dimensions.ToArray(), strides ?? Strides.ToArray());
+}
diff --git a/src/Nncase.Core/TIR/MemSpan.cs b/src/Nncase.Core/TIR/MemSpan.cs
index 0ee5b4a215..3610d198c3 100644
--- a/src/Nncase.Core/TIR/MemSpan.cs
+++ b/src/Nncase.Core/TIR/MemSpan.cs
@@ -9,47 +9,48 @@ namespace Nncase.TIR;
 /// <summary>
 /// the memory type.
 /// </summary>
-public enum MemoryLocation : byte
+[Flags]
+public enum MemoryLocation
 {
     /// <summary>
     /// input.
     /// </summary>
-    Input = 0,
+    Input = 1 << 1,
 
     /// <summary>
     /// output.
     /// </summary>
-    Output = 1,
+    Output = 1 << 2,
 
     /// <summary>
     /// constant data.
     /// </summary>
-    Rdata = 2,
+    Rdata = 1 << 3,
 
     /// <summary>
     /// compute temp data.
     /// </summary>
-    Data = 3,
+    Data = 1 << 4,
 
     /// <summary>
     /// shared data.
     /// </summary>
-    SharedData = 4,
+    SharedData = 1 << 5,
 
     /// <summary>
     /// l2 data.
     /// </summary>
-    L2Data = 5,
+    L2Data = 1 << 6,
 
     /// <summary>
     /// L1 data.
     /// </summary>
-    L1Data = 6,
+    L1Data = 1 << 7,
 
     /// <summary>
     /// base addr.
     /// </summary>
-    PrivateBase = 64,
+    PrivateBase = 1 << 8,
 }
 
 public sealed class MemSpan : Expr
@@ -81,6 +82,8 @@ public MemSpan(Expr start, Expr size, MemoryLocation location)
     /// </summary>
     public MemoryLocation Location { get; }
 
+    public MemSpan SubSpan(Expr offset, Expr size) => new MemSpan((Start is None ? IR.F.Buffer.DDrOf(this) : Start) + offset, size, Location);
+
     /// <inheritdoc/>
     public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context)
         => functor.VisitMemSpan(this, context);
diff --git a/src/Nncase.Core/TIR/PrimFunction.cs b/src/Nncase.Core/TIR/PrimFunction.cs
index ea208efb15..2bf94454eb 100644
--- a/src/Nncase.Core/TIR/PrimFunction.cs
+++ b/src/Nncase.Core/TIR/PrimFunction.cs
@@ -28,8 +28,8 @@ public sealed class PrimFunction : BaseFunction
     /// <param name="moduleKind">module kind.</param>
     /// <param name="parameters">Arguments.</param>
     /// <param name="body">Body.</param>
-    public PrimFunction(string name, string moduleKind, Sequential body, ReadOnlySpan<PhysicalBuffer> parameters)
-        : base(name, moduleKind, ArrayUtility.Concat(body, SpanUtility.UnsafeCast<PhysicalBuffer, Expr>(parameters)))
+    public PrimFunction(string name, string moduleKind, Sequential body, ReadOnlySpan<Buffer> parameters)
+        : base(name, moduleKind, ArrayUtility.Concat(body, SpanUtility.UnsafeCast<Buffer, Expr>(parameters)))
     {
     }
 
@@ -39,7 +39,7 @@ public PrimFunction(string name, string moduleKind, Sequential body, ReadOnlySpa
     /// <param name="moduleKind">module kind.</param>
     /// <param name="parameters">Arguments.</param>
     /// <param name="body">Body.</param>
-    public PrimFunction(string moduleKind, Sequential body, ReadOnlySpan<PhysicalBuffer> parameters)
+    public PrimFunction(string moduleKind, Sequential body, ReadOnlySpan<Buffer> parameters)
         : this($"primfunc_{_globalFuncIndex++}", moduleKind, body, parameters)
     {
     }
@@ -48,7 +48,7 @@ public PrimFunction(string moduleKind, Sequential body, ReadOnlySpan<PhysicalBuf
     /// Initializes a new instance of the <see cref="PrimFunction"/> class.
     /// build function.
     /// </summary>
-    public PrimFunction(string moduleKind, Sequential body, params PhysicalBuffer[] parameters)
+    public PrimFunction(string moduleKind, Sequential body, params Buffer[] parameters)
         : this($"primfunc_{_globalFuncIndex++}", moduleKind, body, new(parameters))
     {
     }
@@ -58,7 +58,7 @@ public PrimFunction(string moduleKind, Sequential body, params PhysicalBuffer[]
     /// </summary>
     public Sequential Body => (Sequential)Operands[0];
 
-    public ReadOnlySpan<PhysicalBuffer> Parameters => SpanUtility.UnsafeCast<Expr, PhysicalBuffer>(Operands.Slice(1));
+    public ReadOnlySpan<Buffer> Parameters => SpanUtility.UnsafeCast<Expr, Buffer>(Operands.Slice(1));
 
     public override IEnumerable<IRType?> ParameterTypes => Parameters.AsValueEnumerable().Select(x => x.CheckedType).ToArray();
 
@@ -66,7 +66,7 @@ public PrimFunction(string moduleKind, Sequential body, params PhysicalBuffer[]
     public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunctor<TExprResult, TTypeResult, TContext> functor, TContext context)
         => functor.VisitPrimFunction(this, context);
 
-    public PrimFunction With(string? name = null, string? moduleKind = null, Sequential? body = null, PhysicalBuffer[]? parameters = null, Schedule.SchedFunctionResult? sched = null)
+    public PrimFunction With(string? name = null, string? moduleKind = null, Sequential? body = null, Buffer[]? parameters = null, Schedule.SchedFunctionResult? sched = null)
         => new PrimFunction(name ?? Name, moduleKind ?? ModuleKind, body ?? Body, parameters ?? Parameters)
         {
             // note maybe add SchedResult into ctor.
diff --git a/src/Nncase.Core/TIR/Script.cs b/src/Nncase.Core/TIR/Script.cs
index ad1b71f0bf..453a336e7f 100644
--- a/src/Nncase.Core/TIR/Script.cs
+++ b/src/Nncase.Core/TIR/Script.cs
@@ -184,7 +184,7 @@ public static ISequentialBuilder<Sequential> Sequential()
     /// ));
     /// </code>
     /// </summary>
-    public static ISequentialBuilder<PrimFunction> PrimFunc(string name, string module_kind, params PhysicalBuffer[] parameters)
+    public static ISequentialBuilder<PrimFunction> PrimFunc(string name, string module_kind, params Buffer[] parameters)
     {
         return new SequentialBuilder<PrimFunction>(body => new PrimFunction(name, module_kind, body, parameters));
     }
@@ -206,54 +206,73 @@ public static IIfThenElseBuilder If(Expr condition)
     }
 
     /// <summary>
-    /// create the memRef by tensortype.
+    /// create the buffer by tensortype.
     /// </summary>
-    public static LogicalBuffer Buffer(DataType elem_type, MemoryLocation location, ReadOnlySpan<Expr> dimensions, out LogicalBuffer buffer, [CallerArgumentExpression("buffer")] string name = "")
+    public static Buffer CreateBuffer(TensorType tensorType, MemoryLocation location, out Buffer buffer, [CallerArgumentExpression("buffer")] string name = "")
     {
         if (name.StartsWith("var "))
         {
             name = name[4..];
         }
 
-        buffer = new LogicalBuffer(name, elem_type, location, dimensions);
+        var dimensions = tensorType.Shape.ToValueArray();
+        var strides = TensorUtilities.GetStrides(dimensions);
+        var size = (int)TensorUtilities.GetProduct(dimensions.ToArray()) * tensorType.DType.SizeInBytes;
+        var memspan = new MemSpan(size, location);
+        buffer = new Buffer(name, tensorType.DType, memspan, dimensions.Select(i => (Expr)i).ToArray(), strides.Select(i => (Expr)i).ToArray());
         return buffer;
     }
 
     /// <summary>
-    /// ctor for physical buffer.
+    /// create buffer by const.
     /// </summary>
-    public static PhysicalBuffer PhysicalBuffer(DataType elem_type, MemoryLocation location, ReadOnlySpan<int> dimensions, out PhysicalBuffer buffer, [CallerArgumentExpression("buffer")] string name = "")
+    public static Buffer AttachBuffer(TensorConst @const, out Buffer buffer, [CallerArgumentExpression("buffer")] string name = "")
     {
         if (name.StartsWith("var "))
         {
             name = name[4..];
         }
 
-        buffer = new PhysicalBuffer(name, elem_type, location, dimensions, 0, (int)TensorUtilities.GetProduct(dimensions.ToArray()) * elem_type.SizeInBytes);
+        var dimensions = @const.ValueType.Shape.ToValueArray();
+        var strides = TensorUtilities.GetStrides(dimensions);
+        var size = (int)TensorUtilities.GetProduct(dimensions.ToArray()) * @const.ValueType.DType.SizeInBytes;
+        var memspan = new MemSpan(IR.F.Buffer.DDrOf(@const), size, MemoryLocation.Rdata);
+        buffer = new Buffer(name, @const.ValueType.DType, memspan, dimensions.Select(i => (Expr)i).ToArray(), strides.Select(i => (Expr)i).ToArray());
         return buffer;
     }
 
     /// <summary>
-    /// create buffer from const.
+    /// attach the buffer.
     /// </summary>
-    public static PhysicalBuffer ConstBuffer(Const expr, out PhysicalBuffer buffer, [CallerArgumentExpression("buffer")] string name = "")
+    public static Buffer AttachBuffer(Buffer originBuffer, Expr offset, TensorType tensorType, out Buffer buffer, [CallerArgumentExpression("buffer")] string name = "")
     {
         if (name.StartsWith("var "))
         {
             name = name[4..];
         }
 
-        int size;
-        if (expr is TensorConst tc)
-        {
-            size = tc.Value.BytesBuffer.Length;
-        }
-        else
+        var dimensions = tensorType.Shape.ToValueArray();
+        var strides = TensorUtilities.GetStrides(dimensions);
+        var size = (int)TensorUtilities.GetProduct(dimensions.ToArray()) * tensorType.DType.SizeInBytes;
+        buffer = new Buffer(name, tensorType.DType, originBuffer.MemSpan.SubSpan(offset, size), dimensions.Select(i => (Expr)i).ToArray(), strides.Select(i => (Expr)i).ToArray());
+        return buffer;
+    }
+
+    /// <summary>
+    /// attach the buffer.
+    /// </summary>
+    public static Buffer AttachBuffer(TensorType tensorType, MemoryLocation location, out Var @var, out Buffer buffer, [CallerArgumentExpression("buffer")] string name = "")
+    {
+        if (name.StartsWith("var "))
         {
-            throw new NotSupportedException();
+            name = name[4..];
         }
 
-        buffer = new PhysicalBuffer(name, MemoryLocation.Rdata, (TensorConst)expr, 0, size);
+        @var = new Var(name, TensorType.Pointer(tensorType.DType));
+        var dimensions = tensorType.Shape.ToValueArray();
+        var strides = TensorUtilities.GetStrides(dimensions);
+        var size = (int)TensorUtilities.GetProduct(dimensions.ToArray()) * tensorType.DType.SizeInBytes;
+        buffer = new Buffer(name, tensorType.DType, new MemSpan(@var, size, location), dimensions.Select(i => (Expr)i).ToArray(), strides.Select(i => (Expr)i).ToArray());
         return buffer;
     }
 
diff --git a/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs b/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
index 9dae59bd85..aa5d9a4126 100644
--- a/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
@@ -216,6 +216,22 @@ protected override IPrintSymbol VisitTuple(IR.Tuple expr)
         return doc;
     }
 
+    protected override IPrintSymbol VisitMemSpan(MemSpan expr)
+    {
+        if (_exprMemo.TryGetValue(expr, out var doc))
+        {
+            return doc;
+        }
+
+        var start = Visit(expr.Start);
+        var size = Visit(expr.Size);
+        _scope.Push();
+        _scope.Append($"MemSpan({start}, {size})@{expr.Location}");
+        doc = new(_scope.Pop());
+        _exprMemo.Add(expr, doc);
+        return doc;
+    }
+
     /// <inheritdoc/>
     protected override IPrintSymbol VisitMarker(Marker expr)
     {
@@ -542,12 +558,8 @@ protected override IPrintSymbol VisitBuffer(TIR.Buffer expr)
         }
 
         _scope.Push();
-        _scope.Append($"T.Buffer({expr.Name}, {expr.MemLocation}, {VisitType(expr.ElemType)})");
-        if (expr is TIR.PhysicalBuffer phy)
-        {
-            _scope.Append($"@({phy.Start}, {phy.Size})");
-        }
-
+        var memSpan = Visit(expr.MemSpan);
+        _scope.Append($"T.Buffer({expr.Name}, {VisitType(expr.ElemType)}, {memSpan.Span})");
         doc = new(_scope.Pop(), expr.Name, true);
         _exprMemo.Add(expr, doc);
         return doc;
diff --git a/src/Nncase.Evaluator/TypeInferenceVisitor.cs b/src/Nncase.Evaluator/TypeInferenceVisitor.cs
index c0f9f28f55..da0ab274b0 100644
--- a/src/Nncase.Evaluator/TypeInferenceVisitor.cs
+++ b/src/Nncase.Evaluator/TypeInferenceVisitor.cs
@@ -68,6 +68,28 @@ protected override IRType VisitLeafBufferRegion(BufferRegion expr)
         return type;
     }
 
+    protected override IRType VisitLeafBuffer(Nncase.TIR.Buffer expr)
+    {
+        VerifySubField(expr, expr.MemSpan, TypePatternUtility.IsTuple());
+        foreach (var r in expr.Dimensions)
+        {
+            VerifySubField(expr, r, TypePatternUtility.IsIntegralScalar());
+        }
+
+        foreach (var r in expr.Strides)
+        {
+            VerifySubField(expr, r, TypePatternUtility.IsIntegralScalar());
+        }
+
+        var type = new TensorType(expr.ElemType, expr.Dimensions.AsValueEnumerable().Select(e => e switch
+        {
+            TensorConst { Value: { Shape: { IsScalar: true } } t } => new Dimension(t.ToScalar<int>()),
+            _ => Dimension.Unknown,
+        }).ToArray());
+
+        return type;
+    }
+
     /// <inheritdoc/>
     protected override IRType VisitLeafCall(Call expr)
     {
@@ -174,13 +196,6 @@ protected override IRType VisitLeafLet(Let expr)
         return type;
     }
 
-    /// <inheritdoc/>
-    protected override IRType VisitLeafLogicalBuffer(LogicalBuffer expr)
-    {
-        var type = new TensorType(expr.ElemType, Shape.Unknown(expr.Rank));
-        return type;
-    }
-
     /// <inheritdoc/>
     protected override IRType VisitLeafMarker(Marker expr)
     {
@@ -203,13 +218,6 @@ protected override IRType VisitLeafOp(Op expr)
         return type;
     }
 
-    /// <inheritdoc/>
-    protected override IRType VisitLeafPhysicalBuffer(PhysicalBuffer expr)
-    {
-        var type = new TensorType(expr.ElemType, new(expr.FixedDimensions));
-        return type;
-    }
-
     /// <inheritdoc/>
     protected override IRType VisitLeafPrimFunction(PrimFunction expr)
     {
@@ -270,6 +278,13 @@ protected override IRType VisitLeafVar(Var expr)
         return type;
     }
 
+    protected override IRType VisitLeafMemSpan(MemSpan expr)
+    {
+        VerifySubField(expr, expr.Start, TypePatternUtility.IsNoneType() | TypePatternUtility.IsIntegralScalar() | TypePatternUtility.IsPointer());
+        VerifySubField(expr, expr.Size, TypePatternUtility.IsIntegralScalar());
+        return TupleType.Void;
+    }
+
     /// <inheritdoc/>
     protected override IRType VisitLet(Let expr)
     {
diff --git a/src/Nncase.Passes/DDrBufferSchdeulePass.cs b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
index e26a62ec0c..e21f833763 100644
--- a/src/Nncase.Passes/DDrBufferSchdeulePass.cs
+++ b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
@@ -23,9 +23,9 @@ namespace Nncase.Passes;
 /// </summary>
 public sealed class DDrBufferSchdeulePass : ModulePass
 {
-    private readonly Dictionary<string, Dictionary<MemoryLocation, int>> _module_usage = new();
+    private readonly Dictionary<string, Dictionary<MemoryLocation, int>> _moduleUsage = new();
 
-    private readonly Dictionary<string, HashSet<TIR.Buffer>> _module_hashset = new();
+    private readonly Dictionary<string, Dictionary<Const, System.Range>> _moduleRdataMaps = new();
 
     private readonly bool _enbaleMergeCall;
 
@@ -40,6 +40,7 @@ public DDrBufferSchdeulePass(bool enableMergeCall = false)
     protected override async Task<IRModule> RunCoreAsync(IRModule module, RunPassContext options)
     {
         // 1. merge the all call prim func
+#if false
         if (_enbaleMergeCall)
         {
             HashSet<BaseFunction> mergedFuncs = new(ReferenceEqualityComparer.Instance);
@@ -78,6 +79,7 @@ protected override async Task<IRModule> RunCoreAsync(IRModule module, RunPassCon
                 module.Remove(item);
             }
         }
+#endif
 
         // 4. schedule the prim funcs.
         for (int i = 0; i < module.Functions.Count; i++)
@@ -86,149 +88,115 @@ protected override async Task<IRModule> RunCoreAsync(IRModule module, RunPassCon
             {
                 if (!prim_func.SchedResult.IsScheduled)
                 {
-                    var ddr_allocator = new DDrBufferAllocator(_module_usage, _module_hashset);
-                    ddr_allocator.Visit(prim_func); // changed ddr buffer.
-                    prim_func.SchedResult.DataUsage = ddr_allocator.DataUsage;
-                    prim_func.SchedResult.IsScheduled = ddr_allocator.Changed;
+                    var rewriter = new DDrBufferRewriter(_moduleUsage, _moduleRdataMaps);
+                    var post = (TIR.PrimFunction)rewriter.Rewrite(prim_func); // changed ddr buffer.
+                    if (rewriter.IsMutated)
+                    {
+                        post.SchedResult.DataUsage = rewriter.DataUsage;
+                        post.SchedResult.IsScheduled = true;
+                    }
+
+                    module.Replace(i, prim_func);
                 }
             }
         }
 
-        _module_hashset.Clear();
-        _module_usage.Clear();
+        _moduleRdataMaps.Clear();
+        _moduleUsage.Clear();
 
         return await Task.FromResult(module);
     }
 }
 
-/// <summary>
-/// collect and assgin the PhysicalBuffer.
-/// </summary>
-internal sealed class DDrBufferAllocator : ExprVisitor<bool, bool>
+internal sealed class DDrBufferRewriter : ExprRewriter
 {
     private readonly Dictionary<MemoryLocation, int> _functionUsage;
-    private readonly HashSet<TIR.Buffer> _functionHashset;
+    private readonly Dictionary<Const, System.Range> _functionRdatas;
 
-    private PrimFunction? _entry;
-
-    public DDrBufferAllocator(Dictionary<string, Dictionary<MemoryLocation, int>> module_usage, Dictionary<string, HashSet<TIR.Buffer>> module_hashset)
+    public DDrBufferRewriter(Dictionary<string, Dictionary<MemoryLocation, int>> moduleUsage, Dictionary<string, Dictionary<Const, System.Range>> moduleRdataMaps)
     {
-        ModuleUsage = module_usage;
-        ModuleHashSet = module_hashset;
+        ModuleUsage = moduleUsage;
+        ModuleRdataMaps = moduleRdataMaps;
         _functionUsage = new();
-        _functionHashset = new(ReferenceEqualityComparer.Instance);
+        _functionRdatas = new();
         Changed = false;
     }
 
     public Dictionary<string, Dictionary<MemoryLocation, int>> ModuleUsage { get; }
 
-    public Dictionary<string, HashSet<TIR.Buffer>> ModuleHashSet { get; }
+    public Dictionary<string, Dictionary<Const, System.Range>> ModuleRdataMaps { get; }
 
     public bool Changed { get; private set; }
 
     public int DataUsage => _functionUsage.GetValueOrDefault(MemoryLocation.Data, 0);
 
-    /// <remarks>
-    /// only visit one prim func.
-    /// </remarks>
-    protected override bool VisitPrimFunction(PrimFunction primFunction)
-    {
-        _entry ??= primFunction;
-        if (object.ReferenceEquals(_entry, primFunction))
-        {
-            foreach (var physical in primFunction.Parameters)
-            {
-                if (physical.MemLocation is MemoryLocation.Input or MemoryLocation.Output)
-                {
-                    // avoid visit same buffer
-                    if (!_functionHashset.Contains(physical))
-                    {
-                        // input/output write into the FunctionUsage
-                        if (!_functionUsage.TryGetValue(physical.MemLocation, out var start))
-                        {
-                            start = 0;
-                        }
-
-                        physical.Start = start;
-                        _functionUsage[physical.MemLocation] = start + physical.Size;
-                        _functionHashset.Add(physical);
-                        Changed = true;
-                    }
-                }
-                else
-                {
-                    throw new NotSupportedException($"The prim function parameters mem location must be input/output but get {physical.MemLocation}!");
-                }
-            }
-
-            return base.VisitPrimFunction(_entry);
-        }
-
-        return true;
-    }
+    public PrimFunction Entry => (PrimFunction)VisitRoot!;
 
-    protected override bool VisitLeafBuffer(TIR.Buffer buffer)
+    protected override TIR.MemSpan RewriteLeafMemSpan(TIR.MemSpan memSpan)
     {
-        if (buffer is not TIR.PhysicalBuffer physical)
-        {
-            return true;
-        }
-
-        // rdata write into the moduleUsage
-        if (physical.MemLocation is MemoryLocation.Rdata)
+        if (memSpan is { Location: MemoryLocation.Rdata, Start: Call { Target: IR.Buffers.DDrOf, Arguments: var arg } } && arg[0] is Const @const)
         {
-            if (!ModuleHashSet.TryGetValue(_entry!.ModuleKind, out var module_hashset))
+            if (!ModuleRdataMaps.TryGetValue(Entry.ModuleKind, out var moduleRdataMap))
             {
-                module_hashset = new(ReferenceEqualityComparer.Instance);
-                ModuleHashSet.Add(_entry!.ModuleKind, module_hashset);
+                moduleRdataMap = new();
+                ModuleRdataMaps.Add(Entry.ModuleKind, moduleRdataMap);
             }
 
-            if (!ModuleUsage.TryGetValue(_entry!.ModuleKind, out var module_usage))
+            if (!ModuleUsage.TryGetValue(Entry.ModuleKind, out var moduleUsage))
             {
-                module_usage = new();
-                ModuleUsage.Add(_entry!.ModuleKind, module_usage);
+                moduleUsage = new();
+                ModuleUsage.Add(Entry.ModuleKind, moduleUsage);
             }
 
-            if (!module_hashset.Contains(physical))
+            if (!moduleRdataMap.TryGetValue(@const, out var memRange))
             {
-                if (!module_usage.TryGetValue(physical.MemLocation, out var start))
+                if (!moduleUsage.TryGetValue(memSpan.Location, out var start))
                 {
                     start = 0;
                 }
 
-                physical.Start = start;
-                module_usage[physical.MemLocation] = start + physical.Size;
-                module_hashset.Add(physical);
-                _entry.SchedResult.Rdatas.Add(physical);
-
+                _ = ComputeSize(@const);
+                moduleUsage[memSpan.Location] = start + ComputeSize(@const);
+                memRange = start..(start + ComputeSize(@const));
+                moduleRdataMap.Add(@const, memRange);
+                Entry.SchedResult.Rdatas.Add(@const, memRange);
                 Changed = true;
             }
-        }
-        else if (physical.MemLocation is MemoryLocation.Data)
-        {
-            // data write into the FunctionUsage
-            if (!_functionHashset.Contains(physical))
-            {
-                if (!_functionUsage.TryGetValue(physical.MemLocation, out var start))
-                {
-                    start = 0;
-                }
 
-                physical.Start = start;
-                _functionUsage[physical.MemLocation] = start + physical.Size;
-                _functionHashset.Add(physical);
-                Changed = true;
-            }
-        }
-        else if (physical.MemLocation is MemoryLocation.SharedData)
-        {
-            throw new NotSupportedException("Current Not Support!");
+            return memSpan.With(memRange.Start.Value, memRange.End.Value - memRange.Start.Value);
         }
 
-        return true;
+        // else if (memSpan.Location is MemoryLocation.Data)
+        // {
+        //     data write into the FunctionUsage
+        //     if (!_functionRdatas.Contains(physical))
+        //     {
+        //         if (!_functionUsage.TryGetValue(physical.Location, out var start))
+        //         {
+        //             start = 0;
+        //         }
+
+        // physical.Start = start;
+        //         _functionUsage[physical.Location] = start + physical.Size;
+        //         _functionRdatas.Add(physical);
+        //         Changed = true;
+        //     }
+        // }
+        // else if (memSpan.Location is MemoryLocation.SharedData)
+        // {
+        //     throw new NotSupportedException("Current Not Support!");
+        // }
+        return memSpan;
     }
 
-    protected override bool DefaultVisitLeaf(Expr expr) => true;
+    private int ComputeSize(IValue v) => v.AsTensors().Select(t => t.BytesBuffer.Length).Sum();
+
+    private int ComputeSize(Const @const) => @const switch
+    {
+        TensorConst { Value: Tensor tc } => tc.BytesBuffer.Length,
+        TupleConst tc => ComputeSize(tc.Value),
+        _ => throw new NotSupportedException(),
+    };
 }
 
 internal sealed class ExternalFuncCollector : ExprWalker
diff --git a/src/Nncase.Passes/Rules/Neutral/PrimFuncMergeRule.cs b/src/Nncase.Passes/Rules/Neutral/PrimFuncMergeRule.cs
index 9e1c2bc22c..16e9b6727c 100644
--- a/src/Nncase.Passes/Rules/Neutral/PrimFuncMergeRule.cs
+++ b/src/Nncase.Passes/Rules/Neutral/PrimFuncMergeRule.cs
@@ -21,6 +21,7 @@
 
 namespace Nncase.Passes.Rules.Neutral;
 
+#if false
 [RuleGenerator]
 public sealed partial class PrimFuncMergeRule : RewriteRule<PatternMatch.Pattern>
 {
@@ -191,3 +192,4 @@ protected override Expr VisitVar(Var var, Unit context)
         }
     }
 }
+#endif
diff --git a/src/Nncase.Tests/Core/UnitTestExpression.cs b/src/Nncase.Tests/Core/UnitTestExpression.cs
index 9cbe60f849..59741a8735 100644
--- a/src/Nncase.Tests/Core/UnitTestExpression.cs
+++ b/src/Nncase.Tests/Core/UnitTestExpression.cs
@@ -261,8 +261,8 @@ public void TestDenseTensorLength()
     public void TestConstBufferNotEqual()
     {
         var c = IR.F.Random.Normal(DataTypes.Float32, 1, 0, 0, new[] { 1, 16, 64, 400 }).Evaluate().AsTensor();
-        var ddr_ld_input = new TIR.BufferRegion(Nncase.TIR.T.ConstBuffer(Const.FromTensor(c), out _, "ddr_ld_input"), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
-        var ddr_ld_output = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
+        var ddr_ld_input = new TIR.BufferRegion(TIR.T.AttachBuffer(Const.FromTensor(c), out _, "ddr_ld_input"), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
+        var ddr_ld_output = new TIR.BufferRegion(new TIR.Buffer("ddr_ld_input", DataTypes.Float32, new MemSpan(0, 0, MemoryLocation.Input), new Expr[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new Expr[] { 1, 16, 64, 400 })), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
         Assert.NotEqual(ddr_ld_input.Buffer, ddr_ld_output.Buffer);
         Assert.NotEqual(ddr_ld_input, ddr_ld_output);
     }
@@ -270,8 +270,8 @@ public void TestConstBufferNotEqual()
     [Fact]
     public void TestBufferEqual()
     {
-        var ddr_ld_input = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
-        var ddr_ld_output = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
+        var ddr_ld_input = new TIR.BufferRegion(new TIR.Buffer("ddr_ld_input", DataTypes.Float32, new MemSpan(0, 0, MemoryLocation.Input), new Expr[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new Expr[] { 1, 16, 64, 400 })), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
+        var ddr_ld_output = new TIR.BufferRegion(new TIR.Buffer("ddr_ld_input", DataTypes.Float32, new MemSpan(0, 0, MemoryLocation.Input), new Expr[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new Expr[] { 1, 16, 64, 400 })), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
         Assert.Equal(ddr_ld_input.Buffer, ddr_ld_output.Buffer);
         Assert.Equal(ddr_ld_input, ddr_ld_output);
     }
@@ -279,8 +279,8 @@ public void TestBufferEqual()
     [Fact]
     public void TestBufferNotEqual()
     {
-        var ddr_ld_input = new TIR.BufferRegion(new TIR.PhysicalBuffer("ddr_ld_input", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
-        var glb_ld_output = new TIR.BufferRegion(new TIR.PhysicalBuffer("glb_ld_output", DataTypes.BFloat16, MemoryLocation.Data, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
+        var ddr_ld_input = new TIR.BufferRegion(new TIR.Buffer("ddr_ld_input", DataTypes.Float32, new MemSpan(0, 0, MemoryLocation.Input), new Expr[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new Expr[] { 1, 16, 64, 400 })), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
+        var glb_ld_output = new TIR.BufferRegion(new TIR.Buffer("glb_ld_output", DataTypes.BFloat16, new MemSpan(0, 0, MemoryLocation.Data), new Expr[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new Expr[] { 1, 16, 64, 400 })), new(new TIR.Range[] { 0..1, 0..16, 0..31, 0..400 }));
         Assert.False(ddr_ld_input.Buffer.Equals(glb_ld_output.Buffer));
         Assert.False(ddr_ld_input.Equals(glb_ld_output));
     }
diff --git a/src/Nncase.Tests/Core/UnitTestStringUtility.cs b/src/Nncase.Tests/Core/UnitTestStringUtility.cs
index c17f577ee2..5505371db5 100644
--- a/src/Nncase.Tests/Core/UnitTestStringUtility.cs
+++ b/src/Nncase.Tests/Core/UnitTestStringUtility.cs
@@ -16,14 +16,14 @@ namespace Nncase.Tests.CoreTest;
 
 public static class TestExtensions
 {
-    public static ArrayExtensions.SpanWhereEnumerable<TIR.PhysicalBuffer, FunctionWrapper<TIR.PhysicalBuffer, bool>> InputOf(this ReadOnlySpan<TIR.PhysicalBuffer> arr) => arr.AsValueEnumerable().Where(b => b.MemLocation == MemoryLocation.Input);
+    public static ArrayExtensions.SpanWhereEnumerable<TIR.Buffer, FunctionWrapper<TIR.Buffer, bool>> InputOf(this ReadOnlySpan<TIR.Buffer> arr) => arr.AsValueEnumerable().Where(b => b.MemSpan.Location == MemoryLocation.Input);
 
-    public static ArrayExtensions.SpanWhereEnumerable<TIR.PhysicalBuffer, FunctionWrapper<TIR.PhysicalBuffer, bool>> OutputOf(this ReadOnlySpan<TIR.PhysicalBuffer> arr) => arr.AsValueEnumerable().Where(b => b.MemLocation == MemoryLocation.Output);
+    public static ArrayExtensions.SpanWhereEnumerable<TIR.Buffer, FunctionWrapper<TIR.Buffer, bool>> OutputOf(this ReadOnlySpan<TIR.Buffer> arr) => arr.AsValueEnumerable().Where(b => b.MemSpan.Location == MemoryLocation.Output);
 }
 
 public sealed class UnitTestStringUtility
 {
-    private readonly TIR.PrimFunction _entry = new("test_module", new Sequential(1), new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0), new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0));
+    private readonly TIR.PrimFunction _entry = new("test_module", new Sequential(1), new TIR.Buffer("testInput", DataTypes.Float32, new MemSpan(0, 123, MemoryLocation.Input), new Expr[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new Expr[] { 1, 16, 64, 400 })), new TIR.Buffer("testInput", DataTypes.Float32, new MemSpan(0, 123, MemoryLocation.Output), new Expr[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new Expr[] { 1, 16, 64, 400 })));
 
     [Fact]
     public void TestJoin()
diff --git a/src/Nncase.Tests/Core/UnitTestTIR.cs b/src/Nncase.Tests/Core/UnitTestTIR.cs
index 9f3b78cf12..c43b9d52b1 100644
--- a/src/Nncase.Tests/Core/UnitTestTIR.cs
+++ b/src/Nncase.Tests/Core/UnitTestTIR.cs
@@ -21,15 +21,6 @@ namespace Nncase.Tests.CoreTest;
 
 public sealed class UnitTestTIR
 {
-    [Fact]
-    public void TestLogicalBuffer()
-    {
-        var logicalBuffer1 = new LogicalBuffer("logicalBuffer", default, new TensorConst(new Tensor<int>(new[] { 1 })));
-        var logicalBuffer2 = new LogicalBuffer("logicalBuffer", DataTypes.Int32, default, new[] { (Expr)new Tensor<int>(new[] { 1 }) });
-        Assert.Equal(logicalBuffer2.Length.ToString(), logicalBuffer1.Length.ToString());
-        Assert.Equal("LogicalBuffer(logicalBuffer, i32, MemLocation)", logicalBuffer1.ToString());
-    }
-
     [Fact]
     public void TestScheduler()
     {
@@ -48,9 +39,9 @@ public void TestScheduler()
     public void TestBufferStore()
     {
         Expr value = 42;
-        var physicalBuffer = new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0);
+        TIR.T.CreateBuffer(new TensorType(DataTypes.Float32, new[] { 1, 16, 64, 400 }), MemoryLocation.Input, out var testInput);
         _ = new Expr[] { 0, 1 };
-        _ = T.Store(physicalBuffer, 0, value);
+        _ = T.Store(testInput, 0, value);
     }
 
     [Fact]
@@ -95,15 +86,6 @@ public void TestSequential()
         Assert.Equal(expect2, actual2);
     }
 
-    [Fact]
-    public void TestBuffer()
-    {
-        var buffer = T.Buffer(DataTypes.Float32, MemoryLocation.Input, new Expr[] { 1, 16, 64, 400 }, out _);
-        Assert.Equal(DataTypes.Float32, buffer.ElemType);
-        var expect = new LogicalBuffer("_", DataTypes.Float32, MemoryLocation.Input, new Expr[] { 1, 16, 64, 400 });
-        Assert.Equal(expect, buffer);
-    }
-
     [Fact]
     public void TestForSegment()
     {
@@ -132,7 +114,7 @@ public void TestEmit()
     [Fact]
     public void TestBufferRegion()
     {
-        var buffer = T.Buffer(DataTypes.Float32, MemoryLocation.Input, new Expr[] { 1, 16, 64, 400 }, out _);
+        var buffer = T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 16, 64, 400 }), MemoryLocation.Input, out _);
         var region = new Range[] { new Range(1, 2, 2), new Range(-1, 3, 2) };
         var bufferRegion = new BufferRegion(buffer, region);
 
@@ -154,8 +136,8 @@ public void TestPrimFunction()
     {
         var primFunc = new PrimFunction("test_module", new Sequential(new Expr[] { 1 }), new[]
         {
-            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
-            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
+            TIR.T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 16, 64, 400 }), MemoryLocation.Input, out var _),
+            TIR.T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 16, 64, 400 }), MemoryLocation.Input, out var _),
         });
 
         var primFuncParameters = primFunc.Parameters;
@@ -167,8 +149,8 @@ public void TestPrimFunction()
         var newBody = new Sequential(new Expr[] { 3 });
         var newParams = new[]
         {
-            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
-            new TIR.PhysicalBuffer("testInput", DataTypes.Float32, MemoryLocation.Input, new[] { 1, 16, 64, 400 }, TensorUtilities.GetStrides(new[] { 1, 16, 64, 400 }), 0, 0),
+            TIR.T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 16, 64, 400 }), MemoryLocation.Input, out var _),
+            TIR.T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 16, 64, 400 }), MemoryLocation.Input, out var _),
         };
 
         var newPrimFunc = primFunc.With(moduleKind: newModuleKind, body: newBody, parameters: newParams);
@@ -179,7 +161,7 @@ public void TestPrimFunction()
         Assert.Equal(newParams, newPrimFunc.Parameters.ToArray());
         Assert.Equal(primFunc.Name, newPrimFunc.Name); // should not change the name
 
-        Assert.NotNull(new PrimFunction("test_module", new Sequential(new Expr[] { 1 }), default(ReadOnlySpan<PhysicalBuffer>)));
+        Assert.NotNull(new PrimFunction("test_module", new Sequential(new Expr[] { 1 }), default(ReadOnlySpan<Buffer>)));
     }
 
     [Fact]
diff --git a/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs b/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
index bd9bcc3c5c..9e2f0f3a44 100644
--- a/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
+++ b/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
@@ -65,7 +65,7 @@ public void TestDumpFusion()
     [Fact]
     public void TestDumpScript()
     {
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out _)).Body(T.Nop()).Build();
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Input, out _), T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Output, out _)).Body(T.Nop()).Build();
 
         Assert.True(CompilerServices.InferenceType(prim_func_1));
 
diff --git a/src/Nncase.Tests/Evaluator/UnitTestEvaluator.cs b/src/Nncase.Tests/Evaluator/UnitTestEvaluator.cs
index 0fdb6fe4da..037e40793b 100755
--- a/src/Nncase.Tests/Evaluator/UnitTestEvaluator.cs
+++ b/src/Nncase.Tests/Evaluator/UnitTestEvaluator.cs
@@ -97,7 +97,7 @@ public void TestOnnxResizeImage()
     public void TestLoadStore()
     {
         var loop_i = new Var(TensorType.Scalar(DataTypes.Int32));
-        T.Buffer(DataTypes.Float32, MemoryLocation.Input, new Expr[] { 1, 2, 3 }, out var bf);
+        T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3 }), MemoryLocation.Input, out var bf);
         var load = T.Load(bf, loop_i);
         CompilerServices.InferenceType(load);
         var store = T.Store(bf, loop_i, IR.F.Tensors.Cast(loop_i, DataTypes.Float32));
diff --git a/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs b/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs
index e514c3e09a..0721bfd29d 100644
--- a/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs
+++ b/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs
@@ -71,7 +71,7 @@ public static PrimFunctionWrapper MakeBinaryFunc(BinaryOp binaryOp, bool mask)
     public static PrimFunctionWrapper MakeMultiInputFunc(int length, bool mask)
     {
         var allocator = new Allocator();
-        var fusion_inputs = new List<TIR.PhysicalBuffer>();
+        var fusion_inputs = new List<TIR.Buffer>();
         for (int i = 0; i < length; i++)
         {
             var fusion_input_i = allocator.Allocate($"fusion_{_count}_input_{i}", TIR.MemoryLocation.Input);
@@ -124,18 +124,19 @@ private static IEnumerable<BinaryOp> GetBinaryOp(int length)
 
     private sealed class Allocator
     {
-        private readonly Dictionary<TIR.MemoryLocation, int> _useage = new() {
+        private readonly Dictionary<TIR.MemoryLocation, int> _usage = new() {
           { TIR.MemoryLocation.Input, 0 },
           { TIR.MemoryLocation.Output, 0 },
           { TIR.MemoryLocation.L2Data, 0 },
         };
 
-        public TIR.PhysicalBuffer Allocate(string name, TIR.MemoryLocation location)
+        public TIR.Buffer Allocate(string name, TIR.MemoryLocation location)
         {
-            var strides = TensorUtilities.GetStrides(Dimensions);
-            var size = TensorUtilities.GetSize(Dimensions, strides, DataTypes.Float32.SizeInBytes);
-            var buffer = new TIR.PhysicalBuffer(name, DataTypes.Float32, location, Dimensions, strides, _useage[location], size);
-            _useage[location] += size;
+            var dims = Dimensions.Select(d => (Expr)d).ToArray();
+            var strides = TensorUtilities.GetStrides(Dimensions).Select(s => (Expr)s).ToArray();
+            var size = TensorUtilities.GetSize(Dimensions, TensorUtilities.GetStrides(Dimensions), DataTypes.Float32.SizeInBytes);
+            var buffer = new TIR.Buffer(name, DataTypes.Float32, new TIR.MemSpan(_usage[location], size, location), dims, strides);
+            _usage[location] += size;
             return buffer;
         }
     }
diff --git a/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs b/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs
index f5183e5127..1b5ce74461 100644
--- a/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs
+++ b/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs
@@ -139,8 +139,8 @@ public IValue Evaluate()
         // 1. copy input into input pool
         foreach (var (arg, param) in _args.Zip(_wrapper.Target.Parameters[.._wrapper.ParametersCount].ToArray()))
         {
-            Assert.Equal(param.Size, arg.AsTensor().BytesBuffer.Length);
-            arg.AsTensor().BytesBuffer.CopyTo(_poolMap[param.MemLocation].AsSpan(param.Start));
+            Assert.Equal(param.MemSpan.Size.Evaluate().AsTensor().ToScalar<int>(), arg.AsTensor().BytesBuffer.Length);
+            arg.AsTensor().BytesBuffer.CopyTo(_poolMap[param.MemSpan.Location].AsSpan(param.MemSpan.Start.Evaluate().AsTensor().ToScalar<int>()));
         }
 
         // 2. start l2 computing
@@ -153,7 +153,7 @@ public IValue Evaluate()
         var tensors = new List<Tensor>();
         foreach (var outputParam in _wrapper.Target.Parameters[_wrapper.ParametersCount..])
         {
-            tensors.Add(Tensor.FromBytes(outputParam.ElemType, GetBufferSpan(outputParam).ToArray(), outputParam.FixedDimensions.ToArray()));
+            tensors.Add(Tensor.FromBytes(outputParam.ElemType, GetBufferSpan(outputParam).ToArray(), outputParam.Dimensions.AsValueEnumerable().Select(e => e.Evaluate().AsTensor().ToScalar<int>()).ToArray()));
         }
 
         return tensors.Count == 1 ? Value.FromTensor(tensors[0]) : Value.FromTensors(tensors.ToArray());
@@ -208,7 +208,7 @@ private void EvaluateStatement(Expr statement)
 
     private Span<byte> GetBufferSpan(Expr expr)
     {
-        var buffer = Assert.IsType<TIR.PhysicalBuffer>(expr);
-        return _poolMap[buffer.MemLocation].AsSpan(buffer.Start, buffer.Size);
+        var buffer = Assert.IsType<TIR.Buffer>(expr);
+        return _poolMap[buffer.MemSpan.Location].AsSpan<byte>(buffer.MemSpan.Start.Evaluate().AsTensor().ToScalar<int>(), buffer.MemSpan.Size.Evaluate().AsTensor().ToScalar<int>());
     }
 }
diff --git a/src/Nncase.Tests/TIR/UnitTestMutators.cs b/src/Nncase.Tests/TIR/UnitTestMutators.cs
index a20d5f7295..7317eb1176 100644
--- a/src/Nncase.Tests/TIR/UnitTestMutators.cs
+++ b/src/Nncase.Tests/TIR/UnitTestMutators.cs
@@ -30,9 +30,9 @@ public UnitTestMutators()
     [Fact]
     public async Task TestFoldConstCallWithTuple()
     {
-        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Input, new[] { 48 }, out var ddr_if);
-        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Data, new[] { 9 }, out var glb_if_ping);
-        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Data, new[] { 9 }, out var glb_if_pong);
+        T.CreateBuffer(new TensorType(DataTypes.BFloat16, new[] { 48 }), MemoryLocation.Input, out var ddr_if);
+        T.CreateBuffer(new TensorType(DataTypes.BFloat16, new[] { 9 }), MemoryLocation.Data, out var glb_if_ping);
+        T.CreateBuffer(new TensorType(DataTypes.BFloat16, new[] { 9 }), MemoryLocation.Data, out var glb_if_pong);
         PrimFunction main;
         {
             main = T.PrimFunc("main", Callable.StackVMModuleKind, ddr_if).Body(
@@ -118,8 +118,8 @@ public async Task TestUnRollLoopSequential()
     [Fact]
     public async Task TestUnRollLoopSequential2()
     {
-        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Input, new[] { 3, 16, 24, 24 }, out var ddr_if);
-        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Data, new[] { 3, 10, 5, 9 }, out var glb_if);
+        T.CreateBuffer(new TensorType(DataTypes.BFloat16, new[] { 3, 16, 24, 24 }), MemoryLocation.Input, out var ddr_if);
+        T.CreateBuffer(new TensorType(DataTypes.BFloat16, new[] { 3, 10, 5, 9 }), MemoryLocation.Data, out var glb_if);
 
         PrimFunction main;
         {
@@ -201,8 +201,8 @@ public async Task TestUnRollLoopSequential2()
     [Fact]
     public async Task TestUnRollLoopSequential3()
     {
-        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Input, new[] { 3, 16, 24, 24 }, out var ddr_if);
-        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Data, new[] { 3, 10, 5, 9 }, out var glb_if);
+        T.CreateBuffer(new TensorType(DataTypes.BFloat16, new[] { 3, 16, 24, 24 }), MemoryLocation.Input, out var ddr_if);
+        T.CreateBuffer(new TensorType(DataTypes.BFloat16, new[] { 3, 10, 5, 9 }), MemoryLocation.Data, out var glb_if);
 
         PrimFunction main;
         {
@@ -362,10 +362,10 @@ public async Task TestFoldLet2()
     [Fact]
     public async Task TestFoldBufferIndex()
     {
-        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Input, new[] { 3, 16, 24, 24 }, out var ddr_if);
-        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Output, new[] { 3, 16, 24, 24 }, out var ddr_of);
-        T.PhysicalBuffer(DataTypes.BFloat16, MemoryLocation.Data, new[] { 3, 10, 5, 9 }, out var glb_if);
-        var bufferIndexMap = new Dictionary<TIR.PhysicalBuffer, int>() {
+        T.CreateBuffer(new(DataTypes.BFloat16, new[] { 3, 16, 24, 24 }), MemoryLocation.Input, out var ddr_if);
+        T.CreateBuffer(new(DataTypes.BFloat16, new[] { 3, 16, 24, 24 }), MemoryLocation.Output, out var ddr_of);
+        T.CreateBuffer(new(DataTypes.BFloat16, new[] { 3, 10, 5, 9 }), MemoryLocation.Data, out var glb_if);
+        var bufferIndexMap = new Dictionary<TIR.Buffer, int>() {
           { ddr_if, 2 },
           { ddr_of, 4 },
         };
@@ -386,7 +386,7 @@ public async Task TestFoldBufferIndex()
         pass.Add<UnRollLoopSequential>();
         pass.Add<Substitutor>(Expr? (Expr e) =>
         {
-            if (e is Call { } call && call.Arguments[0] is PhysicalBuffer physicalBuffer && bufferIndexMap.TryGetValue(physicalBuffer, out var index))
+            if (e is Call { } call && call.Arguments[0] is Buffer physicalBuffer && bufferIndexMap.TryGetValue(physicalBuffer, out var index))
             {
                 return index;
             }
diff --git a/src/Nncase.Tests/Transform/UnitTestPassManager.cs b/src/Nncase.Tests/Transform/UnitTestPassManager.cs
index 85d4cf1442..cfc76bb4eb 100644
--- a/src/Nncase.Tests/Transform/UnitTestPassManager.cs
+++ b/src/Nncase.Tests/Transform/UnitTestPassManager.cs
@@ -22,7 +22,7 @@ public sealed class UnitTestPassManager : TestClassBase
     [Fact]
     public void TestPassMangerUpdateDependence()
     {
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out _)).Body(T.Nop()).Build();
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Input, out _), T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Output, out _)).Body(T.Nop()).Build();
 
         var prim_wrapper = new PrimFunctionWrapper(prim_func_1, 1);
 
@@ -30,7 +30,7 @@ public void TestPassMangerUpdateDependence()
         var main_func = new Function("main", new Call(prim_wrapper, input), input);
 
         // prim_func_2 for update
-        var prim_func_2 = T.PrimFunc("prim_func_2", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out _)).Body(
+        var prim_func_2 = T.PrimFunc("prim_func_2", "k?", T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Input, out _), T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Output, out _)).Body(
           T.Nop(),
           T.Nop()).Build();
 
@@ -54,15 +54,15 @@ public void TestPassMangerUpdateDependence2()
           %3 = %func_3(%2): // f16[1,23,30,16]
         */
 
-        var prim_func_0 = T.PrimFunc("prim_func_0", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 24, 32, 3 }, out var _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 3, 24, 32 }, out var _)).Body(
+        var prim_func_0 = T.PrimFunc("prim_func_0", "k?", T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 24, 32, 3 }), MemoryLocation.Input, out var _), T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 3, 24, 32 }), MemoryLocation.Output, out var _)).Body(
           T.Nop()).Build();
         var func_0 = new PrimFunctionWrapper(prim_func_0, 1);
 
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 3, 24, 32 }, out var _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 3, 24, 32 }, out var _)).Body(
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 3, 24, 32 }), MemoryLocation.Input, out var _), T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 3, 24, 32 }), MemoryLocation.Output, out var _)).Body(
           T.Nop()).Build();
         var func_1 = new PrimFunctionWrapper(prim_func_1, 1);
 
-        var prim_func_2 = T.PrimFunc("prim_func_2", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 3, 24, 32 }, out var _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 23, 30, 16 }, out var _)).Body(
+        var prim_func_2 = T.PrimFunc("prim_func_2", "k?", T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 3, 24, 32 }), MemoryLocation.Input, out var _), T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 23, 30, 16 }), MemoryLocation.Output, out var _)).Body(
           T.Nop()).Build();
         var func_2 = new PrimFunctionWrapper(prim_func_2, 1);
 
@@ -74,7 +74,7 @@ public void TestPassMangerUpdateDependence2()
         Assert.True(CompilerServices.InferenceType(main_func));
 
         // prim_func_2 for update
-        var prim_func_1_update = T.PrimFunc("prim_func_1_update", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 3, 24, 32 }, out var _), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 3, 24, 32 }, out var _)).Body(
+        var prim_func_1_update = T.PrimFunc("prim_func_1_update", "k?", T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 3, 24, 32 }), MemoryLocation.Input, out var _), T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 3, 24, 32 }), MemoryLocation.Output, out var _)).Body(
           T.Nop(),
           T.Nop()).Build();
 
diff --git a/src/Nncase.Tests/Transform/UnitTestSubstitutor.cs b/src/Nncase.Tests/Transform/UnitTestSubstitutor.cs
index f6a1ed969e..0864bca6de 100644
--- a/src/Nncase.Tests/Transform/UnitTestSubstitutor.cs
+++ b/src/Nncase.Tests/Transform/UnitTestSubstitutor.cs
@@ -24,8 +24,8 @@ public sealed class UnitTestSubstitutor : TestClassBase
     public void TestSubstitutorFailed()
     {
         var loop_i = new Var("loop_i", TensorType.Scalar(DataTypes.Int32));
-        T.Buffer(DataTypes.Float32, MemoryLocation.Input, new Expr[] { 1, 2, 3, 4 }, out var hd);
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out var input_a), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out var input_b)).Body(
+        T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Input, out var hd);
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Input, out var input_a), T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Output, out var input_b)).Body(
           T.Load(hd, loop_i)).Build();
 
         var prim_wrapper = new PrimFunctionWrapper(prim_func_1, 1);
@@ -49,8 +49,8 @@ public void TestSubstitutorFailed()
     public void TestSubstitutorTrue()
     {
         var loop_i = new Var("loop_i", TensorType.Scalar(DataTypes.Int32));
-        T.Buffer(DataTypes.Float32, MemoryLocation.Input, new Expr[] { 1, 2, 3, 4 }, out var hd);
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out var input_a), T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out var input_b)).Body(
+        T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Input, out var hd);
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Input, out var input_a), T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Output, out var input_b)).Body(
           T.Load(hd, loop_i)).Build();
 
         Dictionary<Expr, Expr> vmap = new() { { loop_i, 1 } };
@@ -67,8 +67,8 @@ public void TestSubstitutorTrue()
     public void TestSubstitutorTrue2()
     {
         var loop_i = new Var("loop_i", TensorType.Scalar(DataTypes.Int32));
-        T.Buffer(DataTypes.Float32, MemoryLocation.Input, new Expr[] { 1, 2, 3, 4 }, out var hd);
-        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.PhysicalBuffer(DataTypes.Float32, MemoryLocation.Input, new[] { 1, 2, 3, 4 }, out var input_a), T.PhysicalBuffer(DataTypes.Int32, MemoryLocation.Output, new[] { 1, 2, 3, 4 }, out var input_b)).Body(
+        T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Input, out var hd);
+        var prim_func_1 = T.PrimFunc("prim_func_1", "k?", T.CreateBuffer(new(DataTypes.Float32, new[] { 1, 2, 3, 4 }), MemoryLocation.Input, out var input_a), T.CreateBuffer(new(DataTypes.Int32, new[] { 1, 2, 3, 4 }), MemoryLocation.Output, out var input_b)).Body(
           T.Load(hd, loop_i)).Build();
 
         var prim_wrapper = new PrimFunctionWrapper(prim_func_1, 1);

From 8d01066b76f8b65a109c1beb6b2b71fe443a16fb Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Fri, 28 Jul 2023 19:26:03 +0800
Subject: [PATCH 048/308] refactor test

---
 .../CodeGen/CSourceBuiltn.cs                  |   4 +-
 .../CodeGen/CSourceConvertVisitor.cs          |   6 +-
 .../CodeGen/CSourceExtensions.cs              |   1 +
 .../CodeGen/LinkableFunction.cs               |   4 +-
 .../Nncase.Modules.CPU/Targets/CPUTarget.cs   |   4 +-
 modules/cpu/src/runtime/elfloader.cpp         |   4 +-
 modules/cpu/src/runtime/elfloader.h           |   8 +-
 modules/cpu/src/runtime/runtime_function.cpp  | 144 ++++++++----------
 modules/cpu/src/runtime/runtime_function.h    |  12 +-
 src/Nncase.Core/IR/ExprVisitor.g.cs           |  28 ++++
 src/Nncase.Core/IR/IRList.csv                 |   4 +-
 .../Passes/Mutators/FlattenBuffer.cs          |   9 +-
 src/Nncase.Core/TIR/Ops.cs                    |   4 +-
 src/Nncase.Core/TIR/Script.cs                 |   6 +-
 src/Nncase.Evaluator/TIR/Load.cs              |   7 +-
 src/Nncase.Evaluator/TIR/Store.cs             |  11 +-
 src/Nncase.Evaluator/TypeInferenceVisitor.cs  |   1 +
 17 files changed, 143 insertions(+), 114 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index 269e8e5492..b2e0a6fcb3 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -79,9 +79,9 @@ public static class CSourceBuiltn
 #include <stddef.h>
 ";
 
-    public const string FixedParameters = "nncase_mt_t* nncase_mt, void* data, void* rdata";
+    public const string FixedParameters = "nncase_mt_t* nncase_mt, uint8_t* data, const uint8_t* rdata";
 
-    public const string MainPrologue = $@"void _start(size_t func_id, buffer_t** buffers, {FixedParameters}) {{";
+    public const string MainPrologue = $@"void _start(size_t func_id, uint8_t** buffers, {FixedParameters}) {{";
 
     public const string MainEpilogue = @"}";
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 9e71b76ea6..64658b1b06 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -125,7 +125,7 @@ protected override CSymbol VisitPrimFunction(PrimFunction expr)
             throw new NotSupportedException("The PrimFunction must return void!");
         }
 
-        var type = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(b => Visit(b).ToString()).ToArray())}, {CSourceBuiltn.FixedParameters})";
+        var type = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(b => Visit(b.MemSpan.Start).ToString()).ToArray())}, {CSourceBuiltn.FixedParameters})";
 
         using (var scope = new IndentScope(_implBuilder))
         {
@@ -173,10 +173,10 @@ protected override CSymbol VisitCall(Call expr)
                 str = CSourceUtilities.ContertUnary(op, arguments);
                 break;
             case Store:
-                str = $"((({arguments[2].Type} *){arguments[0].Name}->vaddr)[{arguments[1].Name}] = {arguments[2].Name})";
+                str = $"((({arguments[2].Type} *){arguments[0].Name})[{arguments[1].Name}] = {arguments[2].Name})";
                 break;
             case Load:
-                str = $"((({type} *){arguments[0].Name}->vaddr)[{arguments[1].Name}])";
+                str = $"((({type} *){arguments[0].Name})[{arguments[1].Name}])";
                 break;
             case IR.Buffers.MatchBuffer op:
                 var n = arguments[0].Name;
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index 9ba7ff5656..c36037d603 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -29,6 +29,7 @@ public static string ToC(this PrimType primType) =>
     public static string ToC(this DataType dataType) => dataType switch
     {
         PrimType ptype => ptype.ToC(),
+        PointerType ptype => "uint8_t *",
         _ => throw new NotSupportedException(dataType.ToString()),
     };
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
index 8757cc2ccd..bab60300b6 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
@@ -15,7 +15,9 @@ public LinkableFunction(uint id, byte[] descContents, TIR.PrimFunction sourceFun
         PrimFunction = sourceFunction;
         FunctionCSource = funcCSource;
         Text = Array.Empty<byte>();
-        Sections = new ILinkedSection[] { new LinkedSection(descContents, ".desc", 0, 8, (uint)descContents.Length) };
+
+        // new LinkedSection(descContents, ".desc", 0, 8, (uint)descContents.Length)
+        Sections = new ILinkedSection[] {  };
     }
 
     public uint Id { get; }
diff --git a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
index 1e2657ab3b..a354c86557 100644
--- a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
@@ -87,7 +87,6 @@ public void RegisterTargetDependentAfterQuantPass(IPassManager passManager, Comp
         passManager.Add<PrimFuncPass>().Configure(p =>
         {
             p.Add<Passes.Mutators.UnFoldBlock>();
-            p.Add<Passes.Mutators.FlattenBuffer>();
             p.Add<Passes.Mutators.FlattenSequential>();
             p.Add<Passes.Mutators.FoldConstCall>();
         });
@@ -96,8 +95,9 @@ public void RegisterTargetDependentAfterQuantPass(IPassManager passManager, Comp
 
         passManager.AddWithName<PrimFuncPass>("InstStage").Configure(p =>
         {
+            p.Add<Passes.Mutators.FlattenBuffer>();
             p.Add<Passes.Mutators.FoldConstCall>();
-            p.Add<Passes.Mutators.FoldBufferSlot>(); // 折叠自定义op
+            p.Add<Passes.Mutators.RemoveNop>();
         });
     }
 
diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/cpu/src/runtime/elfloader.cpp
index f20063b9d5..c41d7e11ab 100644
--- a/modules/cpu/src/runtime/elfloader.cpp
+++ b/modules/cpu/src/runtime/elfloader.cpp
@@ -4,8 +4,8 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace nncase::runtime::cpu;
 
-int elfloader::invoke_elf(size_t id, buffer_t **buffers, nncase_mt_t *nncase_mt,
-                          void *data, const void *rdata) {
+int elfloader::invoke_elf(size_t id, uint8_t **buffers, nncase_mt_t *nncase_mt,
+                          void *data, const uint8_t *rdata) {
 
     check(el_init(&ctx_), "initialising");
 
diff --git a/modules/cpu/src/runtime/elfloader.h b/modules/cpu/src/runtime/elfloader.h
index 7a0aa36f00..5fc7ceaec3 100644
--- a/modules/cpu/src/runtime/elfloader.h
+++ b/modules/cpu/src/runtime/elfloader.h
@@ -13,8 +13,8 @@
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
-typedef void (*entrypoint_t)(size_t id, buffer_t **buffers,
-                             nncase_mt_t *nncase_mt, void *data, const void *rdata);
+typedef void (*entrypoint_t)(size_t id, uint8_t **buffers,
+                             nncase_mt_t *nncase_mt, void *data, const uint8_t *rdata);
 
 class elfloader {
   public:
@@ -49,8 +49,8 @@ class elfloader {
         }
     }
 
-    int invoke_elf(size_t id, buffer_t **buffers, nncase_mt_t *nncase_mt,
-                   void *data, const void *rdata);
+    int invoke_elf(size_t id, uint8_t **buffers, nncase_mt_t *nncase_mt,
+                   void *data, const uint8_t *rdata);
 
   private:
     void *ptr_;
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 422fd23e59..776da74410 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -48,61 +48,61 @@ cpu_runtime_module &cpu_runtime_function::module() const noexcept {
 result<void> cpu_runtime_function::initialize_core(
     NNCASE_UNUSED runtime_function_init_context &context) noexcept {
 
-    try_(context.read_section(".desc", [this](auto sr, size_t) -> result<void> {
-        auto header = sr.template read<desc_header>();
-        if (parameters_size() != header.inputs + header.outputs)
-            return nncase::err(std::errc::invalid_argument);
-
-        for (uint32_t i = 0; i < header.inputs; i++) {
-            sr.template read<memory_range>();
-            auto rank = sr.template read<uint32_t>();
-            std::vector<uint32_t> shape(rank);
-            std::cout << "shape: ";
-            for (uint32_t j = 0; j < rank; j++) {
-                shape[j] = sr.template read<uint32_t>();
-                std::cout << shape[j] << ", ";
-            }
-            std::cout << std::endl;
-
-            std::vector<uint32_t> stride(rank);
-            std::cout << "stride: ";
-            for (uint32_t j = 0; j < rank; j++) {
-                stride[j] = sr.template read<uint32_t>();
-                std::cout << stride[j] << ", ";
-            }
-            std::cout << std::endl;
-
-            input_ranks_.emplace_back(rank);
-            input_shapes_.emplace_back(shape);
-            input_strides_.emplace_back(stride);
-        }
-
-        for (uint32_t i = 0; i < header.outputs; i++) {
-            sr.template read<memory_range>();
-            auto rank = sr.template read<uint32_t>();
-            std::vector<uint32_t> shape(rank);
-            std::cout << "shape: ";
-            for (uint32_t j = 0; j < rank; j++) {
-                shape[j] = sr.template read<uint32_t>();
-                std::cout << shape[j] << ", ";
-            }
-            std::cout << std::endl;
-
-            std::vector<uint32_t> stride(rank);
-            std::cout << "stride: ";
-            for (uint32_t j = 0; j < rank; j++) {
-                stride[j] = sr.template read<uint32_t>();
-                std::cout << stride[j] << ", ";
-            }
-            std::cout << std::endl;
-
-            output_ranks_.emplace_back(rank);
-            output_shapes_.emplace_back(shape);
-            output_strides_.emplace_back(stride);
-        }
-
-        return ok();
-    }));
+    // try_(context.read_section(".desc", [this](auto sr, size_t) -> result<void> {
+    //     auto header = sr.template read<desc_header>();
+    //     if (parameters_size() != header.inputs + header.outputs)
+    //         return nncase::err(std::errc::invalid_argument);
+
+    //     for (uint32_t i = 0; i < header.inputs; i++) {
+    //         sr.template read<memory_range>();
+    //         auto rank = sr.template read<uint32_t>();
+    //         std::vector<uint32_t> shape(rank);
+    //         std::cout << "shape: ";
+    //         for (uint32_t j = 0; j < rank; j++) {
+    //             shape[j] = sr.template read<uint32_t>();
+    //             std::cout << shape[j] << ", ";
+    //         }
+    //         std::cout << std::endl;
+
+    //         std::vector<uint32_t> stride(rank);
+    //         std::cout << "stride: ";
+    //         for (uint32_t j = 0; j < rank; j++) {
+    //             stride[j] = sr.template read<uint32_t>();
+    //             std::cout << stride[j] << ", ";
+    //         }
+    //         std::cout << std::endl;
+
+    //         input_ranks_.emplace_back(rank);
+    //         input_shapes_.emplace_back(shape);
+    //         input_strides_.emplace_back(stride);
+    //     }
+
+    //     for (uint32_t i = 0; i < header.outputs; i++) {
+    //         sr.template read<memory_range>();
+    //         auto rank = sr.template read<uint32_t>();
+    //         std::vector<uint32_t> shape(rank);
+    //         std::cout << "shape: ";
+    //         for (uint32_t j = 0; j < rank; j++) {
+    //             shape[j] = sr.template read<uint32_t>();
+    //             std::cout << shape[j] << ", ";
+    //         }
+    //         std::cout << std::endl;
+
+    //         std::vector<uint32_t> stride(rank);
+    //         std::cout << "stride: ";
+    //         for (uint32_t j = 0; j < rank; j++) {
+    //             stride[j] = sr.template read<uint32_t>();
+    //             std::cout << stride[j] << ", ";
+    //         }
+    //         std::cout << std::endl;
+
+    //         output_ranks_.emplace_back(rank);
+    //         output_shapes_.emplace_back(shape);
+    //         output_strides_.emplace_back(stride);
+    //     }
+
+    //     return ok();
+    // }));
 
     return ok();
 }
@@ -111,38 +111,20 @@ result<value_t>
 cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
                                   NNCASE_UNUSED value_t return_value) noexcept {
     try_var(id, module().find_id_by_function(this));
-    std::cout << "call " << id << std::endl;
-
-    std::vector<buffer_t *> buffers(input_ranks_.size() + output_ranks_.size());
 
+    uint8_t **buffers = new uint8_t*[parameters.size()];
     // input buffer
-    for (uint32_t i = 0; i < input_ranks_.size(); i++) {
-        auto input_tensor = parameters[i].as<tensor>().expect(
-            "input " + std::to_string(i) + " is not a tensor");
+    for (size_t i = 0; i < parameters.size(); i++) {
+        try_var(input_tensor, parameters[i].as<tensor>());
         try_var(input_span, get_input_span(input_tensor));
-        buffer_t *input_buffer =
-            new buffer_t{input_span.data(), 0, input_shapes_[i].data(),
-                         input_strides_[i].data(), input_ranks_[i]};
-        buffers[i] = input_buffer;
-    }
-
-    // output buffer
-    for (uint32_t i = 0; i < output_ranks_.size(); i++) {
-        auto output_tensor =
-            parameters[input_ranks_.size() + i].as<tensor>().expect(
-                "output " + std::to_string(i) + " is not a tensor");
-        try_var(output_span, get_output_span(output_tensor));
-        buffer_t *output_buffer =
-            new buffer_t{output_span.data(), 0, output_shapes_[i].data(),
-                         output_strides_[i].data(), output_ranks_[i]};
-        buffers[input_ranks_.size() + i] = output_buffer;
+        buffers[i] = (uint8_t *)(input_span.data());
     }
 
     auto elfloader_ = elfloader{(char *)module().text_physical().data()};
-    elfloader_.invoke_elf(id, buffers.data(), &nncase_mt, nullptr, (const void *)module().rdata_physical().data());
-    for (int i = 0; i < buffers.size(); i++) {
-        delete buffers[i];
-    }
+    elfloader_.invoke_elf(id, buffers, &nncase_mt, nullptr,
+                          (const uint8_t *)module().rdata_physical().data());
+
+    delete[] buffers;
 
     return ok<value_t>(tuple(std::in_place));
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/runtime_function.h b/modules/cpu/src/runtime/runtime_function.h
index ba19300437..74b24e0319 100644
--- a/modules/cpu/src/runtime/runtime_function.h
+++ b/modules/cpu/src/runtime/runtime_function.h
@@ -32,12 +32,12 @@ class cpu_runtime_function : public runtime_function {
                                 value_t return_value) noexcept override;
 
   private:
-    std::vector<uint32_t> input_ranks_;
-    std::vector<std::vector<uint32_t>> input_shapes_;
-    std::vector<std::vector<uint32_t>> input_strides_;
-    std::vector<uint32_t> output_ranks_;
-    std::vector<std::vector<uint32_t>> output_shapes_;
-    std::vector<std::vector<uint32_t>> output_strides_;
+    // std::vector<uint32_t> input_ranks_;
+    // std::vector<std::vector<uint32_t>> input_shapes_;
+    // std::vector<std::vector<uint32_t>> input_strides_;
+    // std::vector<uint32_t> output_ranks_;
+    // std::vector<std::vector<uint32_t>> output_shapes_;
+    // std::vector<std::vector<uint32_t>> output_strides_;
 };
 
 END_NS_NNCASE_RT_MODULE
diff --git a/src/Nncase.Core/IR/ExprVisitor.g.cs b/src/Nncase.Core/IR/ExprVisitor.g.cs
index 75dc5ab13d..dd974ec60b 100644
--- a/src/Nncase.Core/IR/ExprVisitor.g.cs
+++ b/src/Nncase.Core/IR/ExprVisitor.g.cs
@@ -102,6 +102,13 @@ protected internal override TExprResult VisitTupleConst(TupleConst expr, TContex
         return VisitLeafTupleConst(expr, context);
     }
 
+    /// <inheritdoc />
+    protected internal override TExprResult VisitMemSpan(TIR.MemSpan expr, TContext context)
+    {
+        VisitOperands(expr, context);
+        return VisitLeafMemSpan(expr, context);
+    }
+
     /// <inheritdoc />
     protected internal override TExprResult VisitVar(Var expr, TContext context)
     {
@@ -116,6 +123,13 @@ protected internal override TExprResult VisitBlock(TIR.Block expr, TContext cont
         return VisitLeafBlock(expr, context);
     }
 
+    /// <inheritdoc />
+    protected internal override TExprResult VisitBuffer(TIR.Buffer expr, TContext context)
+    {
+        VisitOperands(expr, context);
+        return VisitLeafBuffer(expr, context);
+    }
+
     /// <inheritdoc />
     protected internal override TExprResult VisitBufferRegion(TIR.BufferRegion expr, TContext context)
     {
@@ -383,6 +397,13 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitTupleConst(TupleConst expr, Unit context) => VisitTupleConst(expr);
     /// <summary>
+    /// Visit <see cref="TIR.MemSpan"/>.
+    /// </summary>
+    internal protected virtual TExprResult VisitMemSpan(TIR.MemSpan expr) => base.VisitMemSpan(expr, default);
+    
+    /// <inheritdoc/>
+    internal protected sealed override TExprResult VisitMemSpan(TIR.MemSpan expr, Unit context) => VisitMemSpan(expr);
+    /// <summary>
     /// Visit <see cref="Var"/>.
     /// </summary>
     internal protected virtual TExprResult VisitVar(Var expr) => base.VisitVar(expr, default);
@@ -397,6 +418,13 @@ public partial class ExprVisitor<TExprResult, TTypeResult>
     /// <inheritdoc/>
     internal protected sealed override TExprResult VisitBlock(TIR.Block expr, Unit context) => VisitBlock(expr);
     /// <summary>
+    /// Visit <see cref="TIR.Buffer"/>.
+    /// </summary>
+    internal protected virtual TExprResult VisitBuffer(TIR.Buffer expr) => base.VisitBuffer(expr, default);
+    
+    /// <inheritdoc/>
+    internal protected sealed override TExprResult VisitBuffer(TIR.Buffer expr, Unit context) => VisitBuffer(expr);
+    /// <summary>
     /// Visit <see cref="TIR.BufferRegion"/>.
     /// </summary>
     internal protected virtual TExprResult VisitBufferRegion(TIR.BufferRegion expr) => base.VisitBufferRegion(expr, default);
diff --git a/src/Nncase.Core/IR/IRList.csv b/src/Nncase.Core/IR/IRList.csv
index 8a1e2ed2f1..ba9dd8033b 100644
--- a/src/Nncase.Core/IR/IRList.csv
+++ b/src/Nncase.Core/IR/IRList.csv
@@ -11,10 +11,10 @@ PrimFunctionWrapper,true,true,BaseFunction,,Target
 TensorConst,true,false,Const,,
 Tuple,true,false,Default,IR.,@Fields
 TupleConst,true,false,Const,,
-MemSpan,false,false,Default,TIR.,Start;Size;
+MemSpan,true,false,Default,TIR.,Start;Size;
 Var,true,false,Default,,
 Block,true,false,Default,TIR.,Body;InitBody;@IterVars;@Reads;@Writes;@AllocBuffers;Predicate
-Buffer,false,false,Default,TIR.,MemSpan;@Dimensions;@Strides
+Buffer,true,false,Default,TIR.,MemSpan;@Dimensions;@Strides;
 BufferRegion,true,false,Default,TIR.,Buffer;@Region
 For,true,false,Default,TIR.,LoopVar;Domain;Body
 IfThenElse,true,false,Default,TIR.,Condition;Then;Else
diff --git a/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs b/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
index a941477030..28a619fdbb 100644
--- a/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
+++ b/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
@@ -35,13 +35,18 @@ protected override Expr RewriteLeafCall(Call expr)
         {
             var indices = (IR.Tuple)expr[IR.Buffers.BufferLoad.Indices];
             var input = (TIR.Buffer)expr[IR.Buffers.BufferLoad.Input];
-            return T.Load(input, Enumerable.Range(0, indices.Count).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * indices[i])));
+            return T.Load(input.MemSpan.Start, Enumerable.Range(0, indices.Count).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * indices[i])));
         }
         else if (expr.Target is IR.Buffers.BufferStore)
         {
             var indices = (IR.Tuple)expr[IR.Buffers.BufferStore.Indices];
             var input = (TIR.Buffer)expr[IR.Buffers.BufferStore.Input];
-            return T.Store(input, Enumerable.Range(0, indices.Count).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * indices[i])), expr[IR.Buffers.BufferStore.Value]);
+            return T.Store(input.MemSpan.Start, Enumerable.Range(0, indices.Count).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * indices[i])), expr[IR.Buffers.BufferStore.Value]);
+        }
+        else if (expr.Target is IR.Buffers.MatchBuffer && expr.Arguments[0] is TIR.Buffer { MemSpan: { Start: (Const or Var) } })
+        {
+            // remove the all fixed match operation.
+            return T.Nop();
         }
 
         return expr;
diff --git a/src/Nncase.Core/TIR/Ops.cs b/src/Nncase.Core/TIR/Ops.cs
index cb6446fb76..3405cdc841 100644
--- a/src/Nncase.Core/TIR/Ops.cs
+++ b/src/Nncase.Core/TIR/Ops.cs
@@ -19,7 +19,7 @@ public sealed partial class Load : Op
     /// <summary>
     /// Gets handle.
     /// </summary>
-    public static readonly ParameterInfo Handle = new(typeof(Load), 0, "handle");
+    public static readonly ParameterInfo Handle = new(typeof(Load), 0, "handle", IsPointer() | IsIntegralScalar());
 
     /// <summary>
     /// Gets index.
@@ -56,7 +56,7 @@ public sealed partial class Store : Op
     /// <summary>
     /// The buffer variable handle.
     /// </summary>
-    public static readonly ParameterInfo Handle = new(typeof(Store), 0, "handle");
+    public static readonly ParameterInfo Handle = new(typeof(Store), 0, "handle", IsPointer() | IsIntegralScalar());
 
     /// <summary>
     /// The index locations to be stored.
diff --git a/src/Nncase.Core/TIR/Script.cs b/src/Nncase.Core/TIR/Script.cs
index 453a336e7f..28740e43ab 100644
--- a/src/Nncase.Core/TIR/Script.cs
+++ b/src/Nncase.Core/TIR/Script.cs
@@ -52,7 +52,7 @@ public static class T
     /// </summary>
     /// <param name="handle">The buffer handle variable in the load expression.</param>
     /// <param name="index">The index in the load.</param>
-    public static Call Load(TIR.Buffer handle, Expr index) => new Call(new Load(), handle, index);
+    public static Call Load(Expr handle, Expr index) => new Call(new Load(), handle, index);
 
     /// <summary>
     /// get the nop op.
@@ -76,7 +76,7 @@ public static class T
     /// <param name="handle">The buffer Variable.</param>
     /// <param name="index">The index in the store expression.</param>
     /// <param name="value">The value we want to store.</param>
-    public static Call Store(TIR.Buffer handle, Expr index, Expr value) => new Call(new Store(), handle, index, value);
+    public static Call Store(Expr handle, Expr index, Expr value) => new Call(new Store(), handle, index, value);
 
     /// <summary>
     /// build for loop.
@@ -268,7 +268,7 @@ public static Buffer AttachBuffer(TensorType tensorType, MemoryLocation location
             name = name[4..];
         }
 
-        @var = new Var(name, TensorType.Pointer(tensorType.DType));
+        @var = new Var(TensorType.Pointer(tensorType.DType));
         var dimensions = tensorType.Shape.ToValueArray();
         var strides = TensorUtilities.GetStrides(dimensions);
         var size = (int)TensorUtilities.GetProduct(dimensions.ToArray()) * tensorType.DType.SizeInBytes;
diff --git a/src/Nncase.Evaluator/TIR/Load.cs b/src/Nncase.Evaluator/TIR/Load.cs
index 86885bcc48..5898e3d353 100644
--- a/src/Nncase.Evaluator/TIR/Load.cs
+++ b/src/Nncase.Evaluator/TIR/Load.cs
@@ -30,6 +30,11 @@ public string Visit(IIRPrinterContext context, Load target, bool iLmode)
 
     private IRType Visit(Load target, TensorType handle, TensorType index)
     {
-        return TensorType.Scalar(handle.DType);
+        if (handle is not TensorType { DType: PointerType { } p })
+        {
+            return new InvalidType("handle must be pointer type!");
+        }
+
+        return TensorType.Scalar(p.ElemType);
     }
 }
diff --git a/src/Nncase.Evaluator/TIR/Store.cs b/src/Nncase.Evaluator/TIR/Store.cs
index 9a1d6d6cda..b46bf57f52 100644
--- a/src/Nncase.Evaluator/TIR/Store.cs
+++ b/src/Nncase.Evaluator/TIR/Store.cs
@@ -24,18 +24,23 @@ public IRType Visit(ITypeInferenceContext context, Store target)
     public string Visit(IIRPrinterContext context, Store target, bool iLmode)
     {
         var handle = context.GetArgument(target, Store.Handle);
-        _ = context.GetArgument(target, Store.Value);
+        var value = context.GetArgument(target, Store.Value);
         var index = context.GetArgument(target, Store.Index);
-        return $"{handle}[{index}] = {index}";
+        return $"{handle}[{index}] = {value}";
     }
 
     private IRType Visit(Store target, TensorType handle, TensorType index, TensorType value)
     {
-        if (handle.DType != value.DType)
+        if (handle.DType is not PointerType { ElemType: DataType elemType } || elemType != value.DType)
         {
             return new InvalidType($"You Can't Load The {value.DType} To {handle.DType}");
         }
 
+        if (index.DType != DataTypes.Int32)
+        {
+            return new InvalidType($"store value type {index.DType} not supported");
+        }
+
         return TupleType.Void;
     }
 }
diff --git a/src/Nncase.Evaluator/TypeInferenceVisitor.cs b/src/Nncase.Evaluator/TypeInferenceVisitor.cs
index da0ab274b0..365528b6d5 100644
--- a/src/Nncase.Evaluator/TypeInferenceVisitor.cs
+++ b/src/Nncase.Evaluator/TypeInferenceVisitor.cs
@@ -68,6 +68,7 @@ protected override IRType VisitLeafBufferRegion(BufferRegion expr)
         return type;
     }
 
+    /// <inheritdoc/>
     protected override IRType VisitLeafBuffer(Nncase.TIR.Buffer expr)
     {
         VerifySubField(expr, expr.MemSpan, TypePatternUtility.IsTuple());

From c2b23394479679bba47a28137015de9469d815f5 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Mon, 31 Jul 2023 12:18:05 +0800
Subject: [PATCH 049/308] fix const buffer

---
 .../CodeGen/CSourceConvertVisitor.cs          | 34 ++++++++++++++++++-
 src/Nncase.Core/DataType.cs                   |  5 +--
 src/Nncase.Core/DataTypes.cs                  |  4 +--
 src/Nncase.Core/IR/Buffers/DDrOf.cs           |  3 ++
 src/Nncase.Core/IR/IRType.cs                  |  2 +-
 src/Nncase.Core/IR/Var.cs                     |  2 +-
 .../Passes/Mutators/FlattenBuffer.cs          |  4 +--
 src/Nncase.Core/Tensor.cs                     |  6 ++--
 .../Diagnostics/ScriptPrintVisitor.cs         | 11 +++---
 src/Nncase.Evaluator/Buffers/DDrOf.cs         |  2 +-
 src/Nncase.Evaluator/TypeInferenceVisitor.cs  |  4 +--
 src/Nncase.Passes/DDrBufferSchdeulePass.cs    |  4 +--
 .../Core/IR/UnitTestTensorConst.cs            |  2 +-
 src/Nncase.Tests/Core/UnitTestDataType.cs     |  2 +-
 src/Nncase.Tests/Core/UnitTestDataTypes.cs    |  7 ++--
 src/Nncase.Tests/Core/UnitTestTensor.cs       |  2 +-
 .../Targets/UnitTestCPUTargetTiling.cs        | 10 ++++--
 17 files changed, 72 insertions(+), 32 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 64658b1b06..b71479da32 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -147,6 +147,33 @@ protected override CSymbol VisitPrimFunction(PrimFunction expr)
         return symbol;
     }
 
+    /// <inheritdoc/>
+    protected override CSymbol VisitMemSpan(MemSpan expr)
+    {
+        if (_exprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        var start = Visit(expr.Start);
+        var size = Visit(expr.Size);
+        string name = start.Name;
+        if (expr.Start is (TensorConst or Call))
+        {
+            var loc = expr.Location switch
+            {
+                MemoryLocation.Rdata => "rdata",
+                MemoryLocation.Data => "data",
+                _ => throw new NotSupportedException(),
+            };
+            name = $"({loc} + {start.Name})";
+        }
+
+        symbol = new(start.Type, name);
+        _exprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
     /// <inheritdoc/>
     protected override CSymbol VisitCall(Call expr)
     {
@@ -223,9 +250,14 @@ protected override CSymbol VisitConst(Const expr)
 
             type = ptype.ToC();
         }
+        else if (expr is TensorConst { Value: Tensor { ElementType: PointerType { ElemType: PrimType etype }, Shape: { IsScalar: true } } pointer })
+        {
+            str = pointer.ToScalar<ulong>().ToString();
+            type = "uint8_t *";
+        }
         else
         {
-            throw new NotSupportedException($"Not Support {expr.CheckedType} Const");
+            throw new NotSupportedException();
         }
 
         symbol = new(type, str);
diff --git a/src/Nncase.Core/DataType.cs b/src/Nncase.Core/DataType.cs
index 04c3170301..4b86755d22 100644
--- a/src/Nncase.Core/DataType.cs
+++ b/src/Nncase.Core/DataType.cs
@@ -42,7 +42,8 @@ public enum PrimTypeAttributes
 /// </example>
 /// </summary>
 /// <param name="ElemType"> the type the pointer points to. </param>
-public sealed record PointerType(DataType ElemType) : DataType
+/// <param name="Shape">the shape of the pointer points to.</param>
+public sealed record PointerType(DataType ElemType, IR.Shape Shape) : DataType
 {
     /// <inheritdoc/>
     public override Type CLRType { get; } = typeof(Pointer<>).MakeGenericType(ElemType.CLRType);
@@ -81,7 +82,7 @@ public static DataType FromType(Type t)
         {
             if (t.GetGenericTypeDefinition() == typeof(Pointer<>))
             {
-                return new PointerType(FromType(t.GenericTypeArguments[0]));
+                return new PointerType(FromType(t.GenericTypeArguments[0]), IR.Shape.Scalar);
             }
 
             throw new ArgumentException("Unsupported CLR type.");
diff --git a/src/Nncase.Core/DataTypes.cs b/src/Nncase.Core/DataTypes.cs
index d1a24255e7..3c8b65fd3d 100644
--- a/src/Nncase.Core/DataTypes.cs
+++ b/src/Nncase.Core/DataTypes.cs
@@ -114,7 +114,7 @@ public static bool IsPointer(this DataType srcType) =>
     /// <returns> datatype name.</returns>
     public static string GetDisplayName(this DataType dataType) => dataType switch
     {
-        PointerType pointerType => $"({GetDisplayName(pointerType.ElemType)}*)",
+        PointerType pointerType => $"({GetDisplayName(pointerType.ElemType)}{(pointerType.Shape.IsScalar ? string.Empty : pointerType.Shape.ToString())} *)",
         PrimType primType => primType.ShortName,
         ValueType => dataType.ToString(),
         _ => throw new ArgumentOutOfRangeException(dataType.GetType().Name),
@@ -128,7 +128,7 @@ public static bool IsPointer(this DataType srcType) =>
     public static string GetCSharpName(this DataType dataType) => dataType switch
     {
         PrimType primType => $"DataTypes.{primType.FullName}",
-        PointerType pointerType => $"new PointerType({pointerType.ElemType.GetCSharpName()})",
+        PointerType pointerType => $"new PointerType({pointerType.ElemType.GetCSharpName()}, IR.Shape.Scalar)",
         ValueType valueType => $"new {valueType.GetType().Name}()",
         _ => throw new ArgumentOutOfRangeException(dataType.GetType().Name),
     };
diff --git a/src/Nncase.Core/IR/Buffers/DDrOf.cs b/src/Nncase.Core/IR/Buffers/DDrOf.cs
index 8657d3f417..116e019d5f 100644
--- a/src/Nncase.Core/IR/Buffers/DDrOf.cs
+++ b/src/Nncase.Core/IR/Buffers/DDrOf.cs
@@ -17,4 +17,7 @@ public sealed partial class DDrOf : Op
     /// Get the input parameter.
     /// </summary>
     public static readonly ParameterInfo Input = new(typeof(DDrOf), 0, "input", IsTensor());
+
+    /// <inheritdoc/>
+    public override bool CanFoldConstCall => false;
 }
diff --git a/src/Nncase.Core/IR/IRType.cs b/src/Nncase.Core/IR/IRType.cs
index b8aeda469f..ceb76319ad 100644
--- a/src/Nncase.Core/IR/IRType.cs
+++ b/src/Nncase.Core/IR/IRType.cs
@@ -138,7 +138,7 @@ public sealed record TensorType(DataType DType, Shape Shape) : IRType
     /// </summary>
     /// <param name="elemType"> the Pointed Element Type.</param>
     /// <returns>the pointer tensor type.</returns>
-    public static TensorType Pointer(DataType elemType) => new(new PointerType(elemType), Shape.Scalar);
+    public static TensorType Pointer(DataType elemType) => new(new PointerType(elemType, Shape.Scalar), Shape.Scalar);
 }
 
 /// <summary>
diff --git a/src/Nncase.Core/IR/Var.cs b/src/Nncase.Core/IR/Var.cs
index af1987e16b..a37d90eb80 100644
--- a/src/Nncase.Core/IR/Var.cs
+++ b/src/Nncase.Core/IR/Var.cs
@@ -92,7 +92,7 @@ public Var()
     /// get handle var.
     /// </summary>
     /// <returns> var. </returns>
-    public static Var Handle(string name, DataType dtype, string scope = "") => new Var(name, TensorType.Scalar(new PointerType(dtype)));
+    public static Var Handle(string name, DataType dtype, string scope = "") => new Var(name, TensorType.Scalar(new PointerType(dtype, Shape.Scalar)));
 
     /// <summary>
     /// get the size var. it can be used in tensor shape. like n>=0, m>=0.
diff --git a/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs b/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
index 28a619fdbb..1c15637eb6 100644
--- a/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
+++ b/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
@@ -35,13 +35,13 @@ protected override Expr RewriteLeafCall(Call expr)
         {
             var indices = (IR.Tuple)expr[IR.Buffers.BufferLoad.Indices];
             var input = (TIR.Buffer)expr[IR.Buffers.BufferLoad.Input];
-            return T.Load(input.MemSpan.Start, Enumerable.Range(0, indices.Count).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * indices[i])));
+            return T.Load(input.MemSpan, Enumerable.Range(0, indices.Count).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * indices[i])));
         }
         else if (expr.Target is IR.Buffers.BufferStore)
         {
             var indices = (IR.Tuple)expr[IR.Buffers.BufferStore.Indices];
             var input = (TIR.Buffer)expr[IR.Buffers.BufferStore.Input];
-            return T.Store(input.MemSpan.Start, Enumerable.Range(0, indices.Count).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * indices[i])), expr[IR.Buffers.BufferStore.Value]);
+            return T.Store(input.MemSpan, Enumerable.Range(0, indices.Count).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * indices[i])), expr[IR.Buffers.BufferStore.Value]);
         }
         else if (expr.Target is IR.Buffers.MatchBuffer && expr.Arguments[0] is TIR.Buffer { MemSpan: { Start: (Const or Var) } })
         {
diff --git a/src/Nncase.Core/Tensor.cs b/src/Nncase.Core/Tensor.cs
index 6747cddee8..a4875bf7c5 100644
--- a/src/Nncase.Core/Tensor.cs
+++ b/src/Nncase.Core/Tensor.cs
@@ -349,11 +349,11 @@ public static Tensor<Pointer<T>> FromPointer<T>(ulong value)
     /// Create tensor from a ulong address.
     /// </summary>
     /// <param name="value">addr value.</param>
-    /// <param name="elemType">Element type.</param>
+    /// <param name="pointerType">points type.</param>
     /// <returns>Created tensor.</returns>
-    public static Tensor FromPointer(ulong value, DataType elemType)
+    public static Tensor FromPointer(ulong value, PointerType pointerType)
     {
-        return Tensor.FromBytes(TensorType.Scalar(new PointerType(elemType)), BitConverter.GetBytes(value));
+        return Tensor.FromBytes(TensorType.Scalar(pointerType), BitConverter.GetBytes(value));
     }
 
     /// <summary>
diff --git a/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs b/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
index aa5d9a4126..b6bc422147 100644
--- a/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
@@ -295,18 +295,17 @@ protected override IPrintSymbol VisitTensorConst(TensorConst @const)
         {
             doc = new(new($"{@const}"));
         }
-        else
-            if (@const.Value.ElementType.IsFloat())
+        else if (@const.Value.ElementType.IsFloat())
         {
-            doc = new(new($"{string.Join(",", @const.Value.ToArray<float>())}"));
+            doc = new(new(@const.Value.Length > 8 ? @const.CheckedShape.ToString() : $"{string.Join(",", @const.Value.ToArray<float>())}"));
         }
         else if (@const.Value.ElementType.IsIntegral())
         {
-            doc = new(new($"{string.Join(",", @const.Value.ToArray<int>())}"));
+            doc = new(new(@const.Value.Length > 8 ? @const.CheckedShape.ToString() : $"{string.Join(",", @const.Value.ToArray<int>())}"));
         }
-        else if (@const.Value.ElementType.IsPointer())
+        else if (@const.Value.ElementType is PointerType p)
         {
-            doc = new(new($"{string.Join(",", @const.Value.ToArray<int>().Select(i => "0x" + i.ToString("X")))}"));
+            doc = new(new($"*{p.ElemType.GetDisplayName()}@{@const.Value.Shape}"));
         }
 
         _exprMemo.Add(@const, doc!);
diff --git a/src/Nncase.Evaluator/Buffers/DDrOf.cs b/src/Nncase.Evaluator/Buffers/DDrOf.cs
index eb6de07acf..86c53e04b7 100644
--- a/src/Nncase.Evaluator/Buffers/DDrOf.cs
+++ b/src/Nncase.Evaluator/Buffers/DDrOf.cs
@@ -14,6 +14,6 @@ public partial class DDrOfEvaluator : ITypeInferencer<DDrOf>
 {
     private IRType Visit(TensorType input)
     {
-        return new PointerType(input.DType);
+        return TensorType.Pointer(input.DType);
     }
 }
diff --git a/src/Nncase.Evaluator/TypeInferenceVisitor.cs b/src/Nncase.Evaluator/TypeInferenceVisitor.cs
index 365528b6d5..01ff4c48a6 100644
--- a/src/Nncase.Evaluator/TypeInferenceVisitor.cs
+++ b/src/Nncase.Evaluator/TypeInferenceVisitor.cs
@@ -71,7 +71,7 @@ protected override IRType VisitLeafBufferRegion(BufferRegion expr)
     /// <inheritdoc/>
     protected override IRType VisitLeafBuffer(Nncase.TIR.Buffer expr)
     {
-        VerifySubField(expr, expr.MemSpan, TypePatternUtility.IsTuple());
+        VerifySubField(expr, expr.MemSpan, TypePatternUtility.IsPointer());
         foreach (var r in expr.Dimensions)
         {
             VerifySubField(expr, r, TypePatternUtility.IsIntegralScalar());
@@ -283,7 +283,7 @@ protected override IRType VisitLeafMemSpan(MemSpan expr)
     {
         VerifySubField(expr, expr.Start, TypePatternUtility.IsNoneType() | TypePatternUtility.IsIntegralScalar() | TypePatternUtility.IsPointer());
         VerifySubField(expr, expr.Size, TypePatternUtility.IsIntegralScalar());
-        return TupleType.Void;
+        return expr.Start.CheckedType;
     }
 
     /// <inheritdoc/>
diff --git a/src/Nncase.Passes/DDrBufferSchdeulePass.cs b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
index e21f833763..bf79e37d57 100644
--- a/src/Nncase.Passes/DDrBufferSchdeulePass.cs
+++ b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
@@ -134,7 +134,7 @@ public DDrBufferRewriter(Dictionary<string, Dictionary<MemoryLocation, int>> mod
 
     protected override TIR.MemSpan RewriteLeafMemSpan(TIR.MemSpan memSpan)
     {
-        if (memSpan is { Location: MemoryLocation.Rdata, Start: Call { Target: IR.Buffers.DDrOf, Arguments: var arg } } && arg[0] is Const @const)
+        if (memSpan is { Location: MemoryLocation.Rdata, Start: Call { Target: IR.Buffers.DDrOf, Arguments: var arg } } && arg[0] is Const { ValueType: TensorType constType } @const)
         {
             if (!ModuleRdataMaps.TryGetValue(Entry.ModuleKind, out var moduleRdataMap))
             {
@@ -163,7 +163,7 @@ protected override TIR.MemSpan RewriteLeafMemSpan(TIR.MemSpan memSpan)
                 Changed = true;
             }
 
-            return memSpan.With(memRange.Start.Value, memRange.End.Value - memRange.Start.Value);
+            return memSpan.With(new TensorConst(Tensor.FromPointer((ulong)memRange.Start.Value, new PointerType(constType.DType, constType.Shape))), memRange.End.Value - memRange.Start.Value);
         }
 
         // else if (memSpan.Location is MemoryLocation.Data)
diff --git a/src/Nncase.Tests/Core/IR/UnitTestTensorConst.cs b/src/Nncase.Tests/Core/IR/UnitTestTensorConst.cs
index c444a0e45b..d98bf5ed13 100644
--- a/src/Nncase.Tests/Core/IR/UnitTestTensorConst.cs
+++ b/src/Nncase.Tests/Core/IR/UnitTestTensorConst.cs
@@ -179,7 +179,7 @@ public void TestTensorType()
         var actual2 = TensorType.Invalid(DataTypes.Float32);
         Assert.Equal(expect2, actual2);
 
-        var expect3 = new TensorType(new PointerType(DataTypes.Float32), Shape.Scalar);
+        var expect3 = new TensorType(new PointerType(DataTypes.Float32, Shape.Scalar), Shape.Scalar);
         var actual3 = TensorType.Pointer(DataTypes.Float32);
         Assert.Equal(expect3, actual3);
     }
diff --git a/src/Nncase.Tests/Core/UnitTestDataType.cs b/src/Nncase.Tests/Core/UnitTestDataType.cs
index bb734e2671..410b6a13d3 100644
--- a/src/Nncase.Tests/Core/UnitTestDataType.cs
+++ b/src/Nncase.Tests/Core/UnitTestDataType.cs
@@ -15,7 +15,7 @@ public sealed class UnitTestDataType
     [Fact]
     public void TestPointerType()
     {
-        var pType = new PointerType(DataTypes.Float32);
+        var pType = new PointerType(DataTypes.Float32, IR.Shape.Scalar);
         Assert.Equal(8, pType.SizeInBytes);
 
         var t = DataType.FromType(typeof(Pointer<int>));
diff --git a/src/Nncase.Tests/Core/UnitTestDataTypes.cs b/src/Nncase.Tests/Core/UnitTestDataTypes.cs
index 322b989921..31a9249435 100644
--- a/src/Nncase.Tests/Core/UnitTestDataTypes.cs
+++ b/src/Nncase.Tests/Core/UnitTestDataTypes.cs
@@ -53,7 +53,7 @@ public void TestIsFloat()
     public void TestIsPointer()
     {
         Assert.False(DataTypes.IsPointer(DataTypes.Float32));
-        Assert.True(DataTypes.IsPointer(new PointerType(DataTypes.Float32)));
+        Assert.True(DataTypes.IsPointer(new PointerType(DataTypes.Float32, IR.Shape.Scalar)));
     }
 
     [Fact]
@@ -61,7 +61,7 @@ public void TestGetDisplayName()
     {
         var a = new QuantParamType();
         Assert.Equal(a.ToString(), DataTypes.GetDisplayName(a));
-        Assert.Equal("(f32*)", DataTypes.GetDisplayName(new PointerType(DataTypes.Float32)));
+        Assert.Equal("(f32*)", DataTypes.GetDisplayName(new PointerType(DataTypes.Float32, IR.Shape.Scalar)));
         Assert.Equal(DataTypes.Boolean.ShortName, DataTypes.GetDisplayName(DataTypes.Boolean));
         Assert.Equal(DataTypes.Utf8Char.ShortName, DataTypes.GetDisplayName(DataTypes.Utf8Char));
         Assert.Equal(DataTypes.Int8.ShortName, DataTypes.GetDisplayName(DataTypes.Int8));
@@ -82,7 +82,7 @@ public void TestGetDisplayName()
     public void TestCSharpName()
     {
         Assert.Equal("new QuantParamType()", DataTypes.GetCSharpName(new QuantParamType()));
-        Assert.Equal("new PointerType(DataTypes.Float32)", DataTypes.GetCSharpName(new PointerType(DataTypes.Float32)));
+        Assert.Equal("new PointerType(DataTypes.Float32, IR.Shape.Scalar)", DataTypes.GetCSharpName(new PointerType(DataTypes.Float32, IR.Shape.Scalar)));
         Assert.Equal("DataTypes.Boolean", DataTypes.GetCSharpName(DataTypes.Boolean));
         Assert.Equal("DataTypes.Utf8Char", DataTypes.GetCSharpName(DataTypes.Utf8Char));
         Assert.Equal("DataTypes.Int8", DataTypes.GetCSharpName(DataTypes.Int8));
@@ -103,7 +103,6 @@ public void TestCSharpName()
     public void TestBuiltInName()
     {
         Assert.Equal("QuantParam", DataTypes.GetBuiltInName(new QuantParamType()));
-        Assert.Throws<NotSupportedException>(() => DataTypes.GetBuiltInName(new PointerType(DataTypes.Float32)));
         Assert.Equal("bool", DataTypes.GetBuiltInName(DataTypes.Boolean));
         Assert.Equal("Utf8Char", DataTypes.GetBuiltInName(DataTypes.Utf8Char));
         Assert.Equal("sbyte", DataTypes.GetBuiltInName(DataTypes.Int8));
diff --git a/src/Nncase.Tests/Core/UnitTestTensor.cs b/src/Nncase.Tests/Core/UnitTestTensor.cs
index 28a4c31c6e..259de59424 100644
--- a/src/Nncase.Tests/Core/UnitTestTensor.cs
+++ b/src/Nncase.Tests/Core/UnitTestTensor.cs
@@ -111,7 +111,7 @@ public unsafe void TestFromPointerET()
         var p1 = new Pointer<int>(addr1);
         var p2 = new Pointer<int>(addr2);
 
-        var t = Tensor.FromPointer(addr1, DataTypes.Int32);
+        var t = Tensor.FromPointer(addr1, new PointerType(DataTypes.Int32, Shape.Scalar));
         Assert.Equal(p1, t.ToScalar<Pointer<int>>());
         Assert.Equal(addr1, t.ToScalar<Pointer<int>>().Value);
         Assert.NotEqual(p2, t.ToScalar<Pointer<int>>());
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index f3a897f37d..db5c9c5567 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -48,10 +48,13 @@ public async Task TestCpuUnary()
             compiler.Gencode(fs);
         }
 
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 1, 2, 3, 4, 5 }).Evaluate().AsTensor();
         using (var fs = Dumpper.OpenFile("input_0.bin"))
         {
-            fs.Write(IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 1, 2, 3, 4, 5 }).Evaluate().AsTensor().BytesBuffer);
+            fs.Write(input_tensor.BytesBuffer);
         }
+
+        Testing.RunKModel(File.ReadAllBytes(Path.Join(Dumpper.Directory, "test.kmodel")), Dumpper.Directory, new[] { input_tensor });
     }
 
     [Fact]
@@ -72,9 +75,12 @@ public async Task TestCpuMatMul()
             compiler.Gencode(fs);
         }
 
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 3, 4 }).Evaluate().AsTensor();
         using (var fs = Dumpper.OpenFile("input_0.bin"))
         {
-            fs.Write(IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 1, 2, 3, 4, 5 }).Evaluate().AsTensor().BytesBuffer);
+            fs.Write(input_tensor.BytesBuffer);
         }
+
+        Testing.RunKModel(File.ReadAllBytes(Path.Join(Dumpper.Directory, "test.kmodel")), Dumpper.Directory, new[] { input_tensor });
     }
 }

From 1e6da3411ecefb251297b905cf360f76114aab97 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 1 Aug 2023 11:05:46 +0800
Subject: [PATCH 050/308] refactor buffer

---
 .../CodeGen/CSourceConvertVisitor.cs          |   6 +-
 .../CodeGen/CSourceExtensions.cs              |   2 +-
 .../CodeGen/LinkableFunction.cs               |   2 +-
 src/Nncase.Core/IR/Callable.cs                |   2 +-
 .../Passes/Mutators/FlattenBuffer.cs          |   2 +-
 .../BufferSchedule/BufferScheduleTypes.cs     |  67 ++++++++++
 .../BufferSchedule/BufferScheduler.cs         | 114 ++++++++++++++++++
 .../BufferSchedule/LifeTimeCollector.cs       | 103 ++++++++++++++++
 src/Nncase.Passes/DDrBufferSchdeulePass.cs    |  50 ++------
 9 files changed, 304 insertions(+), 44 deletions(-)
 create mode 100644 src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
 create mode 100644 src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
 create mode 100644 src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index b71479da32..bc715c4f2f 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -156,9 +156,9 @@ protected override CSymbol VisitMemSpan(MemSpan expr)
         }
 
         var start = Visit(expr.Start);
-        var size = Visit(expr.Size);
+        _ = Visit(expr.Size);
         string name = start.Name;
-        if (expr.Start is (TensorConst or Call))
+        if (expr.Start is TensorConst or Call)
         {
             var loc = expr.Location switch
             {
@@ -250,7 +250,7 @@ protected override CSymbol VisitConst(Const expr)
 
             type = ptype.ToC();
         }
-        else if (expr is TensorConst { Value: Tensor { ElementType: PointerType { ElemType: PrimType etype }, Shape: { IsScalar: true } } pointer })
+        else if (expr is TensorConst { Value: Tensor { ElementType: PointerType { ElemType: PrimType }, Shape: { IsScalar: true } } pointer })
         {
             str = pointer.ToScalar<ulong>().ToString();
             type = "uint8_t *";
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index c36037d603..43fda30de3 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -29,7 +29,7 @@ public static string ToC(this PrimType primType) =>
     public static string ToC(this DataType dataType) => dataType switch
     {
         PrimType ptype => ptype.ToC(),
-        PointerType ptype => "uint8_t *",
+        PointerType => "uint8_t *",
         _ => throw new NotSupportedException(dataType.ToString()),
     };
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
index bab60300b6..5d3e3aa0fc 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
@@ -17,7 +17,7 @@ public LinkableFunction(uint id, byte[] descContents, TIR.PrimFunction sourceFun
         Text = Array.Empty<byte>();
 
         // new LinkedSection(descContents, ".desc", 0, 8, (uint)descContents.Length)
-        Sections = new ILinkedSection[] {  };
+        Sections = Array.Empty<ILinkedSection>();
     }
 
     public uint Id { get; }
diff --git a/src/Nncase.Core/IR/Callable.cs b/src/Nncase.Core/IR/Callable.cs
index edd6004539..16fc9ad5a7 100644
--- a/src/Nncase.Core/IR/Callable.cs
+++ b/src/Nncase.Core/IR/Callable.cs
@@ -17,7 +17,7 @@ public abstract class Callable : Expr
     /// <summary>
     /// StackVM module kind.
     /// </summary>
-    public static readonly string StackVMModuleKind = "stackvm";
+    public const string StackVMModuleKind = "stackvm";
 
     public Callable(string name, string moduleKind, Expr[] operands)
         : base(operands)
diff --git a/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs b/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
index 1c15637eb6..b0b41be0b6 100644
--- a/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
+++ b/src/Nncase.Core/Passes/Mutators/FlattenBuffer.cs
@@ -43,7 +43,7 @@ protected override Expr RewriteLeafCall(Call expr)
             var input = (TIR.Buffer)expr[IR.Buffers.BufferStore.Input];
             return T.Store(input.MemSpan, Enumerable.Range(0, indices.Count).Aggregate((Expr)0, (acc, i) => acc + (input.Strides[i] * indices[i])), expr[IR.Buffers.BufferStore.Value]);
         }
-        else if (expr.Target is IR.Buffers.MatchBuffer && expr.Arguments[0] is TIR.Buffer { MemSpan: { Start: (Const or Var) } })
+        else if (expr.Target is IR.Buffers.MatchBuffer && expr.Arguments[0] is TIR.Buffer { MemSpan: { Start: Const or Var } })
         {
             // remove the all fixed match operation.
             return T.Nop();
diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
new file mode 100644
index 0000000000..af10e24e63
--- /dev/null
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
@@ -0,0 +1,67 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.Passes.BufferSchedule;
+
+internal sealed class TimeInterval
+{
+    public TimeInterval(int start, int end)
+    {
+        Start = start;
+        End = end;
+    }
+
+    public int Start { get; set; }
+
+    public int End { get; set; }
+
+    public override string ToString()
+    {
+        return $"TimeInterval({Start}, {End})";
+    }
+}
+
+internal sealed class MemSpan
+{
+    public MemSpan(int start, int end)
+    {
+        Start = start;
+        End = end;
+    }
+
+    public int Start { get; set; }
+
+    public int End { get; set; }
+
+    public override string ToString()
+    {
+        return $"MemSpan({Start}, {End})";
+    }
+}
+
+internal class ScheduleBuffer
+{
+    public ScheduleBuffer(string name, TimeInterval interval, MemSpan span, int[] shape, int[] strides)
+    {
+        Name = name;
+        Interval = interval;
+        Span = span;
+        Shape = shape;
+        Strides = strides;
+    }
+
+    public string Name { get; }
+
+    public TimeInterval Interval { get; }
+
+    public MemSpan Span { get; }
+
+    public int[] Shape { get; }
+
+    public int[] Strides { get; }
+
+    public override string ToString()
+    {
+        return $"ScheduledBuffer('{Name}', {Interval}, {Span}, ConstraintsMode.No, [{string.Join(",", Shape)}], [{string.Join(",", Strides)}])";
+    }
+}
diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
new file mode 100644
index 0000000000..eb9853d22c
--- /dev/null
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
@@ -0,0 +1,114 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reactive;
+using Nncase;
+using Nncase.IR;
+
+namespace Nncase.Passes.BufferSchedule;
+
+internal sealed class BufferScheduler
+{
+    public List<ScheduleBuffer> CollectLifeTime(Function func)
+    {
+        var c = new LifeTimeCollector();
+        return c.Collect(func);
+    }
+
+    public void DumpScheduled(string path, List<ScheduleBuffer> buffers)
+    {
+        using (var fs = File.OpenWrite(path))
+        {
+            using (var wr = new StreamWriter(fs))
+            {
+                wr.Write(@"from bokeh.models import ColumnDataSource, HoverTool, FuncTickFormatter, SingleIntervalTicker, SaveTool, WheelZoomTool, WheelPanTool, ResetTool
+from bokeh.palettes import Category20_20 as palette
+from bokeh.plotting import figure, show, save
+import itertools
+from dataclasses import dataclass
+from enum import Enum
+from typing import List
+@dataclass
+class Interval():
+  start: int
+  end: int
+
+@dataclass
+class Location():
+  depth_start: int
+  depth_size: int
+  def __str__(self) -> str:
+    return f'(start: {self.depth_start}, size {self.depth_size})'
+
+class ConstraintsMode(Enum):
+  No = 0
+  Channel = 1
+
+@dataclass
+class ScheduledBuffer():
+  name: str
+  interval: Interval
+  location: Location
+  constraints: ConstraintsMode
+  shape: List[int]
+  stride: List[int]
+
+colors = itertools.cycle(palette)
+
+buffers = [
+");
+                foreach (var item in buffers)
+                {
+                    wr.WriteLine(item.ToString());
+                }
+
+                wr.Write(@"]
+
+source = {
+    'name': [],
+    'x': [],
+    'y': [],
+    'width': [],
+    'height': [],
+    'color': [],
+    'location': [],
+    'shape': [],
+    'stride': [],
+}
+
+y_range_max = 0
+for buffer in buffers:
+  source['name'].append(buffer.name)
+  width = buffer.interval.end - buffer.interval.start
+  x = buffer.interval.start + (width // 2)
+  height = buffer.location.depth_size
+  y = buffer.location.depth_start + (height // 2)
+  y_range_max = max(y_range_max, y)
+  source['x'].append(x)
+  source['y'].append(y)
+  source['width'].append(width)
+  source['height'].append(height)
+  source['color'].append(next(colors))
+  source['location'].append(str(buffer.location))
+  source['shape'].append(','.join([str(s) for s in buffer.shape]))
+  source['stride'].append(','.join([str(s) for s in buffer.stride]))
+
+source = ColumnDataSource(source)
+hover = HoverTool(tooltips=[('name', '@name'), ('location', '@location'),
+                            ('shape', '@shape'), ('stride', '@stride')])
+
+p = figure(tools=[hover, WheelPanTool(), SaveTool(), WheelZoomTool(), ResetTool()], width=1280, height=720,
+           y_range=(0, y_range_max * 2),
+           title='Local Buffer LifeTime (by Steps)')
+p.rect(x='x', y='y', width='width', height='height', fill_color='color', source=source)
+p.xaxis.axis_label = 'Time (steps)'
+p.outline_line_color = None
+
+show(p)");
+            }
+        }
+    }
+}
diff --git a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
new file mode 100644
index 0000000000..281c13891e
--- /dev/null
+++ b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
@@ -0,0 +1,103 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive;
+using Nncase;
+using Nncase.IR;
+
+namespace Nncase.Passes.BufferSchedule;
+
+internal sealed class LifeTimeCollector : ExprVisitor<Unit, Unit>
+{
+    public int TimeStamp { get; private set; }
+
+    public Dictionary<Expr, TimeInterval> LifenessMap { get; } = new(ReferenceEqualityComparer.Instance);
+
+    public List<ScheduleBuffer> Collect(Function entry)
+    {
+        Visit(entry.Body);
+        Alias();
+
+        var l = new List<ScheduleBuffer>();
+        foreach (var (k, v) in LifenessMap)
+        {
+            var name = k switch
+            {
+                Call c => c.Target.GetType().Name,
+                Var va => va.Name,
+                _ => k.GetType().Name,
+            };
+
+            var shape = k.CheckedShape.ToValueArray();
+            var stride = TensorUtilities.GetStrides(shape);
+            var size = TensorUtilities.GetSize(shape, stride, k.CheckedDataType.SizeInBytes);
+
+            l.Add(new(name, v, new(0, size), shape, stride));
+        }
+
+        return l;
+    }
+
+    protected override Unit DefaultVisitLeaf(Expr expr) => Unit.Default;
+
+    protected override Unit VisitLeafCall(Call expr)
+    {
+        foreach (var arg in expr.Arguments)
+        {
+            Update(arg);
+        }
+
+        Update(expr);
+
+        TimeStamp += 1;
+
+        return Unit.Default;
+    }
+
+    private void Update(Expr expr)
+    {
+        if (expr is Const)
+        {
+            return;
+        }
+
+        if (expr is IR.Tuple t)
+        {
+            foreach (var item in t.Fields)
+            {
+                Update(item);
+            }
+
+            return;
+        }
+
+        if (!LifenessMap.TryGetValue(expr, out var interval))
+        {
+            interval = new(TimeStamp, TimeStamp + 1);
+        }
+        else
+        {
+            interval.End += 1;
+        }
+
+        // advance the getitem buffer.
+        if (expr is Call { Target: IR.Tensors.GetItem, Arguments: var args } call && args[0] is Call { CheckedType: TupleType })
+        {
+            interval.Start = LifenessMap[args[0]].Start;
+        }
+
+        LifenessMap[expr] = interval;
+    }
+
+    private void Alias()
+    {
+        // skip the call which output type is tuple.
+        var calls = LifenessMap.Select(kv => kv.Key is Call { CheckedType: TupleType }).ToArray();
+        foreach (var c in calls)
+        {
+            LifenessMap.Remove(c);
+        }
+    }
+}
diff --git a/src/Nncase.Passes/DDrBufferSchdeulePass.cs b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
index bf79e37d57..cdd9fe3be1 100644
--- a/src/Nncase.Passes/DDrBufferSchdeulePass.cs
+++ b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Reactive;
 using System.Text;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
@@ -40,46 +41,14 @@ public DDrBufferSchdeulePass(bool enableMergeCall = false)
     protected override async Task<IRModule> RunCoreAsync(IRModule module, RunPassContext options)
     {
         // 1. merge the all call prim func
-#if false
         if (_enbaleMergeCall)
         {
-            HashSet<BaseFunction> mergedFuncs = new(ReferenceEqualityComparer.Instance);
-            HashSet<BaseFunction> stackvmFuncs = new(ReferenceEqualityComparer.Instance);
-            for (int i = 0; i < module.Functions.Count; i++)
-            {
-                if (module.Functions[i] is Function { ModuleKind: "stackvm" } func)
-                {
-                    var analysis = new Dictionary<Type, IAnalysisResult>
-                    {
-                        [typeof(IExprUserAnalysisResult)] = AnalyzerManager.GetAnaylsis<IExprUserAnalysisResult>(func),
-                    };
-                    _ = new HashSet<BaseFunction>(ReferenceEqualityComparer.Instance);
-                    var mergePass = new DataflowPass();
-                    mergePass.Add<Rules.Neutral.PrimFuncMergeRule>(mergedFuncs);
-                    var post = await mergePass.RunAsync(func, new() { AnalysisResults = analysis, RewriteOnce = true });
-                    module.Replace(i, post);
-                    stackvmFuncs.Add(post);
-                }
-            }
-
-            // 2. add the ext func into module.
-            foreach (var func in stackvmFuncs)
-            {
-                var collector = new ExternalFuncCollector();
-                collector.Visit(func);
-                foreach (var ext_func in collector.GetExternalFuncs())
-                {
-                    module.Add(ext_func);
-                }
-            }
-
-            // 3. remove the all merged funcs
-            foreach (var item in mergedFuncs)
-            {
-                module.Remove(item);
-            }
+            // if (module.Entry is Function { ModuleKind: Callable.StackVMModuleKind, Body: Expr body } func && IsFixedType(body.CheckedType))
+            // {
+            //     var sorter = new TopSorter();
+            //     sorter.GetTimeLine(func);
+            // }
         }
-#endif
 
         // 4. schedule the prim funcs.
         for (int i = 0; i < module.Functions.Count; i++)
@@ -106,6 +75,13 @@ protected override async Task<IRModule> RunCoreAsync(IRModule module, RunPassCon
 
         return await Task.FromResult(module);
     }
+
+    private bool IsFixedType(IRType type) => type switch
+    {
+        TensorType tensorType => tensorType.Shape.IsFixed,
+        TupleType tupleType => tupleType.Fields.All(IsFixedType),
+        _ => false,
+    };
 }
 
 internal sealed class DDrBufferRewriter : ExprRewriter

From 85d565290b3fd1c4568dc2aac1a3716c9f886209 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Tue, 1 Aug 2023 03:09:10 +0000
Subject: [PATCH 051/308] Apply code-format changes

---
 modules/cpu/src/runtime/cpu_common.h                 | 12 ++++++++----
 modules/cpu/src/runtime/elfloader.h                  |  3 ++-
 modules/cpu/src/runtime/runtime_function.cpp         |  5 +++--
 modules/cpu/src/runtime/runtime_module.cpp           |  5 +++--
 .../BufferSchedule/BufferScheduleTypes.cs            |  2 +-
 src/Nncase.Passes/BufferSchedule/BufferScheduler.cs  |  2 +-
 .../BufferSchedule/LifeTimeCollector.cs              |  2 +-
 7 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
index d51e1775aa..8221fa015f 100644
--- a/modules/cpu/src/runtime/cpu_common.h
+++ b/modules/cpu/src/runtime/cpu_common.h
@@ -97,8 +97,10 @@ inline int32_t int32_binary_mul(int32_t x, int32_t y) { return x * y; }
 inline int32_t int32_binary_div(int32_t x, int32_t y) { return x / y; }
 inline int32_t int32_binary_min(int32_t x, int32_t y) { return std::min(x, y); }
 inline int32_t int32_binary_max(int32_t x, int32_t y) { return std::max(x, y); }
-#if defined (__arm64__)  && defined (__APPLE__)   
-inline int32_t int32_binary_pow(int32_t x, int32_t y) { return (int32_t)pow(x, y); }
+#if defined(__arm64__) && defined(__APPLE__)
+inline int32_t int32_binary_pow(int32_t x, int32_t y) {
+    return (int32_t)pow(x, y);
+}
 #else
 inline int32_t int32_binary_pow(int32_t x, int32_t y) { return std::pow(x, y); }
 #endif
@@ -111,8 +113,10 @@ inline int64_t int64_binary_mul(int64_t x, int64_t y) { return x * y; }
 inline int64_t int64_binary_div(int64_t x, int64_t y) { return x / y; }
 inline int64_t int64_binary_min(int64_t x, int64_t y) { return std::min(x, y); }
 inline int64_t int64_binary_max(int64_t x, int64_t y) { return std::max(x, y); }
-#if defined (__arm64__)  && defined (__APPLE__)   
-inline int64_t int64_binary_pow(int64_t x, int64_t y) { return (int64_t)pow(x, y); }
+#if defined(__arm64__) && defined(__APPLE__)
+inline int64_t int64_binary_pow(int64_t x, int64_t y) {
+    return (int64_t)pow(x, y);
+}
 #else
 inline int64_t int64_binary_pow(int64_t x, int64_t y) { return std::pow(x, y); }
 #endif
diff --git a/modules/cpu/src/runtime/elfloader.h b/modules/cpu/src/runtime/elfloader.h
index 5fc7ceaec3..0f9d73e5f7 100644
--- a/modules/cpu/src/runtime/elfloader.h
+++ b/modules/cpu/src/runtime/elfloader.h
@@ -14,7 +14,8 @@
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
 typedef void (*entrypoint_t)(size_t id, uint8_t **buffers,
-                             nncase_mt_t *nncase_mt, void *data, const uint8_t *rdata);
+                             nncase_mt_t *nncase_mt, void *data,
+                             const uint8_t *rdata);
 
 class elfloader {
   public:
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 776da74410..2b4d7e3a8f 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -48,7 +48,8 @@ cpu_runtime_module &cpu_runtime_function::module() const noexcept {
 result<void> cpu_runtime_function::initialize_core(
     NNCASE_UNUSED runtime_function_init_context &context) noexcept {
 
-    // try_(context.read_section(".desc", [this](auto sr, size_t) -> result<void> {
+    // try_(context.read_section(".desc", [this](auto sr, size_t) ->
+    // result<void> {
     //     auto header = sr.template read<desc_header>();
     //     if (parameters_size() != header.inputs + header.outputs)
     //         return nncase::err(std::errc::invalid_argument);
@@ -112,7 +113,7 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
                                   NNCASE_UNUSED value_t return_value) noexcept {
     try_var(id, module().find_id_by_function(this));
 
-    uint8_t **buffers = new uint8_t*[parameters.size()];
+    uint8_t **buffers = new uint8_t *[parameters.size()];
     // input buffer
     for (size_t i = 0; i < parameters.size(); i++) {
         try_var(input_tensor, parameters[i].as<tensor>());
diff --git a/modules/cpu/src/runtime/runtime_module.cpp b/modules/cpu/src/runtime/runtime_module.cpp
index 6e44d1fd3b..989ad42b8e 100644
--- a/modules/cpu/src/runtime/runtime_module.cpp
+++ b/modules/cpu/src/runtime/runtime_module.cpp
@@ -27,8 +27,9 @@ result<void> cpu_runtime_module::initialize_before_functions(
     // if (!context.is_section_pinned())
     //     return nncase::err(std::errc::bad_address);
     // try_var(data, context.get_or_read_section(".data", data_storage_,
-    // false)); 
-    try_set(rdata_, context.get_or_read_section(".rdata", rdata_storage_, true));
+    // false));
+    try_set(rdata_,
+            context.get_or_read_section(".rdata", rdata_storage_, true));
     try_set(text_, context.get_or_read_section(".text", text_storage_, true));
 
     return ok();
diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
index af10e24e63..d68c5ca5e8 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 namespace Nncase.Passes.BufferSchedule;
diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
index eb9853d22c..496d45af2c 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;
diff --git a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
index 281c13891e..454fd25608 100644
--- a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
+++ b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;

From 66865183b4d0744355fb1458ae27bd3fe3e2696d Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 1 Aug 2023 13:41:12 +0800
Subject: [PATCH 052/308] fix mac build

---
 modules/cpu/src/runtime/cpu_common.h          |   4 +-
 tests/config.toml                             |  18 +-
 tests/generator.py                            |   4 +-
 tests/importer/onnx_/basic/test_binary.py     |  12 +-
 .../onnx_/basic/test_binary_from_onnx.py      | 100 ++++----
 .../onnx_/basic/test_conv_transpose.py        | 214 +++++++++++++-----
 tests/importer/onnx_/basic/test_unary.py      |  28 +--
 .../tflite_/basic/test_fully_connected.py     |  19 +-
 tests/test_runner.py                          |   2 +-
 9 files changed, 257 insertions(+), 144 deletions(-)

diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
index 8221fa015f..8fdca3c3aa 100644
--- a/modules/cpu/src/runtime/cpu_common.h
+++ b/modules/cpu/src/runtime/cpu_common.h
@@ -97,7 +97,7 @@ inline int32_t int32_binary_mul(int32_t x, int32_t y) { return x * y; }
 inline int32_t int32_binary_div(int32_t x, int32_t y) { return x / y; }
 inline int32_t int32_binary_min(int32_t x, int32_t y) { return std::min(x, y); }
 inline int32_t int32_binary_max(int32_t x, int32_t y) { return std::max(x, y); }
-#if defined(__arm64__) && defined(__APPLE__)
+#if defined(__APPLE__)
 inline int32_t int32_binary_pow(int32_t x, int32_t y) {
     return (int32_t)pow(x, y);
 }
@@ -113,7 +113,7 @@ inline int64_t int64_binary_mul(int64_t x, int64_t y) { return x * y; }
 inline int64_t int64_binary_div(int64_t x, int64_t y) { return x / y; }
 inline int64_t int64_binary_min(int64_t x, int64_t y) { return std::min(x, y); }
 inline int64_t int64_binary_max(int64_t x, int64_t y) { return std::max(x, y); }
-#if defined(__arm64__) && defined(__APPLE__)
+#if defined(__APPLE__)
 inline int64_t int64_binary_pow(int64_t x, int64_t y) {
     return (int64_t)pow(x, y);
 }
diff --git a/tests/config.toml b/tests/config.toml
index 7d27973767..4a13208015 100644
--- a/tests/config.toml
+++ b/tests/config.toml
@@ -16,7 +16,7 @@ output_layout = 'NHWC'
 model_layout = 'NHWC'
 letterbox_value = 0
 dump_asm = true
-dump_ir = false
+dump_ir = true
 
 [ptq_opt]
 use_mix_quant = false
@@ -59,7 +59,7 @@ args = []
 
 [generator.calibs]
 method = 'random'
-number = 5
+number = 1
 batch = 1
 
 [generator.calibs.random]
@@ -80,21 +80,21 @@ args = []
 [target]
 
 [target.cpu]
-eval = true
+eval = false
 infer = true
 simarity_name = 'cosine'
 
 [target.cpu.mode.noptq]
-enabled = false
+enabled = true
 threshold = 0.999
 
 [target.cpu.mode.ptq]
-enabled = true
+enabled = false
 threshold = 0.98
 
 [target.k510]
-eval = true
-infer = true
+eval = false
+infer = false
 simarity_name = 'cosine'
 
 [target.k510.mode.noptq]
@@ -106,8 +106,8 @@ enabled = true
 threshold = 0.98
 
 [target.k230]
-eval = true
-infer = true
+eval = false
+infer = false
 simarity_name = 'cosine'
 
 [target.k230.mode.noptq]
diff --git a/tests/generator.py b/tests/generator.py
index 631883c757..74408b9e3d 100644
--- a/tests/generator.py
+++ b/tests/generator.py
@@ -14,9 +14,9 @@ def from_random(self, shape: List[int], dtype: np.dtype, abs: bool = False) -> n
         elif dtype == np.bool:
             data = np.random.rand(*shape) > 0.5
         elif dtype == np.int32:
-            data = np.random.randint(1, 5, size=shape, dtype='int32')
+            data = np.random.randint(1, 2, size=shape, dtype='int32')
         elif dtype == np.int64:
-            data = np.random.randint(1, 5, size=shape, dtype='int64')
+            data = np.random.randint(1, 2, size=shape, dtype='int64')
             # data = np.random.randint(1, 128, size=shape, dtype='int64')
         else:
             data = np.random.rand(*shape)
diff --git a/tests/importer/onnx_/basic/test_binary.py b/tests/importer/onnx_/basic/test_binary.py
index c629691f04..abb928157e 100644
--- a/tests/importer/onnx_/basic/test_binary.py
+++ b/tests/importer/onnx_/basic/test_binary.py
@@ -23,13 +23,13 @@ def _make_module(v_shape):
     class BinaryModule(torch.nn.Module):
         def __init__(self):
             super(BinaryModule, self).__init__()
-            # self.v = torch.from_numpy(np.random.rand(*v_shape).astype(np.float32))
-            self.v = torch.from_numpy(np.ones(v_shape).astype(np.float32))
+            self.v = torch.from_numpy(np.random.rand(*v_shape).astype(np.float32))
+            # self.v = torch.from_numpy(np.ones(v_shape).astype(np.float32))
 
         def forward(self, x):
             outs = []
-            outs.append(torch.add(x, self.v))
-            # outs.append(torch.mul(x, self.v))
+            # outs.append(torch.add(x, self.v))
+            outs.append(torch.mul(x, self.v))
             # outs.append(torch.sub(x, self.v))
             # outs.append(torch.max(x, self.v))
             # outs.append(torch.div(x, self.v))
@@ -45,7 +45,7 @@ def forward(self, x):
     # [64, 3],
     # [3, 64, 3],
     # [8, 3, 64, 3]
-    [1, 3, 24, 24]
+    [1, 560, 196]
 ]
 
 rhs_shapes = [
@@ -61,7 +61,7 @@ def forward(self, x):
     # [8, 3, 1, 3],
     # [8, 1, 64, 3],
     # [1, 3, 64, 1]
-    [1, 3, 24, 24]
+    [1, 560, 1]
 ]
 
 
diff --git a/tests/importer/onnx_/basic/test_binary_from_onnx.py b/tests/importer/onnx_/basic/test_binary_from_onnx.py
index f95bf61a80..0a3ba13c62 100644
--- a/tests/importer/onnx_/basic/test_binary_from_onnx.py
+++ b/tests/importer/onnx_/basic/test_binary_from_onnx.py
@@ -31,27 +31,29 @@ def _make_module(op, in_type, in_shape_0, in_shape_1):
     # input1
     input1 = helper.make_tensor_value_info('input1', in_type, in_shape_0)
     inputs.append('input1')
+    input2 = helper.make_tensor_value_info('input2', in_type, in_shape_1)
+    inputs.append('input2')
 
     # set input2 to avoid SIGFPE for div op.
-    if op != 'Pow':
-        tensor = helper.make_tensor(
-            'input2',
-            in_type,
-            dims=in_shape_1,
-            vals=(np.random.rand(*in_shape_1) +
-                  2).astype(onnx.mapping.TENSOR_TYPE_TO_NP_TYPE[in_type]).flatten().tolist()
-        )
-        inputs.append('input2')
-        initializers.append(tensor)
-    else:
-        tensor = helper.make_tensor(
-            'input2',
-            TensorProto.INT32,
-            dims=[1],
-            vals=[2]
-        )
-        inputs.append('input2')
-        initializers.append(tensor)
+    # if op != 'Pow':
+    #     tensor = helper.make_tensor(
+    #         'input2',
+    #         in_type,
+    #         dims=in_shape_1,
+    #         vals=(np.random.rand(*in_shape_1) +
+    #               2).astype(onnx.mapping.TENSOR_TYPE_TO_NP_TYPE[in_type]).flatten().tolist()
+    #     )
+    #     inputs.append('input2')
+    #     initializers.append(tensor)
+    # else:
+    #     tensor = helper.make_tensor(
+    #         'input2',
+    #         TensorProto.INT32,
+    #         dims=[1],
+    #         vals=[2]
+    #     )
+    #     inputs.append('input2')
+    #     initializers.append(tensor)
 
     # output
     x = np.random.randn(*in_shape_0)
@@ -71,7 +73,7 @@ def _make_module(op, in_type, in_shape_0, in_shape_1):
     graph_def = helper.make_graph(
         nodes,
         'test-model',
-        [input1],
+        [input1, input2],
         [output],
         initializer=initializers)
 
@@ -84,9 +86,9 @@ def _make_module(op, in_type, in_shape_0, in_shape_1):
     'Sub',
     'Mul',
     'Div',
-    'Min',
-    'Max',
-    'Pow',
+    # 'Min',
+    # 'Max',
+    # 'Pow',
 ]
 
 in_types = [
@@ -94,45 +96,45 @@ def _make_module(op, in_type, in_shape_0, in_shape_1):
 ]
 
 in_shapes = [
-    [[1, 3, 16, 16], [1]],
-    [[1, 3, 16, 16], [16]],
-    [[1, 3, 16, 16], [1, 16]],
-    [[1, 3, 16, 16], [16, 16]],
-    [[1, 3, 16, 16], [1, 16, 16]],
-    [[1, 3, 16, 16], [3, 16, 16]],
+    # [[1, 3, 16, 16], [1]],
+    # [[1, 3, 16, 16], [16]],
+    # [[1, 3, 16, 16], [1, 16]],
+    # [[1, 3, 16, 16], [16, 16]],
+    # [[1, 3, 16, 16], [1, 16, 16]],
+    # [[1, 3, 16, 16], [3, 16, 16]],
     [[1, 3, 16, 16], [1, 3, 16, 16]],
 
-    [[3, 16, 16], [1]],
-    [[3, 16, 16], [16]],
-    [[3, 16, 16], [1, 16]],
-    [[3, 16, 16], [16, 16]],
+    # [[3, 16, 16], [1]],
+    # [[3, 16, 16], [16]],
+    # [[3, 16, 16], [1, 16]],
+    # [[3, 16, 16], [16, 16]],
     [[3, 16, 16], [1, 16, 16]],
     [[3, 16, 16], [3, 16, 16]],
-    [[3, 16, 16], [1, 3, 16, 16]],
+    # [[3, 16, 16], [1, 3, 16, 16]],
 
-    [[16, 16], [1]],
-    [[16, 16], [16]],
+    # [[16, 16], [1]],
+    # [[16, 16], [16]],
     [[16, 16], [1, 16]],
     [[16, 16], [16, 16]],
-    [[16, 16], [1, 16, 16]],
-    [[16, 16], [3, 16, 16]],
-    [[16, 16], [1, 3, 16, 16]],
+    # [[16, 16], [1, 16, 16]],
+    # [[16, 16], [3, 16, 16]],
+    # [[16, 16], [1, 3, 16, 16]],
 
     [[1], [1]],
     [[1], [16]],
-    [[1], [1, 16]],
-    [[1], [16, 16]],
-    [[1], [1, 16, 16]],
-    [[1], [3, 16, 16]],
-    [[1], [1, 3, 16, 16]],
+    # [[1], [1, 16]],
+    # [[1], [16, 16]],
+    # [[1], [1, 16, 16]],
+    # [[1], [3, 16, 16]],
+    # [[1], [1, 3, 16, 16]],
 
     [[16], [1]],
     [[16], [16]],
-    [[16], [1, 16]],
-    [[16], [16, 16]],
-    [[16], [1, 16, 16]],
-    [[16], [3, 16, 16]],
-    [[16], [1, 3, 16, 16]]
+    # [[16], [1, 16]],
+    # [[16], [16, 16]],
+    # [[16], [1, 16, 16]],
+    # [[16], [3, 16, 16]],
+    # [[16], [1, 3, 16, 16]]
 ]
 
 
diff --git a/tests/importer/onnx_/basic/test_conv_transpose.py b/tests/importer/onnx_/basic/test_conv_transpose.py
index c2cfc3c8c3..a675680e2b 100644
--- a/tests/importer/onnx_/basic/test_conv_transpose.py
+++ b/tests/importer/onnx_/basic/test_conv_transpose.py
@@ -16,88 +16,194 @@
 import math
 import pytest
 import onnx
-import torch
 from onnx import helper
 from onnx import AttributeProto, TensorProto, GraphProto
 from onnx_test_runner import OnnxTestRunner
 import numpy as np
 
 
-def _make_module(in_channel, out_channel, kernel_size, stride, dilation, pad, group, bias):
-    class ConvTransposeModule(torch.nn.Module):
-        def __init__(self):
-            super(ConvTransposeModule, self).__init__()
-            self.conv_transpose = torch.nn.ConvTranspose2d(
-                in_channel, out_channel, kernel_size, stride, pad, [0, 0], group, bias, dilation)
-
-        def forward(self, x):
-            return self.conv_transpose(x)
-
-    return ConvTransposeModule()
-
-
-in_sizes = [
-    [16, 16],
-    [33, 65],
+def _make_module(in_shape, kernel_output_channel, bias_shape, auto_pad_mode, dilation, group, kernel_shape, output_padding, pad, stride):
+    inputs = []
+    initializers = []
+
+    # input
+    input = helper.make_tensor_value_info('input', TensorProto.FLOAT, in_shape)
+    inputs.append('input')
+
+    group = 1 if group is None else group
+
+    # weight
+    w_shape = []
+    w_shape.append(in_shape[1])
+    w_shape.append(kernel_output_channel // group)
+    w_shape.extend(kernel_shape)
+    weight = helper.make_tensor(
+        'weight',
+        TensorProto.FLOAT,
+        dims=w_shape,
+        vals=np.random.rand(*w_shape).astype(np.float32).flatten().tolist()
+    )
+    inputs.append('weight')
+    initializers.append(weight)
+
+    # bias
+    if bias_shape is not None:
+        bias = helper.make_tensor(
+            'bias',
+            TensorProto.FLOAT,
+            dims=bias_shape,
+            vals=np.random.rand(*bias_shape).astype(np.float32).flatten().tolist()
+        )
+        inputs.append('bias')
+        initializers.append(bias)
+
+    # dilation
+    d = [1, 1] if dilation is None else dilation
+
+    # output_padding
+    out_padding = [0, 0] if output_padding is None else output_padding
+
+    # stride
+    s = [1, 1] if stride is None else stride
+
+    # output
+    out_shape = []
+    out_shape.append(in_shape[0])
+    out_shape.append(w_shape[1] * group)
+
+    # pad
+    padding = [0, 0, 0, 0]
+    if auto_pad_mode in [None, 'NOTSET'] and pad is not None:
+        padding = pad
+        out_shape.append(s[0] * (in_shape[2] - 1) + out_padding[0] +
+                         (w_shape[2] - 1) * d[0] + 1 - padding[0] - padding[2])
+        out_shape.append(s[1] * (in_shape[3] - 1) + out_padding[1] +
+                         (w_shape[3] - 1) * d[1] + 1 - padding[1] - padding[3])
+    elif auto_pad_mode in ['SAME_UPPER', 'SAME_LOWER']:
+        out_shape.append(in_shape[2] * s[0])
+        out_shape.append(in_shape[3] * s[1])
+    else:
+        out_shape.append(in_shape[2] + (in_shape[2] - 1) * (s[0] - 1) - w_shape[2] + 1)
+        out_shape.append(in_shape[3] + (in_shape[3] - 1) * (s[1] - 1) - w_shape[3] + 1)
+
+    output = helper.make_tensor_value_info('output', TensorProto.FLOAT, out_shape)
+
+    attributes_dict = {}
+
+    if auto_pad_mode is not None:
+        attributes_dict['auto_pad'] = auto_pad_mode
+
+    if dilation is not None:
+        attributes_dict['dilations'] = dilation
+
+    if group is not None:
+        attributes_dict['group'] = group
+
+    if kernel_shape is not None:
+        attributes_dict['kernel_shape'] = kernel_shape
+
+    if output_padding is not None:
+        attributes_dict['output_padding'] = output_padding
+
+    if pad is not None:
+        attributes_dict['pads'] = padding
+
+    if stride is not None:
+        attributes_dict['strides'] = stride
+
+    node = onnx.helper.make_node(
+        'ConvTranspose',
+        inputs=inputs,
+        outputs=['output'],
+        **attributes_dict
+    )
+
+    nodes = []
+    nodes.append(node)
+
+    graph_def = helper.make_graph(
+        nodes,
+        'test-model',
+        [input],
+        [output],
+        initializer=initializers)
+
+    model_def = helper.make_model(graph_def, producer_name='kendryte')
+
+    return model_def
+
+
+in_shapes = [
+    [1, 3, 10, 10]
 ]
 
-in_channels = [
-    1,
-    3,
-    16
+kernel_output_channels = [
+    3
 ]
 
-out_channels = [
-    1,
-    16
+bias_shapes = [
+    None,
 ]
-
-kernel_sizes = [
-    [1, 1],
-    [3, 3],
+bias_shapes.extend(list([[x] for x in kernel_output_channels]))
+
+auto_pad_modes = [
+    None,
+    # 'NOTSET',
+    # 'SAME_UPPER',
+    # 'SAME_LOWER',
+    # 'VALID'
 ]
 
-strides = [
-    1,
-    [2, 2]
+dilations = [
+    None,
 ]
 
-dilations = [
-    1
+groups = [
+    None,
+    # 3
 ]
 
-pads = [
-    0,
+kernel_shapes = [
     [1, 1],
 ]
 
-groups = [
-    1
+output_paddings = [
+    None,
+    # [1, 1]
+]
+
+pads = [
+    # None,
+    [0, 0, 1, 1],
 ]
 
-biases = [
-    True,
-    False
+strides = [
+    None,
+    # [2, 3],
+    # [3, 2],
+    # [3, 3]
 ]
 
 
-@pytest.mark.parametrize('in_size', in_sizes)
-@pytest.mark.parametrize('in_channel', in_channels)
-@pytest.mark.parametrize('out_channel', out_channels)
-@pytest.mark.parametrize('kernel_size', kernel_sizes)
-@pytest.mark.parametrize('stride', strides)
+@pytest.mark.parametrize('in_shape', in_shapes)
+@pytest.mark.parametrize('kernel_output_channel', kernel_output_channels)
+@pytest.mark.parametrize('bias_shape', bias_shapes)
+@pytest.mark.parametrize('auto_pad_mode', auto_pad_modes)
 @pytest.mark.parametrize('dilation', dilations)
-@pytest.mark.parametrize('pad', pads)
 @pytest.mark.parametrize('group', groups)
-@pytest.mark.parametrize('bias', biases)
-def test_conv_transpose(in_size, in_channel, out_channel, kernel_size, stride, dilation, pad, group, bias, request):
-    model_file = _make_module(in_channel, out_channel, kernel_size,
-                              stride, dilation, pad, group, bias)
+@pytest.mark.parametrize('kernel_shape', kernel_shapes)
+@pytest.mark.parametrize('output_padding', output_paddings)
+@pytest.mark.parametrize('pad', pads)
+@pytest.mark.parametrize('stride', strides)
+def test_conv_transpose(in_shape, kernel_output_channel, bias_shape, auto_pad_mode, dilation, group, kernel_shape, output_padding, pad, stride, request):
+    if (bias_shape is None or (bias_shape is not None and bias_shape[0] == kernel_output_channel)) and ((auto_pad_mode in [None, 'NOTSET'] and pad is not None) or (auto_pad_mode in ['SAME_UPPER', 'SAME_LOWER', 'VALID'] and pad is None)) and (dilation is None or (auto_pad_modes in [None, 'NOTSET'])) and ((output_padding is None) or (output_padding is not None and stride is not None)):
+        model_def = _make_module(in_shape, kernel_output_channel, bias_shape,
+                                 auto_pad_mode, dilation, group, kernel_shape, output_padding, pad, stride)
 
-    runner = OnnxTestRunner(request.node.name)
-    model_file = runner.from_torch(model_file, [1, in_channel, *in_size])
-    runner.run(model_file)
+        runner = OnnxTestRunner(request.node.name)
+        model_file = runner.from_onnx_helper(model_def)
+        runner.run(model_file)
 
 
 if __name__ == "__main__":
-    pytest.main(['-vv', __file__])
+    pytest.main(['-vv', 'test_conv_transpose.py'])
diff --git a/tests/importer/onnx_/basic/test_unary.py b/tests/importer/onnx_/basic/test_unary.py
index 1137dd0a06..58353ff25a 100644
--- a/tests/importer/onnx_/basic/test_unary.py
+++ b/tests/importer/onnx_/basic/test_unary.py
@@ -26,19 +26,19 @@ def __init__(self):
 
         def forward(self, x):
             outs = []
-            outs.append(torch.abs(-x))
-            outs.append(torch.acos(x))
-            outs.append(torch.asin(x))
-            outs.append(torch.ceil(x))
-            outs.append(torch.cos(x))
-            outs.append(torch.exp(x))
+            # outs.append(torch.abs(-x))
+            # outs.append(torch.acos(x))
+            # outs.append(torch.asin(x))
+            # outs.append(torch.ceil(x))
+            # outs.append(torch.cos(x))
+            # outs.append(torch.exp(x))
             outs.append(torch.floor(x * 10))
-            outs.append(torch.log(x + 2))
-            outs.append(torch.neg(x))
-            outs.append(torch.round(x))
-            outs.append(torch.sin(x))
-            outs.append(torch.sqrt(x + 2))
-            outs.append(torch.tanh(x))
+            # outs.append(torch.log(x + 2))
+            # outs.append(torch.neg(x))
+            # outs.append(torch.round(x))
+            # outs.append(torch.sin(x))
+            # outs.append(torch.sqrt(x + 2))
+            # outs.append(torch.tanh(x))
             return outs
 
     return UnaryModule()
@@ -46,7 +46,7 @@ def forward(self, x):
 
 in_shapes = [
     [16],
-    [1, 3, 16, 16]
+    # [1, 3, 16, 16]
 ]
 
 
@@ -60,4 +60,4 @@ def test_unary(in_shape, request):
 
 
 if __name__ == "__main__":
-    pytest.main(['-vv', 'test_unary.py'])
+    pytest.main(['-vv', __file__])
diff --git a/tests/importer/tflite_/basic/test_fully_connected.py b/tests/importer/tflite_/basic/test_fully_connected.py
index 6cc3996d03..c81829f4ce 100644
--- a/tests/importer/tflite_/basic/test_fully_connected.py
+++ b/tests/importer/tflite_/basic/test_fully_connected.py
@@ -28,29 +28,34 @@ def __init__(self):
 
         @tf.function(input_signature=[tf.TensorSpec(input_shape, dtype=tf.float32)])
         def __call__(self, x):
-            return self.out(x)
+            out = []
+            x = self.out(x)
+            y = tf.reshape(x, [1, 1, 560, 80])
+            out.append(x)
+            out.append(y)
+            return out
 
     return FullyConnectedModule()
 
 
 input_shapes = [
-    [4, 6],
-    [3, 7]
+    [1, 560, 128],
+    # [3, 7]
 ]
 
 units = [
-    3,
-    13
+    80,
+    # 13
 ]
 
 activations = [
     None,
-    'relu',
+    # 'relu',
 ]
 
 use_biases = [
     True,
-    False
+    # False
 ]
 
 
diff --git a/tests/test_runner.py b/tests/test_runner.py
index 335b22e2c9..f6b63b0501 100644
--- a/tests/test_runner.py
+++ b/tests/test_runner.py
@@ -255,7 +255,7 @@ def run(self, model_file: Union[List[str], str]):
                             if not judge:
                                 if test_utils.in_ci():
                                     self.clear(self.case_dir)
-                                assert f"Fault result in {stage} + {result}"
+                                assert (judge), f"Fault result in {stage} + {result}"
 
         if test_utils.in_ci():
             self.clear(self.case_dir)

From 42e7b550fe7c64af885b87b42a2e4f545e51a175 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 1 Aug 2023 14:37:15 +0800
Subject: [PATCH 053/308] fix cpu rdata write

---
 modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
index a571294a75..3ba264dbec 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
@@ -127,7 +127,7 @@ public unsafe LinkableFunction Build(TIR.PrimFunction function)
                 throw new InvalidDataException("The Buffer Szie Not Equal!");
             }
 
-            _rdataWriter.Position((uint)size);
+            _rdataWriter.Position(range.Start.Value);
             _rdataWriter.Write(bytes);
         }
 

From 246ff2a494e41b0ba8926f882aa344415b4fd541 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 1 Aug 2023 14:41:51 +0800
Subject: [PATCH 054/308] try to fix msvc build

---
 CMakeLists.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8cbe18e463..019393e9df 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -92,7 +92,7 @@ if (BUILDING_RUNTIME)
 
     if (MSVC)
         add_definitions(/D_CRT_SECURE_NO_WARNINGS /DNOMINMAX)
-        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX /wd4297 -Wno-unused-function -Wno-unused-command-line-argument)
+        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX /wd4297 -Wno-unused-function -Wno-unused-command-line-argument -Wno-int-to-void-pointer-cast)
     else()
         add_compile_options(-Wall -Wextra -pedantic -Werror -Wno-multichar -Wno-missing-field-initializers -Wno-unused-function -Wno-type-limits)
         if (APPLE)
@@ -184,7 +184,7 @@ else()
 
     if (MSVC)
         add_definitions(/D_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS /D_CRT_SECURE_NO_WARNINGS /DNOMINMAX)
-        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX -Wno-unused-function -Wno-unused-command-line-argument)
+        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX -Wno-unused-function -Wno-unused-command-line-argument -Wno-int-to-void-pointer-cast)
         set(PYBIND11_CPP_STANDARD "/std:c++latest")
     else()
         add_compile_options(-fvisibility=hidden)

From fa6611002fc4690b8b657defc30ef9ea6b85ba5d Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 1 Aug 2023 14:57:17 +0800
Subject: [PATCH 055/308] Revert "fix mac build"

This reverts commit 66865183b4d0744355fb1458ae27bd3fe3e2696d.
---
 modules/cpu/src/runtime/cpu_common.h          |   4 +-
 tests/config.toml                             |  18 +-
 tests/generator.py                            |   4 +-
 tests/importer/onnx_/basic/test_binary.py     |  12 +-
 .../onnx_/basic/test_binary_from_onnx.py      | 100 ++++----
 .../onnx_/basic/test_conv_transpose.py        | 214 +++++-------------
 tests/importer/onnx_/basic/test_unary.py      |  28 +--
 .../tflite_/basic/test_fully_connected.py     |  19 +-
 tests/test_runner.py                          |   2 +-
 9 files changed, 144 insertions(+), 257 deletions(-)

diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
index 8fdca3c3aa..8221fa015f 100644
--- a/modules/cpu/src/runtime/cpu_common.h
+++ b/modules/cpu/src/runtime/cpu_common.h
@@ -97,7 +97,7 @@ inline int32_t int32_binary_mul(int32_t x, int32_t y) { return x * y; }
 inline int32_t int32_binary_div(int32_t x, int32_t y) { return x / y; }
 inline int32_t int32_binary_min(int32_t x, int32_t y) { return std::min(x, y); }
 inline int32_t int32_binary_max(int32_t x, int32_t y) { return std::max(x, y); }
-#if defined(__APPLE__)
+#if defined(__arm64__) && defined(__APPLE__)
 inline int32_t int32_binary_pow(int32_t x, int32_t y) {
     return (int32_t)pow(x, y);
 }
@@ -113,7 +113,7 @@ inline int64_t int64_binary_mul(int64_t x, int64_t y) { return x * y; }
 inline int64_t int64_binary_div(int64_t x, int64_t y) { return x / y; }
 inline int64_t int64_binary_min(int64_t x, int64_t y) { return std::min(x, y); }
 inline int64_t int64_binary_max(int64_t x, int64_t y) { return std::max(x, y); }
-#if defined(__APPLE__)
+#if defined(__arm64__) && defined(__APPLE__)
 inline int64_t int64_binary_pow(int64_t x, int64_t y) {
     return (int64_t)pow(x, y);
 }
diff --git a/tests/config.toml b/tests/config.toml
index 4a13208015..7d27973767 100644
--- a/tests/config.toml
+++ b/tests/config.toml
@@ -16,7 +16,7 @@ output_layout = 'NHWC'
 model_layout = 'NHWC'
 letterbox_value = 0
 dump_asm = true
-dump_ir = true
+dump_ir = false
 
 [ptq_opt]
 use_mix_quant = false
@@ -59,7 +59,7 @@ args = []
 
 [generator.calibs]
 method = 'random'
-number = 1
+number = 5
 batch = 1
 
 [generator.calibs.random]
@@ -80,21 +80,21 @@ args = []
 [target]
 
 [target.cpu]
-eval = false
+eval = true
 infer = true
 simarity_name = 'cosine'
 
 [target.cpu.mode.noptq]
-enabled = true
+enabled = false
 threshold = 0.999
 
 [target.cpu.mode.ptq]
-enabled = false
+enabled = true
 threshold = 0.98
 
 [target.k510]
-eval = false
-infer = false
+eval = true
+infer = true
 simarity_name = 'cosine'
 
 [target.k510.mode.noptq]
@@ -106,8 +106,8 @@ enabled = true
 threshold = 0.98
 
 [target.k230]
-eval = false
-infer = false
+eval = true
+infer = true
 simarity_name = 'cosine'
 
 [target.k230.mode.noptq]
diff --git a/tests/generator.py b/tests/generator.py
index 74408b9e3d..631883c757 100644
--- a/tests/generator.py
+++ b/tests/generator.py
@@ -14,9 +14,9 @@ def from_random(self, shape: List[int], dtype: np.dtype, abs: bool = False) -> n
         elif dtype == np.bool:
             data = np.random.rand(*shape) > 0.5
         elif dtype == np.int32:
-            data = np.random.randint(1, 2, size=shape, dtype='int32')
+            data = np.random.randint(1, 5, size=shape, dtype='int32')
         elif dtype == np.int64:
-            data = np.random.randint(1, 2, size=shape, dtype='int64')
+            data = np.random.randint(1, 5, size=shape, dtype='int64')
             # data = np.random.randint(1, 128, size=shape, dtype='int64')
         else:
             data = np.random.rand(*shape)
diff --git a/tests/importer/onnx_/basic/test_binary.py b/tests/importer/onnx_/basic/test_binary.py
index abb928157e..c629691f04 100644
--- a/tests/importer/onnx_/basic/test_binary.py
+++ b/tests/importer/onnx_/basic/test_binary.py
@@ -23,13 +23,13 @@ def _make_module(v_shape):
     class BinaryModule(torch.nn.Module):
         def __init__(self):
             super(BinaryModule, self).__init__()
-            self.v = torch.from_numpy(np.random.rand(*v_shape).astype(np.float32))
-            # self.v = torch.from_numpy(np.ones(v_shape).astype(np.float32))
+            # self.v = torch.from_numpy(np.random.rand(*v_shape).astype(np.float32))
+            self.v = torch.from_numpy(np.ones(v_shape).astype(np.float32))
 
         def forward(self, x):
             outs = []
-            # outs.append(torch.add(x, self.v))
-            outs.append(torch.mul(x, self.v))
+            outs.append(torch.add(x, self.v))
+            # outs.append(torch.mul(x, self.v))
             # outs.append(torch.sub(x, self.v))
             # outs.append(torch.max(x, self.v))
             # outs.append(torch.div(x, self.v))
@@ -45,7 +45,7 @@ def forward(self, x):
     # [64, 3],
     # [3, 64, 3],
     # [8, 3, 64, 3]
-    [1, 560, 196]
+    [1, 3, 24, 24]
 ]
 
 rhs_shapes = [
@@ -61,7 +61,7 @@ def forward(self, x):
     # [8, 3, 1, 3],
     # [8, 1, 64, 3],
     # [1, 3, 64, 1]
-    [1, 560, 1]
+    [1, 3, 24, 24]
 ]
 
 
diff --git a/tests/importer/onnx_/basic/test_binary_from_onnx.py b/tests/importer/onnx_/basic/test_binary_from_onnx.py
index 0a3ba13c62..f95bf61a80 100644
--- a/tests/importer/onnx_/basic/test_binary_from_onnx.py
+++ b/tests/importer/onnx_/basic/test_binary_from_onnx.py
@@ -31,29 +31,27 @@ def _make_module(op, in_type, in_shape_0, in_shape_1):
     # input1
     input1 = helper.make_tensor_value_info('input1', in_type, in_shape_0)
     inputs.append('input1')
-    input2 = helper.make_tensor_value_info('input2', in_type, in_shape_1)
-    inputs.append('input2')
 
     # set input2 to avoid SIGFPE for div op.
-    # if op != 'Pow':
-    #     tensor = helper.make_tensor(
-    #         'input2',
-    #         in_type,
-    #         dims=in_shape_1,
-    #         vals=(np.random.rand(*in_shape_1) +
-    #               2).astype(onnx.mapping.TENSOR_TYPE_TO_NP_TYPE[in_type]).flatten().tolist()
-    #     )
-    #     inputs.append('input2')
-    #     initializers.append(tensor)
-    # else:
-    #     tensor = helper.make_tensor(
-    #         'input2',
-    #         TensorProto.INT32,
-    #         dims=[1],
-    #         vals=[2]
-    #     )
-    #     inputs.append('input2')
-    #     initializers.append(tensor)
+    if op != 'Pow':
+        tensor = helper.make_tensor(
+            'input2',
+            in_type,
+            dims=in_shape_1,
+            vals=(np.random.rand(*in_shape_1) +
+                  2).astype(onnx.mapping.TENSOR_TYPE_TO_NP_TYPE[in_type]).flatten().tolist()
+        )
+        inputs.append('input2')
+        initializers.append(tensor)
+    else:
+        tensor = helper.make_tensor(
+            'input2',
+            TensorProto.INT32,
+            dims=[1],
+            vals=[2]
+        )
+        inputs.append('input2')
+        initializers.append(tensor)
 
     # output
     x = np.random.randn(*in_shape_0)
@@ -73,7 +71,7 @@ def _make_module(op, in_type, in_shape_0, in_shape_1):
     graph_def = helper.make_graph(
         nodes,
         'test-model',
-        [input1, input2],
+        [input1],
         [output],
         initializer=initializers)
 
@@ -86,9 +84,9 @@ def _make_module(op, in_type, in_shape_0, in_shape_1):
     'Sub',
     'Mul',
     'Div',
-    # 'Min',
-    # 'Max',
-    # 'Pow',
+    'Min',
+    'Max',
+    'Pow',
 ]
 
 in_types = [
@@ -96,45 +94,45 @@ def _make_module(op, in_type, in_shape_0, in_shape_1):
 ]
 
 in_shapes = [
-    # [[1, 3, 16, 16], [1]],
-    # [[1, 3, 16, 16], [16]],
-    # [[1, 3, 16, 16], [1, 16]],
-    # [[1, 3, 16, 16], [16, 16]],
-    # [[1, 3, 16, 16], [1, 16, 16]],
-    # [[1, 3, 16, 16], [3, 16, 16]],
+    [[1, 3, 16, 16], [1]],
+    [[1, 3, 16, 16], [16]],
+    [[1, 3, 16, 16], [1, 16]],
+    [[1, 3, 16, 16], [16, 16]],
+    [[1, 3, 16, 16], [1, 16, 16]],
+    [[1, 3, 16, 16], [3, 16, 16]],
     [[1, 3, 16, 16], [1, 3, 16, 16]],
 
-    # [[3, 16, 16], [1]],
-    # [[3, 16, 16], [16]],
-    # [[3, 16, 16], [1, 16]],
-    # [[3, 16, 16], [16, 16]],
+    [[3, 16, 16], [1]],
+    [[3, 16, 16], [16]],
+    [[3, 16, 16], [1, 16]],
+    [[3, 16, 16], [16, 16]],
     [[3, 16, 16], [1, 16, 16]],
     [[3, 16, 16], [3, 16, 16]],
-    # [[3, 16, 16], [1, 3, 16, 16]],
+    [[3, 16, 16], [1, 3, 16, 16]],
 
-    # [[16, 16], [1]],
-    # [[16, 16], [16]],
+    [[16, 16], [1]],
+    [[16, 16], [16]],
     [[16, 16], [1, 16]],
     [[16, 16], [16, 16]],
-    # [[16, 16], [1, 16, 16]],
-    # [[16, 16], [3, 16, 16]],
-    # [[16, 16], [1, 3, 16, 16]],
+    [[16, 16], [1, 16, 16]],
+    [[16, 16], [3, 16, 16]],
+    [[16, 16], [1, 3, 16, 16]],
 
     [[1], [1]],
     [[1], [16]],
-    # [[1], [1, 16]],
-    # [[1], [16, 16]],
-    # [[1], [1, 16, 16]],
-    # [[1], [3, 16, 16]],
-    # [[1], [1, 3, 16, 16]],
+    [[1], [1, 16]],
+    [[1], [16, 16]],
+    [[1], [1, 16, 16]],
+    [[1], [3, 16, 16]],
+    [[1], [1, 3, 16, 16]],
 
     [[16], [1]],
     [[16], [16]],
-    # [[16], [1, 16]],
-    # [[16], [16, 16]],
-    # [[16], [1, 16, 16]],
-    # [[16], [3, 16, 16]],
-    # [[16], [1, 3, 16, 16]]
+    [[16], [1, 16]],
+    [[16], [16, 16]],
+    [[16], [1, 16, 16]],
+    [[16], [3, 16, 16]],
+    [[16], [1, 3, 16, 16]]
 ]
 
 
diff --git a/tests/importer/onnx_/basic/test_conv_transpose.py b/tests/importer/onnx_/basic/test_conv_transpose.py
index a675680e2b..c2cfc3c8c3 100644
--- a/tests/importer/onnx_/basic/test_conv_transpose.py
+++ b/tests/importer/onnx_/basic/test_conv_transpose.py
@@ -16,194 +16,88 @@
 import math
 import pytest
 import onnx
+import torch
 from onnx import helper
 from onnx import AttributeProto, TensorProto, GraphProto
 from onnx_test_runner import OnnxTestRunner
 import numpy as np
 
 
-def _make_module(in_shape, kernel_output_channel, bias_shape, auto_pad_mode, dilation, group, kernel_shape, output_padding, pad, stride):
-    inputs = []
-    initializers = []
-
-    # input
-    input = helper.make_tensor_value_info('input', TensorProto.FLOAT, in_shape)
-    inputs.append('input')
-
-    group = 1 if group is None else group
-
-    # weight
-    w_shape = []
-    w_shape.append(in_shape[1])
-    w_shape.append(kernel_output_channel // group)
-    w_shape.extend(kernel_shape)
-    weight = helper.make_tensor(
-        'weight',
-        TensorProto.FLOAT,
-        dims=w_shape,
-        vals=np.random.rand(*w_shape).astype(np.float32).flatten().tolist()
-    )
-    inputs.append('weight')
-    initializers.append(weight)
-
-    # bias
-    if bias_shape is not None:
-        bias = helper.make_tensor(
-            'bias',
-            TensorProto.FLOAT,
-            dims=bias_shape,
-            vals=np.random.rand(*bias_shape).astype(np.float32).flatten().tolist()
-        )
-        inputs.append('bias')
-        initializers.append(bias)
-
-    # dilation
-    d = [1, 1] if dilation is None else dilation
-
-    # output_padding
-    out_padding = [0, 0] if output_padding is None else output_padding
-
-    # stride
-    s = [1, 1] if stride is None else stride
-
-    # output
-    out_shape = []
-    out_shape.append(in_shape[0])
-    out_shape.append(w_shape[1] * group)
-
-    # pad
-    padding = [0, 0, 0, 0]
-    if auto_pad_mode in [None, 'NOTSET'] and pad is not None:
-        padding = pad
-        out_shape.append(s[0] * (in_shape[2] - 1) + out_padding[0] +
-                         (w_shape[2] - 1) * d[0] + 1 - padding[0] - padding[2])
-        out_shape.append(s[1] * (in_shape[3] - 1) + out_padding[1] +
-                         (w_shape[3] - 1) * d[1] + 1 - padding[1] - padding[3])
-    elif auto_pad_mode in ['SAME_UPPER', 'SAME_LOWER']:
-        out_shape.append(in_shape[2] * s[0])
-        out_shape.append(in_shape[3] * s[1])
-    else:
-        out_shape.append(in_shape[2] + (in_shape[2] - 1) * (s[0] - 1) - w_shape[2] + 1)
-        out_shape.append(in_shape[3] + (in_shape[3] - 1) * (s[1] - 1) - w_shape[3] + 1)
-
-    output = helper.make_tensor_value_info('output', TensorProto.FLOAT, out_shape)
-
-    attributes_dict = {}
-
-    if auto_pad_mode is not None:
-        attributes_dict['auto_pad'] = auto_pad_mode
-
-    if dilation is not None:
-        attributes_dict['dilations'] = dilation
-
-    if group is not None:
-        attributes_dict['group'] = group
-
-    if kernel_shape is not None:
-        attributes_dict['kernel_shape'] = kernel_shape
-
-    if output_padding is not None:
-        attributes_dict['output_padding'] = output_padding
-
-    if pad is not None:
-        attributes_dict['pads'] = padding
-
-    if stride is not None:
-        attributes_dict['strides'] = stride
-
-    node = onnx.helper.make_node(
-        'ConvTranspose',
-        inputs=inputs,
-        outputs=['output'],
-        **attributes_dict
-    )
-
-    nodes = []
-    nodes.append(node)
-
-    graph_def = helper.make_graph(
-        nodes,
-        'test-model',
-        [input],
-        [output],
-        initializer=initializers)
-
-    model_def = helper.make_model(graph_def, producer_name='kendryte')
-
-    return model_def
-
-
-in_shapes = [
-    [1, 3, 10, 10]
-]
+def _make_module(in_channel, out_channel, kernel_size, stride, dilation, pad, group, bias):
+    class ConvTransposeModule(torch.nn.Module):
+        def __init__(self):
+            super(ConvTransposeModule, self).__init__()
+            self.conv_transpose = torch.nn.ConvTranspose2d(
+                in_channel, out_channel, kernel_size, stride, pad, [0, 0], group, bias, dilation)
 
-kernel_output_channels = [
-    3
-]
+        def forward(self, x):
+            return self.conv_transpose(x)
 
-bias_shapes = [
-    None,
-]
-bias_shapes.extend(list([[x] for x in kernel_output_channels]))
-
-auto_pad_modes = [
-    None,
-    # 'NOTSET',
-    # 'SAME_UPPER',
-    # 'SAME_LOWER',
-    # 'VALID'
+    return ConvTransposeModule()
+
+
+in_sizes = [
+    [16, 16],
+    [33, 65],
 ]
 
-dilations = [
-    None,
+in_channels = [
+    1,
+    3,
+    16
 ]
 
-groups = [
-    None,
-    # 3
+out_channels = [
+    1,
+    16
 ]
 
-kernel_shapes = [
+kernel_sizes = [
     [1, 1],
+    [3, 3],
+]
+
+strides = [
+    1,
+    [2, 2]
 ]
 
-output_paddings = [
-    None,
-    # [1, 1]
+dilations = [
+    1
 ]
 
 pads = [
-    # None,
-    [0, 0, 1, 1],
+    0,
+    [1, 1],
 ]
 
-strides = [
-    None,
-    # [2, 3],
-    # [3, 2],
-    # [3, 3]
+groups = [
+    1
+]
+
+biases = [
+    True,
+    False
 ]
 
 
-@pytest.mark.parametrize('in_shape', in_shapes)
-@pytest.mark.parametrize('kernel_output_channel', kernel_output_channels)
-@pytest.mark.parametrize('bias_shape', bias_shapes)
-@pytest.mark.parametrize('auto_pad_mode', auto_pad_modes)
+@pytest.mark.parametrize('in_size', in_sizes)
+@pytest.mark.parametrize('in_channel', in_channels)
+@pytest.mark.parametrize('out_channel', out_channels)
+@pytest.mark.parametrize('kernel_size', kernel_sizes)
+@pytest.mark.parametrize('stride', strides)
 @pytest.mark.parametrize('dilation', dilations)
-@pytest.mark.parametrize('group', groups)
-@pytest.mark.parametrize('kernel_shape', kernel_shapes)
-@pytest.mark.parametrize('output_padding', output_paddings)
 @pytest.mark.parametrize('pad', pads)
-@pytest.mark.parametrize('stride', strides)
-def test_conv_transpose(in_shape, kernel_output_channel, bias_shape, auto_pad_mode, dilation, group, kernel_shape, output_padding, pad, stride, request):
-    if (bias_shape is None or (bias_shape is not None and bias_shape[0] == kernel_output_channel)) and ((auto_pad_mode in [None, 'NOTSET'] and pad is not None) or (auto_pad_mode in ['SAME_UPPER', 'SAME_LOWER', 'VALID'] and pad is None)) and (dilation is None or (auto_pad_modes in [None, 'NOTSET'])) and ((output_padding is None) or (output_padding is not None and stride is not None)):
-        model_def = _make_module(in_shape, kernel_output_channel, bias_shape,
-                                 auto_pad_mode, dilation, group, kernel_shape, output_padding, pad, stride)
+@pytest.mark.parametrize('group', groups)
+@pytest.mark.parametrize('bias', biases)
+def test_conv_transpose(in_size, in_channel, out_channel, kernel_size, stride, dilation, pad, group, bias, request):
+    model_file = _make_module(in_channel, out_channel, kernel_size,
+                              stride, dilation, pad, group, bias)
 
-        runner = OnnxTestRunner(request.node.name)
-        model_file = runner.from_onnx_helper(model_def)
-        runner.run(model_file)
+    runner = OnnxTestRunner(request.node.name)
+    model_file = runner.from_torch(model_file, [1, in_channel, *in_size])
+    runner.run(model_file)
 
 
 if __name__ == "__main__":
-    pytest.main(['-vv', 'test_conv_transpose.py'])
+    pytest.main(['-vv', __file__])
diff --git a/tests/importer/onnx_/basic/test_unary.py b/tests/importer/onnx_/basic/test_unary.py
index 58353ff25a..1137dd0a06 100644
--- a/tests/importer/onnx_/basic/test_unary.py
+++ b/tests/importer/onnx_/basic/test_unary.py
@@ -26,19 +26,19 @@ def __init__(self):
 
         def forward(self, x):
             outs = []
-            # outs.append(torch.abs(-x))
-            # outs.append(torch.acos(x))
-            # outs.append(torch.asin(x))
-            # outs.append(torch.ceil(x))
-            # outs.append(torch.cos(x))
-            # outs.append(torch.exp(x))
+            outs.append(torch.abs(-x))
+            outs.append(torch.acos(x))
+            outs.append(torch.asin(x))
+            outs.append(torch.ceil(x))
+            outs.append(torch.cos(x))
+            outs.append(torch.exp(x))
             outs.append(torch.floor(x * 10))
-            # outs.append(torch.log(x + 2))
-            # outs.append(torch.neg(x))
-            # outs.append(torch.round(x))
-            # outs.append(torch.sin(x))
-            # outs.append(torch.sqrt(x + 2))
-            # outs.append(torch.tanh(x))
+            outs.append(torch.log(x + 2))
+            outs.append(torch.neg(x))
+            outs.append(torch.round(x))
+            outs.append(torch.sin(x))
+            outs.append(torch.sqrt(x + 2))
+            outs.append(torch.tanh(x))
             return outs
 
     return UnaryModule()
@@ -46,7 +46,7 @@ def forward(self, x):
 
 in_shapes = [
     [16],
-    # [1, 3, 16, 16]
+    [1, 3, 16, 16]
 ]
 
 
@@ -60,4 +60,4 @@ def test_unary(in_shape, request):
 
 
 if __name__ == "__main__":
-    pytest.main(['-vv', __file__])
+    pytest.main(['-vv', 'test_unary.py'])
diff --git a/tests/importer/tflite_/basic/test_fully_connected.py b/tests/importer/tflite_/basic/test_fully_connected.py
index c81829f4ce..6cc3996d03 100644
--- a/tests/importer/tflite_/basic/test_fully_connected.py
+++ b/tests/importer/tflite_/basic/test_fully_connected.py
@@ -28,34 +28,29 @@ def __init__(self):
 
         @tf.function(input_signature=[tf.TensorSpec(input_shape, dtype=tf.float32)])
         def __call__(self, x):
-            out = []
-            x = self.out(x)
-            y = tf.reshape(x, [1, 1, 560, 80])
-            out.append(x)
-            out.append(y)
-            return out
+            return self.out(x)
 
     return FullyConnectedModule()
 
 
 input_shapes = [
-    [1, 560, 128],
-    # [3, 7]
+    [4, 6],
+    [3, 7]
 ]
 
 units = [
-    80,
-    # 13
+    3,
+    13
 ]
 
 activations = [
     None,
-    # 'relu',
+    'relu',
 ]
 
 use_biases = [
     True,
-    # False
+    False
 ]
 
 
diff --git a/tests/test_runner.py b/tests/test_runner.py
index f6b63b0501..335b22e2c9 100644
--- a/tests/test_runner.py
+++ b/tests/test_runner.py
@@ -255,7 +255,7 @@ def run(self, model_file: Union[List[str], str]):
                             if not judge:
                                 if test_utils.in_ci():
                                     self.clear(self.case_dir)
-                                assert (judge), f"Fault result in {stage} + {result}"
+                                assert f"Fault result in {stage} + {result}"
 
         if test_utils.in_ci():
             self.clear(self.case_dir)

From 9c98a6a09b86355e8f01c871beaed41252efdaee Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 1 Aug 2023 14:58:15 +0800
Subject: [PATCH 056/308] fix mac build

---
 modules/cpu/src/runtime/cpu_common.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
index 8221fa015f..8fdca3c3aa 100644
--- a/modules/cpu/src/runtime/cpu_common.h
+++ b/modules/cpu/src/runtime/cpu_common.h
@@ -97,7 +97,7 @@ inline int32_t int32_binary_mul(int32_t x, int32_t y) { return x * y; }
 inline int32_t int32_binary_div(int32_t x, int32_t y) { return x / y; }
 inline int32_t int32_binary_min(int32_t x, int32_t y) { return std::min(x, y); }
 inline int32_t int32_binary_max(int32_t x, int32_t y) { return std::max(x, y); }
-#if defined(__arm64__) && defined(__APPLE__)
+#if defined(__APPLE__)
 inline int32_t int32_binary_pow(int32_t x, int32_t y) {
     return (int32_t)pow(x, y);
 }
@@ -113,7 +113,7 @@ inline int64_t int64_binary_mul(int64_t x, int64_t y) { return x * y; }
 inline int64_t int64_binary_div(int64_t x, int64_t y) { return x / y; }
 inline int64_t int64_binary_min(int64_t x, int64_t y) { return std::min(x, y); }
 inline int64_t int64_binary_max(int64_t x, int64_t y) { return std::max(x, y); }
-#if defined(__arm64__) && defined(__APPLE__)
+#if defined(__APPLE__)
 inline int64_t int64_binary_pow(int64_t x, int64_t y) {
     return (int64_t)pow(x, y);
 }

From 0e7d98d89a3d13e6dae6c29f1ba1497a669df386 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 1 Aug 2023 15:48:54 +0800
Subject: [PATCH 057/308] try to fix msvc build

---
 modules/cpu/src/runtime/runtime_function.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 2b4d7e3a8f..9e6b261bb9 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -48,6 +48,8 @@ cpu_runtime_module &cpu_runtime_function::module() const noexcept {
 result<void> cpu_runtime_function::initialize_core(
     NNCASE_UNUSED runtime_function_init_context &context) noexcept {
 
+    printf("Initializing Core\n");
+
     // try_(context.read_section(".desc", [this](auto sr, size_t) ->
     // result<void> {
     //     auto header = sr.template read<desc_header>();
@@ -113,6 +115,8 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
                                   NNCASE_UNUSED value_t return_value) noexcept {
     try_var(id, module().find_id_by_function(this));
 
+    printf("InvokeCore\n");
+
     uint8_t **buffers = new uint8_t *[parameters.size()];
     // input buffer
     for (size_t i = 0; i < parameters.size(); i++) {

From 352b69d507d3ed28999df540207b44e5c79546e6 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 1 Aug 2023 15:52:43 +0800
Subject: [PATCH 058/308] Revert "try to fix msvc build"

This reverts commit 0e7d98d89a3d13e6dae6c29f1ba1497a669df386.
---
 modules/cpu/src/runtime/runtime_function.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 9e6b261bb9..2b4d7e3a8f 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -48,8 +48,6 @@ cpu_runtime_module &cpu_runtime_function::module() const noexcept {
 result<void> cpu_runtime_function::initialize_core(
     NNCASE_UNUSED runtime_function_init_context &context) noexcept {
 
-    printf("Initializing Core\n");
-
     // try_(context.read_section(".desc", [this](auto sr, size_t) ->
     // result<void> {
     //     auto header = sr.template read<desc_header>();
@@ -115,8 +113,6 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
                                   NNCASE_UNUSED value_t return_value) noexcept {
     try_var(id, module().find_id_by_function(this));
 
-    printf("InvokeCore\n");
-
     uint8_t **buffers = new uint8_t *[parameters.size()];
     // input buffer
     for (size_t i = 0; i < parameters.size(); i++) {

From 4b64b4404d1873ec889140ab4134ee9b01b8d38e Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 1 Aug 2023 15:53:22 +0800
Subject: [PATCH 059/308] try to fix msvc build

---
 CMakeLists.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 019393e9df..6b746d454b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -92,7 +92,7 @@ if (BUILDING_RUNTIME)
 
     if (MSVC)
         add_definitions(/D_CRT_SECURE_NO_WARNINGS /DNOMINMAX)
-        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX /wd4297 -Wno-unused-function -Wno-unused-command-line-argument -Wno-int-to-void-pointer-cast)
+        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX /wd4297 -Wno-unused-function -Wno-unused-command-line-argument -Wno-int-to-void-pointer-cast -Wno-int-to-pointer-cast)
     else()
         add_compile_options(-Wall -Wextra -pedantic -Werror -Wno-multichar -Wno-missing-field-initializers -Wno-unused-function -Wno-type-limits)
         if (APPLE)
@@ -184,7 +184,7 @@ else()
 
     if (MSVC)
         add_definitions(/D_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS /D_CRT_SECURE_NO_WARNINGS /DNOMINMAX)
-        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX -Wno-unused-function -Wno-unused-command-line-argument -Wno-int-to-void-pointer-cast)
+        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX -Wno-unused-function -Wno-unused-command-line-argument -Wno-int-to-void-pointer-cast -Wno-int-to-pointer-cast)
         set(PYBIND11_CPP_STANDARD "/std:c++latest")
     else()
         add_compile_options(-fvisibility=hidden)

From 5e85bf33e2f71aaf2a260455554c02be2f590cfe Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 3 Aug 2023 11:12:31 +0800
Subject: [PATCH 060/308] update cpu runtime

---
 .../CodeGen/CSourceCompiler.cs                |   4 +-
 modules/cpu/src/runtime/cpu_common.h          | 103 +++++++++---------
 modules/cpu/src/runtime/elfloader.cpp         |   4 +-
 3 files changed, 55 insertions(+), 56 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
index d59e244f92..449329e034 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
@@ -134,11 +134,11 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
-            return $"{sourcePath} -nostdlib -static -no-pie -fPIC -fno-stack-protector -march={Arch} -o {outPath}";
+            return $"{sourcePath} -nostdlib -static -no-pie -fPIC -fno-stack-protector -o {outPath}";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
         {
-            return $"{sourcePath} -nostdlib -static -nopie -fPIC -arch {Arch} -o {outPath} -e__start";
+            return $"{sourcePath} -nostdlib -static -nopie -fPIC -o {outPath} -e__start";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
         {
diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
index 8fdca3c3aa..aefa9f32d1 100644
--- a/modules/cpu/src/runtime/cpu_common.h
+++ b/modules/cpu/src/runtime/cpu_common.h
@@ -127,57 +127,56 @@ inline bool bool_binary_logical_and(bool x, bool y) { return x && y; }
 inline bool bool_binary_logical_or(bool x, bool y) { return x || y; }
 inline bool bool_binary_logical_xor(bool x, bool y) { return x ^ y; }
 
-[[maybe_unused]] static nncase_mt_t nncase_mt = {
-    .float_unary_abs = fabsf,
-    .float_unary_acos = acosf,
-    .float_unary_acosh = acoshf,
-    .float_unary_asin = asinf,
-    .float_unary_asinh = asinhf,
-    .float_unary_ceil = ceilf,
-    .float_unary_cos = cosf,
-    .float_unary_cosh = coshf,
-    .float_unary_exp = expf,
-    .float_unary_floor = floorf,
-    .float_unary_log = logf,
-    .float_unary_logical_not = float_unary_logical_not,
-    .float_unary_neg = float_unary_neg,
-    .float_unary_round = roundf,
-    .float_unary_rsqrt = float_unary_rsqrt,
-    .float_unary_sign = float_unary_sign,
-    .float_unary_sin = sinf,
-    .float_unary_sinh = sinhf,
-    .float_unary_sqrt = sqrtf,
-    .float_unary_square = float_unary_square,
-    .float_unary_tanh = tanhf,
-    .float_binary_add = float_binary_add,
-    .float_binary_sub = float_binary_sub,
-    .float_binary_mul = float_binary_mul,
-    .float_binary_div = float_binary_div,
-    .float_binary_min = float_binary_min,
-    .float_binary_max = float_binary_max,
-    .float_binary_pow = float_binary_pow,
-    .float_binary_logical_and = float_binary_logical_and,
-    .float_binary_mod = float_binary_mod,
-    .int32_binary_add = int32_binary_add,
-    .int32_binary_sub = int32_binary_sub,
-    .int32_binary_mul = int32_binary_mul,
-    .int32_binary_div = int32_binary_div,
-    .int32_binary_min = int32_binary_min,
-    .int32_binary_max = int32_binary_max,
-    .int32_binary_pow = int32_binary_pow,
-    .int32_binary_logical_and = int32_binary_logical_and,
-    .int32_binary_mod = int32_binary_mod,
-    .int64_binary_add = int64_binary_add,
-    .int64_binary_sub = int64_binary_sub,
-    .int64_binary_mul = int64_binary_mul,
-    .int64_binary_div = int64_binary_div,
-    .int64_binary_min = int64_binary_min,
-    .int64_binary_max = int64_binary_max,
-    .int64_binary_pow = int64_binary_pow,
-    .int64_binary_logical_and = int64_binary_logical_and,
-    .int64_binary_mod = int64_binary_mod,
-    .bool_binary_and = bool_binary_logical_and,
-    .bool_binary_or = bool_binary_logical_or,
-    .bool_binary_xor = bool_binary_logical_xor};
+[[maybe_unused]] static nncase_mt_t nncase_mt{fabsf,
+                                              acosf,
+                                              acoshf,
+                                              asinf,
+                                              asinhf,
+                                              ceilf,
+                                              cosf,
+                                              coshf,
+                                              expf,
+                                              floorf,
+                                              logf,
+                                              float_unary_logical_not,
+                                              float_unary_neg,
+                                              roundf,
+                                              float_unary_rsqrt,
+                                              float_unary_sign,
+                                              sinf,
+                                              sinhf,
+                                              sqrtf,
+                                              float_unary_square,
+                                              tanhf,
+                                              float_binary_add,
+                                              float_binary_sub,
+                                              float_binary_mul,
+                                              float_binary_div,
+                                              float_binary_min,
+                                              float_binary_max,
+                                              float_binary_pow,
+                                              float_binary_logical_and,
+                                              float_binary_mod,
+                                              int32_binary_add,
+                                              int32_binary_sub,
+                                              int32_binary_mul,
+                                              int32_binary_div,
+                                              int32_binary_min,
+                                              int32_binary_max,
+                                              int32_binary_pow,
+                                              int32_binary_logical_and,
+                                              int32_binary_mod,
+                                              int64_binary_add,
+                                              int64_binary_sub,
+                                              int64_binary_mul,
+                                              int64_binary_div,
+                                              int64_binary_min,
+                                              int64_binary_max,
+                                              int64_binary_pow,
+                                              int64_binary_logical_and,
+                                              int64_binary_mod,
+                                              bool_binary_logical_and,
+                                              bool_binary_logical_or,
+                                              bool_binary_logical_xor};
 
 END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/cpu/src/runtime/elfloader.cpp
index c41d7e11ab..394ed6ed3d 100644
--- a/modules/cpu/src/runtime/elfloader.cpp
+++ b/modules/cpu/src/runtime/elfloader.cpp
@@ -29,8 +29,8 @@ int elfloader::invoke_elf(size_t id, uint8_t **buffers, nncase_mt_t *nncase_mt,
 
     entrypoint_t ep = (entrypoint_t)epaddr;
 
-    printf("Binary entrypoint is %" PRIxPTR "; invoking %p\n",
-           (uintptr_t)ctx_.ehdr.e_entry, (void *)epaddr);
+    // printf("Binary entrypoint is %" PRIxPTR "; invoking %p\n",
+    //        (uintptr_t)ctx_.ehdr.e_entry, (void *)epaddr);
 
     ep(id, buffers, nncase_mt, data, rdata);
 

From 5531c7d6c45684c42858624b6a16dbcbac2615ad Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 3 Aug 2023 11:13:20 +0800
Subject: [PATCH 061/308] add cpu_test example

---
 modules/cpu/CMakeLists.txt                   |   4 +
 modules/cpu/examples/CMakeLists.txt          |   4 +
 modules/cpu/examples/cpu_test/CMakeLists.txt |   5 +
 modules/cpu/examples/cpu_test/main.cpp       | 191 +++++++++++++++++++
 toolchains/k230_cpu.linux.toolchain.cmake    |  33 ++++
 5 files changed, 237 insertions(+)
 create mode 100644 modules/cpu/examples/CMakeLists.txt
 create mode 100644 modules/cpu/examples/cpu_test/CMakeLists.txt
 create mode 100644 modules/cpu/examples/cpu_test/main.cpp
 create mode 100644 toolchains/k230_cpu.linux.toolchain.cmake

diff --git a/modules/cpu/CMakeLists.txt b/modules/cpu/CMakeLists.txt
index f030315513..42d6983640 100644
--- a/modules/cpu/CMakeLists.txt
+++ b/modules/cpu/CMakeLists.txt
@@ -45,6 +45,10 @@ if (BUILDING_RUNTIME)
 
         configure_file(${CMAKE_CURRENT_LIST_DIR}/cmake/nncase_rt_modules_cpuConfig.cmake.in nncase_rt_modules_cpuConfig.cmake @ONLY)
         install(FILES ${CMAKE_CURRENT_BINARY_DIR}/nncase_rt_modules_cpuConfig.cmake DESTINATION lib/cmake/nncaseruntime)
+
+        if (K230_LINUX_SDK_DIR)
+            add_subdirectory(examples)
+        endif()
     endif()
 else()
     add_library(nncase_modules_cpu SHARED ${SRCS})
diff --git a/modules/cpu/examples/CMakeLists.txt b/modules/cpu/examples/CMakeLists.txt
new file mode 100644
index 0000000000..ea209b0f0f
--- /dev/null
+++ b/modules/cpu/examples/CMakeLists.txt
@@ -0,0 +1,4 @@
+cmake_minimum_required(VERSION 3.13)
+project(examples C CXX)
+
+add_subdirectory(cpu_test)
\ No newline at end of file
diff --git a/modules/cpu/examples/cpu_test/CMakeLists.txt b/modules/cpu/examples/cpu_test/CMakeLists.txt
new file mode 100644
index 0000000000..92c0068dff
--- /dev/null
+++ b/modules/cpu/examples/cpu_test/CMakeLists.txt
@@ -0,0 +1,5 @@
+set(SRC main.cpp)
+set(bin cpu_test.elf)
+
+add_executable(${bin} ${SRC})
+target_link_libraries(${bin} runtime_cpu)
\ No newline at end of file
diff --git a/modules/cpu/examples/cpu_test/main.cpp b/modules/cpu/examples/cpu_test/main.cpp
new file mode 100644
index 0000000000..95dd514129
--- /dev/null
+++ b/modules/cpu/examples/cpu_test/main.cpp
@@ -0,0 +1,191 @@
+#include <chrono>
+#include <fstream>
+#include <iostream>
+#include <nncase/runtime/interpreter.h>
+#include <nncase/runtime/runtime_op_utility.h>
+
+using namespace nncase;
+using namespace nncase::runtime;
+using namespace nncase::runtime::detail;
+
+template <class T>
+std::vector<T> read_binary_file(const char *file_name)
+{
+    std::ifstream ifs(file_name, std::ios::binary);
+    ifs.seekg(0, ifs.end);
+    size_t len = ifs.tellg();
+    std::vector<T> vec(len / sizeof(T), 0);
+    ifs.seekg(0, ifs.beg);
+    ifs.read(reinterpret_cast<char *>(vec.data()), len);
+    ifs.close();
+    return vec;
+}
+
+void read_binary_file(const char *file_name, char *buffer)
+{
+    std::ifstream ifs(file_name, std::ios::binary);
+    ifs.seekg(0, ifs.end);
+    size_t len = ifs.tellg();
+    ifs.seekg(0, ifs.beg);
+    ifs.read(buffer, len);
+    ifs.close();
+}
+
+auto read_binary(const char *file_name, char *buffer, size_t begin, size_t count)
+{
+    std::ifstream ifs(file_name, std::ios::binary);
+    ifs.seekg(begin, ifs.beg);
+    ifs.read(buffer + begin, count);
+    ifs.close();
+    std::cout << "read bin seg ok" << std::endl;
+}
+
+size_t get_binary_file_size(const char *file_name)
+{
+    std::ifstream ifs(file_name, std::ios::binary);
+    ifs.seekg(0, ifs.end);
+    size_t len = ifs.tellg();
+    ifs.close();
+    return len;
+}
+
+auto load_bin_to_kmodel(char *file_path, interpreter &interp)
+{
+    auto model_size = get_binary_file_size(file_path);
+    auto model_data = std::make_unique<char[]>(model_size);
+    for (size_t i = 0; i < model_size;)
+    {
+        size_t count = 8000000;
+        if (count + i >= model_size)
+            count = model_size - i;
+        read_binary(file_path, model_data.get(), i, count);
+        i += 8000000;
+    }
+    // show the identification of kmodel.
+    // print_one_line_data("kmodel identification :", model_data.get(), 4);
+
+    interp.load_model({ (const gsl::byte *)model_data.get(), model_size }).expect("cannot load kmodel.");
+    std::cout << "load kmodel success" << std::endl;
+
+    return model_data;
+}
+
+template <typename T>
+double dot(const T *v1, const T *v2, size_t size)
+{
+    double ret = 0.f;
+    for (size_t i = 0; i < size; i++)
+    {
+        ret += v1[i] * v2[i];
+    }
+
+    return ret;
+}
+
+template <typename T>
+double cosine(const T *v1, const T *v2, size_t size)
+{
+    for (size_t i = 0; i < 10; i++)
+    {
+        std::cout << v1[i] << " " << v2[i] << std::endl;
+    }
+    return dot(v1, v2, size) / ((sqrt(dot(v1, v1, size)) * sqrt(dot(v2, v2, size))));
+}
+
+int main(int argc, char *argv[])
+{
+    std::cout << "case " << argv[0] << " build " << __DATE__ << " " << __TIME__ << std::endl;
+
+    if (argc < 3)
+    {
+        std::cerr << "Usage: " << std::endl;
+        std::cerr << argv[0] << " <kmodel> <input_0.bin> <input_1.bin> ... <input_N.bin> " << std::endl;
+        std::cerr << argv[0] << " <kmodel> <input_0.bin> <input_1.bin> ... <input_N.bin> <output_0.bin> <output_1.bin> ... <output_N.bin>" << std::endl;
+        return -1;
+    }
+
+    interpreter interp;
+
+    // 1. load model
+    std::ifstream ifs(argv[1], std::ios::binary);
+    interp.load_model(ifs).expect("Invalid kmodel");
+
+    // 2. set inputs
+    for (size_t i = 2, j = 0; i < 2 + interp.inputs_size(); i++, j++)
+    {
+        auto desc = interp.input_desc(j);
+        auto shape = interp.input_shape(j);
+        auto tensor = hrt::create(desc.datatype, shape, hrt::pool_shared).expect("cannot create input tensor");
+        interp.input_tensor(j, tensor).expect("cannot set input tensor");
+
+        auto span = tensor.impl()->to_host().unwrap()->buffer().as_host().unwrap().map(map_access_::map_write).unwrap().buffer();
+        read_binary_file(argv[i], reinterpret_cast<char *>(span.data()));
+        hrt::sync(tensor, sync_op_t::sync_write_back, true).expect("sync write_back failed");
+    }
+
+    // 3. set outputs
+    // for (size_t i = 0; i < interp.outputs_size(); i++)
+    // {
+    //     auto desc = interp.output_desc(i);
+    //     auto shape = interp.output_shape(i);
+    //     auto tensor = hrt::create(desc.datatype, shape, hrt::pool_shared).expect("cannot create input tensor");
+    //     interp.output_tensor(i, tensor).expect("cannot set output tensor");
+    // }
+
+    // 4. run
+    interp.run().expect("error occurred in running model");
+    auto start = std::chrono::steady_clock::now();
+    interp.run().expect("error occurred in running model");
+    auto stop = std::chrono::steady_clock::now();
+    double duration = std::chrono::duration<double, std::milli>(stop - start).count();
+
+    // 5. get outputs
+    double cos = 0.f;
+    for (int i = 2 + interp.inputs_size(), j = 0; i < argc; i++, j++)
+    {
+        auto desc = interp.output_desc(j);
+        auto out = interp.output_tensor(j).expect("cannot get output tensor");
+        auto mapped_buf = std::move(hrt::map(out, map_access_t::map_read).unwrap());
+        auto vec = read_binary_file<unsigned char>(argv[i]);
+        switch (desc.datatype)
+        {
+        case dt_boolean:
+        case dt_uint8:
+        {
+            cos = cosine((const uint8_t *)mapped_buf.buffer().data(), (const uint8_t *)vec.data(), vec.size() / sizeof(uint8_t));
+            break;
+        }
+        case dt_int8:
+        {
+            cos = cosine((const int8_t *)mapped_buf.buffer().data(), (const int8_t *)vec.data(), vec.size() / sizeof(int8_t));
+            break;
+        }
+        case dt_float32:
+        {
+            cos = cosine((const float *)mapped_buf.buffer().data(), (const float *)vec.data(), vec.size() / sizeof(float));
+            break;
+        }
+        case dt_int32:
+        {
+            cos = cosine((const int32_t *)mapped_buf.buffer().data(), (const int32_t *)vec.data(), vec.size() / sizeof(int32_t));
+            break;
+        }
+        case dt_int64:
+        {
+            cos = cosine((const int64_t *)mapped_buf.buffer().data(), (const int64_t *)vec.data(), vec.size() / sizeof(int64_t));
+            break;
+        }
+        default:
+        {
+            std::cerr << "not supported data type: " << desc.datatype << std::endl;
+            std::abort();
+        }
+        }
+
+        std::cout << "output " << j << " cosine similarity: " << cos << std::endl;
+    }
+
+    std::cout << "interp run: " << duration << " ms, fps = " << 1000 / duration << std::endl;
+
+    return 0;
+}
\ No newline at end of file
diff --git a/toolchains/k230_cpu.linux.toolchain.cmake b/toolchains/k230_cpu.linux.toolchain.cmake
new file mode 100644
index 0000000000..4bd9aba679
--- /dev/null
+++ b/toolchains/k230_cpu.linux.toolchain.cmake
@@ -0,0 +1,33 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR riscv64)
+
+if(DEFINED ENV{RISCV_ROOT_PATH})
+    file(TO_CMAKE_PATH $ENV{RISCV_ROOT_PATH} RISCV_ROOT_PATH)
+endif()
+
+if(NOT RISCV_ROOT_PATH)
+    message(FATAL_ERROR "RISCV_ROOT_PATH env must be defined")
+endif()
+
+set(RISCV_ROOT_PATH ${RISCV_ROOT_PATH} CACHE STRING "root path to riscv toolchain")
+set(CMAKE_C_COMPILER "${RISCV_ROOT_PATH}/bin/riscv64-unknown-linux-musl-gcc")
+set(CMAKE_CXX_COMPILER "${RISCV_ROOT_PATH}/bin/riscv64-unknown-linux-musl-g++")
+set(CMAKE_FIND_ROOT_PATH "${RISCV_ROOT_PATH}/riscv64-unknown-linux-musl")
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(ENABLE_VULKAN_RUNTIME OFF)
+set(ENABLE_OPENMP OFF)
+set(ENABLE_HALIDE OFF)
+set(DEFAULT_BUILTIN_RUNTIMES OFF)
+set(DEFAULT_SHARED_RUNTIME_TENSOR_PLATFORM_IMPL ON)
+set(BUILD_BENCHMARK OFF)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=rv64imafdcv -mabi=lp64d -mcmodel=medany")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=rv64imafdcv -mabi=lp64d -mcmodel=medany")
+set(CMAKE_EXE_LINKER_FLAGS "-T ${K230_LINUX_SDK_DIR}/src/big/rt-smart/userapps/linker_scripts/riscv64/link.lds --static")
+
+set(BUILDING_RUNTIME ON)
+set(ENABLE_CPU_RUNTIME ON)
+set(BUILD_SHARED_LIBS OFF)
\ No newline at end of file

From 81b07a263c87e06b69fd1e22cb68ca508876dc80 Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Thu, 3 Aug 2023 03:16:13 +0000
Subject: [PATCH 062/308] Apply code-format changes

---
 modules/cpu/examples/cpu_test/main.cpp | 138 +++++++++++++------------
 1 file changed, 74 insertions(+), 64 deletions(-)

diff --git a/modules/cpu/examples/cpu_test/main.cpp b/modules/cpu/examples/cpu_test/main.cpp
index 95dd514129..3952270f0e 100644
--- a/modules/cpu/examples/cpu_test/main.cpp
+++ b/modules/cpu/examples/cpu_test/main.cpp
@@ -8,9 +8,7 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace nncase::runtime::detail;
 
-template <class T>
-std::vector<T> read_binary_file(const char *file_name)
-{
+template <class T> std::vector<T> read_binary_file(const char *file_name) {
     std::ifstream ifs(file_name, std::ios::binary);
     ifs.seekg(0, ifs.end);
     size_t len = ifs.tellg();
@@ -21,8 +19,7 @@ std::vector<T> read_binary_file(const char *file_name)
     return vec;
 }
 
-void read_binary_file(const char *file_name, char *buffer)
-{
+void read_binary_file(const char *file_name, char *buffer) {
     std::ifstream ifs(file_name, std::ios::binary);
     ifs.seekg(0, ifs.end);
     size_t len = ifs.tellg();
@@ -31,8 +28,8 @@ void read_binary_file(const char *file_name, char *buffer)
     ifs.close();
 }
 
-auto read_binary(const char *file_name, char *buffer, size_t begin, size_t count)
-{
+auto read_binary(const char *file_name, char *buffer, size_t begin,
+                 size_t count) {
     std::ifstream ifs(file_name, std::ios::binary);
     ifs.seekg(begin, ifs.beg);
     ifs.read(buffer + begin, count);
@@ -40,8 +37,7 @@ auto read_binary(const char *file_name, char *buffer, size_t begin, size_t count
     std::cout << "read bin seg ok" << std::endl;
 }
 
-size_t get_binary_file_size(const char *file_name)
-{
+size_t get_binary_file_size(const char *file_name) {
     std::ifstream ifs(file_name, std::ios::binary);
     ifs.seekg(0, ifs.end);
     size_t len = ifs.tellg();
@@ -49,12 +45,10 @@ size_t get_binary_file_size(const char *file_name)
     return len;
 }
 
-auto load_bin_to_kmodel(char *file_path, interpreter &interp)
-{
+auto load_bin_to_kmodel(char *file_path, interpreter &interp) {
     auto model_size = get_binary_file_size(file_path);
     auto model_data = std::make_unique<char[]>(model_size);
-    for (size_t i = 0; i < model_size;)
-    {
+    for (size_t i = 0; i < model_size;) {
         size_t count = 8000000;
         if (count + i >= model_size)
             count = model_size - i;
@@ -64,43 +58,43 @@ auto load_bin_to_kmodel(char *file_path, interpreter &interp)
     // show the identification of kmodel.
     // print_one_line_data("kmodel identification :", model_data.get(), 4);
 
-    interp.load_model({ (const gsl::byte *)model_data.get(), model_size }).expect("cannot load kmodel.");
+    interp.load_model({(const gsl::byte *)model_data.get(), model_size})
+        .expect("cannot load kmodel.");
     std::cout << "load kmodel success" << std::endl;
 
     return model_data;
 }
 
-template <typename T>
-double dot(const T *v1, const T *v2, size_t size)
-{
+template <typename T> double dot(const T *v1, const T *v2, size_t size) {
     double ret = 0.f;
-    for (size_t i = 0; i < size; i++)
-    {
+    for (size_t i = 0; i < size; i++) {
         ret += v1[i] * v2[i];
     }
 
     return ret;
 }
 
-template <typename T>
-double cosine(const T *v1, const T *v2, size_t size)
-{
-    for (size_t i = 0; i < 10; i++)
-    {
+template <typename T> double cosine(const T *v1, const T *v2, size_t size) {
+    for (size_t i = 0; i < 10; i++) {
         std::cout << v1[i] << " " << v2[i] << std::endl;
     }
-    return dot(v1, v2, size) / ((sqrt(dot(v1, v1, size)) * sqrt(dot(v2, v2, size))));
+    return dot(v1, v2, size) /
+           ((sqrt(dot(v1, v1, size)) * sqrt(dot(v2, v2, size))));
 }
 
-int main(int argc, char *argv[])
-{
-    std::cout << "case " << argv[0] << " build " << __DATE__ << " " << __TIME__ << std::endl;
+int main(int argc, char *argv[]) {
+    std::cout << "case " << argv[0] << " build " << __DATE__ << " " << __TIME__
+              << std::endl;
 
-    if (argc < 3)
-    {
+    if (argc < 3) {
         std::cerr << "Usage: " << std::endl;
-        std::cerr << argv[0] << " <kmodel> <input_0.bin> <input_1.bin> ... <input_N.bin> " << std::endl;
-        std::cerr << argv[0] << " <kmodel> <input_0.bin> <input_1.bin> ... <input_N.bin> <output_0.bin> <output_1.bin> ... <output_N.bin>" << std::endl;
+        std::cerr << argv[0]
+                  << " <kmodel> <input_0.bin> <input_1.bin> ... <input_N.bin> "
+                  << std::endl;
+        std::cerr << argv[0]
+                  << " <kmodel> <input_0.bin> <input_1.bin> ... <input_N.bin> "
+                     "<output_0.bin> <output_1.bin> ... <output_N.bin>"
+                  << std::endl;
         return -1;
     }
 
@@ -111,16 +105,25 @@ int main(int argc, char *argv[])
     interp.load_model(ifs).expect("Invalid kmodel");
 
     // 2. set inputs
-    for (size_t i = 2, j = 0; i < 2 + interp.inputs_size(); i++, j++)
-    {
+    for (size_t i = 2, j = 0; i < 2 + interp.inputs_size(); i++, j++) {
         auto desc = interp.input_desc(j);
         auto shape = interp.input_shape(j);
-        auto tensor = hrt::create(desc.datatype, shape, hrt::pool_shared).expect("cannot create input tensor");
+        auto tensor = hrt::create(desc.datatype, shape, hrt::pool_shared)
+                          .expect("cannot create input tensor");
         interp.input_tensor(j, tensor).expect("cannot set input tensor");
 
-        auto span = tensor.impl()->to_host().unwrap()->buffer().as_host().unwrap().map(map_access_::map_write).unwrap().buffer();
+        auto span = tensor.impl()
+                        ->to_host()
+                        .unwrap()
+                        ->buffer()
+                        .as_host()
+                        .unwrap()
+                        .map(map_access_::map_write)
+                        .unwrap()
+                        .buffer();
         read_binary_file(argv[i], reinterpret_cast<char *>(span.data()));
-        hrt::sync(tensor, sync_op_t::sync_write_back, true).expect("sync write_back failed");
+        hrt::sync(tensor, sync_op_t::sync_write_back, true)
+            .expect("sync write_back failed");
     }
 
     // 3. set outputs
@@ -128,7 +131,8 @@ int main(int argc, char *argv[])
     // {
     //     auto desc = interp.output_desc(i);
     //     auto shape = interp.output_shape(i);
-    //     auto tensor = hrt::create(desc.datatype, shape, hrt::pool_shared).expect("cannot create input tensor");
+    //     auto tensor = hrt::create(desc.datatype, shape,
+    //     hrt::pool_shared).expect("cannot create input tensor");
     //     interp.output_tensor(i, tensor).expect("cannot set output tensor");
     // }
 
@@ -137,55 +141,61 @@ int main(int argc, char *argv[])
     auto start = std::chrono::steady_clock::now();
     interp.run().expect("error occurred in running model");
     auto stop = std::chrono::steady_clock::now();
-    double duration = std::chrono::duration<double, std::milli>(stop - start).count();
+    double duration =
+        std::chrono::duration<double, std::milli>(stop - start).count();
 
     // 5. get outputs
     double cos = 0.f;
-    for (int i = 2 + interp.inputs_size(), j = 0; i < argc; i++, j++)
-    {
+    for (int i = 2 + interp.inputs_size(), j = 0; i < argc; i++, j++) {
         auto desc = interp.output_desc(j);
         auto out = interp.output_tensor(j).expect("cannot get output tensor");
-        auto mapped_buf = std::move(hrt::map(out, map_access_t::map_read).unwrap());
+        auto mapped_buf =
+            std::move(hrt::map(out, map_access_t::map_read).unwrap());
         auto vec = read_binary_file<unsigned char>(argv[i]);
-        switch (desc.datatype)
-        {
+        switch (desc.datatype) {
         case dt_boolean:
-        case dt_uint8:
-        {
-            cos = cosine((const uint8_t *)mapped_buf.buffer().data(), (const uint8_t *)vec.data(), vec.size() / sizeof(uint8_t));
+        case dt_uint8: {
+            cos = cosine((const uint8_t *)mapped_buf.buffer().data(),
+                         (const uint8_t *)vec.data(),
+                         vec.size() / sizeof(uint8_t));
             break;
         }
-        case dt_int8:
-        {
-            cos = cosine((const int8_t *)mapped_buf.buffer().data(), (const int8_t *)vec.data(), vec.size() / sizeof(int8_t));
+        case dt_int8: {
+            cos =
+                cosine((const int8_t *)mapped_buf.buffer().data(),
+                       (const int8_t *)vec.data(), vec.size() / sizeof(int8_t));
             break;
         }
-        case dt_float32:
-        {
-            cos = cosine((const float *)mapped_buf.buffer().data(), (const float *)vec.data(), vec.size() / sizeof(float));
+        case dt_float32: {
+            cos = cosine((const float *)mapped_buf.buffer().data(),
+                         (const float *)vec.data(), vec.size() / sizeof(float));
             break;
         }
-        case dt_int32:
-        {
-            cos = cosine((const int32_t *)mapped_buf.buffer().data(), (const int32_t *)vec.data(), vec.size() / sizeof(int32_t));
+        case dt_int32: {
+            cos = cosine((const int32_t *)mapped_buf.buffer().data(),
+                         (const int32_t *)vec.data(),
+                         vec.size() / sizeof(int32_t));
             break;
         }
-        case dt_int64:
-        {
-            cos = cosine((const int64_t *)mapped_buf.buffer().data(), (const int64_t *)vec.data(), vec.size() / sizeof(int64_t));
+        case dt_int64: {
+            cos = cosine((const int64_t *)mapped_buf.buffer().data(),
+                         (const int64_t *)vec.data(),
+                         vec.size() / sizeof(int64_t));
             break;
         }
-        default:
-        {
-            std::cerr << "not supported data type: " << desc.datatype << std::endl;
+        default: {
+            std::cerr << "not supported data type: " << desc.datatype
+                      << std::endl;
             std::abort();
         }
         }
 
-        std::cout << "output " << j << " cosine similarity: " << cos << std::endl;
+        std::cout << "output " << j << " cosine similarity: " << cos
+                  << std::endl;
     }
 
-    std::cout << "interp run: " << duration << " ms, fps = " << 1000 / duration << std::endl;
+    std::cout << "interp run: " << duration << " ms, fps = " << 1000 / duration
+              << std::endl;
 
     return 0;
 }
\ No newline at end of file

From 6f1c48bab3a86b51cd1b1b9ab9124eeb4cbb6e18 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 2 Aug 2023 16:24:18 +0800
Subject: [PATCH 063/308] add test

---
 .../BufferScheduleExtensions.cs               |  17 ++
 .../BufferSchedule/BufferScheduleTypes.cs     |  19 ++-
 .../BufferSchedule/BufferScheduler.cs         | 145 +++++++++++++++---
 .../BufferSchedule/LifeTimeCollector.cs       |  65 +++++---
 src/Nncase.Passes/DDrBufferSchdeulePass.cs    |  15 +-
 src/Nncase.Tests/EGraph/UnitTestVrp.cs        |  29 ++++
 6 files changed, 234 insertions(+), 56 deletions(-)
 create mode 100644 src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs

diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs
new file mode 100644
index 0000000000..91cf5e8dd4
--- /dev/null
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs
@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using System.Linq;
+using Nncase.IR;
+
+namespace Nncase.Passes.BufferSchedule;
+
+public static class BufferScheduleExtensions
+{
+
+    public static IEnumerable<Expr> GetUsers(this Call call)
+    {
+        var hs = new HashSet<Expr>(ReferenceEqualityComparer.Instance);
+        hs.UnionWith(call.Users.Where(e => e is not BaseFunction).ToArray().Select(e => e switch { IR.Tuple tp => tp.Fields.ToArray(), _ => new[] { e } }).SelectMany(i => i));
+        return hs;
+    }
+
+}
\ No newline at end of file
diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
index d68c5ca5e8..449102871f 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
@@ -7,17 +7,19 @@ internal sealed class TimeInterval
 {
     public TimeInterval(int start, int end)
     {
-        Start = start;
-        End = end;
+        Brith = start;
+        Death = end;
     }
 
-    public int Start { get; set; }
+    public int Brith { get; set; }
 
-    public int End { get; set; }
+    public int Death { get; set; }
+
+    public int Size => Death - Brith;
 
     public override string ToString()
     {
-        return $"TimeInterval({Start}, {End})";
+        return $"TimeInterval({Brith}, {Death})";
     }
 }
 
@@ -41,13 +43,14 @@ public override string ToString()
 
 internal class ScheduleBuffer
 {
-    public ScheduleBuffer(string name, TimeInterval interval, MemSpan span, int[] shape, int[] strides)
+    public ScheduleBuffer(string name, TimeInterval interval, MemSpan span, int[] shape, int[] strides, bool inplace)
     {
         Name = name;
         Interval = interval;
         Span = span;
         Shape = shape;
         Strides = strides;
+        Inplace = inplace;
     }
 
     public string Name { get; }
@@ -60,8 +63,10 @@ public ScheduleBuffer(string name, TimeInterval interval, MemSpan span, int[] sh
 
     public int[] Strides { get; }
 
+    public bool Inplace { get; }
+
     public override string ToString()
     {
-        return $"ScheduledBuffer('{Name}', {Interval}, {Span}, ConstraintsMode.No, [{string.Join(",", Shape)}], [{string.Join(",", Strides)}])";
+        return $"ScheduledBuffer('{Name}', {Interval}, {Span}, ConstraintsMode.No, [{string.Join(",", Shape)}], [{string.Join(",", Strides)}], {Inplace})";
     }
 }
diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
index 496d45af2c..66ebe81736 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
@@ -1,10 +1,13 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reactive;
+using Google.OrTools.Sat;
+using NetFabric.Hyperlinq;
 using Nncase;
 using Nncase.IR;
 
@@ -12,36 +15,119 @@ namespace Nncase.Passes.BufferSchedule;
 
 internal sealed class BufferScheduler
 {
-    public List<ScheduleBuffer> CollectLifeTime(Function func)
+    public IReadOnlyDictionary<Expr, ScheduleBuffer> CollectLifeTime(Function func)
     {
         var c = new LifeTimeCollector();
         return c.Collect(func);
     }
 
-    public void DumpScheduled(string path, List<ScheduleBuffer> buffers)
+    public void Schedule(IReadOnlyDictionary<Expr, ScheduleBuffer> bufferMap)
     {
-        using (var fs = File.OpenWrite(path))
+        var model = new CpModel();
+        var noOverlap = model.AddNoOverlap2D();
+        var boxs = new Dictionary<Expr, (IntervalVar X, IntervalVar Y)>(ReferenceEqualityComparer.Instance);
+        var timeMap = new Dictionary<int, List<Expr>>();
+        var yStarts = new List<IntVar>();
+        foreach (var (expr, item) in bufferMap)
         {
-            using (var wr = new StreamWriter(fs))
+            var xInterval = model.NewIntervalVar(model.NewConstant(item.Interval.Brith), model.NewConstant(item.Interval.Size), model.NewConstant(item.Interval.Death), item.Name + "_x");
+
+            var upbound = 2147483648 - item.Span.End;
+            if (upbound <= 0)
+            {
+                throw new System.NotSupportedException();
+            }
+
+            var memStartVar = model.NewIntVar(0, upbound, $"{item.Name}_y_start");
+            var yInterval = model.NewFixedSizeIntervalVar(memStartVar, item.Span.End, $"{item.Name}_y");
+
+            if (!item.Inplace)
+            {
+                noOverlap.AddRectangle(xInterval, yInterval);
+            }
+
+            yStarts.Add(memStartVar);
+            boxs.Add(expr, (xInterval, yInterval));
+
+            for (int time = item.Interval.Brith; time < item.Interval.Death; time++)
+            {
+                if (!timeMap.TryGetValue(time, out var timelist))
+                {
+                    timelist = new();
+                    timeMap.Add(time, timelist);
+                }
+
+                timelist.Add(expr);
+            }
+        }
+
+        foreach (var (expr, item) in bufferMap)
+        {
+            if (expr is Call { Target: IR.Tensors.Concat } concatCall && concatCall.Arguments[0] is IR.Tuple tuple)
+            {
+                // the concat inputs must contiguous
+                model.AddMinEquality(boxs[concatCall].Y.StartExpr(), tuple.Fields.ToArray().Select(arg => boxs[arg].Y.StartExpr()));
+                model.AddMaxEquality(boxs[concatCall].Y.EndExpr(), tuple.Fields.ToArray().Select(arg => boxs[arg].Y.EndExpr()));
+            }
+            else if (expr is Call { Target: IR.Tensors.Split } splitCall)
+            {
+                // the split must equal with input.
+                model.Add(boxs[splitCall].Y.StartExpr() == boxs[splitCall.Arguments[0]].Y.StartExpr());
+
+                // the split outputs must contiguous
+                var users = splitCall.GetUsers();
+                model.AddMinEquality(boxs[splitCall].Y.StartExpr(), users.Select(e => boxs[e].Y.StartExpr()));
+                model.AddMaxEquality(boxs[splitCall].Y.EndExpr(), users.Select(e => boxs[e].Y.EndExpr()));
+            }
+            else if (expr is Call { Target: IR.Tensors.Reshape } reshapCall)
             {
-                wr.Write(@"from bokeh.models import ColumnDataSource, HoverTool, FuncTickFormatter, SingleIntervalTicker, SaveTool, WheelZoomTool, WheelPanTool, ResetTool
+                // the reshape must equal with it's input.
+                model.Add(boxs[reshapCall].Y.StartExpr() == boxs[reshapCall.Arguments[0]].Y.StartExpr());
+            }
+        }
+
+        model.Minimize(LinearExpr.Sum(yStarts));
+
+        var solver = new CpSolver();
+        solver.StringParameters = $"max_time_in_seconds:{60},num_workers:{8}";
+        CpSolverStatus solve_status = solver.Solve(model);
+        if (solve_status != CpSolverStatus.Optimal && solve_status != CpSolverStatus.Feasible)
+        {
+            throw new System.NotSupportedException();
+        }
+
+        foreach (var (k, v) in bufferMap)
+        {
+            bufferMap[k].Span.Start = checked((int)solver.Value(boxs[k].Y.StartExpr()));
+            bufferMap[k].Span.End = checked((int)solver.Value(boxs[k].Y.EndExpr()));
+        }
+    }
+
+    public void Dump(Stream fs, IReadOnlyDictionary<Expr, ScheduleBuffer> buffers)
+    {
+        using (var wr = new StreamWriter(fs))
+        {
+            wr.Write(@"from bokeh.models import ColumnDataSource, HoverTool, FuncTickFormatter, SingleIntervalTicker, SaveTool, WheelZoomTool, WheelPanTool, ResetTool
 from bokeh.palettes import Category20_20 as palette
 from bokeh.plotting import figure, show, save
 import itertools
 from dataclasses import dataclass
 from enum import Enum
 from typing import List
+
 @dataclass
-class Interval():
+class TimeInterval():
   start: int
   end: int
+  def __str__(self) -> str:
+    return f'(start: {self.start}, end {self.end})'
 
 @dataclass
-class Location():
+class MemSpan():
   depth_start: int
-  depth_size: int
+  depth_end: int
   def __str__(self) -> str:
-    return f'(start: {self.depth_start}, size {self.depth_size})'
+    return f'(start: {self.depth_start}, size {self.depth_end - self.depth_start})'
 
 class ConstraintsMode(Enum):
   No = 0
@@ -50,22 +136,23 @@ class ConstraintsMode(Enum):
 @dataclass
 class ScheduledBuffer():
   name: str
-  interval: Interval
-  location: Location
+  interval: TimeInterval
+  location: MemSpan
   constraints: ConstraintsMode
   shape: List[int]
   stride: List[int]
+  inplace: bool
 
 colors = itertools.cycle(palette)
 
 buffers = [
 ");
-                foreach (var item in buffers)
-                {
-                    wr.WriteLine(item.ToString());
-                }
+            foreach (var (k, v) in buffers)
+            {
+                wr.WriteLine(v.ToString() + ",");
+            }
 
-                wr.Write(@"]
+            wr.Write(@"]
 
 source = {
     'name': [],
@@ -73,42 +160,52 @@ class ScheduledBuffer():
     'y': [],
     'width': [],
     'height': [],
+    'alpha': [],
     'color': [],
     'location': [],
+    'interval': [],
     'shape': [],
     'stride': [],
 }
 
 y_range_max = 0
+x_range_max = 0
+color_dict = {}
 for buffer in buffers:
   source['name'].append(buffer.name)
   width = buffer.interval.end - buffer.interval.start
-  x = buffer.interval.start + (width // 2)
-  height = buffer.location.depth_size
-  y = buffer.location.depth_start + (height // 2)
+  x = buffer.interval.start + (width / 2)
+  height = buffer.location.depth_end - buffer.location.depth_start
+  y = buffer.location.depth_start + (height / 2)
   y_range_max = max(y_range_max, y)
+  x_range_max = max(x_range_max, buffer.interval.end)
   source['x'].append(x)
   source['y'].append(y)
   source['width'].append(width)
   source['height'].append(height)
-  source['color'].append(next(colors))
+  color = color_dict.get(buffer.name)
+  if color == None:
+    color = next(colors)
+    color_dict[buffer.name] = color
+  source['color'].append(color)
+  source['alpha'].append(0.2 if buffer.inplace else 1.0)
+  source['interval'].append(str(buffer.interval))
   source['location'].append(str(buffer.location))
   source['shape'].append(','.join([str(s) for s in buffer.shape]))
   source['stride'].append(','.join([str(s) for s in buffer.stride]))
 
 source = ColumnDataSource(source)
-hover = HoverTool(tooltips=[('name', '@name'), ('location', '@location'),
+hover = HoverTool(tooltips=[('name', '@name'), ('interval', '@interval'), ('location', '@location'),
                             ('shape', '@shape'), ('stride', '@stride')])
 
 p = figure(tools=[hover, WheelPanTool(), SaveTool(), WheelZoomTool(), ResetTool()], width=1280, height=720,
-           y_range=(0, y_range_max * 2),
+           y_range=(0, y_range_max * 1.2), x_range=(-1, x_range_max + 1),
            title='Local Buffer LifeTime (by Steps)')
-p.rect(x='x', y='y', width='width', height='height', fill_color='color', source=source)
+p.rect(x='x', y='y', width='width', height='height', fill_color='color', legend_field='name', fill_alpha='alpha', source=source)
 p.xaxis.axis_label = 'Time (steps)'
 p.outline_line_color = None
 
 show(p)");
-            }
         }
     }
 }
diff --git a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
index 454fd25608..760083f1da 100644
--- a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
+++ b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reactive;
@@ -15,12 +16,11 @@ internal sealed class LifeTimeCollector : ExprVisitor<Unit, Unit>
 
     public Dictionary<Expr, TimeInterval> LifenessMap { get; } = new(ReferenceEqualityComparer.Instance);
 
-    public List<ScheduleBuffer> Collect(Function entry)
+    public IReadOnlyDictionary<Expr, ScheduleBuffer> Collect(Function entry)
     {
         Visit(entry.Body);
-        Alias();
 
-        var l = new List<ScheduleBuffer>();
+        var d = new Dictionary<Expr, ScheduleBuffer>(ReferenceEqualityComparer.Instance);
         foreach (var (k, v) in LifenessMap)
         {
             var name = k switch
@@ -29,15 +29,12 @@ public List<ScheduleBuffer> Collect(Function entry)
                 Var va => va.Name,
                 _ => k.GetType().Name,
             };
+            var size = GetSize(k.CheckedType, out var shape, out var stride);
 
-            var shape = k.CheckedShape.ToValueArray();
-            var stride = TensorUtilities.GetStrides(shape);
-            var size = TensorUtilities.GetSize(shape, stride, k.CheckedDataType.SizeInBytes);
-
-            l.Add(new(name, v, new(0, size), shape, stride));
+            d.Add(k, new(name, v, new(0, size), shape, stride, IsInPlace(k)));
         }
 
-        return l;
+        return d;
     }
 
     protected override Unit DefaultVisitLeaf(Expr expr) => Unit.Default;
@@ -58,7 +55,7 @@ protected override Unit VisitLeafCall(Call expr)
 
     private void Update(Expr expr)
     {
-        if (expr is Const)
+        if (expr is (Const or None))
         {
             return;
         }
@@ -79,25 +76,53 @@ private void Update(Expr expr)
         }
         else
         {
-            interval.End += 1;
+            interval.Death = TimeStamp + 1;
         }
 
-        // advance the getitem buffer.
-        if (expr is Call { Target: IR.Tensors.GetItem, Arguments: var args } call && args[0] is Call { CheckedType: TupleType })
+        LifenessMap[expr] = interval;
+    }
+
+    private bool IsInPlace(Expr expr)
+    {
+        if (expr is Call { Target: IR.Tensors.Reshape } callReshape)
         {
-            interval.Start = LifenessMap[args[0]].Start;
+            return true;
         }
 
-        LifenessMap[expr] = interval;
+        if (expr is Call { Target: IR.Tensors.Concat } concatCall && concatCall.Arguments[0] is IR.Tuple concatTuple)
+        {
+            return true;
+        }
+
+        if (expr is Call { Target: IR.Tensors.Split } splitCall)
+        {
+            return true;
+        }
+
+        return false;
     }
 
-    private void Alias()
+    private int GetSize(IRType type, out int[] shape, out int[] stride)
     {
-        // skip the call which output type is tuple.
-        var calls = LifenessMap.Select(kv => kv.Key is Call { CheckedType: TupleType }).ToArray();
-        foreach (var c in calls)
+        shape = Array.Empty<int>();
+        stride = Array.Empty<int>();
+        var size = 0;
+        if (type is TensorType tensorType)
         {
-            LifenessMap.Remove(c);
+            shape = tensorType.Shape.ToValueArray();
+            stride = TensorUtilities.GetStrides(shape);
+            size = TensorUtilities.GetSize(shape, stride, tensorType.DType.SizeInBytes);
         }
+        else if (type is TupleType tupleType)
+        {
+            size = 0;
+            foreach (var item in tupleType)
+            {
+                size += GetSize(item, out _, out _);
+            }
+        }
+
+        return size;
     }
+
 }
diff --git a/src/Nncase.Passes/DDrBufferSchdeulePass.cs b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
index cdd9fe3be1..015b9d3dd3 100644
--- a/src/Nncase.Passes/DDrBufferSchdeulePass.cs
+++ b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
@@ -43,11 +43,16 @@ protected override async Task<IRModule> RunCoreAsync(IRModule module, RunPassCon
         // 1. merge the all call prim func
         if (_enbaleMergeCall)
         {
-            // if (module.Entry is Function { ModuleKind: Callable.StackVMModuleKind, Body: Expr body } func && IsFixedType(body.CheckedType))
-            // {
-            //     var sorter = new TopSorter();
-            //     sorter.GetTimeLine(func);
-            // }
+            if (module.Entry is Function { ModuleKind: Callable.StackVMModuleKind, Body: Expr body } func && IsFixedType(body.CheckedType))
+            {
+                var sch = new BufferSchedule.BufferScheduler();
+                var buffers = sch.CollectLifeTime(func);
+                sch.Schedule(buffers);
+                using (var fs = Diagnostics.DumpScope.Current.OpenFile("draw_buffers.py"))
+                {
+                    sch.Dump(fs, buffers);
+                }
+            }
         }
 
         // 4. schedule the prim funcs.
diff --git a/src/Nncase.Tests/EGraph/UnitTestVrp.cs b/src/Nncase.Tests/EGraph/UnitTestVrp.cs
index 5a9f4b564e..f421022a7c 100644
--- a/src/Nncase.Tests/EGraph/UnitTestVrp.cs
+++ b/src/Nncase.Tests/EGraph/UnitTestVrp.cs
@@ -174,6 +174,35 @@ public void TestSimpleEgraphSat()
         }
     }
 
+    [Fact]
+    public void TestOverLap()
+    {
+        // note ortools no overlap not support 0 size.
+        var model = new CpModel();
+
+        var x0 = model.NewIntervalVar(model.NewConstant(0), model.NewConstant(2), model.NewConstant(2), "x0");
+        var y0 = model.NewFixedSizeIntervalVar(model.NewIntVar(0, 10, "y0_start"), 7, "y0");
+
+        var x1 = model.NewIntervalVar(model.NewConstant(2), model.NewConstant(0), model.NewConstant(2), "x1");
+        var y1 = model.NewFixedSizeIntervalVar(model.NewIntVar(0, 10, "y1_start"), 7, "y1");
+
+        var x2 = model.NewIntervalVar(model.NewConstant(2), model.NewConstant(1), model.NewConstant(3), "x2");
+        var y2 = model.NewFixedSizeIntervalVar(model.NewIntVar(0, 10, "y2_start"), 7, "y2");
+
+        model.Add(y0.StartExpr() == y1.StartExpr());
+        model.Add(y1.StartExpr() == y2.StartExpr());
+        var nooverlap = model.AddNoOverlap2D();
+        nooverlap.AddRectangle(x0, y0);
+        nooverlap.AddRectangle(x1, y1);
+        nooverlap.AddRectangle(x2, y2);
+        model.Minimize(y0.StartExpr() + y1.StartExpr() + y2.StartExpr());
+
+        var solver = new CpSolver();
+        var status = solver.Solve(model);
+
+        Assert.Equal(CpSolverStatus.Infeasible, status);
+    }
+
     private static void PrintSolution(in IDataModel data, in RoutingModel routing, in RoutingIndexManager manager, in Assignment solution)
     {
         Console.WriteLine($"Objective {solution.ObjectiveValue()}:");

From 858e2af2fb4ba481928f3ec163fc38f692ccbb38 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 2 Aug 2023 18:16:58 +0800
Subject: [PATCH 064/308] fix bug

---
 .../BufferScheduleExtensions.cs               |  7 +++
 .../BufferSchedule/BufferScheduleTypes.cs     |  7 ++-
 .../BufferSchedule/BufferScheduler.cs         | 14 ++---
 .../BufferSchedule/LifeTimeCollector.cs       | 62 +++++++++++++++----
 4 files changed, 67 insertions(+), 23 deletions(-)

diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs
index 91cf5e8dd4..f10e080fc0 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs
@@ -7,6 +7,13 @@ namespace Nncase.Passes.BufferSchedule;
 public static class BufferScheduleExtensions
 {
 
+    public static IEnumerable<Expr> GetArguments(this Call call)
+    {
+        var hs = new HashSet<Expr>(ReferenceEqualityComparer.Instance);
+        hs.UnionWith(call.Arguments.ToArray().Where(e => e is not (BaseFunction or Const)).ToArray().Select(e => e switch { IR.Tuple tp => tp.Fields.ToArray(), _ => new[] { e } }).SelectMany(i => i));
+        return hs;
+    }
+
     public static IEnumerable<Expr> GetUsers(this Call call)
     {
         var hs = new HashSet<Expr>(ReferenceEqualityComparer.Instance);
diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
index 449102871f..a7920aca48 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
@@ -43,9 +43,10 @@ public override string ToString()
 
 internal class ScheduleBuffer
 {
-    public ScheduleBuffer(string name, TimeInterval interval, MemSpan span, int[] shape, int[] strides, bool inplace)
+    public ScheduleBuffer(string name, int number, TimeInterval interval, MemSpan span, int[] shape, int[] strides, bool inplace)
     {
         Name = name;
+        Number = number;
         Interval = interval;
         Span = span;
         Shape = shape;
@@ -54,7 +55,7 @@ public ScheduleBuffer(string name, TimeInterval interval, MemSpan span, int[] sh
     }
 
     public string Name { get; }
-
+    public int Number { get; }
     public TimeInterval Interval { get; }
 
     public MemSpan Span { get; }
@@ -67,6 +68,6 @@ public ScheduleBuffer(string name, TimeInterval interval, MemSpan span, int[] sh
 
     public override string ToString()
     {
-        return $"ScheduledBuffer('{Name}', {Interval}, {Span}, ConstraintsMode.No, [{string.Join(",", Shape)}], [{string.Join(",", Strides)}], {Inplace})";
+        return $"ScheduledBuffer('{Name}', {Number}, {Interval}, {Span}, ConstraintsMode.No, [{string.Join(",", Shape)}], [{string.Join(",", Strides)}], {Inplace})";
     }
 }
diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
index 66ebe81736..88225cb76e 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
@@ -30,7 +30,7 @@ public void Schedule(IReadOnlyDictionary<Expr, ScheduleBuffer> bufferMap)
         var yStarts = new List<IntVar>();
         foreach (var (expr, item) in bufferMap)
         {
-            var xInterval = model.NewIntervalVar(model.NewConstant(item.Interval.Brith), model.NewConstant(item.Interval.Size), model.NewConstant(item.Interval.Death), item.Name + "_x");
+            var xInterval = model.NewIntervalVar(model.NewConstant(item.Interval.Brith), model.NewConstant(item.Interval.Size), model.NewConstant(item.Interval.Death), item.Name + $"{item.Number}_x");
 
             var upbound = 2147483648 - item.Span.End;
             if (upbound <= 0)
@@ -38,14 +38,9 @@ public void Schedule(IReadOnlyDictionary<Expr, ScheduleBuffer> bufferMap)
                 throw new System.NotSupportedException();
             }
 
-            var memStartVar = model.NewIntVar(0, upbound, $"{item.Name}_y_start");
-            var yInterval = model.NewFixedSizeIntervalVar(memStartVar, item.Span.End, $"{item.Name}_y");
-
-            if (!item.Inplace)
-            {
-                noOverlap.AddRectangle(xInterval, yInterval);
-            }
-
+            var memStartVar = model.NewIntVar(0, upbound, $"{item.Name}_{item.Number}_y_start");
+            var yInterval = model.NewFixedSizeIntervalVar(memStartVar, item.Span.End, $"{item.Name}_{item.Number}_y");
+            noOverlap.AddRectangle(xInterval, yInterval);
             yStarts.Add(memStartVar);
             boxs.Add(expr, (xInterval, yInterval));
 
@@ -136,6 +131,7 @@ class ConstraintsMode(Enum):
 @dataclass
 class ScheduledBuffer():
   name: str
+  number: int
   interval: TimeInterval
   location: MemSpan
   constraints: ConstraintsMode
diff --git a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
index 760083f1da..7a7f04561b 100644
--- a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
+++ b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
@@ -19,8 +19,10 @@ internal sealed class LifeTimeCollector : ExprVisitor<Unit, Unit>
     public IReadOnlyDictionary<Expr, ScheduleBuffer> Collect(Function entry)
     {
         Visit(entry.Body);
+        Alias();
 
         var d = new Dictionary<Expr, ScheduleBuffer>(ReferenceEqualityComparer.Instance);
+        int count = 0;
         foreach (var (k, v) in LifenessMap)
         {
             var name = k switch
@@ -31,7 +33,7 @@ public IReadOnlyDictionary<Expr, ScheduleBuffer> Collect(Function entry)
             };
             var size = GetSize(k.CheckedType, out var shape, out var stride);
 
-            d.Add(k, new(name, v, new(0, size), shape, stride, IsInPlace(k)));
+            d.Add(k, new(name, count++, v, new(0, size), shape, stride, false));
         }
 
         return d;
@@ -48,7 +50,12 @@ protected override Unit VisitLeafCall(Call expr)
 
         Update(expr);
 
-        TimeStamp += 1;
+        TimeStamp += 2;
+
+        foreach (var item in expr.GetUsers())
+        {
+            Update(item);
+        }
 
         return Unit.Default;
     }
@@ -82,24 +89,57 @@ private void Update(Expr expr)
         LifenessMap[expr] = interval;
     }
 
-    private bool IsInPlace(Expr expr)
+    private void Alias()
     {
-        if (expr is Call { Target: IR.Tensors.Reshape } callReshape)
+        bool changed = true;
+        do
         {
-            return true;
-        }
+            changed = false;
+            foreach (var (expr, interval) in LifenessMap)
+            {
+                if (expr is Call { Target: IR.Tensors.Reshape } callReshape)
+                {
+                    changed = AliasTime(callReshape, interval);
+                }
+            }
+
+            foreach (var (expr, interval) in LifenessMap)
+            {
+
+                if (expr is Call { Target: IR.Tensors.Concat } concatCall)
+                {
+                    changed = AliasTime(concatCall, interval);
+                }
+            }
+
+            foreach (var (expr, interval) in LifenessMap)
+            {
+                if (expr is Call { Target: IR.Tensors.Split } splitCall)
+                {
+                    changed = AliasTime(splitCall, interval);
+                }
+            }
+        } while (!changed);
+    }
+
+    private bool AliasTime(Call call, TimeInterval interval)
+    {
+        var brith = call.GetArguments().Select(arg => LifenessMap[arg].Death).Concat(new[] { interval.Brith }).Max();
+        var death = call.GetUsers().Select(usr => LifenessMap[usr].Brith).Concat(new[] { interval.Death }).Min();
 
-        if (expr is Call { Target: IR.Tensors.Concat } concatCall && concatCall.Arguments[0] is IR.Tuple concatTuple)
+        if (brith == interval.Brith && death == interval.Death)
         {
-            return true;
+            return false;
         }
 
-        if (expr is Call { Target: IR.Tensors.Split } splitCall)
+        if (brith >= death)
         {
-            return true;
+            throw new InvalidOperationException();
         }
 
-        return false;
+        interval.Brith = brith;
+        interval.Death = death;
+        return true;
     }
 
     private int GetSize(IRType type, out int[] shape, out int[] stride)

From 6553c0cae2fa75539a3a94715c6c5041010f3bb6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 2 Aug 2023 19:56:36 +0800
Subject: [PATCH 065/308] fix bug

---
 src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs | 3 +--
 src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs        | 5 +++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs
index f10e080fc0..706fbac412 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs
@@ -17,8 +17,7 @@ public static IEnumerable<Expr> GetArguments(this Call call)
     public static IEnumerable<Expr> GetUsers(this Call call)
     {
         var hs = new HashSet<Expr>(ReferenceEqualityComparer.Instance);
-        hs.UnionWith(call.Users.Where(e => e is not BaseFunction).ToArray().Select(e => e switch { IR.Tuple tp => tp.Fields.ToArray(), _ => new[] { e } }).SelectMany(i => i));
+        hs.UnionWith(call.Users.Where(e => e is not BaseFunction).ToArray().Select(e => e switch { IR.Tuple tp => tp.Users.ToArray(), _ => new[] { e } }).SelectMany(i => i));
         return hs;
     }
-
 }
\ No newline at end of file
diff --git a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
index 7a7f04561b..bfa43f9707 100644
--- a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
+++ b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
@@ -19,6 +19,7 @@ internal sealed class LifeTimeCollector : ExprVisitor<Unit, Unit>
     public IReadOnlyDictionary<Expr, ScheduleBuffer> Collect(Function entry)
     {
         Visit(entry.Body);
+        Update(entry.Body); // avoid final call time interval size == 1.
         Alias();
 
         var d = new Dictionary<Expr, ScheduleBuffer>(ReferenceEqualityComparer.Instance);
@@ -52,7 +53,8 @@ protected override Unit VisitLeafCall(Call expr)
 
         TimeStamp += 2;
 
-        foreach (var item in expr.GetUsers())
+        // note we will update tuple field on the next call.
+        foreach (var item in expr.Users.Where(e => e is not (BaseFunction or IR.Tuple)))
         {
             Update(item);
         }
@@ -105,7 +107,6 @@ private void Alias()
 
             foreach (var (expr, interval) in LifenessMap)
             {
-
                 if (expr is Call { Target: IR.Tensors.Concat } concatCall)
                 {
                     changed = AliasTime(concatCall, interval);

From 191bd67b171e9e6783854403d20f47484896b4ac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 3 Aug 2023 10:56:01 +0800
Subject: [PATCH 066/308] fix concat/split order

---
 .../BufferSchedule/BufferScheduleTypes.cs        |  2 ++
 .../BufferSchedule/BufferScheduler.cs            | 16 ++++++++++++----
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
index a7920aca48..f3b548cf1b 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
@@ -35,6 +35,8 @@ public MemSpan(int start, int end)
 
     public int End { get; set; }
 
+    public int Size => End - Start;
+
     public override string ToString()
     {
         return $"MemSpan({Start}, {End})";
diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
index 88225cb76e..cdad8d521d 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
@@ -61,8 +61,12 @@ public void Schedule(IReadOnlyDictionary<Expr, ScheduleBuffer> bufferMap)
             if (expr is Call { Target: IR.Tensors.Concat } concatCall && concatCall.Arguments[0] is IR.Tuple tuple)
             {
                 // the concat inputs must contiguous
-                model.AddMinEquality(boxs[concatCall].Y.StartExpr(), tuple.Fields.ToArray().Select(arg => boxs[arg].Y.StartExpr()));
-                model.AddMaxEquality(boxs[concatCall].Y.EndExpr(), tuple.Fields.ToArray().Select(arg => boxs[arg].Y.EndExpr()));
+                int offset = 0;
+                for (int i = 0; i < tuple.Fields.Length; i++)
+                {
+                    model.Add((boxs[concatCall].Y.StartExpr() + offset) == boxs[tuple.Fields[i]].Y.StartExpr());
+                    offset += bufferMap[tuple.Fields[i]].Span.Size;
+                }
             }
             else if (expr is Call { Target: IR.Tensors.Split } splitCall)
             {
@@ -71,8 +75,12 @@ public void Schedule(IReadOnlyDictionary<Expr, ScheduleBuffer> bufferMap)
 
                 // the split outputs must contiguous
                 var users = splitCall.GetUsers();
-                model.AddMinEquality(boxs[splitCall].Y.StartExpr(), users.Select(e => boxs[e].Y.StartExpr()));
-                model.AddMaxEquality(boxs[splitCall].Y.EndExpr(), users.Select(e => boxs[e].Y.EndExpr()));
+                int offset = 0;
+                foreach (var user in users.OrderBy(e => ((Call)e).Arguments[1].Evaluate().AsTensor().ToScalar<int>()))
+                {
+                    model.Add((boxs[splitCall].Y.StartExpr() + offset) == boxs[user].Y.StartExpr());
+                    offset += bufferMap[user].Span.Size;
+                }
             }
             else if (expr is Call { Target: IR.Tensors.Reshape } reshapCall)
             {

From 98d57a3a6e04b7412a80a218451389f7826e042b Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Thu, 3 Aug 2023 03:29:27 +0000
Subject: [PATCH 067/308] Apply code-format changes

---
 .../BufferSchedule/BufferScheduleExtensions.cs              | 6 ++++--
 src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs     | 2 ++
 src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs       | 5 ++---
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs
index 706fbac412..4a07e97a8b 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduleExtensions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
 using System.Collections.Generic;
 using System.Linq;
 using Nncase.IR;
@@ -6,7 +9,6 @@ namespace Nncase.Passes.BufferSchedule;
 
 public static class BufferScheduleExtensions
 {
-
     public static IEnumerable<Expr> GetArguments(this Call call)
     {
         var hs = new HashSet<Expr>(ReferenceEqualityComparer.Instance);
@@ -20,4 +22,4 @@ public static IEnumerable<Expr> GetUsers(this Call call)
         hs.UnionWith(call.Users.Where(e => e is not BaseFunction).ToArray().Select(e => e switch { IR.Tuple tp => tp.Users.ToArray(), _ => new[] { e } }).SelectMany(i => i));
         return hs;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
index f3b548cf1b..13e8ab86f0 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduleTypes.cs
@@ -57,7 +57,9 @@ public ScheduleBuffer(string name, int number, TimeInterval interval, MemSpan sp
     }
 
     public string Name { get; }
+
     public int Number { get; }
+
     public TimeInterval Interval { get; }
 
     public MemSpan Span { get; }
diff --git a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
index bfa43f9707..284a56b659 100644
--- a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
+++ b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
@@ -64,7 +64,7 @@ protected override Unit VisitLeafCall(Call expr)
 
     private void Update(Expr expr)
     {
-        if (expr is (Const or None))
+        if (expr is Const or None)
         {
             return;
         }
@@ -93,7 +93,7 @@ private void Update(Expr expr)
 
     private void Alias()
     {
-        bool changed = true;
+        bool changed;
         do
         {
             changed = false;
@@ -165,5 +165,4 @@ private int GetSize(IRType type, out int[] shape, out int[] stride)
 
         return size;
     }
-
 }

From e6bb3fddbd97fd6765eebfc8016808e85f14c924 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 3 Aug 2023 12:01:01 +0800
Subject: [PATCH 068/308] format

---
 src/Nncase.Passes/BufferSchedule/BufferScheduler.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
index cdad8d521d..25f7d6f5b8 100644
--- a/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
+++ b/src/Nncase.Passes/BufferSchedule/BufferScheduler.cs
@@ -151,7 +151,7 @@ class ScheduledBuffer():
 
 buffers = [
 ");
-            foreach (var (k, v) in buffers)
+            foreach (var (_, v) in buffers)
             {
                 wr.WriteLine(v.ToString() + ",");
             }

From 945799cc49d539bcc375271d95fc96ea43b7ec62 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 8 Aug 2023 19:55:42 +0800
Subject: [PATCH 069/308] add unary parallel

---
 .../CodeGen/CSourceBuiltn.cs                  |  3 +
 .../CodeGen/CSourceConvertVisitor.cs          | 88 +++++++++++++++++--
 .../Passes/Tile/SingleCPUFusionConverter.cs   |  4 +-
 3 files changed, 87 insertions(+), 8 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index b2e0a6fcb3..a945b05958 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -72,6 +72,9 @@ public static class CSourceBuiltn
     bool (*bool_binary_and)(bool, bool);
     bool (*bool_binary_or)(bool, bool);
     bool (*bool_binary_xor)(bool, bool);
+    // paralell 
+    void *thread_start(void *(*callable)(void *args), void *user);
+    void thread_end();
 } nncase_mt_t;";
 
     public const string Include = @"#include <stdbool.h>
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index bc715c4f2f..2803ebba94 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -27,8 +27,8 @@ internal struct IndentScope : IDisposable
     public IndentScope(StringBuilder sb)
     {
         _initialized = true;
+        _originalWriter = _writer.Value;
         _writer.Value = new IndentWriter(sb);
-        _originalWriter = null;
     }
 
     public IndentScope()
@@ -70,6 +70,12 @@ public CSymbol(string type, string name)
     public string Name { get; }
 
     public override string ToString() => $"{Type} {Name}";
+
+    public static IReadOnlyList<CSymbol> Builtns => new CSymbol[] {
+        new CSymbol("nncase_mt_t*", "nncase_mt"),
+        new CSymbol("uint8_t*", "data"),
+        new CSymbol("const uint8_t*", "rdata"),
+    };
 }
 
 internal sealed class IndentWriter : StringWriter
@@ -100,16 +106,22 @@ internal sealed class CSourceConvertVisitor : ExprFunctor<CSymbol, Unit>
 {
     private readonly Dictionary<Expr, CSymbol> _exprMemo;
     private readonly StringBuilder _implBuilder;
+    private readonly StringBuilder _declBuilder;
+    private readonly StringWriter _declWriter;
 
     public CSourceConvertVisitor()
     {
         _implBuilder = new StringBuilder();
+        _declBuilder = new StringBuilder();
+        _declWriter = new StringWriter(_declBuilder);
         _exprMemo = new(ReferenceEqualityComparer.Instance);
     }
 
+    public PrimFunction VisitEntry => (TIR.PrimFunction)VisitRoot!;
+
     public FunctionCSource GetFunctionCSource()
     {
-        return new(_exprMemo[VisitRoot!].Type + ";", _implBuilder.ToString());
+        return new(_declBuilder.ToString(), _implBuilder.ToString());
     }
 
     /// <inheritdoc/>
@@ -127,6 +139,9 @@ protected override CSymbol VisitPrimFunction(PrimFunction expr)
 
         var type = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(b => Visit(b.MemSpan.Start).ToString()).ToArray())}, {CSourceBuiltn.FixedParameters})";
 
+        _declWriter.WriteLine(type + ";");
+        _declWriter.WriteLine();
+
         using (var scope = new IndentScope(_implBuilder))
         {
             // 1. Function signature
@@ -142,7 +157,8 @@ protected override CSymbol VisitPrimFunction(PrimFunction expr)
             IndentScope.Writer.IndWrite("}\n");
         }
 
-        symbol = new(type, new(expr.Name));
+        var ctype = $"void (*{expr.Name})({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(b => Visit(b.MemSpan.Start).ToString()).ToArray())}, {CSourceBuiltn.FixedParameters})";
+        symbol = new(ctype, expr.Name);
         _exprMemo.Add(expr, symbol);
         return symbol;
     }
@@ -294,10 +310,51 @@ protected override CSymbol VisitFor(For expr)
         // 1. For Loop signature
         var loopVar = Visit(expr.LoopVar);
         IndentScope.Writer.IndWrite($"for ({loopVar.Type} {loopVar.Name} = {Visit(expr.Domain.Start).Name}; {loopVar.Name} < {Visit(expr.Domain.Stop).Name}; {loopVar.Name}+={Visit(expr.Domain.Step).Name}) {{\n");
-        using (_ = new IndentScope())
+
+        if (expr.Mode == LoopMode.Parallel)
+        {
+            // find the vars will be used and make new struct type.
+            var msg_fields = _exprMemo.Where(p => p.Key is MemSpan or TIR.Buffer or Var).Select(p => p.Value).Concat(CSymbol.Builtns);
+            var msg_type = DeclThreadMessageStruct(msg_fields);
+
+            using (new IndentScope(_declBuilder))
+            {
+                IndentScope.Writer.IndWrite($"void *{VisitEntry.Name}_inner(void *args) {{\n");
+                using (new IndentScope())
+                {
+                    IndentScope.Writer.IndWrite($"{msg_type}* _message = ({msg_type}*)args;\n");
+                    foreach (var sym in msg_fields)
+                    {
+                        IndentScope.Writer.IndWrite($"{sym.Type} {sym.Name} = _message->{sym.Name};\n");
+                    }
+
+                    Visit(expr.Body);
+                }
+
+                IndentScope.Writer.IndWrite(" return 0;\n");
+                IndentScope.Writer.IndWrite("}\n");
+            }
+
+            using (new IndentScope())
+            {
+                IndentScope.Writer.IndWrite($"{msg_type} _message = {{\n");
+                foreach (var sym in msg_fields)
+                {
+                    IndentScope.Writer.IndWrite($".{sym.Name} = {sym.Name},\n");
+                }
+
+                IndentScope.Writer.IndWrite("};\n");
+
+                IndentScope.Writer.IndWrite($"nncase_mt->thread_start({VisitEntry.Name}_inner, (void *)_message);\n");
+            }
+        }
+        else
         {
-            // 2. For Body
-            Visit(expr.Body);
+            using (_ = new IndentScope())
+            {
+                // 2. For Body
+                Visit(expr.Body);
+            }
         }
 
         // 3. For closing
@@ -360,4 +417,23 @@ protected override CSymbol VisitIfThenElse(IfThenElse expr)
         _exprMemo.Add(expr, symbol);
         return symbol;
     }
+
+    private string DeclThreadMessageStruct(IEnumerable<CSymbol> keyValues)
+    {
+        var type = $"{VisitEntry.Name}_thread_message_t";
+        _declWriter.WriteLine("typedef struct {");
+        foreach (var sym in keyValues)
+        {
+            if (sym.Name == string.Empty)
+            {
+                throw new InvalidOperationException("empty name");
+            }
+
+            _declWriter.WriteLine("  " + sym.Type + " " + sym.Name + ";");
+        }
+
+        _declWriter.WriteLine($"}} {type};");
+        _declWriter.WriteLine();
+        return type;
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index bd45b072ca..2dc177c607 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -86,7 +86,7 @@ private void GenerateMatMul(ReadOnlySpan<Buffer> arguments, Buffer ret, Call exp
             var lhs = arguments[0];
             var rhs = arguments[1];
 
-            var loops = Enumerable.Range(0, lhs.Rank - 2).Select(i => (T.ForLoop(out var loopVar, (0, lhs.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
+            var loops = Enumerable.Range(0, lhs.Rank - 2).Select(i => (T.ForLoop(out var loopVar, (0, lhs.Dimensions[i]), i == 0 ? LoopMode.Parallel : LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
             var loopVars = loops.Select(f => f.loopVar).ToArray();
             var stmt = T.Serial(out var m, (0, lhs.Dimensions[^2])).Body(
                 T.Serial(out var n, (0, rhs.Dimensions[^1])).Body(
@@ -108,7 +108,7 @@ private void GenerateMatMul(ReadOnlySpan<Buffer> arguments, Buffer ret, Call exp
         private void GenerateUnary(Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
             var input = arguments[Unary.Input.Index];
-            var loops = Enumerable.Range(0, input.Rank).Select(i => (T.ForLoop(out var loopVar, (0, input.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
+            var loops = Enumerable.Range(0, input.Rank).Select(i => (T.ForLoop(out var loopVar, (0, input.Dimensions[i]), i == 0 ? LoopMode.Parallel : LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
             var loopVars = loops.Select(f => f.loopVar).ToArray();
             Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Unary(unary.UnaryOp, T.BufferLoad(input, loopVars)));
             var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());

From c4464cac9cd0deb39a4d3ed456d851cf5d9a5e0b Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Tue, 8 Aug 2023 11:58:41 +0000
Subject: [PATCH 070/308] Apply code-format changes

---
 .../CodeGen/CSourceConvertVisitor.cs                 | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 2803ebba94..636cf1e2ea 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -65,17 +65,17 @@ public CSymbol(string type, string name)
         Name = name;
     }
 
-    public string Type { get; }
-
-    public string Name { get; }
-
-    public override string ToString() => $"{Type} {Name}";
-
     public static IReadOnlyList<CSymbol> Builtns => new CSymbol[] {
         new CSymbol("nncase_mt_t*", "nncase_mt"),
         new CSymbol("uint8_t*", "data"),
         new CSymbol("const uint8_t*", "rdata"),
     };
+
+    public string Type { get; }
+
+    public string Name { get; }
+
+    public override string ToString() => $"{Type} {Name}";
 }
 
 internal sealed class IndentWriter : StringWriter

From 9404c5fba4938fe71ebd9326a574993c40b21bcb Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 9 Aug 2023 19:15:43 +0800
Subject: [PATCH 071/308] support multi-thread

---
 modules/cpu/src/runtime/CMakeLists.txt  |  5 ++-
 modules/cpu/src/runtime/cpu_common.h    |  5 +++
 modules/cpu/src/runtime/elfloader.cpp   |  4 ++
 modules/cpu/src/runtime/thread_pool.cpp | 53 +++++++++++++++++++++++++
 modules/cpu/src/runtime/thread_pool.h   | 28 +++++++++++++
 5 files changed, 93 insertions(+), 2 deletions(-)
 create mode 100644 modules/cpu/src/runtime/thread_pool.cpp
 create mode 100644 modules/cpu/src/runtime/thread_pool.h

diff --git a/modules/cpu/src/runtime/CMakeLists.txt b/modules/cpu/src/runtime/CMakeLists.txt
index ebba027d8d..37da417626 100644
--- a/modules/cpu/src/runtime/CMakeLists.txt
+++ b/modules/cpu/src/runtime/CMakeLists.txt
@@ -2,6 +2,7 @@
 
 set(SRCS runtime_module.cpp
          runtime_function.cpp
+         thread_pool.cpp
          elfload.cpp
          elfloader.cpp
          elfreloc_aarch64.cpp
@@ -12,13 +13,13 @@ set(SRCS runtime_module.cpp
 if (BUILDING_RUNTIME)
     if (ENABLE_CPU_RUNTIME)
         add_library(runtime_cpu OBJECT ${SRCS})
-        target_link_libraries(runtime_cpu PUBLIC nncaseruntime)
+        target_link_libraries(runtime_cpu PUBLIC nncaseruntime pthread)
         set_target_properties(runtime_cpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
         install(TARGETS runtime_cpu EXPORT nncaseruntimeTargets)
     endif()
 else()
     add_library(simulator_cpu OBJECT ${SRCS})
-    target_link_libraries(simulator_cpu PUBLIC nncasebase nncaseruntime)
+    target_link_libraries(simulator_cpu PUBLIC nncasebase nncaseruntime pthread)
     target_compile_definitions(simulator_cpu PUBLIC -DNNCASE_MODULES_CPU_DLL -DNNCASE_SIMULATOR)
     set_target_properties(simulator_cpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
index aefa9f32d1..d28d6ed69e 100644
--- a/modules/cpu/src/runtime/cpu_common.h
+++ b/modules/cpu/src/runtime/cpu_common.h
@@ -1,4 +1,5 @@
 #pragma once
+#include "thread_pool.h"
 #include <functional>
 #include <math.h>
 #include <nncase/runtime/cpu/compiler_defs.h>
@@ -65,6 +66,10 @@ typedef struct nncase_method_table {
     bool (*bool_binary_and)(bool, bool);
     bool (*bool_binary_or)(bool, bool);
     bool (*bool_binary_xor)(bool, bool);
+
+    // multi-thread
+    void *(*thread_start)(void *(*callable)(void *), void *user, size_t user_size);
+    void *(*thread_end)();
 } nncase_mt_t;
 
 typedef struct buffer {
diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/cpu/src/runtime/elfloader.cpp
index 394ed6ed3d..d9845fcf72 100644
--- a/modules/cpu/src/runtime/elfloader.cpp
+++ b/modules/cpu/src/runtime/elfloader.cpp
@@ -1,4 +1,5 @@
 #include "elfloader.h"
+#include "thread_pool.h"
 
 using namespace nncase;
 using namespace nncase::runtime;
@@ -32,6 +33,9 @@ int elfloader::invoke_elf(size_t id, uint8_t **buffers, nncase_mt_t *nncase_mt,
     // printf("Binary entrypoint is %" PRIxPTR "; invoking %p\n",
     //        (uintptr_t)ctx_.ehdr.e_entry, (void *)epaddr);
 
+    thread_pool::paddr_offset = (uintptr_t)buf_;
+    nncase_mt->thread_start = thread_pool::thread_start;
+    nncase_mt->thread_end = thread_pool::thread_end;
     ep(id, buffers, nncase_mt, data, rdata);
 
     free(ptr_);
diff --git a/modules/cpu/src/runtime/thread_pool.cpp b/modules/cpu/src/runtime/thread_pool.cpp
new file mode 100644
index 0000000000..757aaad32a
--- /dev/null
+++ b/modules/cpu/src/runtime/thread_pool.cpp
@@ -0,0 +1,53 @@
+#include "thread_pool.h"
+
+using namespace nncase::runtime::cpu::thread_pool;
+
+static int threads_size = atoi(getenv("NNCASE_MAX_THREADS") ? getenv("NNCASE_MAX_THREADS") : "0");
+static int threads_count;
+static std::vector<pthread_t> threads;
+static std::vector<void *> users;
+
+static void *thread_start(thread_func callable, void *user, size_t user_size) {
+    auto user_ = malloc(user_size);
+    std::memcpy(user_, user, user_size);
+    thread_func new_call = thread_func((char *)callable + paddr_offset);
+    if (threads_size == 0) {
+        new_call(user_);
+    } else {
+        auto idx = threads_count % threads_size;
+        if (threads_count >= threads_size) {
+            pthread_join(threads[idx], NULL);
+            free(users[idx]);
+        }
+        pthread_t pt;
+        auto ret = pthread_create(&pt, NULL, new_call, user_);
+        if (ret != 0) {
+            throw std::runtime_error("thread creation failed\n");
+        }
+
+        if (threads_count == 0) {
+            threads.resize(threads_size);
+            users.resize(threads_size);
+        }
+        threads[idx] = pt;
+        users[idx] = user_;
+        threads_count++;
+    }
+    return nullptr;
+}
+
+static void *thread_end() {
+    if (threads_size) {
+        for (int i = 0; i < std::min(threads_size, threads_count); i++) {
+            // if (threads[i].joinable()) {
+            pthread_join(threads[i], NULL);
+            free(users[i]);
+            // }
+        }
+        threads_count = 0;
+        threads.clear();
+        users.clear();
+    }
+    return nullptr;
+}
+
diff --git a/modules/cpu/src/runtime/thread_pool.h b/modules/cpu/src/runtime/thread_pool.h
new file mode 100644
index 0000000000..6cdfd64817
--- /dev/null
+++ b/modules/cpu/src/runtime/thread_pool.h
@@ -0,0 +1,28 @@
+#ifndef THREAD_POOL_
+#define THREAD_POOL_
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <nncase/runtime/cpu/compiler_defs.h>
+#include <pthread.h>
+#include <utility>
+#include <vector>
+
+BEGIN_NS_NNCASE_RT_MODULE(cpu)
+namespace thread_pool {
+
+using thread_func = void *(*)(void *);
+
+// static int threads_size = atoi(getenv("NNCASE_MAX_THREADS") ? getenv("NNCASE_MAX_THREADS") : "0");
+// static int threads_count;
+// static std::vector<pthread_t> threads;
+// static std::vector<void *> users;
+uintptr_t paddr_offset;
+
+void *thread_start(thread_func callable, void *user, size_t user_size);
+void *thread_end();
+
+} // namespace thread_pool
+END_NS_NNCASE_RT_MODULE
+
+#endif

From 427d290e68c22f29760fc17cc28baee0a20858b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 9 Aug 2023 19:18:37 +0800
Subject: [PATCH 072/308] fix build

---
 modules/cpu/src/runtime/thread_pool.cpp | 13 +++++++------
 modules/cpu/src/runtime/thread_pool.h   |  2 +-
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/modules/cpu/src/runtime/thread_pool.cpp b/modules/cpu/src/runtime/thread_pool.cpp
index 757aaad32a..43846aed35 100644
--- a/modules/cpu/src/runtime/thread_pool.cpp
+++ b/modules/cpu/src/runtime/thread_pool.cpp
@@ -2,12 +2,13 @@
 
 using namespace nncase::runtime::cpu::thread_pool;
 
-static int threads_size = atoi(getenv("NNCASE_MAX_THREADS") ? getenv("NNCASE_MAX_THREADS") : "0");
-static int threads_count;
-static std::vector<pthread_t> threads;
-static std::vector<void *> users;
+int threads_size = atoi(getenv("NNCASE_MAX_THREADS") ? getenv("NNCASE_MAX_THREADS") : "0");
+int threads_count;
+std::vector<pthread_t> threads;
+std::vector<void *> users;
+uintptr_t nncase::runtime::cpu::thread_pool::paddr_offset;
 
-static void *thread_start(thread_func callable, void *user, size_t user_size) {
+void *nncase::runtime::cpu::thread_pool::thread_start(thread_func callable, void *user, size_t user_size) {
     auto user_ = malloc(user_size);
     std::memcpy(user_, user, user_size);
     thread_func new_call = thread_func((char *)callable + paddr_offset);
@@ -36,7 +37,7 @@ static void *thread_start(thread_func callable, void *user, size_t user_size) {
     return nullptr;
 }
 
-static void *thread_end() {
+void *nncase::runtime::cpu::thread_pool::thread_end() {
     if (threads_size) {
         for (int i = 0; i < std::min(threads_size, threads_count); i++) {
             // if (threads[i].joinable()) {
diff --git a/modules/cpu/src/runtime/thread_pool.h b/modules/cpu/src/runtime/thread_pool.h
index 6cdfd64817..eb5819f6f8 100644
--- a/modules/cpu/src/runtime/thread_pool.h
+++ b/modules/cpu/src/runtime/thread_pool.h
@@ -17,7 +17,7 @@ using thread_func = void *(*)(void *);
 // static int threads_count;
 // static std::vector<pthread_t> threads;
 // static std::vector<void *> users;
-uintptr_t paddr_offset;
+extern uintptr_t paddr_offset;
 
 void *thread_start(thread_func callable, void *user, size_t user_size);
 void *thread_end();

From 18fc13b1608b838026441d2f2d5cec436547d4b9 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Wed, 9 Aug 2023 11:21:25 +0000
Subject: [PATCH 073/308] Apply code-format changes

---
 modules/cpu/src/runtime/cpu_common.h    | 3 ++-
 modules/cpu/src/runtime/thread_pool.cpp | 8 +++++---
 modules/cpu/src/runtime/thread_pool.h   | 7 +++----
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
index d28d6ed69e..60b87e5ccc 100644
--- a/modules/cpu/src/runtime/cpu_common.h
+++ b/modules/cpu/src/runtime/cpu_common.h
@@ -68,7 +68,8 @@ typedef struct nncase_method_table {
     bool (*bool_binary_xor)(bool, bool);
 
     // multi-thread
-    void *(*thread_start)(void *(*callable)(void *), void *user, size_t user_size);
+    void *(*thread_start)(void *(*callable)(void *), void *user,
+                          size_t user_size);
     void *(*thread_end)();
 } nncase_mt_t;
 
diff --git a/modules/cpu/src/runtime/thread_pool.cpp b/modules/cpu/src/runtime/thread_pool.cpp
index 43846aed35..69de596cbd 100644
--- a/modules/cpu/src/runtime/thread_pool.cpp
+++ b/modules/cpu/src/runtime/thread_pool.cpp
@@ -2,13 +2,16 @@
 
 using namespace nncase::runtime::cpu::thread_pool;
 
-int threads_size = atoi(getenv("NNCASE_MAX_THREADS") ? getenv("NNCASE_MAX_THREADS") : "0");
+int threads_size =
+    atoi(getenv("NNCASE_MAX_THREADS") ? getenv("NNCASE_MAX_THREADS") : "0");
 int threads_count;
 std::vector<pthread_t> threads;
 std::vector<void *> users;
 uintptr_t nncase::runtime::cpu::thread_pool::paddr_offset;
 
-void *nncase::runtime::cpu::thread_pool::thread_start(thread_func callable, void *user, size_t user_size) {
+void *nncase::runtime::cpu::thread_pool::thread_start(thread_func callable,
+                                                      void *user,
+                                                      size_t user_size) {
     auto user_ = malloc(user_size);
     std::memcpy(user_, user, user_size);
     thread_func new_call = thread_func((char *)callable + paddr_offset);
@@ -51,4 +54,3 @@ void *nncase::runtime::cpu::thread_pool::thread_end() {
     }
     return nullptr;
 }
-
diff --git a/modules/cpu/src/runtime/thread_pool.h b/modules/cpu/src/runtime/thread_pool.h
index eb5819f6f8..f5baed41f7 100644
--- a/modules/cpu/src/runtime/thread_pool.h
+++ b/modules/cpu/src/runtime/thread_pool.h
@@ -13,10 +13,9 @@ namespace thread_pool {
 
 using thread_func = void *(*)(void *);
 
-// static int threads_size = atoi(getenv("NNCASE_MAX_THREADS") ? getenv("NNCASE_MAX_THREADS") : "0");
-// static int threads_count;
-// static std::vector<pthread_t> threads;
-// static std::vector<void *> users;
+// static int threads_size = atoi(getenv("NNCASE_MAX_THREADS") ?
+// getenv("NNCASE_MAX_THREADS") : "0"); static int threads_count; static
+// std::vector<pthread_t> threads; static std::vector<void *> users;
 extern uintptr_t paddr_offset;
 
 void *thread_start(thread_func callable, void *user, size_t user_size);

From d926f7f2c40d6b2cc1955eaee0409d1fa84a025f Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 9 Aug 2023 19:23:15 +0800
Subject: [PATCH 074/308] fix runtime build

---
 modules/cpu/src/runtime/elfloader.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/cpu/src/runtime/elfloader.cpp
index d9845fcf72..da4cc1f71f 100644
--- a/modules/cpu/src/runtime/elfloader.cpp
+++ b/modules/cpu/src/runtime/elfloader.cpp
@@ -33,7 +33,7 @@ int elfloader::invoke_elf(size_t id, uint8_t **buffers, nncase_mt_t *nncase_mt,
     // printf("Binary entrypoint is %" PRIxPTR "; invoking %p\n",
     //        (uintptr_t)ctx_.ehdr.e_entry, (void *)epaddr);
 
-    thread_pool::paddr_offset = (uintptr_t)buf_;
+    nncase::runtime::cpu::thread_pool::paddr_offset = (uintptr_t)buf_;
     nncase_mt->thread_start = thread_pool::thread_start;
     nncase_mt->thread_end = thread_pool::thread_end;
     ep(id, buffers, nncase_mt, data, rdata);

From 5cf33c7c116c3540efd6f3c5b3b20fd2d48cb967 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 9 Aug 2023 19:24:11 +0800
Subject: [PATCH 075/308] update thread related csouce gen

---
 .../CodeGen/CSourceBuiltn.cs                  |  6 +-
 .../CodeGen/CSourceCompiler.cs                |  2 +-
 .../CodeGen/CSourceConvertVisitor.cs          |  9 ++-
 .../Passes/Tile/SingleCPUFusionConverter.cs   |  4 +-
 src/Native/src/test_cli.cpp                   | 65 ++++++++++++-------
 5 files changed, 54 insertions(+), 32 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index a945b05958..81c495da47 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -72,9 +72,9 @@ public static class CSourceBuiltn
     bool (*bool_binary_and)(bool, bool);
     bool (*bool_binary_or)(bool, bool);
     bool (*bool_binary_xor)(bool, bool);
-    // paralell 
-    void *thread_start(void *(*callable)(void *args), void *user);
-    void thread_end();
+    // multi-thread
+    void *(*thread_start)(void *(*callable)(void *), void *user, size_t user_size);
+    void *(*thread_end)();
 } nncase_mt_t;";
 
     public const string Include = @"#include <stdbool.h>
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
index 449329e034..691fe6cd24 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
@@ -138,7 +138,7 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
         {
-            return $"{sourcePath} -nostdlib -static -nopie -fPIC -o {outPath} -e__start";
+            return $"{sourcePath} -nostartfiles -pie -fPIC -o {outPath} -static -e__start";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
         {
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 636cf1e2ea..1b05cacccf 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -314,7 +314,7 @@ protected override CSymbol VisitFor(For expr)
         if (expr.Mode == LoopMode.Parallel)
         {
             // find the vars will be used and make new struct type.
-            var msg_fields = _exprMemo.Where(p => p.Key is MemSpan or TIR.Buffer or Var).Select(p => p.Value).Concat(CSymbol.Builtns);
+            var msg_fields = _exprMemo.Where(p => p.Key is MemSpan or TIR.Buffer or Var).Select(p => p.Value).Concat(CSymbol.Builtns).ToArray();
             var msg_type = DeclThreadMessageStruct(msg_fields);
 
             using (new IndentScope(_declBuilder))
@@ -345,7 +345,7 @@ protected override CSymbol VisitFor(For expr)
 
                 IndentScope.Writer.IndWrite("};\n");
 
-                IndentScope.Writer.IndWrite($"nncase_mt->thread_start({VisitEntry.Name}_inner, (void *)_message);\n");
+                IndentScope.Writer.IndWrite($"nncase_mt->thread_start({VisitEntry.Name}_inner, (void *)&_message, sizeof ({msg_type}));\n");
             }
         }
         else
@@ -360,6 +360,11 @@ protected override CSymbol VisitFor(For expr)
         // 3. For closing
         IndentScope.Writer.IndWrite("}\n");
 
+        if (expr.Mode == LoopMode.Parallel)
+        {
+            IndentScope.Writer.IndWrite("nncase_mt->thread_end();\n");
+        }
+
         symbol = new(string.Empty, string.Empty);
         _exprMemo.Add(expr, symbol);
         return symbol;
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 2dc177c607..99ba7688ab 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -86,9 +86,9 @@ private void GenerateMatMul(ReadOnlySpan<Buffer> arguments, Buffer ret, Call exp
             var lhs = arguments[0];
             var rhs = arguments[1];
 
-            var loops = Enumerable.Range(0, lhs.Rank - 2).Select(i => (T.ForLoop(out var loopVar, (0, lhs.Dimensions[i]), i == 0 ? LoopMode.Parallel : LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
+            var loops = Enumerable.Range(0, lhs.Rank - 2).Select(i => (T.ForLoop(out var loopVar, (0, lhs.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
             var loopVars = loops.Select(f => f.loopVar).ToArray();
-            var stmt = T.Serial(out var m, (0, lhs.Dimensions[^2])).Body(
+            var stmt = T.ForLoop(out var m, (0, lhs.Dimensions[^2]), LoopMode.Parallel).Body(
                 T.Serial(out var n, (0, rhs.Dimensions[^1])).Body(
                     T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), 0f),
                     T.Serial(out var k, (0, lhs.Dimensions[^1])).Body(
diff --git a/src/Native/src/test_cli.cpp b/src/Native/src/test_cli.cpp
index 7f703a216a..ea375f4f35 100644
--- a/src/Native/src/test_cli.cpp
+++ b/src/Native/src/test_cli.cpp
@@ -12,6 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <chrono>
 #include <cstring>
 #include <iostream>
 #include <nncase/io_utils.h>
@@ -19,6 +20,7 @@
 
 using namespace nncase;
 using namespace nncase::runtime;
+constexpr size_t loop_count = 10;
 
 #define TRY(x)                                                                 \
     if (x)                                                                     \
@@ -34,8 +36,7 @@ result<void> write_tensor_buffer(value_t value, std::ofstream &of) {
 }
 
 result<void> run_core(const std::string &kmodel_path,
-                      const std::vector<std::string> &input_bins,
-                      const std::string &output_bin) {
+                      const std::vector<std::string> &bins) {
     auto kmodel = read_file(kmodel_path);
     interpreter *interp = new interpreter();
     // auto dump_path =
@@ -47,16 +48,16 @@ result<void> run_core(const std::string &kmodel_path,
 
     try_var(entry, interp->entry_function());
 
-    if (entry->parameters_size() != input_bins.size())
+    if (entry->parameters_size() > bins.size())
         return err(std::errc::argument_list_too_long);
     /* create the input parameters tensor
        note the input tenosr must be contiguous
     */
     std::vector<value_t> parameters;
-    for (int i = 0; i < input_bins.size(); i++) {
+    for (int i = 0; i < entry->parameters_size(); i++) {
         try_var(type, entry->parameter_type(i));
         try_var(ts_type, type.as<tensor_type>());
-        auto input_pool = read_file(input_bins[i]);
+        auto input_pool = read_file(bins[i]);
         gsl::span<gsl::byte> input_pool_span = {
             reinterpret_cast<gsl::byte *>(input_pool.data()),
             input_pool.size()};
@@ -66,21 +67,38 @@ result<void> run_core(const std::string &kmodel_path,
         parameters.push_back(_.impl());
     }
 
-    try_var(ret, entry->invoke({parameters.data(), parameters.size()}));
+    double total_time = 0.0;
+    for (size_t i = 0; i < loop_count; i++) {
+        auto start_time = std::chrono::steady_clock::now();
+        try_var(ret, entry->invoke({parameters.data(), parameters.size()}));
+        auto end_time = std::chrono::steady_clock::now();
+        total_time += (std::chrono::duration_cast<std::chrono::nanoseconds>(
+                           end_time - start_time)
+                           .count() /
+                       1e6);
 
-    std::ofstream output_stream(output_bin, std::ios::binary);
-
-    if (ret.is_a<tensor>()) {
-        try_(write_tensor_buffer(ret, output_stream));
-    } else if (ret.is_a<tuple>()) {
-        try_var(tp, ret.as<tuple>());
-        for (auto &&ret_v : tp->fields()) {
-            try_(write_tensor_buffer(ret_v, output_stream));
+        if (i == (loop_count - 1)) {
+            if (entry->parameters_size() == (bins.size() - 1)) {
+                auto output_bin = *bins.end();
+                std::ofstream output_stream(output_bin, std::ios::binary);
+                if (ret.is_a<tensor>()) {
+                    try_(write_tensor_buffer(ret, output_stream));
+                } else if (ret.is_a<tuple>()) {
+                    try_var(tp, ret.as<tuple>());
+                    for (auto &&ret_v : tp->fields()) {
+                        try_(write_tensor_buffer(ret_v, output_stream));
+                    }
+                } else {
+                    return nncase::err(std::errc::bad_message);
+                }
+                output_stream.close();
+            }
         }
-    } else {
-        return nncase::err(std::errc::bad_message);
     }
-    output_stream.close();
+
+    std::cout << "interp run: " << (total_time / loop_count)
+              << " ms, fps = " << 1000 / (total_time / loop_count) << std::endl;
+
     return ok();
 }
 
@@ -92,13 +110,12 @@ result<void> run_core(const std::string &kmodel_path,
  * @return int
  */
 int main(NNCASE_UNUSED int argc, char **argv) {
-    assert(argc >= 4);
-    std::vector<std::string> input_bins;
-    for (int i = 2; i < argc - 1; i++) {
-        input_bins.push_back(argv[i]);
+    assert(argc >= 3);
+    std::vector<std::string> bins;
+    for (int i = 2; i < argc; i++) {
+        bins.push_back(argv[i]);
     }
     std::string kmodel_bin(argv[1]);
-    std::string output_bin(argv[argc - 1]);
-    run_core(kmodel_bin, input_bins, output_bin).unwrap_or_throw();
+    run_core(kmodel_bin, bins).unwrap_or_throw();
     return 0;
-}
+}
\ No newline at end of file

From 1e9ffd5ad9314f42b5e7cd97298789097f40d1c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 15 Aug 2023 15:54:03 +0800
Subject: [PATCH 076/308] add simulator

---
 modules/cpu/src/runtime/CMakeLists.txt        |   2 +
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |  21 +++
 .../cpu/src/runtime/cmodel/include/apply.h    | 102 +++++++++++++
 .../runtime/cmodel/include/hardware_context.h |  24 +++
 .../src/runtime/cmodel/include/hardware_def.h |   5 +
 .../runtime/cmodel/include/runtime_utils.h    |  85 +++++++++++
 modules/cpu/src/runtime/cmodel/include/tdma.h | 140 ++++++++++++++++++
 .../cpu/src/runtime/cmodel/include/tensor.h   |  66 +++++++++
 .../runtime/cmodel/include/thread_context.h   |  16 ++
 .../cpu/src/runtime/cmodel/src/cpu_cmodel.cpp |  58 ++++++++
 .../runtime/cmodel/src/hardware_context.cpp   | 113 ++++++++++++++
 .../src/runtime/cmodel/tests/demo1/kernel.h   | 100 +++++++++++++
 .../src/runtime/cmodel/tests/demo1/main.cpp   |  76 ++++++++++
 .../runtime/cmodel/tests/demo1/shared_def.h   |   9 ++
 modules/cpu/src/runtime/shared_memory.cpp     | 125 ++++++++++++++++
 modules/cpu/src/runtime/shared_memory.h       |  51 +++++++
 16 files changed, 993 insertions(+)
 create mode 100644 modules/cpu/src/runtime/cmodel/CMakeLists.txt
 create mode 100644 modules/cpu/src/runtime/cmodel/include/apply.h
 create mode 100644 modules/cpu/src/runtime/cmodel/include/hardware_context.h
 create mode 100644 modules/cpu/src/runtime/cmodel/include/hardware_def.h
 create mode 100644 modules/cpu/src/runtime/cmodel/include/runtime_utils.h
 create mode 100644 modules/cpu/src/runtime/cmodel/include/tdma.h
 create mode 100644 modules/cpu/src/runtime/cmodel/include/tensor.h
 create mode 100644 modules/cpu/src/runtime/cmodel/include/thread_context.h
 create mode 100644 modules/cpu/src/runtime/cmodel/src/cpu_cmodel.cpp
 create mode 100644 modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
 create mode 100644 modules/cpu/src/runtime/shared_memory.cpp
 create mode 100644 modules/cpu/src/runtime/shared_memory.h

diff --git a/modules/cpu/src/runtime/CMakeLists.txt b/modules/cpu/src/runtime/CMakeLists.txt
index 37da417626..a0d8e42910 100644
--- a/modules/cpu/src/runtime/CMakeLists.txt
+++ b/modules/cpu/src/runtime/CMakeLists.txt
@@ -1,5 +1,7 @@
 cmake_minimum_required (VERSION 3.13)
 
+add_subdirectory(cmodel)
+
 set(SRCS runtime_module.cpp
          runtime_function.cpp
          thread_pool.cpp
diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
new file mode 100644
index 0000000000..0a071feced
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -0,0 +1,21 @@
+
+add_library(cpu_cmodel STATIC
+  src/hardware_context.cpp
+)
+
+target_include_directories(cpu_cmodel PUBLIC include)
+set_target_properties(cpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
+        
+add_executable(cpu_cmodel_cli src/cpu_cmodel.cpp ../shared_memory.cpp)
+target_link_libraries(cpu_cmodel_cli PUBLIC cpu_cmodel)
+set_target_properties(cpu_cmodel_cli PROPERTIES POSITION_INDEPENDENT_CODE ON
+  OUTPUT_NAME "nncase.simulator.cpu.c")
+install(TARGETS cpu_cmodel_cli COMPONENT nncase-runtime)
+
+
+function(add_test name test_path)
+  add_executable(${name} "${test_path}/main.cpp")
+  target_include_directories(${name} PUBLIC include)
+endfunction(add_test)
+
+add_test(demo1 tests/demo1)
diff --git a/modules/cpu/src/runtime/cmodel/include/apply.h b/modules/cpu/src/runtime/cmodel/include/apply.h
new file mode 100644
index 0000000000..6b519f8c48
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/apply.h
@@ -0,0 +1,102 @@
+#pragma once
+#include <gsl/gsl-lite.hpp>
+
+namespace detail {
+#define APPLY_IMPL_FOR(i) for (index[i] = 0; index[i] < shape[i]; index[i]++)
+
+template <class Callable>
+void apply_1(gsl::span<const size_t> shape, Callable &&callable) noexcept {
+    size_t index[1];
+    APPLY_IMPL_FOR(0)
+    callable(gsl::span(index));
+}
+
+template <class Callable>
+void apply_2(gsl::span<const size_t> shape, Callable &&callable) noexcept {
+    size_t index[2];
+    APPLY_IMPL_FOR(0)
+    APPLY_IMPL_FOR(1)
+    callable(gsl::span(index));
+}
+
+template <class Callable>
+void apply_3(gsl::span<const size_t> shape, Callable &&callable) noexcept {
+    size_t index[3];
+    APPLY_IMPL_FOR(0)
+    APPLY_IMPL_FOR(1)
+    APPLY_IMPL_FOR(2)
+    callable(gsl::span(index));
+}
+
+template <class Callable>
+void apply_4(gsl::span<const size_t> shape, Callable &&callable) noexcept {
+    size_t index[4];
+    APPLY_IMPL_FOR(0)
+    APPLY_IMPL_FOR(1)
+    APPLY_IMPL_FOR(2)
+    APPLY_IMPL_FOR(3)
+    callable(gsl::span(index));
+}
+
+template <class Callable>
+void apply_5(gsl::span<const size_t> shape, Callable &&callable) noexcept {
+    size_t index[5];
+    APPLY_IMPL_FOR(0)
+    APPLY_IMPL_FOR(1)
+    APPLY_IMPL_FOR(2)
+    APPLY_IMPL_FOR(3)
+    APPLY_IMPL_FOR(4)
+    callable(gsl::span(index));
+}
+
+template <class Callable>
+void apply_generic(gsl::span<const size_t> shape,
+                   Callable &&callable) noexcept {
+    auto index_buffer = (size_t *)
+#ifdef _WIN32
+        _alloca
+#else
+        __builtin_alloca
+#endif
+        (sizeof(size_t) * shape.size());
+
+    gsl::span<size_t> index(index_buffer, shape.size());
+    std::fill(index.begin(), index.end(), 0);
+    auto last_dim_idx = (int32_t)shape.size() - 1;
+    while (true) {
+        int dim = last_dim_idx;
+        while (index[dim] == shape[dim]) {
+            if (dim == 0) {
+            }
+
+            index[dim] = 0;
+            index[--dim]++;
+        }
+
+        callable(index);
+        index[last_dim_idx]++;
+    }
+}
+} // namespace detail
+
+template <class Callable>
+void apply(gsl::span<const size_t> shape, Callable &&callable) noexcept {
+    switch (shape.size()) {
+    case 0:
+        return callable(shape);
+    case 1:
+        return detail::apply_1(shape, std::forward<Callable>(callable));
+    case 2:
+        return detail::apply_2(shape, std::forward<Callable>(callable));
+    case 3:
+        return detail::apply_3(shape, std::forward<Callable>(callable));
+    case 4:
+        return detail::apply_4(shape, std::forward<Callable>(callable));
+    case 5:
+        return detail::apply_5(shape, std::forward<Callable>(callable));
+    default:
+        break;
+    }
+
+    return detail::apply_generic(shape, std::forward<Callable>(callable));
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_context.h b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
new file mode 100644
index 0000000000..e01366c9f2
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <iostream>
+
+struct hardware_context_impl;
+
+class hardware_context {
+  public:
+    hardware_context();
+    void lock_block(int bid);
+    int mark_block_visit(int bid, int tid);
+    void unlock_block(int bid);
+    void wait_block_sync(int bid, int visited);
+    void lock_all();
+    int mark_all_visit(int bid, int tid);
+    void unlock_all();
+    void wait_all_sync(int visited);
+    void *all_reduce_var = nullptr;
+
+  private:
+    std::unique_ptr<hardware_context_impl> impl_;
+};
+
+extern std::unique_ptr<hardware_context> global_hardware_ctx;
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_def.h b/modules/cpu/src/runtime/cmodel/include/hardware_def.h
new file mode 100644
index 0000000000..9dfdcd946a
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/hardware_def.h
@@ -0,0 +1,5 @@
+#pragma once
+#include <stddef.h>
+
+constexpr size_t BLOCKS = 8;
+constexpr size_t CORES = 4;
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
new file mode 100644
index 0000000000..68d944706d
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -0,0 +1,85 @@
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <gsl/gsl-lite.hpp>
+#include <iostream>
+#include <nncase/runtime/small_vector.hpp>
+#include <numeric>
+#include <vector>
+
+using dims_t = itlib::small_vector<size_t, 8>;
+using strides_t = itlib::small_vector<size_t, 8>;
+
+void print_vec(itlib::small_vector<size_t, 8> vec) {
+    for (const size_t v : vec) {
+        std::cout << std::to_string(v) << ", ";
+    }
+    std::cout << std::endl;
+}
+
+template <class TShape> inline size_t compute_size(const TShape &shape) {
+    return std::accumulate(shape.begin(), shape.end(), 1,
+                           std::multiplies<size_t>());
+}
+
+template <class TShape>
+inline size_t compute_size(const TShape &shape, const TShape &strides) {
+    size_t max_stride = 1, max_shape = 1;
+    for (size_t i = 0; i < shape.size(); i++) {
+        if ((shape[i] == 1 ? 0 : strides[i]) >= max_stride) {
+            max_stride = strides[i];
+            max_shape = shape[i];
+        }
+    }
+    size_t size = max_stride * max_shape;
+    return size;
+}
+
+template <class shape_type, class strides_type>
+inline std::size_t compute_strides(const shape_type &shape,
+                                   strides_type &strides) {
+    using strides_value_type = typename std::decay_t<strides_type>::value_type;
+    strides_value_type data_size = 1;
+    for (std::size_t i = shape.size(); i != 0; --i) {
+        strides[i - 1] = data_size;
+        data_size =
+            strides[i - 1] * static_cast<strides_value_type>(shape[i - 1]);
+    }
+    return static_cast<std::size_t>(data_size);
+}
+
+inline strides_t get_default_strides(dims_t shape) {
+    strides_t strides(shape.size());
+    compute_strides(shape, strides);
+    return strides;
+}
+
+template <class offset_type, class S, class It>
+inline offset_type element_offset(const S &strides, It first,
+                                  It last) noexcept {
+    using difference_type = typename std::iterator_traits<It>::difference_type;
+    auto size = static_cast<difference_type>((std::min)(
+        static_cast<size_t>(std::distance(first, last)), strides.size()));
+    return std::inner_product(last - size, last, strides.cend() - size,
+                              offset_type(0));
+}
+
+inline size_t offset(gsl::span<const size_t> strides,
+                     gsl::span<const size_t> index) {
+    // scalar
+    if (strides.size() == 0 || index.size() == 0) {
+        return 0;
+    }
+    assert(strides.size() == index.size());
+    return element_offset<size_t>(strides, index.begin(), index.end());
+}
+
+inline bool is_shape_equal(const dims_t &a, const dims_t &b) {
+    for (size_t i = 0; i < a.size(); i++) {
+        if (a[i] != b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
new file mode 100644
index 0000000000..9a66bb403c
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -0,0 +1,140 @@
+#pragma once
+#include <apply.h>
+#include <cassert>
+#include <hardware_context.h>
+#include <tensor.h>
+#include <thread_context.h>
+
+template <template <class, tensor_loc_t> class TS, class DT>
+void __tensor_copy_sync(TS<DT, tensor_loc_t::local> &&dest,
+                        TS<DT, tensor_loc_t::local> &&src) {
+    assert(dest.dimension() == src.dimension());
+    apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
+          [&](gsl::span<const size_t> index) -> void {
+              dest.data()[offset(dest.strides(), index)] =
+                  src.data()[offset(src.strides(), index)];
+          });
+}
+
+template <template <class, tensor_loc_t> class TS, class DT>
+void __tensor_copy_sync(TS<DT, tensor_loc_t::local> &&dest,
+                        TS<DT, tensor_loc_t::device> &&src) {
+    assert(dest.dimension() == src.dimension());
+    apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
+          [&](gsl::span<const size_t> index) -> void {
+              dest.data()[offset(dest.strides(), index)] =
+                  src.data()[offset(src.strides(), index)];
+          });
+}
+
+template <template <class, tensor_loc_t> class TS, class DT>
+void __tensor_copy_sync(TS<DT, tensor_loc_t::shared> &&dest,
+                        TS<DT, tensor_loc_t::local> &&src,
+                        thread_context &ctx) {
+    assert(dest.dimension() == src.dimension());
+    apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
+          [&](gsl::span<const size_t> index) -> void {
+              dest.shared_data(ctx.bid())[offset(dest.strides(), index)] =
+                  src.data()[offset(src.strides(), index)];
+          });
+}
+
+template <class T>
+void __tensor_add_sync(tensor<T, tensor_loc_t::local> &a,
+                       tensor<T, tensor_loc_t::local> &b,
+                       tensor<T, tensor_loc_t::local> &out) {
+    assert(a.dimension() == b.dimension());
+    assert(a.dimension() == out.dimension());
+    apply(a.dimension(), [&](gsl::span<size_t> index) -> void {
+        out.data()[offset(out.strides(), index)] =
+            (a.data()[offset(a.strides(), index)] +
+             b.data()[offset(b.strides(), index)]);
+    });
+}
+
+template <class T>
+void tdma_load_async(tensor<T, tensor_loc_t::local> &dest,
+                     tensor<T, tensor_loc_t::device> &&src) {
+    __tensor_copy_sync(std::forward<tensor<T, tensor_loc_t::local>>(dest),
+                       std::forward<tensor<T, tensor_loc_t::device>>(src));
+}
+
+template <class T>
+void tdma_store_async(tensor<T, tensor_loc_t::local> &src,
+                      tensor<T, tensor_loc_t::device> &&dest) {
+    __tensor_copy_sync(dest, src);
+}
+
+template <class T>
+void tdma_fill_async(tensor<T, tensor_loc_t::local> &src, T data) {
+    apply(src.dimension(), [&](gsl::span<size_t> index) -> void {
+        src.data()[offset(src.strides(), index)] = data;
+    });
+}
+
+template <class T>
+void tdma_broadcast_async(tensor<T, tensor_loc_t::local> &src,
+                          tensor<T, tensor_loc_t::shared> &dest,
+                          thread_context &ctx) {
+
+    global_hardware_ctx->lock_block(ctx.bid());
+    __tensor_copy_sync(dest, src);
+    // int cnt = global_hardware_ctx->mark_block_visit(ctx.tid());
+    global_hardware_ctx->unlock_block(ctx.bid());
+    // global_hardware_ctx->wait_block_sync(ctx.bid(), cnt);
+}
+
+template <class T, tensor_loc_t Src, tensor_loc_t Dest>
+void tdma_load_broadcast_async([[maybe_unused]] tensor<T, Dest> &dest,
+                               [[maybe_unused]] tensor<T, Src> &src,
+                               [[maybe_unused]] thread_context &ctx) {
+    throw std::system_error(std::make_error_code(std::errc::not_supported));
+}
+
+void tdma_reduce_async() {
+    throw std::system_error(std::make_error_code(std::errc::not_supported));
+}
+
+enum class reduce_op_t : uint8_t {
+    SUM,
+};
+
+template <class T>
+void tdma_all_reduce_async(tensor<T, tensor_loc_t::local> &src,
+                           thread_context &ctx,
+                           reduce_op_t reduce_op = reduce_op_t::SUM) {
+    switch (reduce_op) {
+    case reduce_op_t::SUM: {
+        global_hardware_ctx->lock_all();
+        int visited = global_hardware_ctx->mark_all_visit(ctx.bid(), ctx.tid());
+        if (global_hardware_ctx->all_reduce_var == nullptr) {
+            global_hardware_ctx->all_reduce_var =
+                (void *)malloc(sizeof(tensor<T>));
+            auto reduce_tensor = tensor<T>(src.dimension());
+            tdma_fill_async(reduce_tensor, (T)0);
+            memcpy(global_hardware_ctx->all_reduce_var, &reduce_tensor,
+                   sizeof(tensor<T>));
+        }
+        auto reduce_tensor = (tensor<T> *)global_hardware_ctx->all_reduce_var;
+        __tensor_add_sync(src, *reduce_tensor, *reduce_tensor);
+        global_hardware_ctx->unlock_all();
+        global_hardware_ctx->wait_all_sync(visited);
+        break;
+    }
+    default:
+        throw std::system_error(std::make_error_code(std::errc::not_supported));
+        break;
+    }
+}
+
+void tdma_gather_async() {}
+
+void tdma_all_gather_async() {}
+
+void tdma_scatter_async() {}
+
+void tdma_wait() {}
+
+void tdma_cancel() {}
+
+void tdma_status() {}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
new file mode 100644
index 0000000000..05171d68a3
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -0,0 +1,66 @@
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <gsl/gsl-lite.hpp>
+#include <hardware_def.h>
+#include <runtime_utils.h>
+
+enum class tensor_loc_t : uint8_t {
+    shared,
+    device,
+    local,
+};
+
+template <typename T, tensor_loc_t Loc = tensor_loc_t::local> class tensor {
+
+  public:
+    using value_type = T;
+
+    tensor(dims_t dims)
+        : dims_(dims),
+          strides_(get_default_strides(dims_)),
+          size_(compute_size(dims_)) {
+        parent_ = nullptr;
+        auto ptr = new T[size_];
+        data_ = gsl::make_span(ptr, size_);
+    }
+
+    const dims_t &dimension() { return dims_; }
+    const strides_t &strides() { return strides_; }
+
+    gsl::span<T> data() {
+        if (Loc != tensor_loc_t::shared) {
+            return data_;
+        }
+        assert(false);
+    }
+
+    tensor<T, Loc> operator()(std::initializer_list<size_t> begins,
+                              std::initializer_list<size_t> shapes) {
+        return tensor(this, begins, shapes);
+    }
+
+    ~tensor() {
+        if (parent_ == nullptr) {
+            delete[] data_.data();
+        }
+    }
+
+  private:
+    tensor(tensor<T, Loc> *parent, std::vector<size_t> begins,
+           std::vector<size_t> shapes)
+        : parent_(parent),
+          dims_(shapes.begin(), shapes.end()),
+          strides_(parent->strides().begin(), parent->strides().end()) {
+        size_ = compute_size(shapes);
+        strides_ = parent->strides();
+        data_ = parent->data_.subspan(offset(strides_, begins));
+    }
+
+    gsl::span<T> data_;
+    void *parent_;
+    dims_t dims_;
+    strides_t strides_;
+    std::size_t size_;
+};
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/thread_context.h b/modules/cpu/src/runtime/cmodel/include/thread_context.h
new file mode 100644
index 0000000000..22c76fbc78
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/thread_context.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstddef>
+
+class thread_context {
+  public:
+    thread_context(size_t bid, size_t tid) : bid_(bid), tid_(tid) {}
+
+    size_t bid() noexcept { return bid_; }
+
+    size_t tid() noexcept { return tid_; }
+
+  private:
+    size_t bid_;
+    size_t tid_;
+};
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/src/cpu_cmodel.cpp b/modules/cpu/src/runtime/cmodel/src/cpu_cmodel.cpp
new file mode 100644
index 0000000000..1201fd8a01
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/src/cpu_cmodel.cpp
@@ -0,0 +1,58 @@
+#include <hardware_context.h>
+#include <nncase/compiler_defs.h>
+#include <tdma.h>
+
+namespace block0 {
+namespace thread0 {}
+namespace thread1 {}
+namespace thread2 {}
+namespace thread3 {}
+} // namespace block0
+namespace block1 {
+namespace thread0 {}
+namespace thread1 {}
+namespace thread2 {}
+namespace thread3 {}
+} // namespace block1
+namespace block2 {
+namespace thread0 {}
+namespace thread1 {}
+namespace thread2 {}
+namespace thread3 {}
+} // namespace block2
+namespace block3 {
+namespace thread0 {}
+namespace thread1 {}
+namespace thread2 {}
+namespace thread3 {}
+} // namespace block3
+namespace block4 {
+namespace thread0 {}
+namespace thread1 {}
+namespace thread2 {}
+namespace thread3 {}
+} // namespace block4
+namespace block5 {
+namespace thread0 {}
+namespace thread1 {}
+namespace thread2 {}
+namespace thread3 {}
+} // namespace block5
+namespace block6 {
+namespace thread0 {}
+namespace thread1 {}
+namespace thread2 {}
+namespace thread3 {}
+} // namespace block6
+namespace block7 {
+namespace thread0 {}
+namespace thread1 {}
+namespace thread2 {}
+namespace thread3 {}
+} // namespace block7
+
+int main(NNCASE_UNUSED int argc, NNCASE_UNUSED char **argv) {
+    // std::array<size_t, 3> shape = {3, 2, 4};
+
+    return 0;
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp b/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
new file mode 100644
index 0000000000..5c0c3ec175
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
@@ -0,0 +1,113 @@
+#include <hardware_context.h>
+#include <hardware_def.h>
+#include <pthread.h>
+
+class condition_variable {
+  public:
+    condition_variable() {
+        pthread_cond_init(&cond, NULL);
+        pthread_mutex_init(&mutex, NULL);
+    }
+
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+};
+
+struct hardware_context_impl {
+  public:
+    hardware_context_impl() {
+        global_cond = condition_variable();
+        pthread_mutex_init(&global_mutex, NULL);
+
+        for (size_t i = 0; i < BLOCKS; i++) {
+            pthread_mutex_init(&block_mutexs[i], NULL);
+            block_conds[i] = condition_variable();
+            for (size_t j = 0; j < CORES; j++) {
+                block_visited[i][j] = false;
+                global_visited[i][j] = false;
+            }
+        }
+    }
+
+    void reset_block_visited(int bid) {
+        for (size_t i = 0; i < CORES; i++) {
+            block_visited[bid][i] = false;
+        }
+    }
+
+    void reset_global_visited() {
+        for (size_t i = 0; i < BLOCKS; i++) {
+            for (size_t j = 0; j < CORES; j++) {
+                global_visited[i][j] = false;
+            }
+        }
+    }
+
+    pthread_mutex_t global_mutex;
+    condition_variable global_cond;
+    bool global_visited[BLOCKS][CORES];
+    pthread_mutex_t block_mutexs[BLOCKS];
+    condition_variable block_conds[BLOCKS];
+    bool block_visited[BLOCKS][CORES];
+};
+
+hardware_context::hardware_context() {
+    impl_ = std::make_unique<hardware_context_impl>();
+}
+
+void hardware_context::lock_block(int bid) {
+    pthread_mutex_lock(&impl_->block_mutexs[bid]);
+}
+
+void hardware_context::unlock_block(int bid) {
+    pthread_mutex_unlock(&impl_->block_mutexs[bid]);
+}
+
+int hardware_context::mark_block_visit(int bid, int tid) {
+    impl_->block_visited[bid][tid] = true;
+    int visited = 0;
+    for (size_t i = 0; i < CORES; i++) {
+        visited += impl_->block_visited[bid][i] == true ? 1 : 0;
+    }
+    return visited;
+}
+
+void hardware_context::wait_block_sync(int bid, int visited) {
+    pthread_mutex_lock(&impl_->block_conds[bid].mutex);
+    if (visited == CORES) {
+        impl_->reset_block_visited(bid);
+        pthread_cond_broadcast(&impl_->block_conds[bid].cond);
+    } else {
+        pthread_cond_wait(&impl_->block_conds[bid].cond,
+                          &impl_->block_conds[bid].mutex);
+    }
+    pthread_mutex_unlock(&impl_->block_conds[bid].mutex);
+}
+
+void hardware_context::lock_all() { pthread_mutex_lock(&impl_->global_mutex); }
+
+void hardware_context::unlock_all() {
+    pthread_mutex_unlock(&impl_->global_mutex);
+}
+
+int hardware_context::mark_all_visit(int bid, int tid) {
+    impl_->global_visited[bid][tid] = true;
+    int visited = 0;
+    for (size_t i = 0; i < BLOCKS; i++) {
+        for (size_t j = 0; j < CORES; j++) {
+            visited += impl_->global_visited[i][j] == true ? 1 : 0;
+        }
+    }
+    return visited;
+}
+
+void hardware_context::wait_all_sync(int visited) {
+    pthread_mutex_lock(&impl_->global_cond.mutex);
+    if (visited == BLOCKS * CORES) {
+        impl_->reset_global_visited();
+        pthread_cond_broadcast(&impl_->global_cond.cond);
+    } else {
+        pthread_cond_wait(&impl_->global_cond.cond, &impl_->global_cond.mutex);
+    }
+    pthread_mutex_unlock(&impl_->global_cond.mutex);
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
new file mode 100644
index 0000000000..6e91f7e9ea
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -0,0 +1,100 @@
+// llama 65B
+// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
+// 1 chips, 8 blocks per chip, 4 threads per block
+
+// tensor<float, tensor_loc_t::shared> X({384, 8192});
+// tensor<float, tensor_loc_t::shared> kh({8, 384, 128}), vh({8, 384, 128}); //
+// [8, 384, 128] tensor<float, tensor_loc_t::shared> qkh({8, 384, 384});    //
+// [8, 384, 384] tensor<float, tensor_loc_t::shared> qkh({8, 384, 384});    //
+// [8, 384, 384]
+using namespace shared;
+
+static bool w_loaded = false;
+static tensor<float> wqh({8, 2048, 128});
+static tensor<float> wkh({8, 2048, 128});
+static tensor<float> wvh({8, 2048, 128}); // [8, 2048, 128]
+static tensor<float> wfc1ih({1024, 2752});
+static tensor<float> wfc2ih({1024, 2752}); // [1024, 2752]
+static tensor<float> yih({96, 1024});
+
+// 8 head per block
+// 2048 w-len per thread
+void stage1_kernel(tensor<float, tensor_loc_t::device> &WQ,  /* 64, 8192, 128 */
+                   tensor<float, tensor_loc_t::device> &WK,  /* 64, 8192, 128 */
+                   tensor<float, tensor_loc_t::device> &WV,  /* 64, 8192, 128 */
+                   tensor<float, tensor_loc_t::device> &WFC1 /* 384, 8192*/
+) {
+    // 1. Get xi
+    auto xi = X({0, tid * 2048}, {384, 2048}); // [384, 2048]
+
+    // 2. load wqh wkh wvh
+    if (!w_loaded) {
+        tdma_load_async(wqh, WQ({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
+        tdma_load_async(wkh, WK({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
+        tdma_load_async(wvh, WV({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
+        tdma_load_async(wfc1ih, WFC1({bid * 1024, tid * 8192}, {1024, 8192}));
+        tdma_wait(); // 等待 x, wqh, wkh, wvh ready
+        w_loaded = true;
+    }
+
+    // 3. compute k, v
+    // set_sched_strategy(
+    //     sched_strategy_t::pin_block_tensor); // 仅在 block 内调度线程的
+    //     tensor
+    //                                          // 指令
+
+    // tensor_block_mma_sync(
+    //     xi, wkh,
+    //     shared::kh); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
+    // vh = tensor_block_mma_sync(
+    //     xi, wvh); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
+
+    // // 4. compute qk
+    // tensor<float> qih({8, 384, 128});
+    // qih = tensor_mma_sync(
+    //     xi, wqh); // [384, 2048] x [8, 2048, 128] = [8, 384, 128]
+    // qkh = tensor_block_mma_sync(
+    //     qih, kh.T); // [8, 384, 128] x [8, 128, 384] = [8, 384, 384]
+
+    // set_sched_strategy(sched_strategy_t::normal);
+}
+
+// // 8 head per block
+// // 96 seq-len per thread
+// void stage2_kernel() {
+//     // 5. compute softmax
+//     auto qkhi = qkh({bid * 8, tid * 96, 0}, {8, 96, 384});
+
+//     tensor<float, 8, 96, 384> sih;
+//     sih = softmax(qkhi, 2);
+
+//     // 6. compute y
+//     tensor<float, 8, 96, 128> yihT;
+//     yihT = __tensor_mma_sync(sih,
+//                              vh); // [8, 96, 384] x [8, 384, 128] = [8, 96,
+//                              128]
+//     // 下面的 transpose 可以在计算 yih 的过程中通过指定输出 stride
+//     // 无代价地做到。
+//     yih = reshape(transpose(yihT, {1, 0, 2}) /* [96, 8, 128] */,
+//                   {96, 1024}); // [96, 1024]
+
+//     // 7. Add and sum & sqr
+//     tensor<float, 96> sum, sum_sqr;
+//     auto xi = X({tid * 96, bid * 1024}, {96, 1024}); // [96, 1024]
+//     yih = add_and_sum_sqr(yih, xi, sum, sum_sqr);
+//     __tdma_all_reduce_async(sum, sum_sqr,
+//                             reduce_op_t::SUM); // All blocks & threads reduce
+//     __tdma_wait();
+
+//     // 8. compute LayerNorm
+//     yih = layer_norm(yih, sum, sum_sqr); // [96, 1024]
+// }
+
+// //
+// void stage3_kernel(tensor<float> &WFC1, tensor<float> &WFC2) {
+//     // 9. fc1
+//     tensor<float> fc1ih({96, 2752});
+//     fc1ih =
+//         __tensor_mma_sync(yih, fc1ih); // [96, 1024] x [1024, 8192] = [96,
+//         8192]
+// }
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
new file mode 100644
index 0000000000..6775c08ec0
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
@@ -0,0 +1,76 @@
+#include <hardware_context.h>
+#include <nncase/compiler_defs.h>
+#include <tdma.h>
+
+namespace block0 {
+#include "shared_def.h"
+constexpr size_t bid = 0;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block0
+
+// namespace block1 {
+// namespace thread0 {}
+// namespace thread1 {}
+// namespace thread2 {}
+// namespace thread3 {}
+// } // namespace block1
+// namespace block2 {
+// namespace thread0 {}
+// namespace thread1 {}
+// namespace thread2 {}
+// namespace thread3 {}
+// } // namespace block2
+// namespace block3 {
+// namespace thread0 {}
+// namespace thread1 {}
+// namespace thread2 {}
+// namespace thread3 {}
+// } // namespace block3
+// namespace block4 {
+// namespace thread0 {}
+// namespace thread1 {}
+// namespace thread2 {}
+// namespace thread3 {}
+// } // namespace block4
+// namespace block5 {
+// namespace thread0 {}
+// namespace thread1 {}
+// namespace thread2 {}
+// namespace thread3 {}
+// } // namespace block5
+// namespace block6 {
+// namespace thread0 {}
+// namespace thread1 {}
+// namespace thread2 {}
+// namespace thread3 {}
+// } // namespace block6
+// namespace block7 {
+// namespace thread0 {}
+// namespace thread1 {}
+// namespace thread2 {}
+// namespace thread3 {}
+// } // namespace block7
+
+int main() {
+    tensor<float, tensor_loc_t::device> WQ({64, 8192, 128});
+    tensor<float, tensor_loc_t::device> WK({64, 8192, 128});
+    tensor<float, tensor_loc_t::device> WV({64, 8192, 128});
+    tensor<float, tensor_loc_t::device> WFC1({384, 8192});
+    block0::thread0::stage1_kernel(WQ, WK, WV, WFC1);
+    return 0;
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
new file mode 100644
index 0000000000..16f55bf71d
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
@@ -0,0 +1,9 @@
+#pragma once
+#include <tdma.h>
+
+namespace shared {
+static tensor<float, tensor_loc_t::shared> X({384, 8192});
+static tensor<float, tensor_loc_t::shared> kh({8, 384, 128}),
+    vh({8, 384, 128});                                         // [8, 384, 128]
+static tensor<float, tensor_loc_t::shared> qkh({8, 384, 384}); // [8, 384, 384]
+} // namespace shared
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/shared_memory.cpp b/modules/cpu/src/runtime/shared_memory.cpp
new file mode 100644
index 0000000000..9a26358e29
--- /dev/null
+++ b/modules/cpu/src/runtime/shared_memory.cpp
@@ -0,0 +1,125 @@
+/* Copyright 2020 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "shared_memory.h"
+#include <iostream>
+
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <cerrno>
+#include <cstring>
+#include <fcntl.h> // for O_* constants
+#include <sys/mman.h> // mmap, munmap
+#include <sys/stat.h> // for mode constants
+#include <unistd.h> // unlink
+#endif
+
+using namespace nncase;
+using namespace nncase::runtime;
+using namespace nncase::runtime::cpu;
+
+shared_memory::shared_memory(const std::filesystem::path &path, size_t size, shared_memory_openmode mode)
+    :
+#ifdef WIN32
+    handle_(nullptr)
+#else
+    fd_(-1)
+    , path_(path.c_str())
+#endif
+    , data_(nullptr)
+    , size_(size)
+{
+    if (mode == shared_memory_openmode::create)
+    {
+#ifdef WIN32
+        handle_ = CreateFileMappingW(nullptr, nullptr, PAGE_READWRITE, 0, (DWORD)size, path.c_str());
+        if (!handle_)
+            throw std::runtime_error("Failed to create shared memory.");
+#else
+        // shm segments persist across runs, and macOS will refuse
+        // to ftruncate an existing shm segment, so to be on the safe
+        // side, we unlink it beforehand.
+        // TODO(amos) check errno while ignoring ENOENT?
+        int ret = shm_unlink(path.c_str());
+        if (ret < 0)
+        {
+            if (errno != ENOENT)
+                throw std::runtime_error("Failed to unlink shared memory when create : " + std::string(std::strerror(errno)));
+        }
+
+        fd_ = shm_open(path.c_str(), O_CREAT | O_RDWR, 0755);
+        if (fd_ < 0)
+            throw std::runtime_error("Failed to open shared memory when create : " + std::string(std::strerror(errno)));
+
+        // this is the only way to specify the size of a
+        // newly-created POSIX shared memory object
+        ret = ftruncate(fd_, size);
+        if (ret != 0)
+            throw std::runtime_error("Failed to ftruncate shared memory when create : " + std::string(std::strerror(errno)) + " " + std::to_string(size_) + " " + std::to_string(fd_));
+#endif
+    }
+    else if (mode == shared_memory_openmode::open)
+    {
+#ifdef WIN32
+        handle_ = OpenFileMappingW(FILE_MAP_READ | FILE_MAP_WRITE, FALSE, path.c_str());
+        if (!handle_)
+            throw std::runtime_error("Failed to open shared memory.");
+#else
+        fd_ = shm_open(path.c_str(), O_RDWR, 0755);
+        if (fd_ < 0)
+            throw std::runtime_error("Failed to open shared memory.");
+#endif
+    }
+    else
+    {
+        throw std::runtime_error("Invalid shared memory openmode.");
+    }
+
+#ifdef WIN32
+    data_ = (gsl::byte *)MapViewOfFile(handle_, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, size);
+#else
+    auto memory = mmap(nullptr, // addr
+        size, // length
+        PROT_READ | PROT_WRITE, // prot
+        MAP_SHARED, // flags
+        fd_, // fd
+        0 // offset
+    );
+
+    if (memory == MAP_FAILED)
+        throw std::runtime_error("Failed to map shared memory.");
+    data_ = (gsl::byte *)memory;
+#endif
+}
+
+shared_memory ::~shared_memory()
+{
+    if (data_)
+    {
+#ifdef WIN32
+        UnmapViewOfFile(data_);
+#else
+        munmap(data_, size_);
+#endif
+    }
+
+#ifdef WIN32
+    CloseHandle(handle_);
+    handle_ = nullptr;
+#else
+    close(fd_);
+    shm_unlink(path_.c_str());
+#endif
+}
diff --git a/modules/cpu/src/runtime/shared_memory.h b/modules/cpu/src/runtime/shared_memory.h
new file mode 100644
index 0000000000..40701c867f
--- /dev/null
+++ b/modules/cpu/src/runtime/shared_memory.h
@@ -0,0 +1,51 @@
+/* Copyright 2020 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#include <filesystem>
+#include <nncase/runtime/cpu/compiler_defs.h>
+
+#ifdef WIN32
+#include <Windows.h>
+#endif
+
+BEGIN_NS_NNCASE_RT_MODULE(cpu)
+
+enum class shared_memory_openmode
+{
+    create,
+    open
+};
+
+class shared_memory
+{
+public:
+    shared_memory(const std::filesystem::path &path, size_t size, shared_memory_openmode mode);
+    ~shared_memory();
+
+    gsl::byte *data() noexcept { return data_; };
+    size_t size() const noexcept { return size_; }
+
+private:
+#ifdef WIN32
+    HANDLE handle_;
+#else
+    int fd_;
+    std::string path_;
+#endif
+    gsl::byte *data_;
+    size_t size_;
+};
+
+END_NS_NNCASE_RT_MODULE

From 3422bd88529c34bbffc7ef636d50fbc48a433454 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Tue, 15 Aug 2023 07:57:03 +0000
Subject: [PATCH 077/308] Apply code-format changes

---
 modules/cpu/src/runtime/shared_memory.cpp | 73 ++++++++++++-----------
 modules/cpu/src/runtime/shared_memory.h   | 16 ++---
 2 files changed, 44 insertions(+), 45 deletions(-)

diff --git a/modules/cpu/src/runtime/shared_memory.cpp b/modules/cpu/src/runtime/shared_memory.cpp
index 9a26358e29..bd402dcf09 100644
--- a/modules/cpu/src/runtime/shared_memory.cpp
+++ b/modules/cpu/src/runtime/shared_memory.cpp
@@ -20,31 +20,32 @@
 #else
 #include <cerrno>
 #include <cstring>
-#include <fcntl.h> // for O_* constants
+#include <fcntl.h>    // for O_* constants
 #include <sys/mman.h> // mmap, munmap
 #include <sys/stat.h> // for mode constants
-#include <unistd.h> // unlink
+#include <unistd.h>   // unlink
 #endif
 
 using namespace nncase;
 using namespace nncase::runtime;
 using namespace nncase::runtime::cpu;
 
-shared_memory::shared_memory(const std::filesystem::path &path, size_t size, shared_memory_openmode mode)
+shared_memory::shared_memory(const std::filesystem::path &path, size_t size,
+                             shared_memory_openmode mode)
     :
 #ifdef WIN32
-    handle_(nullptr)
+      handle_(nullptr)
 #else
-    fd_(-1)
-    , path_(path.c_str())
+      fd_(-1),
+      path_(path.c_str())
 #endif
-    , data_(nullptr)
-    , size_(size)
-{
-    if (mode == shared_memory_openmode::create)
-    {
+      ,
+      data_(nullptr),
+      size_(size) {
+    if (mode == shared_memory_openmode::create) {
 #ifdef WIN32
-        handle_ = CreateFileMappingW(nullptr, nullptr, PAGE_READWRITE, 0, (DWORD)size, path.c_str());
+        handle_ = CreateFileMappingW(nullptr, nullptr, PAGE_READWRITE, 0,
+                                     (DWORD)size, path.c_str());
         if (!handle_)
             throw std::runtime_error("Failed to create shared memory.");
 #else
@@ -53,27 +54,32 @@ shared_memory::shared_memory(const std::filesystem::path &path, size_t size, sha
         // side, we unlink it beforehand.
         // TODO(amos) check errno while ignoring ENOENT?
         int ret = shm_unlink(path.c_str());
-        if (ret < 0)
-        {
+        if (ret < 0) {
             if (errno != ENOENT)
-                throw std::runtime_error("Failed to unlink shared memory when create : " + std::string(std::strerror(errno)));
+                throw std::runtime_error(
+                    "Failed to unlink shared memory when create : " +
+                    std::string(std::strerror(errno)));
         }
 
         fd_ = shm_open(path.c_str(), O_CREAT | O_RDWR, 0755);
         if (fd_ < 0)
-            throw std::runtime_error("Failed to open shared memory when create : " + std::string(std::strerror(errno)));
+            throw std::runtime_error(
+                "Failed to open shared memory when create : " +
+                std::string(std::strerror(errno)));
 
         // this is the only way to specify the size of a
         // newly-created POSIX shared memory object
         ret = ftruncate(fd_, size);
         if (ret != 0)
-            throw std::runtime_error("Failed to ftruncate shared memory when create : " + std::string(std::strerror(errno)) + " " + std::to_string(size_) + " " + std::to_string(fd_));
+            throw std::runtime_error(
+                "Failed to ftruncate shared memory when create : " +
+                std::string(std::strerror(errno)) + " " +
+                std::to_string(size_) + " " + std::to_string(fd_));
 #endif
-    }
-    else if (mode == shared_memory_openmode::open)
-    {
+    } else if (mode == shared_memory_openmode::open) {
 #ifdef WIN32
-        handle_ = OpenFileMappingW(FILE_MAP_READ | FILE_MAP_WRITE, FALSE, path.c_str());
+        handle_ = OpenFileMappingW(FILE_MAP_READ | FILE_MAP_WRITE, FALSE,
+                                   path.c_str());
         if (!handle_)
             throw std::runtime_error("Failed to open shared memory.");
 #else
@@ -81,21 +87,20 @@ shared_memory::shared_memory(const std::filesystem::path &path, size_t size, sha
         if (fd_ < 0)
             throw std::runtime_error("Failed to open shared memory.");
 #endif
-    }
-    else
-    {
+    } else {
         throw std::runtime_error("Invalid shared memory openmode.");
     }
 
 #ifdef WIN32
-    data_ = (gsl::byte *)MapViewOfFile(handle_, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, size);
+    data_ = (gsl::byte *)MapViewOfFile(handle_, FILE_MAP_READ | FILE_MAP_WRITE,
+                                       0, 0, size);
 #else
-    auto memory = mmap(nullptr, // addr
-        size, // length
-        PROT_READ | PROT_WRITE, // prot
-        MAP_SHARED, // flags
-        fd_, // fd
-        0 // offset
+    auto memory = mmap(nullptr,                // addr
+                       size,                   // length
+                       PROT_READ | PROT_WRITE, // prot
+                       MAP_SHARED,             // flags
+                       fd_,                    // fd
+                       0                       // offset
     );
 
     if (memory == MAP_FAILED)
@@ -104,10 +109,8 @@ shared_memory::shared_memory(const std::filesystem::path &path, size_t size, sha
 #endif
 }
 
-shared_memory ::~shared_memory()
-{
-    if (data_)
-    {
+shared_memory ::~shared_memory() {
+    if (data_) {
 #ifdef WIN32
         UnmapViewOfFile(data_);
 #else
diff --git a/modules/cpu/src/runtime/shared_memory.h b/modules/cpu/src/runtime/shared_memory.h
index 40701c867f..b1eab116aa 100644
--- a/modules/cpu/src/runtime/shared_memory.h
+++ b/modules/cpu/src/runtime/shared_memory.h
@@ -22,22 +22,18 @@
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
-enum class shared_memory_openmode
-{
-    create,
-    open
-};
+enum class shared_memory_openmode { create, open };
 
-class shared_memory
-{
-public:
-    shared_memory(const std::filesystem::path &path, size_t size, shared_memory_openmode mode);
+class shared_memory {
+  public:
+    shared_memory(const std::filesystem::path &path, size_t size,
+                  shared_memory_openmode mode);
     ~shared_memory();
 
     gsl::byte *data() noexcept { return data_; };
     size_t size() const noexcept { return size_; }
 
-private:
+  private:
 #ifdef WIN32
     HANDLE handle_;
 #else

From aeda89efb658b685561ce599ea6d8cf5853e93d2 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 15 Aug 2023 16:26:55 +0800
Subject: [PATCH 078/308] fix namespace of lstm

---
 .../CodeGen/StackVM/CodeGenVisitor.g.cs             |  2 +-
 src/Nncase.Core/IR/RNN/Functional.cs                |  2 +-
 src/Nncase.Core/IR/RNN/LSTM.cs                      |  2 +-
 src/Nncase.Evaluator/RNN/LSTM.cs                    |  5 ++---
 .../Rules/Neutral/AddRangeOfAndMarker.cs            |  1 +
 .../Rewrite/Fusion/UnitTestFusionMaker.cs           | 13 ++++++-------
 src/Nncase.Tests/Rules/Neutral/UnitTestAddMarker.cs |  4 ++--
 7 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/modules/Nncase.Modules.StackVM/CodeGen/StackVM/CodeGenVisitor.g.cs b/modules/Nncase.Modules.StackVM/CodeGen/StackVM/CodeGenVisitor.g.cs
index f73d629c40..e31fc77e10 100644
--- a/modules/Nncase.Modules.StackVM/CodeGen/StackVM/CodeGenVisitor.g.cs
+++ b/modules/Nncase.Modules.StackVM/CodeGen/StackVM/CodeGenVisitor.g.cs
@@ -205,7 +205,7 @@ private void EmitTensorCall(Op op)
             case IR.Tensors.IndexOf top:
                 Emitter.T.IndexOf();
                 break;
-            case IR.Tensors.LSTM top:
+            case IR.RNN.LSTM top:
                 Emitter.T.LSTM(top.Direction, top.Layout, top.Activations);
                 break;
             case IR.Tensors.Prod top:
diff --git a/src/Nncase.Core/IR/RNN/Functional.cs b/src/Nncase.Core/IR/RNN/Functional.cs
index 07ebf7f8d6..571bb2141f 100644
--- a/src/Nncase.Core/IR/RNN/Functional.cs
+++ b/src/Nncase.Core/IR/RNN/Functional.cs
@@ -19,5 +19,5 @@ namespace Nncase.IR.F;
 public static class RNN
 {
     public static Call LSTM(LSTMDirection direction, LSTMLayout layout, string[] acts, Expr x, Expr w, Expr r, Expr b, Expr seqLens, Expr initH, Expr initC, Expr p, Expr actAlpha, Expr actBeta, Expr clip, Expr hiddenSize, Expr inputForget, Expr outputSize) =>
-        new Call(new IR.Tensors.LSTM(direction, layout, acts), x, w, r, b, seqLens, initH, initC, p, actAlpha, actBeta, clip, hiddenSize, inputForget, outputSize);
+        new Call(new IR.RNN.LSTM(direction, layout, acts), x, w, r, b, seqLens, initH, initC, p, actAlpha, actBeta, clip, hiddenSize, inputForget, outputSize);
 }
diff --git a/src/Nncase.Core/IR/RNN/LSTM.cs b/src/Nncase.Core/IR/RNN/LSTM.cs
index ec5b9802b3..4bdd60f223 100644
--- a/src/Nncase.Core/IR/RNN/LSTM.cs
+++ b/src/Nncase.Core/IR/RNN/LSTM.cs
@@ -5,7 +5,7 @@
 using Nncase.PatternMatch;
 using static Nncase.IR.TypePatternUtility;
 
-namespace Nncase.IR.Tensors;
+namespace Nncase.IR.RNN;
 
 /// <summary>
 /// LSTM expression.
diff --git a/src/Nncase.Evaluator/RNN/LSTM.cs b/src/Nncase.Evaluator/RNN/LSTM.cs
index 9abd5964e4..fc1d1f3daa 100644
--- a/src/Nncase.Evaluator/RNN/LSTM.cs
+++ b/src/Nncase.Evaluator/RNN/LSTM.cs
@@ -6,12 +6,11 @@
 using Nncase.CostModel;
 using Nncase.IR;
 
-// using Nncase.IR.NN;
-using Nncase.IR.Tensors;
+using Nncase.IR.RNN;
 using OrtKISharp;
 using static Nncase.LSTMHelper;
 
-namespace Nncase.Evaluator.NN;
+namespace Nncase.Evaluator.RNN;
 
 /// <summary>
 /// Evaluator for <see cref="LSTM"/>.
diff --git a/src/Nncase.Passes/Rules/Neutral/AddRangeOfAndMarker.cs b/src/Nncase.Passes/Rules/Neutral/AddRangeOfAndMarker.cs
index a53c2d3166..e59d473c7d 100644
--- a/src/Nncase.Passes/Rules/Neutral/AddRangeOfAndMarker.cs
+++ b/src/Nncase.Passes/Rules/Neutral/AddRangeOfAndMarker.cs
@@ -10,6 +10,7 @@
 using Nncase.IR.Imaging;
 using Nncase.IR.Math;
 using Nncase.IR.NN;
+using Nncase.IR.RNN;
 using Nncase.IR.Tensors;
 using Nncase.PatternMatch;
 using static Nncase.IR.TypePatternUtility;
diff --git a/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionMaker.cs b/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionMaker.cs
index 70259ef6eb..c3e4bac4c7 100644
--- a/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionMaker.cs
+++ b/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionMaker.cs
@@ -9,7 +9,7 @@
 using NetFabric.Hyperlinq;
 using Nncase.IR;
 using Nncase.IR.Math;
-using Nncase.IR.Tensors;
+using Nncase.IR.RNN;
 using Nncase.Passes;
 using Nncase.Passes.Analysis;
 using Nncase.Passes.Mutators;
@@ -20,9 +20,8 @@
 using Xunit;
 using Xunit.Abstractions;
 using static Nncase.IR.F.Math;
+using static Nncase.IR.F.RNN;
 using static Nncase.IR.F.Tensors;
-using static Nncase.IR.TypePatternUtility;
-using static Nncase.PatternMatch.F.Math;
 using static Nncase.PatternMatch.Utility;
 using Transpose = Nncase.IR.Tensors.Transpose;
 using Tuple = Nncase.IR.Tuple;
@@ -330,9 +329,9 @@ IR.Tuple WrapOutput(Call call)
         var newVar2 = newVars[2];
         var pairs = new[]
         {
-            (LSTM.X, (Expr)WrapInput(newVar0)),
-            (LSTM.InitialC, WrapInput(newVar1)),
-            (LSTM.InitialH, WrapInput(newVar2)),
+            (IR.RNN.LSTM.X, (Expr)WrapInput(newVar0)),
+            (IR.RNN.LSTM.InitialC, WrapInput(newVar1)),
+            (IR.RNN.LSTM.InitialH, WrapInput(newVar2)),
         };
         var expectLSTM = ReplaceUtility.ReplaceCallParams(lstm.Target, lstm.Arguments.ToArray(), pairs);
         var expectBody = WrapOutput(expectLSTM);
@@ -363,7 +362,7 @@ internal sealed class TestTransposeComplexFusion : ComplexFusion<Transpose, Quan
     internal sealed class LSTMFusion : ComplexFusion<LSTM, Quantize, Dequantize>
     {
         public override (ParameterInfo, CallPattern)[] InputPatterns { get; } =
-            GenerateInputPatterns(LSTM.X, LSTM.InitialC, LSTM.InitialH);
+            GenerateInputPatterns(IR.RNN.LSTM.X, IR.RNN.LSTM.InitialC, IR.RNN.LSTM.InitialH);
     }
 }
 
diff --git a/src/Nncase.Tests/Rules/Neutral/UnitTestAddMarker.cs b/src/Nncase.Tests/Rules/Neutral/UnitTestAddMarker.cs
index 74f6188c93..c705e5dac2 100644
--- a/src/Nncase.Tests/Rules/Neutral/UnitTestAddMarker.cs
+++ b/src/Nncase.Tests/Rules/Neutral/UnitTestAddMarker.cs
@@ -96,7 +96,7 @@ public async Task TestAddMarkerWithLstm()
         var module = new IRModule(main);
         await TestAddMarkerPasses(module);
         Assert.True(((Function)module.Entry!).Body is Tuple t
-                    && CompilerServices.TryMatchRoot(t, IsWrappedLSTM(PatternMatch.F.Tensors.IsLSTM("lstm", "lstmCall", _ => true), (x, _) => IsRangeOfMarker(x, IsWildcard())), out var result)
+                    && CompilerServices.TryMatchRoot(t, IsWrappedLSTM(PatternMatch.F.RNN.IsLSTM("lstm", "lstmCall", _ => true), (x, _) => IsRangeOfMarker(x, IsWildcard())), out var result)
                     && result["lstmCall"] is Call call
                     && new[] { 0, 1, 2, 5, 6 }.All(i => call.Arguments[i] is Marker));
     }
@@ -126,7 +126,7 @@ public async Task TestAddMarkerWithLstmInitHEqualsInitC()
         var module = new IRModule(main);
         await TestAddMarkerPasses(module);
         Assert.True(((Function)module.Entry!).Body is Tuple t
-                    && CompilerServices.TryMatchRoot(t, IsWrappedLSTM(PatternMatch.F.Tensors.IsLSTM("lstm", "lstmCall", _ => true), (x, _) => IsRangeOfMarker(x, IsWildcard())), out var result)
+                    && CompilerServices.TryMatchRoot(t, IsWrappedLSTM(PatternMatch.F.RNN.IsLSTM("lstm", "lstmCall", _ => true), (x, _) => IsRangeOfMarker(x, IsWildcard())), out var result)
                     && result["lstmCall"] is Call call
                     && new[] { 0, 1, 2, 5, 6 }.All(i => call.Arguments[i] is Marker));
     }

From 937bf6135d9d787db74319e246f7bf4a1a6b0300 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 15 Aug 2023 16:27:30 +0800
Subject: [PATCH 079/308] dump pattern

---
 src/Nncase.Core/CompilerServices.cs           |  21 ++
 src/Nncase.Core/Diagnostics/IDumpper.cs       |   2 +
 src/Nncase.Core/Diagnostics/NullDumpper.cs    |   5 +
 src/Nncase.Core/IR/IIRPrinterProvider.cs      |   8 +
 src/Nncase.Diagnostics/Diagnostics/Dumpper.cs |   6 +
 .../Diagnostics/IRPrinterProvider.cs          |  19 ++
 .../Diagnostics/PatternPrintVisitor.cs        | 245 ++++++++++++++++++
 .../Diagnostics/UnitTestDumpper.cs            |  11 +
 8 files changed, 317 insertions(+)
 create mode 100644 src/Nncase.Diagnostics/Diagnostics/PatternPrintVisitor.cs

diff --git a/src/Nncase.Core/CompilerServices.cs b/src/Nncase.Core/CompilerServices.cs
index 3cbaca536e..6147ad30eb 100644
--- a/src/Nncase.Core/CompilerServices.cs
+++ b/src/Nncase.Core/CompilerServices.cs
@@ -73,6 +73,14 @@ public interface ICompilerServicesProvider
     /// <param name="randConst">false for save const into bin.</param>
     public void DumpCSharpIR(Expr expr, string prefix, string dumpDir, bool randConst);
 
+    /// <summary>
+    /// dump the expr as csharp code.
+    /// </summary>
+    /// <param name="expr">expression.</param>
+    /// <param name="prefix">file prefix.</param>
+    /// <param name="dumpDir">file dump ir.</param>
+    public void DumpPatternIR(Expr expr, string prefix, string dumpDir);
+
     /// <summary>
     /// print ir type.
     /// </summary>
@@ -468,6 +476,15 @@ public static void DumpDotIR(Expr expr, string prefix, string dumpPath, bool dis
     public static void DumpCSharpIR(Expr expr, string prefix, string dumpDir, bool randConst = true) =>
       Provider.DumpCSharpIR(expr, prefix, dumpDir, randConst);
 
+    /// <summary>
+    /// dump the expr as csharp code.
+    /// </summary>
+    /// <param name="expr">expression.</param>
+    /// <param name="prefix">file prefix.</param>
+    /// <param name="dumpDir">file dump ir.</param>
+    public static void DumpPatternIR(Expr expr, string prefix, string dumpDir) =>
+      Provider.DumpPatternIR(expr, prefix, dumpDir);
+
     public static string Print(IRType type) => Provider.Print(type);
 
     public static string Print(Expr expr, bool useScript = false) => Provider.Print(expr, useScript);
@@ -583,6 +600,10 @@ public void DumpDotIR(Expr expr, string prefix, string dumpPath, bool display_ca
     public void DumpCSharpIR(Expr expr, string prefix, string dumpDir, bool randConst) =>
     _irprinterProvider.DumpCSharpIR(expr, prefix, dumpDir, randConst);
 
+    /// <inheritdoc/>
+    public void DumpPatternIR(Expr expr, string prefix, string dumpDir) =>
+    _irprinterProvider.DumpPatternIR(expr, prefix, dumpDir);
+
     /// <inheritdoc/>
     public string Print(IRType type) => _irprinterProvider.Print(type);
 
diff --git a/src/Nncase.Core/Diagnostics/IDumpper.cs b/src/Nncase.Core/Diagnostics/IDumpper.cs
index 0e07109232..cc84bf46cb 100644
--- a/src/Nncase.Core/Diagnostics/IDumpper.cs
+++ b/src/Nncase.Core/Diagnostics/IDumpper.cs
@@ -42,6 +42,8 @@ public interface IDumpper
 
     void DumpCSharpIR(Expr expr, string prefix, string? reletivePath = null);
 
+    void DumpPatternIR(Expr expr, string prefix, string? reletivePath = null);
+
     void DumpModule(IRModule module, string? reletivePath = null);
 
     Stream OpenFile(string reletivePath, FileMode fileMode = FileMode.Create);
diff --git a/src/Nncase.Core/Diagnostics/NullDumpper.cs b/src/Nncase.Core/Diagnostics/NullDumpper.cs
index 7212fc7686..3120fa25e5 100644
--- a/src/Nncase.Core/Diagnostics/NullDumpper.cs
+++ b/src/Nncase.Core/Diagnostics/NullDumpper.cs
@@ -46,6 +46,11 @@ public void DumpCSharpIR(Expr expr, string prefix, string? reletivePath = null)
     {
     }
 
+    /// <inheritdoc/>
+    public void DumpPatternIR(Expr expr, string prefix, string? reletivePath = null)
+    {
+    }
+
     /// <inheritdoc/>
     public bool IsEnabled(DumpFlags dumpFlags) => false;
 
diff --git a/src/Nncase.Core/IR/IIRPrinterProvider.cs b/src/Nncase.Core/IR/IIRPrinterProvider.cs
index 3c267771df..f411167f2a 100644
--- a/src/Nncase.Core/IR/IIRPrinterProvider.cs
+++ b/src/Nncase.Core/IR/IIRPrinterProvider.cs
@@ -73,6 +73,14 @@ public interface IIRPrinterProvider
     /// <param name="randConst">randConst = false will save the const into bin.</param>
     public void DumpCSharpIR(Expr expr, string prefix, string dumpDir, bool randConst);
 
+    /// <summary>
+    /// dump the expr as csharp code.
+    /// </summary>
+    /// <param name="expr">expression.</param>
+    /// <param name="prefix">file prefix.</param>
+    /// <param name="dumpDir">file dump ir.</param>
+    public void DumpPatternIR(Expr expr, string prefix, string dumpDir);
+
     /// <summary>
     /// print ir type.
     /// </summary>
diff --git a/src/Nncase.Diagnostics/Diagnostics/Dumpper.cs b/src/Nncase.Diagnostics/Diagnostics/Dumpper.cs
index 399ba10b28..8bd3794074 100644
--- a/src/Nncase.Diagnostics/Diagnostics/Dumpper.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/Dumpper.cs
@@ -52,6 +52,12 @@ public void DumpCSharpIR(Expr expr, string prefix, string? reletivePath = null)
         CompilerServices.DumpCSharpIR(expr, prefix, EnsureWritable(path));
     }
 
+    public void DumpPatternIR(Expr expr, string prefix, string? reletivePath = null)
+    {
+        var path = Path.Join(_dumpDirectory, reletivePath);
+        CompilerServices.DumpPatternIR(expr, prefix, EnsureWritable(path));
+    }
+
     public void DumpModule(IRModule module, string? reletivePath = null)
     {
         foreach (var func in module.Functions)
diff --git a/src/Nncase.Diagnostics/Diagnostics/IRPrinterProvider.cs b/src/Nncase.Diagnostics/Diagnostics/IRPrinterProvider.cs
index d396e9de74..9d2b7c87a9 100644
--- a/src/Nncase.Diagnostics/Diagnostics/IRPrinterProvider.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/IRPrinterProvider.cs
@@ -102,6 +102,25 @@ public void DumpCSharpIR(Expr expr, string prefix, string dumpDir, bool randCons
         }
     }
 
+    /// <inheritdoc/>
+    public void DumpPatternIR(Expr expr, string prefix, string dumpDir)
+    {
+        var nprefix = prefix.Any() ? prefix + "_" : prefix;
+        string ext = "cs";
+        string name = expr is Callable c ? c.Name : expr.GetType().Name;
+        string file_path = Path.Combine(dumpDir, $"{nprefix}{name}.{ext}");
+        if (string.IsNullOrEmpty(dumpDir))
+        {
+            throw new ArgumentException("The dumpDir Is Empty!");
+        }
+
+        Directory.CreateDirectory(dumpDir);
+
+        using var dumpFile = File.Open(file_path, FileMode.Create);
+        using var dumpWriter = new StreamWriter(dumpFile);
+        new PatternPrintVisitor(dumpWriter, 0).Visit(expr);
+    }
+
     /// <inheritdoc/>
     public string Print(IRType type)
     {
diff --git a/src/Nncase.Diagnostics/Diagnostics/PatternPrintVisitor.cs b/src/Nncase.Diagnostics/Diagnostics/PatternPrintVisitor.cs
new file mode 100644
index 0000000000..caeb52b7c2
--- /dev/null
+++ b/src/Nncase.Diagnostics/Diagnostics/PatternPrintVisitor.cs
@@ -0,0 +1,245 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using NetFabric.Hyperlinq;
+using Nncase.IR;
+using Nncase.IR.Math;
+using Nncase.TIR;
+using Nncase.Utilities;
+
+namespace Nncase.Diagnostics;
+
+internal sealed class PatternPrintVisitor : ExprFunctor<string, string>
+{
+    private readonly ScopeWriter _scope;
+    private readonly Dictionary<Expr, string> _names = new Dictionary<Expr, string>(ReferenceEqualityComparer.Instance);
+    private int _localId;
+
+    public PatternPrintVisitor(TextWriter textWriter, int indentLevel)
+    {
+        _scope = new(textWriter, indentLevel);
+    }
+
+    /// <inheritdoc/>
+    public override string VisitType(AnyType type) => "any";
+
+    /// <inheritdoc/>
+    public override string VisitType(CallableType type) =>
+        $"({string.Join(", ", type.Parameters.Select(VisitType))}) -> {VisitType(type.ReturnType)}";
+
+    /// <inheritdoc/>
+    public override string VisitType(InvalidType type) => $"invalid:{type.Reason}";
+
+    /// <inheritdoc/>
+    public override string VisitType(NoneType type) => $"";
+
+    /// <inheritdoc/>
+    public override string VisitType(TensorType type) => type.DType switch
+    {
+        PrimType ptype => ptype.GetDisplayName() + (type.Shape.IsScalar ? string.Empty : type.Shape.ToString()),
+        PointerType { ElemType: PrimType etype } ptype => $"*{etype.GetDisplayName()}",
+        ValueType => $"{type.DType.ToString()}",
+        _ => throw new NotSupportedException(type.DType.GetType().Name),
+    };
+
+    /// <inheritdoc/>
+    public override string VisitType(TupleType type) =>
+        $"({string.Join(", ", type.Fields.Select(VisitType))})";
+
+    /// <inheritdoc/>
+    protected override string VisitCall(Call expr)
+    {
+        if (_names.TryGetValue(expr, out var name))
+        {
+            return name;
+        }
+
+        var target = Visit(expr.Target);
+        var args = expr.Arguments.AsValueEnumerable().Select(Visit).ToArray();
+        name = AllocateTempVar(expr);
+        _scope.IndWrite($"var {name} = IsCall(\"{name}\", IsOp<{expr.Target.GetType().Name}>(), IsVArgs({string.Join(",", args)}));\n");
+
+        // AppendCheckedType(expr.CheckedType);
+        return name;
+    }
+
+    /// <inheritdoc/>
+    protected override string VisitConst(Const expr)
+    {
+        if (_names.TryGetValue(expr, out var name))
+        {
+            return name;
+        }
+
+        name = AllocateTempVar(expr);
+        _scope.IndWrite($"var {name} = IsTensorConst(\"{name}\");\n");
+        return name;
+    }
+
+    /// <inheritdoc/>
+    protected override string VisitFunction(Function expr)
+    {
+        if (_names.TryGetValue(expr, out var name))
+        {
+            return name;
+        }
+
+        name = AllocateTempVar(expr);
+        _scope.Push();
+
+        // 1. functionv var
+        _scope.IndWrite($"Function {name}");
+        AppendCheckedType(expr.CheckedType);
+
+        // 2. Function body
+        _scope.IndWriteLine("{");
+        using (_scope.IndentUp())
+        {
+            var body = Visit(expr.Body);
+
+            // _scope.IndWriteLine($"{name} = new Function(\"{expr.Name}\", {body}, new Var[] {{{StringUtility.Join(", ", expr.Parameters.AsValueEnumerable().Select(Visit))}}});");
+        }
+
+        // 3. Function signature
+        _scope.IndWriteLine("}");
+        _scope.Append(_scope.Pop());
+        return name;
+    }
+
+    protected override string VisitFusion(Fusion expr)
+    {
+        if (_names.TryGetValue(expr, out var name))
+        {
+            return name;
+        }
+
+        name = AllocateTempVar(expr);
+
+        _scope.IndWrite($"Fusion {name}");
+        AppendCheckedType(expr.CheckedType);
+        _scope.Push();
+        _scope.IndWriteLine("{");
+        using (_scope.IndentUp())
+        {
+            var body_builder = new StringBuilder();
+            string body;
+            using (var body_writer = new StringWriter(body_builder))
+            {
+                var visitor = new PatternPrintVisitor(body_writer, _scope.IndentLevel) { _localId = _localId };
+                body = visitor.Visit(expr.Body);
+                _scope.Append(body_writer.ToString());
+            }
+
+            _scope.IndWriteLine($"{name} = new Fusion(\"{expr.Name}\", \"{expr.ModuleKind}\", {body}, new Var[] {{{StringUtility.Join(", ", expr.Parameters.AsValueEnumerable().Select(Visit))}}});");
+        }
+
+        _scope.IndWriteLine("}");
+        _scope.Append(_scope.Pop());
+        return name;
+    }
+
+    /// <inheritdoc/>
+    protected override string VisitOp(Op expr)
+    {
+        if (_names.TryGetValue(expr, out var name))
+        {
+            return name;
+        }
+
+        name = $"new {expr.GetType().Name}({expr.DisplayProperty()})";
+        _names.Add(expr, name);
+        return name;
+    }
+
+    /// <inheritdoc/>
+    protected override string VisitTuple(IR.Tuple expr)
+    {
+        if (_names.TryGetValue(expr, out var name))
+        {
+            return name;
+        }
+
+        var fields = expr.Fields.AsValueEnumerable().Select(Visit).ToArray();
+        name = AllocateTempVar(expr);
+        _scope.IndWrite($"var {name} = IsTuple(\"{name}\", IsVArgs({string.Join(",", fields)}));\n");
+
+        // AppendCheckedType(expr.CheckedType);
+        _scope.IndWriteLine();
+        return name;
+    }
+
+    /// <inheritdoc/>
+    protected override string VisitVar(Var expr)
+    {
+        if (_names.TryGetValue(expr, out var name))
+        {
+            return name;
+        }
+
+        name = AllocateTempVar(expr);
+        _scope.IndWriteLine($"var {name} = IsWildcard(\"{expr.Name}\");\n");
+        return name;
+    }
+
+    /// <inheritdoc/>
+    protected override string VisitNone(None expr)
+    {
+        if (_names.TryGetValue(expr, out var name))
+        {
+            return name;
+        }
+
+        name = $"None.Default";
+        _names.Add(expr, name);
+        return name;
+    }
+
+    /// <inheritdoc/>
+    protected override string VisitMarker(Marker expr)
+    {
+        if (_names.TryGetValue(expr, out var name))
+        {
+            return name;
+        }
+
+        var target = Visit(expr.Target);
+        var attr = Visit(expr.Attribute);
+        name = AllocateTempVar(expr);
+        _scope.IndWrite($"var {name} = new Marker(\"{expr.Name}\",{target},{attr})");
+        AppendCheckedType(expr.CheckedType);
+        return name;
+    }
+
+    private string AllocateTempVar(Expr expr)
+    {
+        var name = $"v{_localId++}";
+        _names.Add(expr, name);
+        return name;
+    }
+
+    private void AppendCheckedType(IRType? type, string end = "", bool hasNewLine = true)
+    {
+        if (type is not null)
+        {
+            if (hasNewLine)
+            {
+                _scope.AppendLine($"; // {VisitType(type)}{end}");
+            }
+            else
+            {
+                _scope.Append($"; // {VisitType(type)}{end}");
+            }
+        }
+        else
+        {
+            _scope.Append(";\n");
+        }
+    }
+}
diff --git a/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs b/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
index 9e2f0f3a44..408a625058 100644
--- a/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
+++ b/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
@@ -194,6 +194,17 @@ public void TestDumperCSharpIRFunction()
         CompilerServices.DumpCSharpIR(main, string.Empty, Dumpper.Directory);
     }
 
+    [Fact]
+    public void TestDumperPatternIRFunction()
+    {
+        var x = IR.F.Math.Quantize(IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, new[] { 1, 2, 2, 2 }), new QuantParam(1, 2.0f), DataTypes.UInt8);
+        var y = new Var("y", new TensorType(DataTypes.UInt8, new int[] { 1, 2, 2, 2 }));
+        var z = IR.F.Random.Normal(DataTypes.UInt8, 0, 1, 0, new[] { 1, 2, 2, 2 });
+        var m = IR.F.Random.Normal(DataTypes.UInt8, 0, 1, 0, new[] { 1, 20, 2, 2 });
+        var main = new Function("main", IR.F.Tensors.Concat(new IR.Tuple(new Expr[] { x, y, z, m }), 1), new[] { y });
+        CompilerServices.DumpPatternIR(main, string.Empty, Dumpper.Directory);
+    }
+
     [Fact]
     public void TestDumperCSharpIRFusion()
     {

From 1f7ab49a04d32689d503e04fc384df4a4c36a737 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 15 Aug 2023 16:28:53 +0800
Subject: [PATCH 080/308] fuse MHA of bert

---
 .../Passes/Rules/MHAFusion.cs                 | 92 +++++++++++++++++++
 src/Nncase.Compiler/Compiler.cs               |  5 +
 src/Nncase.Core/IR/Fusion.cs                  | 12 +++
 3 files changed, 109 insertions(+)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
new file mode 100644
index 0000000000..476b9ab2e1
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -0,0 +1,92 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.CPU;
+using Nncase.IR.Math;
+using Nncase.IR.NN;
+using Nncase.IR.Tensors;
+using Nncase.Passes.Rules.Neutral;
+using Nncase.PatternMatch;
+using Nncase.Targets;
+using static Nncase.PatternMatch.F.Tensors;
+using static Nncase.PatternMatch.Utility;
+using static Nncase.Utilities.ReplaceUtility;
+
+namespace Nncase.Passes.Rules;
+
+// pattern from BERT
+[RuleGenerator]
+public sealed partial class FuseMHA1 : FusionMaker
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern => CreatePattern();
+
+    private static Pattern CreatePattern()
+    {
+        var v0 = IsTensorConst("v0");
+        var v1 = IsTensorConst("v1");
+        var v2 = IsWildcard("x");
+
+        var v3 = IsTensorConst("v3");
+        var v4 = IsCall("v4", IsOp<MatMul>(), IsVArgs(v2, v3));
+        var v5 = IsCall("v5", IsOp<Binary>(), IsVArgs(v1, v4));
+        var v6 = IsTensorConst("v6");
+        var v7 = IsCall("v7", IsOp<Reshape>(), IsVArgs(v5, v6));
+        var v8 = IsTensorConst("v8");
+        var v9 = IsCall("v9", IsOp<Transpose>(), IsVArgs(v7, v8));
+        var v10 = IsTensorConst("v10");
+        var v11 = IsTensorConst("v11");
+        var v12 = IsCall("v12", IsOp<MatMul>(), IsVArgs(v2, v11));
+        var v13 = IsCall("v13", IsOp<Binary>(), IsVArgs(v10, v12));
+        var v14 = IsCall("v14", IsOp<Reshape>(), IsVArgs(v13, v6));
+        var v15 = IsTensorConst("v15");
+        var v16 = IsCall("v16", IsOp<Transpose>(), IsVArgs(v14, v15));
+        var v17 = IsCall("v17", IsOp<MatMul>(), IsVArgs(v9, v16));
+        var v18 = IsTensorConst("v18");
+        var v19 = IsCall("v19", IsOp<Binary>(), IsVArgs(v17, v18));
+        var v20 = IsWildcard("mask");
+
+        var v21 = IsCall("v21", IsOp<Binary>(), IsVArgs(v19, v20));
+        var v22 = IsTensorConst("v22");
+        var v23 = IsCall("v23", IsOp<Reshape>(), IsVArgs(v21, v22));
+        var v24 = IsTensorConst("v24");
+        var v25 = IsCall("v25", IsOp<Softmax>(), IsVArgs(v23, v24));
+        var v26 = IsTensorConst("v26");
+        var v27 = IsCall("v27", IsOp<Reshape>(), IsVArgs(v25, v26));
+        var v28 = IsTensorConst("v28");
+        var v29 = IsTensorConst("v29");
+        var v30 = IsCall("v30", IsOp<MatMul>(), IsVArgs(v2, v29));
+        var v31 = IsCall("v31", IsOp<Binary>(), IsVArgs(v28, v30));
+        var v32 = IsCall("v32", IsOp<Reshape>(), IsVArgs(v31, v6));
+        var v33 = IsCall("v33", IsOp<Transpose>(), IsVArgs(v32, v8));
+        var v34 = IsCall("v34", IsOp<MatMul>(), IsVArgs(v27, v33));
+        var v35 = IsCall("v35", IsOp<Transpose>(), IsVArgs(v34, v8));
+        var v36 = IsTensorConst("v36");
+        var v37 = IsCall("v37", IsOp<Reshape>(), IsVArgs(v35, v36));
+        var v38 = IsTensorConst("v38");
+        var v39 = IsCall("v39", IsOp<MatMul>(), IsVArgs(v37, v38));
+        var v40 = IsCall("v40", IsOp<Binary>(), IsVArgs(v0, v39));
+        var v41 = IsCall("v41", IsOp<Binary>(), IsVArgs(v40, v2));
+        var v42 = IsTensorConst("v42");
+        var v43 = IsTensorConst("v43");
+        var v44 = IsCall("ln", IsOp<LayerNorm>(), IsVArgs(v41, v42, v43));
+        return v44;
+    }
+
+    private Call? GetReplace(Call ln, Expr x, Expr mask)
+    {
+        var newInputs = new List<Expr>();
+        newInputs.Add(new Var(x.CheckedType!));
+        newInputs.Add(new Var(mask.CheckedType!));
+
+        var callFusion = new Call(new Fusion("MHA1", $"{ln.Target.GetType().Name}", "cpu", ln, newInputs.OfType<Var>().ToArray()), x, mask);
+        return callFusion;
+    }
+}
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index db653f4962..2033276712 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -148,6 +148,11 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.Neutral.SpaceToBatchToPad>();
         });
 
+        passManager.AddWithName<DataflowPass>("MHAFusion").Configure(p =>
+        {
+            // p.Add<Passes.Rules.FuseMHA1>();
+        });
+
         // passManager.AddWithName<EGraphPass>("NeutralOptimizeClamp").Configure(p =>
         // {
         //     p.Add<Passes.Rules.Neutral.FoldConstCall>();
diff --git a/src/Nncase.Core/IR/Fusion.cs b/src/Nncase.Core/IR/Fusion.cs
index c42800523f..d1a8b71aa7 100644
--- a/src/Nncase.Core/IR/Fusion.cs
+++ b/src/Nncase.Core/IR/Fusion.cs
@@ -41,6 +41,16 @@ public Fusion(string name, string moduleKind, Expr body, params Var[] parameters
     {
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Fusion"/> class.
+    /// build function.
+    /// </summary>
+    public Fusion(string type, string name, string moduleKind, Expr body, params Var[] parameters)
+        : base(name, moduleKind, ArrayUtility.Concat(body, SpanUtility.UnsafeCast<Var, Expr>(parameters)))
+    {
+        FusionType = type;
+    }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="Fusion"/> class.
     /// build function.
@@ -50,6 +60,8 @@ public Fusion(string moduleKind, Expr body, params Var[] parameters)
     {
     }
 
+    public string? FusionType { get; }
+
     public Expr Body => Operands[0];
 
     public ReadOnlySpan<Var> Parameters => SpanUtility.UnsafeCast<Expr, Var>(Operands[1..]);

From 5ffcd0ca94948b48f0ccc1921cb2d6d2d446d117 Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Tue, 15 Aug 2023 08:32:05 +0000
Subject: [PATCH 081/308] Apply code-format changes

---
 src/Nncase.Diagnostics/Diagnostics/PatternPrintVisitor.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Nncase.Diagnostics/Diagnostics/PatternPrintVisitor.cs b/src/Nncase.Diagnostics/Diagnostics/PatternPrintVisitor.cs
index caeb52b7c2..3b8d5df531 100644
--- a/src/Nncase.Diagnostics/Diagnostics/PatternPrintVisitor.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/PatternPrintVisitor.cs
@@ -44,7 +44,7 @@ public override string VisitType(CallableType type) =>
     public override string VisitType(TensorType type) => type.DType switch
     {
         PrimType ptype => ptype.GetDisplayName() + (type.Shape.IsScalar ? string.Empty : type.Shape.ToString()),
-        PointerType { ElemType: PrimType etype } ptype => $"*{etype.GetDisplayName()}",
+        PointerType { ElemType: PrimType etype } => $"*{etype.GetDisplayName()}",
         ValueType => $"{type.DType.ToString()}",
         _ => throw new NotSupportedException(type.DType.GetType().Name),
     };

From 3da8e9b880d4f84c259adf72e2f7de456fd35110 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 15 Aug 2023 18:07:24 +0800
Subject: [PATCH 082/308] fix build

---
 modules/cpu/src/runtime/cmodel/include/hardware_context.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_context.h b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
index e01366c9f2..6b1f2fee9a 100644
--- a/modules/cpu/src/runtime/cmodel/include/hardware_context.h
+++ b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <iostream>
+#include <memory>
 
 struct hardware_context_impl;
 

From f7b3c470cf401b063a7e28d6b2a338752284c0c1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 15 Aug 2023 20:00:56 +0800
Subject: [PATCH 083/308] add demo

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |   2 +-
 .../runtime/cmodel/include/hardware_context.h |   4 +-
 .../cpu/src/runtime/cmodel/include/matmul.h   | 136 ++++++++++++++
 .../runtime/cmodel/include/runtime_types.h    |   5 +
 .../runtime/cmodel/include/runtime_utils.h    |  46 ++++-
 modules/cpu/src/runtime/cmodel/include/tdma.h |  83 +++++++--
 .../cpu/src/runtime/cmodel/include/tensor.h   |  15 +-
 .../runtime/cmodel/src/hardware_context.cpp   |   6 +
 .../runtime/cmodel/tests/demo1/cluster_def.h  | 171 ++++++++++++++++++
 .../src/runtime/cmodel/tests/demo1/kernel.h   |  35 ++--
 .../src/runtime/cmodel/tests/demo1/main.cpp   | 151 +++++++++-------
 .../runtime/cmodel/tests/demo1/shared_def.h   |   7 +-
 12 files changed, 544 insertions(+), 117 deletions(-)
 create mode 100644 modules/cpu/src/runtime/cmodel/include/matmul.h
 create mode 100644 modules/cpu/src/runtime/cmodel/include/runtime_types.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo1/cluster_def.h

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index 0a071feced..91ff29bb32 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -15,7 +15,7 @@ install(TARGETS cpu_cmodel_cli COMPONENT nncase-runtime)
 
 function(add_test name test_path)
   add_executable(${name} "${test_path}/main.cpp")
-  target_include_directories(${name} PUBLIC include)
+  target_link_libraries(${name} cpu_cmodel)
 endfunction(add_test)
 
 add_test(demo1 tests/demo1)
diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_context.h b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
index 6b1f2fee9a..2b701051cf 100644
--- a/modules/cpu/src/runtime/cmodel/include/hardware_context.h
+++ b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
@@ -22,4 +22,6 @@ class hardware_context {
     std::unique_ptr<hardware_context_impl> impl_;
 };
 
-extern std::unique_ptr<hardware_context> global_hardware_ctx;
\ No newline at end of file
+extern std::unique_ptr<hardware_context> global_hardware_ctx;
+
+void global_hardware_init();
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
new file mode 100644
index 0000000000..3cb60a08f8
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -0,0 +1,136 @@
+#include "runtime_utils.h"
+
+namespace {
+template <typename T>
+void matmul_unit_impl(const T *input_a, const T *input_b, T *output,
+                      gsl::span<const size_t> in_a_shape,
+                      gsl::span<const size_t> in_b_shape) noexcept {
+    int32_t a_rows = static_cast<int32_t>(in_a_shape[0]);
+    int32_t a_cols = static_cast<int32_t>(in_a_shape[1]);
+    int32_t b_cols = static_cast<int32_t>(in_b_shape[1]);
+
+    for (int32_t oy = 0; oy < a_rows; oy++) {
+        for (int32_t ox = 0; ox < b_cols; ox++) {
+            T value = 0;
+
+            for (int32_t i = 0; i < a_cols; i++) {
+                const auto a = input_a[oy * a_cols + i];
+                const auto b = input_b[i * b_cols + ox];
+                value += a * b;
+            }
+
+            output[oy * b_cols + ox] = value;
+        }
+    }
+}
+
+template <typename T>
+void contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
+                            gsl::span<const size_t> in_a_shape,
+                            gsl::span<const size_t> in_b_shape) noexcept {
+    auto new_a_shape = to_nd(in_a_shape, 5);
+    auto new_b_shape = to_nd(in_b_shape, 5);
+    auto a_unit_size = new_a_shape[3] * new_a_shape[4];
+    auto b_unit_size = new_b_shape[3] * new_b_shape[4];
+    auto out_unit_size = new_a_shape[3] * new_b_shape[4];
+
+    auto dim0 = std::max(new_a_shape[0], new_b_shape[0]);
+    auto dim1 = std::max(new_a_shape[1], new_b_shape[1]);
+    auto dim2 = std::max(new_a_shape[2], new_b_shape[2]);
+    auto ah_size = a_unit_size * new_a_shape[2];
+    auto bh_size = b_unit_size * new_b_shape[2];
+    auto oh_size = out_unit_size * dim2;
+
+    auto ab_size = ah_size * new_a_shape[1];
+    auto bb_size = bh_size * new_b_shape[1];
+    auto ob_size = oh_size * dim1;
+
+    for (size_t n = 0; n < dim0; ++n) {
+        auto an = new_a_shape[0] == 1 ? 0 : n;
+        auto bn = new_b_shape[0] == 1 ? 0 : n;
+        for (size_t c = 0; c < dim1; ++c) {
+            auto ac = new_a_shape[1] == 1 ? 0 : c;
+            auto bc = new_b_shape[1] == 1 ? 0 : c;
+            for (size_t h = 0; h < dim2; ++h) {
+                auto ah = new_a_shape[2] == 1 ? 0 : h;
+                auto bh = new_b_shape[2] == 1 ? 0 : h;
+                matmul_unit_impl(
+                    input_a + an * ab_size + ac * ah_size + ah * a_unit_size,
+                    input_b + bn * bb_size + bc * bh_size + bh * b_unit_size,
+                    output + n * ob_size + c * oh_size + h * out_unit_size,
+                    std::array<size_t, 2>{new_a_shape[3], new_a_shape[4]},
+                    std::array<size_t, 2>{new_b_shape[3], new_b_shape[4]});
+            }
+        }
+    }
+}
+
+template <typename T>
+void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
+                               gsl::span<const size_t> in_a_shape,
+                               gsl::span<const size_t> in_a_stride,
+                               gsl::span<const size_t> in_b_shape,
+                               gsl::span<const size_t> in_b_stride,
+                               gsl::span<const size_t> out_shape,
+                               gsl::span<const size_t> out_stride) noexcept {
+    auto [new_a_shape, new_a_stride] = to_nd(in_a_shape, in_a_stride, 5);
+    auto [new_b_shape, new_b_stride] = to_nd(in_b_shape, in_b_stride, 5);
+    auto [new_out_shape, new_out_stride] = to_nd(out_shape, out_stride, 5);
+
+    for (size_t n = 0; n < new_out_shape[0]; ++n) {
+        auto an = new_a_shape[0] == 1 ? 0 : n;
+        auto bn = new_b_shape[0] == 1 ? 0 : n;
+        for (size_t c = 0; c < new_out_shape[1]; ++c) {
+            auto ac = new_a_shape[1] == 1 ? 0 : c;
+            auto bc = new_b_shape[1] == 1 ? 0 : c;
+            for (size_t h = 0; h < new_out_shape[2]; ++h) {
+                auto ah = new_a_shape[2] == 1 ? 0 : h;
+                auto bh = new_b_shape[2] == 1 ? 0 : h;
+
+                const T *in_a_ptr = input_a + an * new_a_stride[0] +
+                                    ac * new_a_stride[1] + ah * new_a_stride[2];
+                const T *in_b_ptr = input_b + bn * new_b_stride[0] +
+                                    bc * new_b_stride[1] + bh * new_b_stride[2];
+                T *out_ptr = output + n * new_out_stride[0] +
+                             c * new_out_stride[1] + h * new_out_stride[2];
+                for (size_t m = 0; m < new_a_shape[3]; m++) {
+                    for (size_t n = 0; n < new_b_shape[4]; n++) {
+                        T value = 0;
+                        for (size_t k = 0; k < new_a_shape[4]; k++) {
+                            value += in_a_ptr[m * new_a_stride[3] + k] *
+                                     in_b_ptr[k * new_b_stride[3] + n];
+                        }
+                        out_ptr[m * new_out_stride[3] + n] = value;
+                    }
+                }
+            }
+        }
+    }
+}
+
+} // namespace
+
+template <class T>
+void matmul(const T *input_a, const T *input_b, T *output, dims_t in_a_dims,
+            strides_t in_a_strides, dims_t in_b_dims, strides_t in_b_strides,
+            dims_t output_dims, strides_t output_strides
+
+) {
+    if (is_contiguous(in_a_dims, in_a_strides) &&
+        is_contiguous(in_b_dims, in_b_strides) &&
+        is_contiguous(output_dims, output_strides)) {
+        return contiguous_matmul_impl(
+            input_a, input_b, output,
+            gsl::make_span(in_a_dims).template as_span<const size_t>(),
+            gsl::make_span(in_b_dims).template as_span<const size_t>());
+    } else {
+        return no_contiguous_matmul_impl(
+            input_a, input_b, output,
+            gsl::make_span(in_a_dims).template as_span<const size_t>(),
+            gsl::make_span(in_a_strides).template as_span<const size_t>(),
+            gsl::make_span(in_b_dims).template as_span<const size_t>(),
+            gsl::make_span(in_b_strides).template as_span<const size_t>(),
+            gsl::make_span(output_dims).template as_span<const size_t>(),
+            gsl::make_span(output_strides).template as_span<const size_t>());
+    }
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_types.h b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
new file mode 100644
index 0000000000..bfe9fecd67
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
@@ -0,0 +1,5 @@
+#pragma once
+#include <nncase/runtime/small_vector.hpp>
+
+using dims_t = itlib::small_vector<size_t, 8>;
+using strides_t = itlib::small_vector<size_t, 8>;
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 68d944706d..977cb747e4 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -4,13 +4,10 @@
 #include <cstddef>
 #include <gsl/gsl-lite.hpp>
 #include <iostream>
-#include <nncase/runtime/small_vector.hpp>
 #include <numeric>
+#include <runtime_types.h>
 #include <vector>
 
-using dims_t = itlib::small_vector<size_t, 8>;
-using strides_t = itlib::small_vector<size_t, 8>;
-
 void print_vec(itlib::small_vector<size_t, 8> vec) {
     for (const size_t v : vec) {
         std::cout << std::to_string(v) << ", ";
@@ -83,3 +80,44 @@ inline bool is_shape_equal(const dims_t &a, const dims_t &b) {
     }
     return true;
 }
+
+inline dims_t to_nd(dims_t in_shape, size_t n) {
+    auto size = n - in_shape.size();
+    for (size_t i = 0; i < size; ++i) {
+        in_shape.insert(in_shape.begin(), 1);
+    }
+    return in_shape;
+}
+
+inline std::tuple<dims_t, strides_t> to_nd(dims_t in_shape, strides_t in_stride,
+                                           size_t n) {
+    auto size = n - in_shape.size();
+    auto stride = *in_stride.begin();
+    for (size_t i = 0; i < size; ++i) {
+        in_shape.insert(in_shape.begin(), 1);
+        in_stride.insert(in_stride.begin(), stride);
+    }
+    return std::make_tuple(in_shape, in_stride);
+}
+
+template <class T> inline bool is_contiguous(const T &shape, const T &strides) {
+    size_t data_size = 1;
+    for (std::size_t i = shape.size(); i != 0; --i) {
+        if (strides[i - 1] != data_size) {
+            return false;
+        }
+        data_size *= shape[i - 1];
+    }
+    return true;
+}
+
+inline int
+get_last_not_contiguous_index(gsl::span<const size_t> strides,
+                              gsl::span<const size_t> default_strides) {
+    for (int i = strides.size() - 1; i >= 0; --i) {
+        if (strides[i] != default_strides[i]) {
+            return i + 1;
+        }
+    }
+    return -1;
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 9a66bb403c..6c451b0bd5 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -2,6 +2,7 @@
 #include <apply.h>
 #include <cassert>
 #include <hardware_context.h>
+#include <matmul.h>
 #include <tensor.h>
 #include <thread_context.h>
 
@@ -39,17 +40,68 @@ void __tensor_copy_sync(TS<DT, tensor_loc_t::shared> &&dest,
           });
 }
 
-template <class T>
-void __tensor_add_sync(tensor<T, tensor_loc_t::local> &a,
-                       tensor<T, tensor_loc_t::local> &b,
-                       tensor<T, tensor_loc_t::local> &out) {
+template <class T, tensor_loc_t ALoc, tensor_loc_t BLoc, tensor_loc_t CLoc>
+void __tensor_binary_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
+                          tensor<T, CLoc> &out,
+                          std::function<T(T a, T b)> callable) {
     assert(a.dimension() == b.dimension());
     assert(a.dimension() == out.dimension());
-    apply(a.dimension(), [&](gsl::span<size_t> index) -> void {
-        out.data()[offset(out.strides(), index)] =
-            (a.data()[offset(a.strides(), index)] +
-             b.data()[offset(b.strides(), index)]);
-    });
+    apply(gsl::make_span(a.dimension()).template as_span<const size_t>(),
+          [&](gsl::span<const size_t> index) -> void {
+              out.data()[offset(out.strides(), index)] =
+                  callable(a.data()[offset(a.strides(), index)],
+                           b.data()[offset(b.strides(), index)]);
+          });
+}
+
+template <class T, tensor_loc_t ALoc, tensor_loc_t BLoc, tensor_loc_t CLoc>
+void __tensor_unary_sync(tensor<T, ALoc> &a, tensor<T, CLoc> &out,
+                         std::function<T(T a)> callable) {
+    assert(a.dimension() == out.dimension());
+    apply(gsl::make_span(a.dimension()).template as_span<const size_t>(),
+          [&](gsl::span<const size_t> index) -> void {
+              out.data()[offset(out.strides(), index)] =
+                  callable(a.data()[offset(a.strides(), index)]);
+          });
+}
+
+template <typename T, tensor_loc_t ALoc, tensor_loc_t BLoc>
+void tensor_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
+                     tensor<T, tensor_loc_t::local> &c) {
+    matmul(a.cdata().data(), b.cdata().data(), c.data().data(), a.dimension(),
+           a.strides(), b.dimension(), b.strides(), c.dimension(), c.strides());
+}
+
+template <typename T, tensor_loc_t ALoc, tensor_loc_t BLoc>
+void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
+                           tensor<T, tensor_loc_t::shared> &c, bool load_psum,
+                           thread_context &ctx) {
+    tensor<T> tmp(c.dimension());
+    tensor_mma_sync(a, b, tmp);
+
+    __tdma_block_sync_apply(
+        [&](int visited) -> void {
+            if (load_psum) {
+                __tensor_binary_sync<T, tensor_loc_t::local,
+                                     tensor_loc_t::shared,
+                                     tensor_loc_t::shared>(
+                    tmp, c, c, [](T _a, T _b) -> T { return _a + _b; });
+            } else {
+                if (visited == 1) {
+                    __tensor_binary_sync<T, tensor_loc_t::local,
+                                         tensor_loc_t::shared,
+                                         tensor_loc_t::shared>(
+                        tmp, c, c,
+                        [](T _a, [[maybe_unused]] T _b) -> T { return _a; });
+                } else {
+                    __tensor_binary_sync<T, tensor_loc_t::local,
+                                         tensor_loc_t::shared,
+                                         tensor_loc_t::shared>(
+                        tmp, c, c, [](T _a, T _b) -> T { return _a + _b; });
+                }
+            }
+        },
+        ctx);
 }
 
 template <class T>
@@ -79,8 +131,8 @@ void tdma_broadcast_async(tensor<T, tensor_loc_t::local> &src,
 
     global_hardware_ctx->lock_block(ctx.bid());
     __tensor_copy_sync(dest, src);
-    // int cnt = global_hardware_ctx->mark_block_visit(ctx.tid());
     global_hardware_ctx->unlock_block(ctx.bid());
+    // int cnt = global_hardware_ctx->mark_block_visit(ctx.tid());
     // global_hardware_ctx->wait_block_sync(ctx.bid(), cnt);
 }
 
@@ -137,4 +189,13 @@ void tdma_wait() {}
 
 void tdma_cancel() {}
 
-void tdma_status() {}
\ No newline at end of file
+void tdma_status() {}
+
+void __tdma_block_sync_apply(std::function<void(int)> func,
+                             thread_context &ctx) {
+    global_hardware_ctx->lock_block(ctx.bid());
+    int visited = global_hardware_ctx->mark_block_visit(ctx.bid(), ctx.tid());
+    func(visited);
+    global_hardware_ctx->unlock_block(ctx.bid());
+    global_hardware_ctx->wait_block_sync(ctx.bid(), visited);
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index 05171d68a3..eb79aeed34 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -29,16 +29,14 @@ template <typename T, tensor_loc_t Loc = tensor_loc_t::local> class tensor {
     const dims_t &dimension() { return dims_; }
     const strides_t &strides() { return strides_; }
 
-    gsl::span<T> data() {
-        if (Loc != tensor_loc_t::shared) {
-            return data_;
-        }
-        assert(false);
-    }
+    gsl::span<T> data() { return data_; }
+
+    gsl::span<const T> cdata() { return data_.template as_span<const T>(); }
 
     tensor<T, Loc> operator()(std::initializer_list<size_t> begins,
                               std::initializer_list<size_t> shapes) {
-        return tensor(this, begins, shapes);
+        return tensor(this, dims_t(begins.begin(), begins.end()),
+                      dims_t(shapes.begin(), shapes.end()));
     }
 
     ~tensor() {
@@ -48,8 +46,7 @@ template <typename T, tensor_loc_t Loc = tensor_loc_t::local> class tensor {
     }
 
   private:
-    tensor(tensor<T, Loc> *parent, std::vector<size_t> begins,
-           std::vector<size_t> shapes)
+    tensor(tensor<T, Loc> *parent, dims_t begins, dims_t shapes)
         : parent_(parent),
           dims_(shapes.begin(), shapes.end()),
           strides_(parent->strides().begin(), parent->strides().end()) {
diff --git a/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp b/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
index 5c0c3ec175..8412c5b678 100644
--- a/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
+++ b/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
@@ -110,4 +110,10 @@ void hardware_context::wait_all_sync(int visited) {
         pthread_cond_wait(&impl_->global_cond.cond, &impl_->global_cond.mutex);
     }
     pthread_mutex_unlock(&impl_->global_cond.mutex);
+}
+
+std::unique_ptr<hardware_context> global_hardware_ctx;
+
+void global_hardware_init() {
+    global_hardware_ctx = std::make_unique<hardware_context>();
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/cluster_def.h b/modules/cpu/src/runtime/cmodel/tests/demo1/cluster_def.h
new file mode 100644
index 0000000000..8fd5d84ed7
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/cluster_def.h
@@ -0,0 +1,171 @@
+#pragma once
+#include <hardware_context.h>
+#include <tdma.h>
+
+namespace block0 {
+#include "shared_def.h"
+constexpr size_t bid = 0;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block0
+
+namespace block1 {
+#include "shared_def.h"
+constexpr size_t bid = 1;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block1
+
+namespace block2 {
+#include "shared_def.h"
+constexpr size_t bid = 2;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block2
+
+namespace block3 {
+#include "shared_def.h"
+constexpr size_t bid = 3;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block3
+
+namespace block4 {
+#include "shared_def.h"
+constexpr size_t bid = 4;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block4
+
+namespace block5 {
+#include "shared_def.h"
+constexpr size_t bid = 5;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block5
+
+namespace block6 {
+#include "shared_def.h"
+constexpr size_t bid = 6;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block6
+
+namespace block7 {
+#include "shared_def.h"
+constexpr size_t bid = 7;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block7
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index 6e91f7e9ea..e7dbce55b6 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -7,33 +7,35 @@
 // [8, 384, 128] tensor<float, tensor_loc_t::shared> qkh({8, 384, 384});    //
 // [8, 384, 384] tensor<float, tensor_loc_t::shared> qkh({8, 384, 384});    //
 // [8, 384, 384]
+#include "thread_context.h"
 using namespace shared;
 
 static bool w_loaded = false;
-static tensor<float> wqh({8, 2048, 128});
+// static tensor<float> wqh({8, 2048, 128});
 static tensor<float> wkh({8, 2048, 128});
-static tensor<float> wvh({8, 2048, 128}); // [8, 2048, 128]
-static tensor<float> wfc1ih({1024, 2752});
-static tensor<float> wfc2ih({1024, 2752}); // [1024, 2752]
-static tensor<float> yih({96, 1024});
+// static tensor<float> wvh({8, 2048, 128}); // [8, 2048, 128]
+// static tensor<float> wfc1ih({1024, 2752});
+// static tensor<float> wfc2ih({1024, 2752}); // [1024, 2752]
+// static tensor<float> yih({96, 1024});
 
 // 8 head per block
 // 2048 w-len per thread
-void stage1_kernel(tensor<float, tensor_loc_t::device> &WQ,  /* 64, 8192, 128 */
-                   tensor<float, tensor_loc_t::device> &WK,  /* 64, 8192, 128 */
-                   tensor<float, tensor_loc_t::device> &WV,  /* 64, 8192, 128 */
-                   tensor<float, tensor_loc_t::device> &WFC1 /* 384, 8192*/
+void stage1_kernel(
+    // tensor<float, tensor_loc_t::device> &WQ,  /* 64, 8192, 128 */
+    tensor<float, tensor_loc_t::device> &WK /* 64, 8192, 128 */
+    //  tensor<float, tensor_loc_t::device> &WV,  /* 64, 8192, 128 */
+    //  tensor<float, tensor_loc_t::device> &WFC1 /* 384, 8192*/
 ) {
     // 1. Get xi
     auto xi = X({0, tid * 2048}, {384, 2048}); // [384, 2048]
 
     // 2. load wqh wkh wvh
     if (!w_loaded) {
-        tdma_load_async(wqh, WQ({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
+        // tdma_load_async(wqh, WQ({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
         tdma_load_async(wkh, WK({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
-        tdma_load_async(wvh, WV({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
-        tdma_load_async(wfc1ih, WFC1({bid * 1024, tid * 8192}, {1024, 8192}));
-        tdma_wait(); // 等待 x, wqh, wkh, wvh ready
+        // tdma_load_async(wvh, WV({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
+        // tdma_load_async(wfc1ih, WFC1({bid * 1024, tid * 8192}, {1024,
+        // 8192})); tdma_wait(); // 等待 x, wqh, wkh, wvh ready
         w_loaded = true;
     }
 
@@ -42,10 +44,9 @@ void stage1_kernel(tensor<float, tensor_loc_t::device> &WQ,  /* 64, 8192, 128 */
     //     sched_strategy_t::pin_block_tensor); // 仅在 block 内调度线程的
     //     tensor
     //                                          // 指令
-
-    // tensor_block_mma_sync(
-    //     xi, wkh,
-    //     shared::kh); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
+    thread_context ctx(tid, bid);
+    tensor_block_mma_sync(xi, wkh, kh, false,
+                          ctx); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
     // vh = tensor_block_mma_sync(
     //     xi, wvh); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
 
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
index 6775c08ec0..8a7ce6da77 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
@@ -1,76 +1,87 @@
-#include <hardware_context.h>
-#include <nncase/compiler_defs.h>
-#include <tdma.h>
+#include "cluster_def.h"
+// #include <pthread.h>
 
-namespace block0 {
-#include "shared_def.h"
-constexpr size_t bid = 0;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block0
-
-// namespace block1 {
-// namespace thread0 {}
-// namespace thread1 {}
-// namespace thread2 {}
-// namespace thread3 {}
-// } // namespace block1
-// namespace block2 {
-// namespace thread0 {}
-// namespace thread1 {}
-// namespace thread2 {}
-// namespace thread3 {}
-// } // namespace block2
-// namespace block3 {
-// namespace thread0 {}
-// namespace thread1 {}
-// namespace thread2 {}
-// namespace thread3 {}
-// } // namespace block3
-// namespace block4 {
-// namespace thread0 {}
-// namespace thread1 {}
-// namespace thread2 {}
-// namespace thread3 {}
-// } // namespace block4
-// namespace block5 {
-// namespace thread0 {}
-// namespace thread1 {}
-// namespace thread2 {}
-// namespace thread3 {}
-// } // namespace block5
-// namespace block6 {
-// namespace thread0 {}
-// namespace thread1 {}
-// namespace thread2 {}
-// namespace thread3 {}
-// } // namespace block6
-// namespace block7 {
-// namespace thread0 {}
-// namespace thread1 {}
-// namespace thread2 {}
-// namespace thread3 {}
-// } // namespace block7
+#define DEFINE_THREAD(b, t)                                                    \
+    [[maybe_unused]] std::function<void *(void *)> func_##b##_##t =            \
+        [&WK](void *) -> void * {                                              \
+        block##b::thread##t::stage1_kernel(WK);                                \
+        return nullptr;                                                        \
+    };                                                                         \
+    [[maybe_unused]] pthread_t t_##b##_##t
 
 int main() {
-    tensor<float, tensor_loc_t::device> WQ({64, 8192, 128});
+    global_hardware_init();
+
+    // tensor<float, tensor_loc_t::device> WQ({64, 8192, 128});
     tensor<float, tensor_loc_t::device> WK({64, 8192, 128});
-    tensor<float, tensor_loc_t::device> WV({64, 8192, 128});
-    tensor<float, tensor_loc_t::device> WFC1({384, 8192});
-    block0::thread0::stage1_kernel(WQ, WK, WV, WFC1);
+    // tensor<float, tensor_loc_t::device> WV({64, 8192, 128});
+    // tensor<float, tensor_loc_t::device> WFC1({384, 8192});
+
+    DEFINE_THREAD(0, 0);
+    DEFINE_THREAD(0, 1);
+    DEFINE_THREAD(0, 2);
+    DEFINE_THREAD(0, 3);
+    DEFINE_THREAD(1, 0);
+    DEFINE_THREAD(1, 1);
+    DEFINE_THREAD(1, 2);
+    DEFINE_THREAD(1, 3);
+    DEFINE_THREAD(2, 0);
+    DEFINE_THREAD(2, 1);
+    DEFINE_THREAD(2, 2);
+    DEFINE_THREAD(2, 3);
+    DEFINE_THREAD(3, 0);
+    DEFINE_THREAD(3, 1);
+    DEFINE_THREAD(3, 2);
+    DEFINE_THREAD(3, 3);
+    DEFINE_THREAD(4, 0);
+    DEFINE_THREAD(4, 1);
+    DEFINE_THREAD(4, 2);
+    DEFINE_THREAD(4, 3);
+    DEFINE_THREAD(5, 0);
+    DEFINE_THREAD(5, 1);
+    DEFINE_THREAD(5, 2);
+    DEFINE_THREAD(5, 3);
+    DEFINE_THREAD(6, 0);
+    DEFINE_THREAD(6, 1);
+    DEFINE_THREAD(6, 2);
+    DEFINE_THREAD(6, 3);
+    DEFINE_THREAD(7, 0);
+    DEFINE_THREAD(7, 1);
+    DEFINE_THREAD(7, 2);
+    DEFINE_THREAD(7, 3);
+
+    pthread_create(&t_0_0, NULL, (void *(*)(void *)) & func_0_0, NULL);
+    pthread_create(&t_0_1, NULL, (void *(*)(void *)) & func_0_1, NULL);
+    pthread_create(&t_0_2, NULL, (void *(*)(void *)) & func_0_2, NULL);
+    pthread_create(&t_0_3, NULL, (void *(*)(void *)) & func_0_3, NULL);
+    pthread_create(&t_1_0, NULL, (void *(*)(void *)) & func_1_0, NULL);
+    pthread_create(&t_1_1, NULL, (void *(*)(void *)) & func_1_1, NULL);
+    pthread_create(&t_1_2, NULL, (void *(*)(void *)) & func_1_2, NULL);
+    pthread_create(&t_1_3, NULL, (void *(*)(void *)) & func_1_3, NULL);
+    pthread_create(&t_2_0, NULL, (void *(*)(void *)) & func_2_0, NULL);
+    pthread_create(&t_2_1, NULL, (void *(*)(void *)) & func_2_1, NULL);
+    pthread_create(&t_2_2, NULL, (void *(*)(void *)) & func_2_2, NULL);
+    pthread_create(&t_2_3, NULL, (void *(*)(void *)) & func_2_3, NULL);
+    pthread_create(&t_3_0, NULL, (void *(*)(void *)) & func_3_0, NULL);
+    pthread_create(&t_3_1, NULL, (void *(*)(void *)) & func_3_1, NULL);
+    pthread_create(&t_3_2, NULL, (void *(*)(void *)) & func_3_2, NULL);
+    pthread_create(&t_3_3, NULL, (void *(*)(void *)) & func_3_3, NULL);
+    pthread_create(&t_4_0, NULL, (void *(*)(void *)) & func_4_0, NULL);
+    pthread_create(&t_4_1, NULL, (void *(*)(void *)) & func_4_1, NULL);
+    pthread_create(&t_4_2, NULL, (void *(*)(void *)) & func_4_2, NULL);
+    pthread_create(&t_4_3, NULL, (void *(*)(void *)) & func_4_3, NULL);
+    pthread_create(&t_5_0, NULL, (void *(*)(void *)) & func_5_0, NULL);
+    pthread_create(&t_5_1, NULL, (void *(*)(void *)) & func_5_1, NULL);
+    pthread_create(&t_5_2, NULL, (void *(*)(void *)) & func_5_2, NULL);
+    pthread_create(&t_5_3, NULL, (void *(*)(void *)) & func_5_3, NULL);
+    pthread_create(&t_6_0, NULL, (void *(*)(void *)) & func_6_0, NULL);
+    pthread_create(&t_6_1, NULL, (void *(*)(void *)) & func_6_1, NULL);
+    pthread_create(&t_6_2, NULL, (void *(*)(void *)) & func_6_2, NULL);
+    pthread_create(&t_6_3, NULL, (void *(*)(void *)) & func_6_3, NULL);
+    pthread_create(&t_7_0, NULL, (void *(*)(void *)) & func_7_0, NULL);
+    pthread_create(&t_7_1, NULL, (void *(*)(void *)) & func_7_1, NULL);
+    pthread_create(&t_7_2, NULL, (void *(*)(void *)) & func_7_2, NULL);
+    pthread_create(&t_7_3, NULL, (void *(*)(void *)) & func_7_3, NULL);
+
     return 0;
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
index 16f55bf71d..c87adb48ba 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
@@ -1,9 +1,8 @@
-#pragma once
 #include <tdma.h>
 
 namespace shared {
 static tensor<float, tensor_loc_t::shared> X({384, 8192});
-static tensor<float, tensor_loc_t::shared> kh({8, 384, 128}),
-    vh({8, 384, 128});                                         // [8, 384, 128]
-static tensor<float, tensor_loc_t::shared> qkh({8, 384, 384}); // [8, 384, 384]
+static tensor<float, tensor_loc_t::shared> kh({8, 384, 128});
+    // vh({8, 384, 128});                                         // [8, 384, 128]
+// static tensor<float, tensor_loc_t::shared> qkh({8, 384, 384}); // [8, 384, 384]
 } // namespace shared
\ No newline at end of file

From ff448d5ba9d3d14c36302eaa0f5a61a06a90d672 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Tue, 15 Aug 2023 12:04:32 +0000
Subject: [PATCH 084/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
index c87adb48ba..c53827bbaa 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
@@ -3,6 +3,7 @@
 namespace shared {
 static tensor<float, tensor_loc_t::shared> X({384, 8192});
 static tensor<float, tensor_loc_t::shared> kh({8, 384, 128});
-    // vh({8, 384, 128});                                         // [8, 384, 128]
-// static tensor<float, tensor_loc_t::shared> qkh({8, 384, 384}); // [8, 384, 384]
+// vh({8, 384, 128});                                         // [8, 384, 128]
+// static tensor<float, tensor_loc_t::shared> qkh({8, 384, 384}); // [8, 384,
+// 384]
 } // namespace shared
\ No newline at end of file

From 10602a57ffcd2c46e7f4d0df6eb513d0223d6314 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 15 Aug 2023 20:23:36 +0800
Subject: [PATCH 085/308] fix thread start

---
 .../src/runtime/cmodel/tests/demo1/kernel.h   |   1 +
 .../src/runtime/cmodel/tests/demo1/main.cpp   | 138 ++++++++----------
 2 files changed, 64 insertions(+), 75 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index e7dbce55b6..04f6023a36 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -58,6 +58,7 @@ void stage1_kernel(
     //     qih, kh.T); // [8, 384, 128] x [8, 128, 384] = [8, 384, 384]
 
     // set_sched_strategy(sched_strategy_t::normal);
+    
 }
 
 // // 8 head per block
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
index 8a7ce6da77..072a057158 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
@@ -1,87 +1,75 @@
 #include "cluster_def.h"
 // #include <pthread.h>
 
-#define DEFINE_THREAD(b, t)                                                    \
-    [[maybe_unused]] std::function<void *(void *)> func_##b##_##t =            \
-        [&WK](void *) -> void * {                                              \
+#define DEFINE_TFUNC(b, t)                                                     \
+    void *f_##b##_##t(void *arg) {                                             \
         block##b::thread##t::stage1_kernel(WK);                                \
-        return nullptr;                                                        \
-    };                                                                         \
-    [[maybe_unused]] pthread_t t_##b##_##t
+        return arg;                                                            \
+    }
+
+#define DEFINE_BFUNC(b)                                                        \
+    DEFINE_TFUNC(b, 0)                                                         \
+    DEFINE_TFUNC(b, 1)                                                         \
+    DEFINE_TFUNC(b, 2)                                                         \
+    DEFINE_TFUNC(b, 3)
+
+tensor<float, tensor_loc_t::device> WK({64, 8192, 128});
+
+DEFINE_BFUNC(0)
+DEFINE_BFUNC(1)
+DEFINE_BFUNC(2)
+DEFINE_BFUNC(3)
+DEFINE_BFUNC(4)
+DEFINE_BFUNC(5)
+DEFINE_BFUNC(6)
+DEFINE_BFUNC(7)
 
 int main() {
     global_hardware_init();
 
-    // tensor<float, tensor_loc_t::device> WQ({64, 8192, 128});
-    tensor<float, tensor_loc_t::device> WK({64, 8192, 128});
-    // tensor<float, tensor_loc_t::device> WV({64, 8192, 128});
-    // tensor<float, tensor_loc_t::device> WFC1({384, 8192});
-
-    DEFINE_THREAD(0, 0);
-    DEFINE_THREAD(0, 1);
-    DEFINE_THREAD(0, 2);
-    DEFINE_THREAD(0, 3);
-    DEFINE_THREAD(1, 0);
-    DEFINE_THREAD(1, 1);
-    DEFINE_THREAD(1, 2);
-    DEFINE_THREAD(1, 3);
-    DEFINE_THREAD(2, 0);
-    DEFINE_THREAD(2, 1);
-    DEFINE_THREAD(2, 2);
-    DEFINE_THREAD(2, 3);
-    DEFINE_THREAD(3, 0);
-    DEFINE_THREAD(3, 1);
-    DEFINE_THREAD(3, 2);
-    DEFINE_THREAD(3, 3);
-    DEFINE_THREAD(4, 0);
-    DEFINE_THREAD(4, 1);
-    DEFINE_THREAD(4, 2);
-    DEFINE_THREAD(4, 3);
-    DEFINE_THREAD(5, 0);
-    DEFINE_THREAD(5, 1);
-    DEFINE_THREAD(5, 2);
-    DEFINE_THREAD(5, 3);
-    DEFINE_THREAD(6, 0);
-    DEFINE_THREAD(6, 1);
-    DEFINE_THREAD(6, 2);
-    DEFINE_THREAD(6, 3);
-    DEFINE_THREAD(7, 0);
-    DEFINE_THREAD(7, 1);
-    DEFINE_THREAD(7, 2);
-    DEFINE_THREAD(7, 3);
+    pthread_t t_0_0; // t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+    pthread_t t_0_1; // t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+    pthread_t t_0_2; // t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+    pthread_t t_0_3; // t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
-    pthread_create(&t_0_0, NULL, (void *(*)(void *)) & func_0_0, NULL);
-    pthread_create(&t_0_1, NULL, (void *(*)(void *)) & func_0_1, NULL);
-    pthread_create(&t_0_2, NULL, (void *(*)(void *)) & func_0_2, NULL);
-    pthread_create(&t_0_3, NULL, (void *(*)(void *)) & func_0_3, NULL);
-    pthread_create(&t_1_0, NULL, (void *(*)(void *)) & func_1_0, NULL);
-    pthread_create(&t_1_1, NULL, (void *(*)(void *)) & func_1_1, NULL);
-    pthread_create(&t_1_2, NULL, (void *(*)(void *)) & func_1_2, NULL);
-    pthread_create(&t_1_3, NULL, (void *(*)(void *)) & func_1_3, NULL);
-    pthread_create(&t_2_0, NULL, (void *(*)(void *)) & func_2_0, NULL);
-    pthread_create(&t_2_1, NULL, (void *(*)(void *)) & func_2_1, NULL);
-    pthread_create(&t_2_2, NULL, (void *(*)(void *)) & func_2_2, NULL);
-    pthread_create(&t_2_3, NULL, (void *(*)(void *)) & func_2_3, NULL);
-    pthread_create(&t_3_0, NULL, (void *(*)(void *)) & func_3_0, NULL);
-    pthread_create(&t_3_1, NULL, (void *(*)(void *)) & func_3_1, NULL);
-    pthread_create(&t_3_2, NULL, (void *(*)(void *)) & func_3_2, NULL);
-    pthread_create(&t_3_3, NULL, (void *(*)(void *)) & func_3_3, NULL);
-    pthread_create(&t_4_0, NULL, (void *(*)(void *)) & func_4_0, NULL);
-    pthread_create(&t_4_1, NULL, (void *(*)(void *)) & func_4_1, NULL);
-    pthread_create(&t_4_2, NULL, (void *(*)(void *)) & func_4_2, NULL);
-    pthread_create(&t_4_3, NULL, (void *(*)(void *)) & func_4_3, NULL);
-    pthread_create(&t_5_0, NULL, (void *(*)(void *)) & func_5_0, NULL);
-    pthread_create(&t_5_1, NULL, (void *(*)(void *)) & func_5_1, NULL);
-    pthread_create(&t_5_2, NULL, (void *(*)(void *)) & func_5_2, NULL);
-    pthread_create(&t_5_3, NULL, (void *(*)(void *)) & func_5_3, NULL);
-    pthread_create(&t_6_0, NULL, (void *(*)(void *)) & func_6_0, NULL);
-    pthread_create(&t_6_1, NULL, (void *(*)(void *)) & func_6_1, NULL);
-    pthread_create(&t_6_2, NULL, (void *(*)(void *)) & func_6_2, NULL);
-    pthread_create(&t_6_3, NULL, (void *(*)(void *)) & func_6_3, NULL);
-    pthread_create(&t_7_0, NULL, (void *(*)(void *)) & func_7_0, NULL);
-    pthread_create(&t_7_1, NULL, (void *(*)(void *)) & func_7_1, NULL);
-    pthread_create(&t_7_2, NULL, (void *(*)(void *)) & func_7_2, NULL);
-    pthread_create(&t_7_3, NULL, (void *(*)(void *)) & func_7_3, NULL);
+    pthread_create(&t_0_0, NULL, f_0_0, NULL);
+    pthread_create(&t_0_1, NULL, f_0_1, NULL);
+    pthread_create(&t_0_2, NULL, f_0_2, NULL);
+    pthread_create(&t_0_3, NULL, f_0_3, NULL);
+    // pthread_create(&t_0_2, NULL, (void *(*)(void *)) & func_0_2, NULL);
+    // pthread_create(&t_0_3, NULL, (void *(*)(void *)) & func_0_3, NULL);
+    // pthread_create(&t_1_0, NULL, (void *(*)(void *)) & func_1_0, NULL);
+    // pthread_create(&t_1_1, NULL, (void *(*)(void *)) & func_1_1, NULL);
+    // pthread_create(&t_1_2, NULL, (void *(*)(void *)) & func_1_2, NULL);
+    // pthread_create(&t_1_3, NULL, (void *(*)(void *)) & func_1_3, NULL);
+    // pthread_create(&t_2_0, NULL, (void *(*)(void *)) & func_2_0, NULL);
+    // pthread_create(&t_2_1, NULL, (void *(*)(void *)) & func_2_1, NULL);
+    // pthread_create(&t_2_2, NULL, (void *(*)(void *)) & func_2_2, NULL);
+    // pthread_create(&t_2_3, NULL, (void *(*)(void *)) & func_2_3, NULL);
+    // pthread_create(&t_3_0, NULL, (void *(*)(void *)) & func_3_0, NULL);
+    // pthread_create(&t_3_1, NULL, (void *(*)(void *)) & func_3_1, NULL);
+    // pthread_create(&t_3_2, NULL, (void *(*)(void *)) & func_3_2, NULL);
+    // pthread_create(&t_3_3, NULL, (void *(*)(void *)) & func_3_3, NULL);
+    // pthread_create(&t_4_0, NULL, (void *(*)(void *)) & func_4_0, NULL);
+    // pthread_create(&t_4_1, NULL, (void *(*)(void *)) & func_4_1, NULL);
+    // pthread_create(&t_4_2, NULL, (void *(*)(void *)) & func_4_2, NULL);
+    // pthread_create(&t_4_3, NULL, (void *(*)(void *)) & func_4_3, NULL);
+    // pthread_create(&t_5_0, NULL, (void *(*)(void *)) & func_5_0, NULL);
+    // pthread_create(&t_5_1, NULL, (void *(*)(void *)) & func_5_1, NULL);
+    // pthread_create(&t_5_2, NULL, (void *(*)(void *)) & func_5_2, NULL);
+    // pthread_create(&t_5_3, NULL, (void *(*)(void *)) & func_5_3, NULL);
+    // pthread_create(&t_6_0, NULL, (void *(*)(void *)) & func_6_0, NULL);
+    // pthread_create(&t_6_1, NULL, (void *(*)(void *)) & func_6_1, NULL);
+    // pthread_create(&t_6_2, NULL, (void *(*)(void *)) & func_6_2, NULL);
+    // pthread_create(&t_6_3, NULL, (void *(*)(void *)) & func_6_3, NULL);
+    // pthread_create(&t_7_0, NULL, (void *(*)(void *)) & func_7_0, NULL);
+    // pthread_create(&t_7_1, NULL, (void *(*)(void *)) & func_7_1, NULL);
+    // pthread_create(&t_7_2, NULL, (void *(*)(void *)) & func_7_2, NULL);
+    // pthread_create(&t_7_3, NULL, (void *(*)(void *)) & func_7_3, NULL);
+    pthread_join(t_0_0, NULL);
+    pthread_join(t_0_1, NULL);
+    pthread_join(t_0_2, NULL);
+    pthread_join(t_0_3, NULL);
 
     return 0;
 }
\ No newline at end of file

From 383a5e4bea7a54108297554d86587b63d090334d Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Tue, 15 Aug 2023 12:26:22 +0000
Subject: [PATCH 086/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index 04f6023a36..e7dbce55b6 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -58,7 +58,6 @@ void stage1_kernel(
     //     qih, kh.T); // [8, 384, 128] x [8, 128, 384] = [8, 384, 384]
 
     // set_sched_strategy(sched_strategy_t::normal);
-    
 }
 
 // // 8 head per block

From 4b6f1c72dfea25285cf64a0e061361ac04b6ce9e Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 16 Aug 2023 13:46:45 +0800
Subject: [PATCH 087/308] fix build

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 6c451b0bd5..932a567d2e 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -5,6 +5,7 @@
 #include <matmul.h>
 #include <tensor.h>
 #include <thread_context.h>
+#include <functional>
 
 template <template <class, tensor_loc_t> class TS, class DT>
 void __tensor_copy_sync(TS<DT, tensor_loc_t::local> &&dest,

From 4476b3abdea81995a443c81f83b188bf3c12541a Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Wed, 16 Aug 2023 05:50:55 +0000
Subject: [PATCH 088/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 932a567d2e..72d9f60020 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -1,11 +1,11 @@
 #pragma once
 #include <apply.h>
 #include <cassert>
+#include <functional>
 #include <hardware_context.h>
 #include <matmul.h>
 #include <tensor.h>
 #include <thread_context.h>
-#include <functional>
 
 template <template <class, tensor_loc_t> class TS, class DT>
 void __tensor_copy_sync(TS<DT, tensor_loc_t::local> &&dest,

From ecb55a8ee424e438e689e6ac36b8a11c386987e3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 16 Aug 2023 14:20:19 +0800
Subject: [PATCH 089/308] add demo1 test

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |   4 +-
 .../cpu/src/runtime/cmodel/include/io_utils.h |  22 +++
 .../runtime/cmodel/include/runtime_utils.h    |   5 +
 modules/cpu/src/runtime/cmodel/include/tdma.h | 143 +++++++++++++-----
 .../cpu/src/runtime/cmodel/include/tensor.h   |   4 +-
 .../src/runtime/cmodel/tests/demo1/golden.py  |  12 ++
 .../src/runtime/cmodel/tests/demo1/kernel.h   |  24 +--
 .../src/runtime/cmodel/tests/demo1/main.cpp   | 129 +++++++++++-----
 .../runtime/cmodel/tests/demo1/shared_def.h   |   4 +-
 9 files changed, 253 insertions(+), 94 deletions(-)
 create mode 100644 modules/cpu/src/runtime/cmodel/include/io_utils.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo1/golden.py

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index 91ff29bb32..df0bf6fa1e 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -1,9 +1,9 @@
-
 add_library(cpu_cmodel STATIC
   src/hardware_context.cpp
 )
 
 target_include_directories(cpu_cmodel PUBLIC include)
+target_link_libraries(cpu_cmodel PUBLIC fmt::fmt spdlog::spdlog)
 set_target_properties(cpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
         
 add_executable(cpu_cmodel_cli src/cpu_cmodel.cpp ../shared_memory.cpp)
@@ -15,7 +15,7 @@ install(TARGETS cpu_cmodel_cli COMPONENT nncase-runtime)
 
 function(add_test name test_path)
   add_executable(${name} "${test_path}/main.cpp")
-  target_link_libraries(${name} cpu_cmodel)
+  target_link_libraries(${name} cpu_cmodel spdlog)
 endfunction(add_test)
 
 add_test(demo1 tests/demo1)
diff --git a/modules/cpu/src/runtime/cmodel/include/io_utils.h b/modules/cpu/src/runtime/cmodel/include/io_utils.h
new file mode 100644
index 0000000000..8dceaa9bfe
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/io_utils.h
@@ -0,0 +1,22 @@
+#pragma once
+#include <filesystem>
+#include <fstream>
+#include <tensor.h>
+#include <vector>
+
+
+inline std::vector<uint8_t> read_stream(std::istream &stream) {
+    stream.seekg(0, std::ios::end);
+    size_t length = stream.tellg();
+    stream.seekg(0, std::ios::beg);
+    std::vector<uint8_t> data(length);
+    stream.read(reinterpret_cast<char *>(data.data()), length);
+    return data;
+}
+
+inline std::vector<uint8_t> read_file(const std::filesystem::path &filename) {
+    std::ifstream infile(filename.string(), std::ios::binary | std::ios::in);
+    if (!infile.good())
+        throw std::runtime_error("Cannot open file: " + filename.string());
+    return read_stream(infile);
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 977cb747e4..6d7ff3c8e6 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -120,4 +120,9 @@ get_last_not_contiguous_index(gsl::span<const size_t> strides,
         }
     }
     return -1;
+}
+
+template <typename T>
+inline void span_copy(gsl::span<T> dest, gsl::span<T> src) {
+    std::copy(src.begin(), src.end(), dest.begin());
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 72d9f60020..6ec0254f55 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -6,10 +6,14 @@
 #include <matmul.h>
 #include <tensor.h>
 #include <thread_context.h>
+#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
+#include <spdlog/spdlog.h>
 
-template <template <class, tensor_loc_t> class TS, class DT>
-void __tensor_copy_sync(TS<DT, tensor_loc_t::local> &&dest,
-                        TS<DT, tensor_loc_t::local> &&src) {
+
+template <template <class, loc_t> class TS, class DT>
+void __tensor_copy_sync(TS<DT, loc_t::local> &&dest,
+                        TS<DT, loc_t::local> &&src,
+                        [[maybe_unused]] thread_context &ctx) {
     assert(dest.dimension() == src.dimension());
     apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
           [&](gsl::span<const size_t> index) -> void {
@@ -18,9 +22,10 @@ void __tensor_copy_sync(TS<DT, tensor_loc_t::local> &&dest,
           });
 }
 
-template <template <class, tensor_loc_t> class TS, class DT>
-void __tensor_copy_sync(TS<DT, tensor_loc_t::local> &&dest,
-                        TS<DT, tensor_loc_t::device> &&src) {
+template <template <class, loc_t> class TS, class DT>
+void __tensor_copy_sync(TS<DT, loc_t::local> &&dest,
+                        TS<DT, loc_t::device> &&src,
+                        [[maybe_unused]] thread_context &ctx) {
     assert(dest.dimension() == src.dimension());
     apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
           [&](gsl::span<const size_t> index) -> void {
@@ -29,19 +34,59 @@ void __tensor_copy_sync(TS<DT, tensor_loc_t::local> &&dest,
           });
 }
 
-template <template <class, tensor_loc_t> class TS, class DT>
-void __tensor_copy_sync(TS<DT, tensor_loc_t::shared> &&dest,
-                        TS<DT, tensor_loc_t::local> &&src,
-                        thread_context &ctx) {
+template <template <class, loc_t> class TS, class DT>
+void __tensor_copy_sync(TS<DT, loc_t::shared> &&dest,
+                        TS<DT, loc_t::device> &&src,
+                        [[maybe_unused]] thread_context &ctx) {
+
+    __tdma_block_sync_apply(
+        [&dest, &src](int visited) -> void {
+            if (visited == 1) {
+                assert(dest.dimension() == src.dimension());
+                apply(gsl::make_span(src.dimension())
+                          .template as_span<const size_t>(),
+                      [&](gsl::span<const size_t> index) -> void {
+                          dest.data()[offset(dest.strides(), index)] =
+                              src.data()[offset(src.strides(), index)];
+                      });
+            }
+        },
+        ctx);
+}
+
+template <template <class, loc_t> class TS, class DT>
+void __tensor_copy_sync(TS<DT, loc_t::device> &&dest,
+                        TS<DT, loc_t::shared> &&src,
+                        [[maybe_unused]] thread_context &ctx) {
+
+    __tdma_block_sync_apply(
+        [&dest, &src](int visited) -> void {
+            if (visited == 1) {
+                assert(dest.dimension() == src.dimension());
+                apply(gsl::make_span(src.dimension())
+                          .template as_span<const size_t>(),
+                      [&](gsl::span<const size_t> index) -> void {
+                          dest.data()[offset(dest.strides(), index)] =
+                              src.data()[offset(src.strides(), index)];
+                      });
+            }
+        },
+        ctx);
+}
+
+template <template <class, loc_t> class TS, class DT>
+void __tensor_copy_sync(TS<DT, loc_t::shared> &&dest,
+                        TS<DT, loc_t::local> &&src,
+                        [[maybe_unused]] thread_context &ctx) {
     assert(dest.dimension() == src.dimension());
     apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
           [&](gsl::span<const size_t> index) -> void {
-              dest.shared_data(ctx.bid())[offset(dest.strides(), index)] =
+              dest.data(ctx.bid())[offset(dest.strides(), index)] =
                   src.data()[offset(src.strides(), index)];
           });
 }
 
-template <class T, tensor_loc_t ALoc, tensor_loc_t BLoc, tensor_loc_t CLoc>
+template <class T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
 void __tensor_binary_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
                           tensor<T, CLoc> &out,
                           std::function<T(T a, T b)> callable) {
@@ -55,7 +100,7 @@ void __tensor_binary_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
           });
 }
 
-template <class T, tensor_loc_t ALoc, tensor_loc_t BLoc, tensor_loc_t CLoc>
+template <class T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
 void __tensor_unary_sync(tensor<T, ALoc> &a, tensor<T, CLoc> &out,
                          std::function<T(T a)> callable) {
     assert(a.dimension() == out.dimension());
@@ -66,16 +111,29 @@ void __tensor_unary_sync(tensor<T, ALoc> &a, tensor<T, CLoc> &out,
           });
 }
 
-template <typename T, tensor_loc_t ALoc, tensor_loc_t BLoc>
+template <typename T, loc_t ALoc, loc_t BLoc>
 void tensor_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
-                     tensor<T, tensor_loc_t::local> &c) {
+                     tensor<T, loc_t::local> &c) {
     matmul(a.cdata().data(), b.cdata().data(), c.data().data(), a.dimension(),
            a.strides(), b.dimension(), b.strides(), c.dimension(), c.strides());
 }
 
-template <typename T, tensor_loc_t ALoc, tensor_loc_t BLoc>
+/**
+ * @brief Block 级别的 mma，每个 thread 执行自己的 mma，最终 psum 累加写入
+ * shared memory
+ *
+ * @tparam T type
+ * @tparam ALoc shared or local
+ * @tparam BLoc shared or local
+ * @param a
+ * @param b
+ * @param c must be shared
+ * @param load_psum
+ * @param ctx
+ */
+template <typename T, loc_t ALoc, loc_t BLoc>
 void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
-                           tensor<T, tensor_loc_t::shared> &c, bool load_psum,
+                           tensor<T, loc_t::shared> &c, bool load_psum,
                            thread_context &ctx) {
     tensor<T> tmp(c.dimension());
     tensor_mma_sync(a, b, tmp);
@@ -83,21 +141,21 @@ void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
     __tdma_block_sync_apply(
         [&](int visited) -> void {
             if (load_psum) {
-                __tensor_binary_sync<T, tensor_loc_t::local,
-                                     tensor_loc_t::shared,
-                                     tensor_loc_t::shared>(
+                __tensor_binary_sync<T, loc_t::local,
+                                     loc_t::shared,
+                                     loc_t::shared>(
                     tmp, c, c, [](T _a, T _b) -> T { return _a + _b; });
             } else {
                 if (visited == 1) {
-                    __tensor_binary_sync<T, tensor_loc_t::local,
-                                         tensor_loc_t::shared,
-                                         tensor_loc_t::shared>(
+                    __tensor_binary_sync<T, loc_t::local,
+                                         loc_t::shared,
+                                         loc_t::shared>(
                         tmp, c, c,
                         [](T _a, [[maybe_unused]] T _b) -> T { return _a; });
                 } else {
-                    __tensor_binary_sync<T, tensor_loc_t::local,
-                                         tensor_loc_t::shared,
-                                         tensor_loc_t::shared>(
+                    __tensor_binary_sync<T, loc_t::local,
+                                         loc_t::shared,
+                                         loc_t::shared>(
                         tmp, c, c, [](T _a, T _b) -> T { return _a + _b; });
                 }
             }
@@ -105,29 +163,32 @@ void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
         ctx);
 }
 
-template <class T>
-void tdma_load_async(tensor<T, tensor_loc_t::local> &dest,
-                     tensor<T, tensor_loc_t::device> &&src) {
-    __tensor_copy_sync(std::forward<tensor<T, tensor_loc_t::local>>(dest),
-                       std::forward<tensor<T, tensor_loc_t::device>>(src));
+template <class T, loc_t DestLoc>
+void tdma_load_async(tensor<T, DestLoc> &dest,
+                     tensor<T, loc_t::device> &&src,
+                     thread_context &ctx) {
+    __tensor_copy_sync(std::forward<tensor<T, DestLoc>>(dest),
+                       std::forward<tensor<T, loc_t::device>>(src), ctx);
 }
 
-template <class T>
-void tdma_store_async(tensor<T, tensor_loc_t::local> &src,
-                      tensor<T, tensor_loc_t::device> &&dest) {
-    __tensor_copy_sync(dest, src);
+template <class T, loc_t SrcLoc>
+void tdma_store_async(tensor<T, SrcLoc> &src,
+                      tensor<T, loc_t::device> &&dest,
+                      thread_context &ctx) {
+    __tensor_copy_sync(std::forward<tensor<T, loc_t::device>>(dest),
+                       std::forward<tensor<T, SrcLoc>>(src), ctx);
 }
 
 template <class T>
-void tdma_fill_async(tensor<T, tensor_loc_t::local> &src, T data) {
+void tdma_fill_async(tensor<T, loc_t::local> &src, T data) {
     apply(src.dimension(), [&](gsl::span<size_t> index) -> void {
         src.data()[offset(src.strides(), index)] = data;
     });
 }
 
 template <class T>
-void tdma_broadcast_async(tensor<T, tensor_loc_t::local> &src,
-                          tensor<T, tensor_loc_t::shared> &dest,
+void tdma_broadcast_async(tensor<T, loc_t::local> &src,
+                          tensor<T, loc_t::shared> &dest,
                           thread_context &ctx) {
 
     global_hardware_ctx->lock_block(ctx.bid());
@@ -137,7 +198,7 @@ void tdma_broadcast_async(tensor<T, tensor_loc_t::local> &src,
     // global_hardware_ctx->wait_block_sync(ctx.bid(), cnt);
 }
 
-template <class T, tensor_loc_t Src, tensor_loc_t Dest>
+template <class T, loc_t Src, loc_t Dest>
 void tdma_load_broadcast_async([[maybe_unused]] tensor<T, Dest> &dest,
                                [[maybe_unused]] tensor<T, Src> &src,
                                [[maybe_unused]] thread_context &ctx) {
@@ -153,7 +214,7 @@ enum class reduce_op_t : uint8_t {
 };
 
 template <class T>
-void tdma_all_reduce_async(tensor<T, tensor_loc_t::local> &src,
+void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
                            thread_context &ctx,
                            reduce_op_t reduce_op = reduce_op_t::SUM) {
     switch (reduce_op) {
@@ -196,6 +257,8 @@ void __tdma_block_sync_apply(std::function<void(int)> func,
                              thread_context &ctx) {
     global_hardware_ctx->lock_block(ctx.bid());
     int visited = global_hardware_ctx->mark_block_visit(ctx.bid(), ctx.tid());
+    SPDLOG_DEBUG("__tdma_block_sync_apply bid {} tid {} visited {}\n",
+                 ctx.bid(), ctx.tid(), visited);
     func(visited);
     global_hardware_ctx->unlock_block(ctx.bid());
     global_hardware_ctx->wait_block_sync(ctx.bid(), visited);
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index eb79aeed34..6d0a792881 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -6,13 +6,13 @@
 #include <hardware_def.h>
 #include <runtime_utils.h>
 
-enum class tensor_loc_t : uint8_t {
+enum class loc_t : uint8_t {
     shared,
     device,
     local,
 };
 
-template <typename T, tensor_loc_t Loc = tensor_loc_t::local> class tensor {
+template <typename T, loc_t Loc = loc_t::local> class tensor {
 
   public:
     using value_type = T;
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
new file mode 100644
index 0000000000..8059af00b6
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
@@ -0,0 +1,12 @@
+import numpy as np
+
+X = np.random.rand(384,8192).astype(np.float32)
+WK = np.random.rand(64,8192,128).astype(np.float32) * 5 - 1
+
+K = X @ WK
+
+
+
+X.tofile("X.bin")
+WK.tofile("WK.bin")
+K.tofile("K.bin")
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index e7dbce55b6..fce9775de4 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -2,10 +2,10 @@
 // seq-len = 384, w-len = 8192, heads = 64, head-len = 128
 // 1 chips, 8 blocks per chip, 4 threads per block
 
-// tensor<float, tensor_loc_t::shared> X({384, 8192});
-// tensor<float, tensor_loc_t::shared> kh({8, 384, 128}), vh({8, 384, 128}); //
-// [8, 384, 128] tensor<float, tensor_loc_t::shared> qkh({8, 384, 384});    //
-// [8, 384, 384] tensor<float, tensor_loc_t::shared> qkh({8, 384, 384});    //
+// tensor<float, loc_t::shared> X({384, 8192});
+// tensor<float, loc_t::shared> kh({8, 384, 128}), vh({8, 384, 128}); //
+// [8, 384, 128] tensor<float, loc_t::shared> qkh({8, 384, 384});    //
+// [8, 384, 384] tensor<float, loc_t::shared> qkh({8, 384, 384});    //
 // [8, 384, 384]
 #include "thread_context.h"
 using namespace shared;
@@ -21,18 +21,20 @@ static tensor<float> wkh({8, 2048, 128});
 // 8 head per block
 // 2048 w-len per thread
 void stage1_kernel(
-    // tensor<float, tensor_loc_t::device> &WQ,  /* 64, 8192, 128 */
-    tensor<float, tensor_loc_t::device> &WK /* 64, 8192, 128 */
-    //  tensor<float, tensor_loc_t::device> &WV,  /* 64, 8192, 128 */
-    //  tensor<float, tensor_loc_t::device> &WFC1 /* 384, 8192*/
+    // tensor<float, loc_t::device> &WQ,  /* 64, 8192, 128 */
+    tensor<float, loc_t::device> &WK, /* 64, 8192, 128 */
+    tensor<float, loc_t::device> &K   /* 64, 384, 128 */
+    //  tensor<float, loc_t::device> &WV,  /* 64, 8192, 128 */
+    //  tensor<float, loc_t::device> &WFC1 /* 384, 8192*/
 ) {
+    thread_context ctx(bid, tid);
     // 1. Get xi
     auto xi = X({0, tid * 2048}, {384, 2048}); // [384, 2048]
 
     // 2. load wqh wkh wvh
     if (!w_loaded) {
         // tdma_load_async(wqh, WQ({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
-        tdma_load_async(wkh, WK({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
+        tdma_load_async(wkh, WK({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
         // tdma_load_async(wvh, WV({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
         // tdma_load_async(wfc1ih, WFC1({bid * 1024, tid * 8192}, {1024,
         // 8192})); tdma_wait(); // 等待 x, wqh, wkh, wvh ready
@@ -44,9 +46,11 @@ void stage1_kernel(
     //     sched_strategy_t::pin_block_tensor); // 仅在 block 内调度线程的
     //     tensor
     //                                          // 指令
-    thread_context ctx(tid, bid);
+
     tensor_block_mma_sync(xi, wkh, kh, false,
                           ctx); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
+
+    tdma_store_async(kh, K({bid * 8, 0, 0}, {8, 384, 128}), ctx);
     // vh = tensor_block_mma_sync(
     //     xi, wvh); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
 
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
index 072a057158..ed9da9b70d 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
@@ -1,9 +1,11 @@
 #include "cluster_def.h"
+#include <io_utils.h>
+#include <runtime_utils.h>
 // #include <pthread.h>
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(WK);                                \
+        block##b::thread##t::stage1_kernel(WK, K);                             \
         return arg;                                                            \
     }
 
@@ -13,7 +15,8 @@
     DEFINE_TFUNC(b, 2)                                                         \
     DEFINE_TFUNC(b, 3)
 
-tensor<float, tensor_loc_t::device> WK({64, 8192, 128});
+tensor<float, loc_t::device> WK({64, 8192, 128});
+tensor<float, loc_t::device> K({64, 384, 128});
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
@@ -24,52 +27,102 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
-int main() {
+/**
+ * @brief demo1 X.bin WK.bin K.bin
+ * 
+ * @param argc 
+ * @param argv 
+ * @return int 
+ */
+int main([[maybe_unused]] int argc, char **argv) {
+    assert(argc == 4);
+    spdlog::set_level(spdlog::level::debug);
     global_hardware_init();
 
-    pthread_t t_0_0; // t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-    pthread_t t_0_1; // t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-    pthread_t t_0_2; // t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-    pthread_t t_0_3; // t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
+    /* fill tensor */
+    auto src_X = read_file(std::string(argv[1]));
+    auto src_WK = read_file(std::string(argv[2]));
+    auto src_K = read_file(std::string(argv[3]));
+    span_copy(WK.data(), gsl::make_span(src_WK).as_span<float>());
+    span_copy(block0::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block1::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block2::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block3::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block4::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block5::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block6::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block7::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    
+
+    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
     pthread_create(&t_0_0, NULL, f_0_0, NULL);
     pthread_create(&t_0_1, NULL, f_0_1, NULL);
     pthread_create(&t_0_2, NULL, f_0_2, NULL);
     pthread_create(&t_0_3, NULL, f_0_3, NULL);
-    // pthread_create(&t_0_2, NULL, (void *(*)(void *)) & func_0_2, NULL);
-    // pthread_create(&t_0_3, NULL, (void *(*)(void *)) & func_0_3, NULL);
-    // pthread_create(&t_1_0, NULL, (void *(*)(void *)) & func_1_0, NULL);
-    // pthread_create(&t_1_1, NULL, (void *(*)(void *)) & func_1_1, NULL);
-    // pthread_create(&t_1_2, NULL, (void *(*)(void *)) & func_1_2, NULL);
-    // pthread_create(&t_1_3, NULL, (void *(*)(void *)) & func_1_3, NULL);
-    // pthread_create(&t_2_0, NULL, (void *(*)(void *)) & func_2_0, NULL);
-    // pthread_create(&t_2_1, NULL, (void *(*)(void *)) & func_2_1, NULL);
-    // pthread_create(&t_2_2, NULL, (void *(*)(void *)) & func_2_2, NULL);
-    // pthread_create(&t_2_3, NULL, (void *(*)(void *)) & func_2_3, NULL);
-    // pthread_create(&t_3_0, NULL, (void *(*)(void *)) & func_3_0, NULL);
-    // pthread_create(&t_3_1, NULL, (void *(*)(void *)) & func_3_1, NULL);
-    // pthread_create(&t_3_2, NULL, (void *(*)(void *)) & func_3_2, NULL);
-    // pthread_create(&t_3_3, NULL, (void *(*)(void *)) & func_3_3, NULL);
-    // pthread_create(&t_4_0, NULL, (void *(*)(void *)) & func_4_0, NULL);
-    // pthread_create(&t_4_1, NULL, (void *(*)(void *)) & func_4_1, NULL);
-    // pthread_create(&t_4_2, NULL, (void *(*)(void *)) & func_4_2, NULL);
-    // pthread_create(&t_4_3, NULL, (void *(*)(void *)) & func_4_3, NULL);
-    // pthread_create(&t_5_0, NULL, (void *(*)(void *)) & func_5_0, NULL);
-    // pthread_create(&t_5_1, NULL, (void *(*)(void *)) & func_5_1, NULL);
-    // pthread_create(&t_5_2, NULL, (void *(*)(void *)) & func_5_2, NULL);
-    // pthread_create(&t_5_3, NULL, (void *(*)(void *)) & func_5_3, NULL);
-    // pthread_create(&t_6_0, NULL, (void *(*)(void *)) & func_6_0, NULL);
-    // pthread_create(&t_6_1, NULL, (void *(*)(void *)) & func_6_1, NULL);
-    // pthread_create(&t_6_2, NULL, (void *(*)(void *)) & func_6_2, NULL);
-    // pthread_create(&t_6_3, NULL, (void *(*)(void *)) & func_6_3, NULL);
-    // pthread_create(&t_7_0, NULL, (void *(*)(void *)) & func_7_0, NULL);
-    // pthread_create(&t_7_1, NULL, (void *(*)(void *)) & func_7_1, NULL);
-    // pthread_create(&t_7_2, NULL, (void *(*)(void *)) & func_7_2, NULL);
-    // pthread_create(&t_7_3, NULL, (void *(*)(void *)) & func_7_3, NULL);
+    pthread_create(&t_1_0, NULL, f_1_0, NULL);
+    pthread_create(&t_1_1, NULL, f_1_1, NULL);
+    pthread_create(&t_1_2, NULL, f_1_2, NULL);
+    pthread_create(&t_1_3, NULL, f_1_3, NULL);
+    pthread_create(&t_2_0, NULL, f_2_0, NULL);
+    pthread_create(&t_2_1, NULL, f_2_1, NULL);
+    pthread_create(&t_2_2, NULL, f_2_2, NULL);
+    pthread_create(&t_2_3, NULL, f_2_3, NULL);
+    pthread_create(&t_3_0, NULL, f_3_0, NULL);
+    pthread_create(&t_3_1, NULL, f_3_1, NULL);
+    pthread_create(&t_3_2, NULL, f_3_2, NULL);
+    pthread_create(&t_3_3, NULL, f_3_3, NULL);
+    pthread_create(&t_4_0, NULL, f_4_0, NULL);
+    pthread_create(&t_4_1, NULL, f_4_1, NULL);
+    pthread_create(&t_4_2, NULL, f_4_2, NULL);
+    pthread_create(&t_4_3, NULL, f_4_3, NULL);
+    pthread_create(&t_5_0, NULL, f_5_0, NULL);
+    pthread_create(&t_5_1, NULL, f_5_1, NULL);
+    pthread_create(&t_5_2, NULL, f_5_2, NULL);
+    pthread_create(&t_5_3, NULL, f_5_3, NULL);
+    pthread_create(&t_6_0, NULL, f_6_0, NULL);
+    pthread_create(&t_6_1, NULL, f_6_1, NULL);
+    pthread_create(&t_6_2, NULL, f_6_2, NULL);
+    pthread_create(&t_6_3, NULL, f_6_3, NULL);
+    pthread_create(&t_7_0, NULL, f_7_0, NULL);
+    pthread_create(&t_7_1, NULL, f_7_1, NULL);
+    pthread_create(&t_7_2, NULL, f_7_2, NULL);
+    pthread_create(&t_7_3, NULL, f_7_3, NULL);
+
     pthread_join(t_0_0, NULL);
     pthread_join(t_0_1, NULL);
     pthread_join(t_0_2, NULL);
     pthread_join(t_0_3, NULL);
-
+    pthread_join(t_1_0, NULL);
+    pthread_join(t_1_1, NULL);
+    pthread_join(t_1_2, NULL);
+    pthread_join(t_1_3, NULL);
+    pthread_join(t_2_0, NULL);
+    pthread_join(t_2_1, NULL);
+    pthread_join(t_2_2, NULL);
+    pthread_join(t_2_3, NULL);
+    pthread_join(t_3_0, NULL);
+    pthread_join(t_3_1, NULL);
+    pthread_join(t_3_2, NULL);
+    pthread_join(t_3_3, NULL);
+    pthread_join(t_4_0, NULL);
+    pthread_join(t_4_1, NULL);
+    pthread_join(t_4_2, NULL);
+    pthread_join(t_4_3, NULL);
+    pthread_join(t_5_0, NULL);
+    pthread_join(t_5_1, NULL);
+    pthread_join(t_5_2, NULL);
+    pthread_join(t_5_3, NULL);
+    pthread_join(t_6_0, NULL);
+    pthread_join(t_6_1, NULL);
+    pthread_join(t_6_2, NULL);
+    pthread_join(t_6_3, NULL);
+    pthread_join(t_7_0, NULL);
+    pthread_join(t_7_1, NULL);
+    pthread_join(t_7_2, NULL);
+    pthread_join(t_7_3, NULL);
     return 0;
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
index c53827bbaa..9635ff25ee 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
@@ -1,8 +1,8 @@
 #include <tdma.h>
 
 namespace shared {
-static tensor<float, tensor_loc_t::shared> X({384, 8192});
-static tensor<float, tensor_loc_t::shared> kh({8, 384, 128});
+static tensor<float, loc_t::shared> X({384, 8192});
+static tensor<float, loc_t::shared> kh({8, 384, 128});
 // vh({8, 384, 128});                                         // [8, 384, 128]
 // static tensor<float, tensor_loc_t::shared> qkh({8, 384, 384}); // [8, 384,
 // 384]

From 78f59c336ab49fb3eea839791c945f1e730c9be2 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Wed, 16 Aug 2023 06:23:22 +0000
Subject: [PATCH 090/308] Apply code-format changes

---
 .../cpu/src/runtime/cmodel/include/io_utils.h |  1 -
 modules/cpu/src/runtime/cmodel/include/tdma.h | 28 ++++++-------------
 .../src/runtime/cmodel/tests/demo1/main.cpp   |  9 +++---
 3 files changed, 13 insertions(+), 25 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/io_utils.h b/modules/cpu/src/runtime/cmodel/include/io_utils.h
index 8dceaa9bfe..937e025848 100644
--- a/modules/cpu/src/runtime/cmodel/include/io_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/io_utils.h
@@ -4,7 +4,6 @@
 #include <tensor.h>
 #include <vector>
 
-
 inline std::vector<uint8_t> read_stream(std::istream &stream) {
     stream.seekg(0, std::ios::end);
     size_t length = stream.tellg();
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 6ec0254f55..a5eee0cce4 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -9,10 +9,8 @@
 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
 #include <spdlog/spdlog.h>
 
-
 template <template <class, loc_t> class TS, class DT>
-void __tensor_copy_sync(TS<DT, loc_t::local> &&dest,
-                        TS<DT, loc_t::local> &&src,
+void __tensor_copy_sync(TS<DT, loc_t::local> &&dest, TS<DT, loc_t::local> &&src,
                         [[maybe_unused]] thread_context &ctx) {
     assert(dest.dimension() == src.dimension());
     apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
@@ -141,20 +139,17 @@ void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
     __tdma_block_sync_apply(
         [&](int visited) -> void {
             if (load_psum) {
-                __tensor_binary_sync<T, loc_t::local,
-                                     loc_t::shared,
+                __tensor_binary_sync<T, loc_t::local, loc_t::shared,
                                      loc_t::shared>(
                     tmp, c, c, [](T _a, T _b) -> T { return _a + _b; });
             } else {
                 if (visited == 1) {
-                    __tensor_binary_sync<T, loc_t::local,
-                                         loc_t::shared,
+                    __tensor_binary_sync<T, loc_t::local, loc_t::shared,
                                          loc_t::shared>(
                         tmp, c, c,
                         [](T _a, [[maybe_unused]] T _b) -> T { return _a; });
                 } else {
-                    __tensor_binary_sync<T, loc_t::local,
-                                         loc_t::shared,
+                    __tensor_binary_sync<T, loc_t::local, loc_t::shared,
                                          loc_t::shared>(
                         tmp, c, c, [](T _a, T _b) -> T { return _a + _b; });
                 }
@@ -164,23 +159,20 @@ void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
 }
 
 template <class T, loc_t DestLoc>
-void tdma_load_async(tensor<T, DestLoc> &dest,
-                     tensor<T, loc_t::device> &&src,
+void tdma_load_async(tensor<T, DestLoc> &dest, tensor<T, loc_t::device> &&src,
                      thread_context &ctx) {
     __tensor_copy_sync(std::forward<tensor<T, DestLoc>>(dest),
                        std::forward<tensor<T, loc_t::device>>(src), ctx);
 }
 
 template <class T, loc_t SrcLoc>
-void tdma_store_async(tensor<T, SrcLoc> &src,
-                      tensor<T, loc_t::device> &&dest,
+void tdma_store_async(tensor<T, SrcLoc> &src, tensor<T, loc_t::device> &&dest,
                       thread_context &ctx) {
     __tensor_copy_sync(std::forward<tensor<T, loc_t::device>>(dest),
                        std::forward<tensor<T, SrcLoc>>(src), ctx);
 }
 
-template <class T>
-void tdma_fill_async(tensor<T, loc_t::local> &src, T data) {
+template <class T> void tdma_fill_async(tensor<T, loc_t::local> &src, T data) {
     apply(src.dimension(), [&](gsl::span<size_t> index) -> void {
         src.data()[offset(src.strides(), index)] = data;
     });
@@ -188,8 +180,7 @@ void tdma_fill_async(tensor<T, loc_t::local> &src, T data) {
 
 template <class T>
 void tdma_broadcast_async(tensor<T, loc_t::local> &src,
-                          tensor<T, loc_t::shared> &dest,
-                          thread_context &ctx) {
+                          tensor<T, loc_t::shared> &dest, thread_context &ctx) {
 
     global_hardware_ctx->lock_block(ctx.bid());
     __tensor_copy_sync(dest, src);
@@ -214,8 +205,7 @@ enum class reduce_op_t : uint8_t {
 };
 
 template <class T>
-void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
-                           thread_context &ctx,
+void tdma_all_reduce_async(tensor<T, loc_t::local> &src, thread_context &ctx,
                            reduce_op_t reduce_op = reduce_op_t::SUM) {
     switch (reduce_op) {
     case reduce_op_t::SUM: {
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
index ed9da9b70d..3923e01c24 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
@@ -29,10 +29,10 @@ DEFINE_BFUNC(7)
 
 /**
  * @brief demo1 X.bin WK.bin K.bin
- * 
- * @param argc 
- * @param argv 
- * @return int 
+ *
+ * @param argc
+ * @param argv
+ * @return int
  */
 int main([[maybe_unused]] int argc, char **argv) {
     assert(argc == 4);
@@ -52,7 +52,6 @@ int main([[maybe_unused]] int argc, char **argv) {
     span_copy(block5::shared::X.data(), gsl::make_span(src_X).as_span<float>());
     span_copy(block6::shared::X.data(), gsl::make_span(src_X).as_span<float>());
     span_copy(block7::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;

From 703c08116eb884f9a8215f196f6a9a4a909a1337 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 16 Aug 2023 14:52:41 +0800
Subject: [PATCH 091/308] pass mma k

---
 .../runtime/cmodel/include/runtime_utils.h    | 22 +++++++++++++++++++
 .../runtime/cmodel/src/hardware_context.cpp   | 14 +++++++++++-
 .../src/runtime/cmodel/tests/demo1/main.cpp   |  5 +++++
 3 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 6d7ff3c8e6..429312fda6 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -125,4 +125,26 @@ get_last_not_contiguous_index(gsl::span<const size_t> strides,
 template <typename T>
 inline void span_copy(gsl::span<T> dest, gsl::span<T> src) {
     std::copy(src.begin(), src.end(), dest.begin());
+}
+
+template <typename T>
+inline void span_equal(gsl::span<T> dest, gsl::span<T> src) {
+    std::copy(src.begin(), src.end(), dest.begin());
+}
+
+template <typename T> double dot(const T *v1, const T *v2, size_t size) {
+    double ret = 0.f;
+    for (size_t i = 0; i < size; i++) {
+        ret += v1[i] * v2[i];
+    }
+
+    return ret;
+}
+
+template <typename T> double cosine(const T *v1, const T *v2, size_t size) {
+    for (size_t i = 0; i < 10; i++) {
+        std::cout << v1[i] << " " << v2[i] << std::endl;
+    }
+    return dot(v1, v2, size) /
+           ((sqrt(dot(v1, v1, size)) * sqrt(dot(v2, v2, size))));
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp b/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
index 8412c5b678..4878c3f00e 100644
--- a/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
+++ b/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
@@ -11,6 +11,11 @@ class condition_variable {
 
     pthread_mutex_t mutex;
     pthread_cond_t cond;
+
+    ~condition_variable() {
+        pthread_mutex_destroy(&mutex);
+        pthread_cond_destroy(&cond);
+    }
 };
 
 struct hardware_context_impl {
@@ -49,6 +54,13 @@ struct hardware_context_impl {
     pthread_mutex_t block_mutexs[BLOCKS];
     condition_variable block_conds[BLOCKS];
     bool block_visited[BLOCKS][CORES];
+
+    ~hardware_context_impl() {
+        pthread_mutex_destroy(&global_mutex);
+        for (size_t i = 0; i < BLOCKS; i++) {
+            pthread_mutex_destroy(&block_mutexs[i]);
+        }
+    }
 };
 
 hardware_context::hardware_context() {
@@ -112,7 +124,7 @@ void hardware_context::wait_all_sync(int visited) {
     pthread_mutex_unlock(&impl_->global_cond.mutex);
 }
 
-std::unique_ptr<hardware_context> global_hardware_ctx;
+std::unique_ptr<hardware_context> global_hardware_ctx = nullptr;
 
 void global_hardware_init() {
     global_hardware_ctx = std::make_unique<hardware_context>();
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
index 3923e01c24..3729b4aed1 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
@@ -123,5 +123,10 @@ int main([[maybe_unused]] int argc, char **argv) {
     pthread_join(t_7_1, NULL);
     pthread_join(t_7_2, NULL);
     pthread_join(t_7_3, NULL);
+
+    auto cos =
+        cosine(K.data().begin(), gsl::make_span(src_K).as_span<float>().begin(),
+               K.data().size());
+    printf("K cosine %f\n", cos);
     return 0;
 }
\ No newline at end of file

From bdd866ce2ce615d0430c22cd5b43774f13fbec35 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 16 Aug 2023 15:07:31 +0800
Subject: [PATCH 092/308] update matmul

---
 .../cpu/src/runtime/cmodel/include/matmul.h   | 27 ++++++++++---------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
index 3cb60a08f8..e2d9a5d8c3 100644
--- a/modules/cpu/src/runtime/cmodel/include/matmul.h
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -10,17 +10,16 @@ void matmul_unit_impl(const T *input_a, const T *input_b, T *output,
     int32_t b_cols = static_cast<int32_t>(in_b_shape[1]);
 
     for (int32_t oy = 0; oy < a_rows; oy++) {
-        for (int32_t ox = 0; ox < b_cols; ox++) {
-            T value = 0;
-
-            for (int32_t i = 0; i < a_cols; i++) {
+        T *values = new T[b_cols]();
+        for (int32_t i = 0; i < a_cols; i++) {
+            for (int32_t ox = 0; ox < b_cols; ox++) {
                 const auto a = input_a[oy * a_cols + i];
                 const auto b = input_b[i * b_cols + ox];
-                value += a * b;
+                values[ox] += a * b;
             }
-
-            output[oy * b_cols + ox] = value;
         }
+        std::copy_n(values, b_cols, output + oy * b_cols);
+        delete[] values;
     }
 }
 
@@ -94,14 +93,16 @@ void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                 T *out_ptr = output + n * new_out_stride[0] +
                              c * new_out_stride[1] + h * new_out_stride[2];
                 for (size_t m = 0; m < new_a_shape[3]; m++) {
-                    for (size_t n = 0; n < new_b_shape[4]; n++) {
-                        T value = 0;
-                        for (size_t k = 0; k < new_a_shape[4]; k++) {
-                            value += in_a_ptr[m * new_a_stride[3] + k] *
-                                     in_b_ptr[k * new_b_stride[3] + n];
+                    T *values = new T[new_b_shape[4]]();
+                    for (size_t k = 0; k < new_a_shape[4]; k++) {
+                        for (size_t n = 0; n < new_b_shape[4]; n++) {
+                            values[n] += in_a_ptr[m * new_a_stride[3] + k] *
+                                         in_b_ptr[k * new_b_stride[3] + n];
                         }
-                        out_ptr[m * new_out_stride[3] + n] = value;
                     }
+                    std::copy_n(values, new_b_shape[4],
+                                out_ptr + m * new_out_stride[3]);
+                    delete[] values;
                 }
             }
         }

From b510e6d5f65d438ca97b39c4b4edfc673f68423e Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 16 Aug 2023 16:59:46 +0800
Subject: [PATCH 093/308] fix build

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt          | 2 +-
 modules/cpu/src/runtime/cmodel/include/runtime_utils.h | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index df0bf6fa1e..9508765184 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -15,7 +15,7 @@ install(TARGETS cpu_cmodel_cli COMPONENT nncase-runtime)
 
 function(add_test name test_path)
   add_executable(${name} "${test_path}/main.cpp")
-  target_link_libraries(${name} cpu_cmodel spdlog)
+  target_link_libraries(${name} cpu_cmodel spdlogd)
 endfunction(add_test)
 
 add_test(demo1 tests/demo1)
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 429312fda6..b4885f0fe4 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -7,6 +7,7 @@
 #include <numeric>
 #include <runtime_types.h>
 #include <vector>
+#include <cmath>
 
 void print_vec(itlib::small_vector<size_t, 8> vec) {
     for (const size_t v : vec) {

From e5c71c07ab70d2f0bd351f3ada0d52e989088a14 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 16 Aug 2023 17:06:27 +0800
Subject: [PATCH 094/308] add layernorm

---
 .../src/runtime/cmodel/include/layernorm.h    | 125 ++++++++++++++++++
 modules/cpu/src/runtime/cmodel/include/tdma.h |   1 +
 2 files changed, 126 insertions(+)
 create mode 100644 modules/cpu/src/runtime/cmodel/include/layernorm.h

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
new file mode 100644
index 0000000000..52a13c2ae3
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -0,0 +1,125 @@
+#include "runtime_utils.h"
+#include <cmath>
+#ifdef __riscv_vector
+#include <riscv_vector.h>
+#endif
+
+namespace {
+template <typename T>
+void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *gamma,
+                          T *beta, gsl::span<const size_t> input_shape,
+                          [[maybe_unused]] gsl::span<const size_t> input_stride,
+                          T *eps, int32_t axis, int32_t norm_size) noexcept {
+    // only process continues tensor for now
+    size_t outer_size = 1;
+    for (auto i = 0; i < axis; i++) {
+        outer_size *= input_shape[i];
+    }
+
+    size_t inner_size = 1;
+    for (auto i = axis; i < input_shape.size(); i++) {
+        inner_size *= input_shape[i];
+    }
+
+    for (size_t o = 0; o < outer_size; o++) {
+        auto mean = sum[o] / norm_size;
+        auto sigma = std::sqrt(sum_sqr[o] / norm_size + eps);
+        for (size_t i = 0; i < inner_size; i++) {
+            auto x = input + o * inner_size + i;
+            *x = (*x - mean) / sigma * gamma[i] + beta[i];
+        }
+    }
+}
+
+#ifdef __riscv_vector
+template <typename T>
+void layernorm_rvv_impl(const T *input, const T *sum, T *sum_sqr, T *gamma,
+                        T *beta, gsl::span<const size_t> input_shape,
+                        [[maybe_unused]] gsl::span<const size_t> input_stride,
+                        T *eps, int32_t axis, int32_t norm_size) noexcept {
+    // only process continues float32 tensor for now
+    size_t outer_size = 1;
+    for (auto i = 0; i < axis; i++) {
+        outer_size *= input_shape[i];
+    }
+
+    size_t inner_size = 1;
+    for (auto i = axis; i < input_shape.size(); i++) {
+        inner_size *= input_shape[i];
+    }
+
+    size_t vl;
+    float *sum_ptr = sum;
+    float *sum_sqr_ptr = sum_sqr;
+    std::vector<float> mean(outer_size, 0);
+    std::vector<float> sigma(outer_size, 0);
+    vfloat32m8_t vmean;
+    vfloat32m8_t vsigma;
+    size_t offset = 0;
+    for (size_t o = outer_size; o > 0; o -= vl) {
+        vl = vsetvl_e32m8(o);
+
+        // mean
+        vmean = vle32_v_f32m8(sum_ptr, vl);
+        vmean = vfdiv_vf_f32m8(vmean, norm_size);
+        vse32_v_f32m8(mean.data() + offset, vmean, vl);
+
+        // sigma
+        vsigma = vle32_v_f32m8(sum_sqr_ptr, vl);
+        vsigma = vfdiv_vf_f32m8(vsigma, norm_size);
+        vsigma = vfadd_vf_f32m8(vsigma, eps);
+        vsigma = vfsqrt_v_f32m8(vsigma);
+        vse32_v_f32m8(sigma.data() + offset, vsigma, vl);
+
+        sum_ptr += vl;
+        sum_sqr_ptr += vl;
+        offset += vl;
+    }
+
+    float *input_ptr = input;
+    float *gamma_ptr = gamma;
+    float *beta_ptr = beta;
+    vfloat32m8_t vx;
+    vfloat32m8_t vgamma;
+    vfloat32m8_t vbeta;
+    for (size_t i = inner_size; i < inner_size; i -= vl) {
+        vl = vsetvl_e32m8(i);
+
+        vgamma = vle32_v_f32m8(gamma_ptr, vl);
+        vbeta = vle32_v_f32m8(beta_ptr, vl);
+
+        for (size_t o = 0; o < outer_size; o++) {
+            vx = vle32_v_f32m8(input_ptr, vl);
+            vx = vfsub_vf_f32m8(vx, mean[o], vl);
+            vx = vfdiv_vf_f32m8(vx, sigma[o], vl);
+            vx = vfmacc_vv_f32m8(vbeta, vx, vgamma, vl);
+            input_ptr += inner_size;
+        }
+
+        gamma_ptr += vl;
+        beta_ptr += vl;
+        input_ptr = input + vl;
+    }
+}
+#endif
+
+} // namespace
+
+template <class T>
+void layernorm(T *input, T *sum, T *sum_sqr, T *gamma, T *beta,
+               dims_t input_dims, strides_t input_strides, T *eps, int32_t axis,
+               int32_t norm_size) {
+#ifdef __riscv_vector
+    return layernorm_rvv_impl(
+        input, sum, sum_sqr, gamma, beta,
+        gsl::make_span(input_dims).template as_span<const size_t>(),
+        gsl::make_span(input_strides).template as_span<const size_t>(), eps,
+        axis, norm_size);
+#else
+    return layernorm_naive_impl(
+        input, sum, sum_sqr, gamma, beta,
+        gsl::make_span(input_dims).template as_span<const size_t>(),
+        gsl::make_span(input_strides).template as_span<const size_t>(), eps,
+        axis, norm_size);
+#endif
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index a5eee0cce4..9a0d914d76 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -4,6 +4,7 @@
 #include <functional>
 #include <hardware_context.h>
 #include <matmul.h>
+#include <layernorm.h>
 #include <tensor.h>
 #include <thread_context.h>
 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG

From 33ea7ac014c1b2a9d1ff753f36fbfb4f22b82d76 Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Wed, 16 Aug 2023 09:09:47 +0000
Subject: [PATCH 095/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/include/runtime_utils.h | 2 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h          | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index b4885f0fe4..864a782070 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -1,13 +1,13 @@
 #pragma once
 
 #include <array>
+#include <cmath>
 #include <cstddef>
 #include <gsl/gsl-lite.hpp>
 #include <iostream>
 #include <numeric>
 #include <runtime_types.h>
 #include <vector>
-#include <cmath>
 
 void print_vec(itlib::small_vector<size_t, 8> vec) {
     for (const size_t v : vec) {
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 9a0d914d76..7afb48e268 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -3,8 +3,8 @@
 #include <cassert>
 #include <functional>
 #include <hardware_context.h>
-#include <matmul.h>
 #include <layernorm.h>
+#include <matmul.h>
 #include <tensor.h>
 #include <thread_context.h>
 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG

From 23385f512b76d7fe825e94fd7dcb02b65203d327 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 16 Aug 2023 19:35:21 +0800
Subject: [PATCH 096/308] pass reduce

---
 .../runtime/cmodel/include/hardware_context.h |   8 +-
 .../cpu/src/runtime/cmodel/include/reduce.h   | 146 ++++++++++++
 .../runtime/cmodel/include/runtime_utils.h    |  48 ++++
 modules/cpu/src/runtime/cmodel/include/tdma.h | 222 ++++++++++--------
 .../cpu/src/runtime/cmodel/include/tensor.h   |  17 +-
 .../runtime/cmodel/src/hardware_context.cpp   |   8 +-
 .../src/runtime/cmodel/tests/demo1/golden.py  |   9 +-
 .../src/runtime/cmodel/tests/demo1/kernel.h   |  14 +-
 .../src/runtime/cmodel/tests/demo1/main.cpp   |  13 +-
 9 files changed, 368 insertions(+), 117 deletions(-)
 create mode 100644 modules/cpu/src/runtime/cmodel/include/reduce.h

diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_context.h b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
index 2b701051cf..442160c2f0 100644
--- a/modules/cpu/src/runtime/cmodel/include/hardware_context.h
+++ b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
@@ -11,12 +11,14 @@ class hardware_context {
     void lock_block(int bid);
     int mark_block_visit(int bid, int tid);
     void unlock_block(int bid);
-    void wait_block_sync(int bid, int visited);
+    void wait_block_sync(
+        int bid, int visited, std::function<void()> callable = []() -> void {});
     void lock_all();
     int mark_all_visit(int bid, int tid);
     void unlock_all();
-    void wait_all_sync(int visited);
-    void *all_reduce_var = nullptr;
+    void wait_all_sync(
+        int visited, std::function<void()> callable = []() -> void {});
+    void *global_var = nullptr;
 
   private:
     std::unique_ptr<hardware_context_impl> impl_;
diff --git a/modules/cpu/src/runtime/cmodel/include/reduce.h b/modules/cpu/src/runtime/cmodel/include/reduce.h
new file mode 100644
index 0000000000..ca1f1f2008
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/reduce.h
@@ -0,0 +1,146 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <apply.h>
+#include <gsl/gsl-lite.hpp>
+#include <runtime_utils.h>
+
+enum class reduce_op_t : uint8_t {
+    mean = 0,
+    min = 1,
+    max = 2,
+    sum = 3,
+    prod = 4,
+};
+
+namespace {
+template <class T> struct identity {
+    T operator()(const T &src) const noexcept { return src; }
+};
+
+template <class TReducer, class TPostProcess, class T>
+void reduce_impl(TReducer &&reducer, TPostProcess &&post_process, T init_value,
+                 const T *input, T *output, gsl::span<const size_t> in_shape,
+                 gsl::span<const size_t> axis,
+                 gsl::span<const size_t> in_strides,
+                 gsl::span<const size_t> out_shape,
+                 gsl::span<const size_t> out_strides, bool keep_dims) noexcept {
+    apply(out_shape, [&](gsl::span<const size_t> index) -> void {
+        output[offset(out_strides, index)] = init_value;
+    });
+    apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        const auto v = input[offset(in_strides, index)];
+        const auto out_index = get_reduced_offset(index, axis, keep_dims);
+        auto &dest = output[offset(out_strides, out_index)];
+        dest = reducer(dest, v);
+    });
+    apply(out_shape, [&](gsl::span<const size_t> index) -> void {
+        auto &dest = output[offset(out_strides, index)];
+        dest = post_process(dest);
+    });
+}
+} // namespace
+
+// #define REDUCE_IMPL(_ty, op, reducer, post_process)                            \
+//     case op:                                                                   \
+//         return reduce_impl(reducer, post_process,                              \
+//                            SCALAR_CAST(_ty, init_value), IN_CAST(_ty, input),  \
+//                            OUT_CAST(_ty, output), in_shape, axis, in_strides,  \
+//                            out_shape, out_strides, keep_dims, context)
+
+#define REDUCE_IMPL_NO_POST(op, reducer)                                       \
+    case op:                                                                   \
+        return reduce_impl(reducer, identity<T>(),                             \
+                           *reinterpret_cast<const T *>(init_value), input,    \
+                           output, in_shape, axis, in_strides, out_shape,      \
+                           out_strides, keep_dims)
+
+template <typename T>
+void reduce_prod(const T *input, T *output, gsl::span<const size_t> in_shape,
+                 gsl::span<const size_t> in_strides,
+                 gsl::span<const size_t> out_strides_origin,
+                 gsl::span<const size_t> axes, bool keep_dims) noexcept {
+    auto out_shape = get_reduced_shape(in_shape, axes, keep_dims);
+    auto out_strides =
+        out_strides_origin.size() == 0 ? dims_t{1} : dims_t(out_strides_origin);
+    // init with init_value
+    apply(gsl::make_span(out_shape).as_span<const size_t>(),
+          [&](gsl::span<const size_t> index) -> void {
+              output[offset(out_strides, index)] = 1;
+          });
+
+    apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        const auto src = input[offset(in_strides, index)];
+        auto out_idx =
+            offset(out_strides, get_reduced_offset(index, axes, keep_dims));
+        auto &dst = output[out_idx];
+        dst *= src;
+    });
+}
+
+template <>
+void reduce_prod(const bool *input, bool *output,
+                 gsl::span<const size_t> in_shape,
+                 gsl::span<const size_t> in_strides,
+                 gsl::span<const size_t> out_strides_origin,
+                 gsl::span<const size_t> axes, bool keep_dims) noexcept {
+    auto out_shape = get_reduced_shape(in_shape, axes, keep_dims);
+    auto out_strides =
+        out_strides_origin.size() == 0 ? dims_t{1} : dims_t(out_strides_origin);
+    // init with init_value
+    apply(gsl::make_span(out_shape).as_span<const size_t>(),
+          [&](gsl::span<const size_t> index) -> void {
+              output[offset(out_strides, index)] = 1;
+          });
+
+    apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        const auto src = input[offset(in_strides, index)];
+        auto out_idx =
+            offset(out_strides, get_reduced_offset(index, axes, keep_dims));
+        auto &dst = output[out_idx];
+        dst &= src;
+    });
+}
+
+template void reduce_prod<float>(const float *input, float *output,
+                                 gsl::span<const size_t> in_shape,
+                                 gsl::span<const size_t> in_strides,
+                                 gsl::span<const size_t> out_strides,
+                                 gsl::span<const size_t> axis,
+                                 bool keep_dims) noexcept;
+
+template <class T>
+void reduce(reduce_op_t op, const T *init_value, const T *input, T *output,
+            gsl::span<const size_t> in_shape, gsl::span<const size_t> axis,
+            gsl::span<const size_t> in_strides,
+            gsl::span<const size_t> out_strides, bool keep_dims) noexcept {
+    auto out_shape = get_reduced_shape(in_shape, axis, keep_dims);
+    switch (op) {
+        // REDUCE_IMPL(_ty, reduce_op_t::mean, std::plus<T>(),
+        //             [block_size = (T)get_reduce_block_size(in_shape, axis)](
+        //                 T v) { return v / block_size; });
+        REDUCE_IMPL_NO_POST(reduce_op_t::min,
+                            [](T a, T b) { return std::min(a, b); });
+        REDUCE_IMPL_NO_POST(reduce_op_t::max,
+                            [](T a, T b) { return std::max(a, b); });
+        REDUCE_IMPL_NO_POST(reduce_op_t::sum, std::plus<T>());
+    case reduce_op_t::prod:
+        return reduce_prod(reinterpret_cast<const T *>(input),
+                           reinterpret_cast<T *>(output), in_shape, in_strides,
+                           out_strides, axis, keep_dims);
+    default:
+        return;
+    }
+}
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 864a782070..3831c91958 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -148,4 +148,52 @@ template <typename T> double cosine(const T *v1, const T *v2, size_t size) {
     }
     return dot(v1, v2, size) /
            ((sqrt(dot(v1, v1, size)) * sqrt(dot(v2, v2, size))));
+}
+
+inline dims_t get_reduced_offset(gsl::span<const size_t> in_offset,
+                                 gsl::span<const size_t> axis, bool keep_dims) {
+    if (in_offset.size() == 0) {
+        return in_offset;
+    }
+    dims_t off;
+    off.reserve(in_offset.size() - (keep_dims ? 0 : axis.size()));
+    for (size_t i = 0; i < in_offset.size(); i++) {
+        if (std::find(axis.begin(), axis.end(), i) == axis.end()) {
+            off.push_back(in_offset[i]);
+        } else {
+            if (keep_dims)
+                off.push_back(0);
+        }
+    }
+
+    return off;
+}
+
+inline dims_t get_reduced_offset(gsl::span<const size_t> in_offset,
+                                 gsl::span<const size_t> reduced_shape) {
+    dims_t off(reduced_shape.size());
+    const auto dims_ext = in_offset.size() - reduced_shape.size();
+    for (size_t i = 0; i < reduced_shape.size(); i++) {
+        if (in_offset[i + dims_ext] >= reduced_shape[i])
+            off[i] = 0;
+        else
+            off[i] = in_offset[i + dims_ext];
+    }
+
+    return off;
+}
+
+inline dims_t get_reduced_shape(gsl::span<const size_t> in_shape,
+                                gsl::span<const size_t> axis, bool keep_dims) {
+    dims_t shape;
+    shape.reserve(in_shape.size() - (keep_dims ? 0 : axis.size()));
+    for (size_t i = 0; i < in_shape.size(); i++) {
+        if (std::find(axis.begin(), axis.end(), i) == axis.end()) {
+            shape.push_back(in_shape[i]);
+        } else {
+            if (keep_dims)
+                shape.push_back(1);
+        }
+    }
+    return shape;
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 7afb48e268..5b309ce633 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -5,26 +5,22 @@
 #include <hardware_context.h>
 #include <layernorm.h>
 #include <matmul.h>
+#include <reduce.h>
 #include <tensor.h>
 #include <thread_context.h>
 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
 #include <spdlog/spdlog.h>
 
-template <template <class, loc_t> class TS, class DT>
-void __tensor_copy_sync(TS<DT, loc_t::local> &&dest, TS<DT, loc_t::local> &&src,
-                        [[maybe_unused]] thread_context &ctx) {
-    assert(dest.dimension() == src.dimension());
-    apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
-          [&](gsl::span<const size_t> index) -> void {
-              dest.data()[offset(dest.strides(), index)] =
-                  src.data()[offset(src.strides(), index)];
-          });
+template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &dest) {
+    auto new_dims = dims_t(dest.dimension());
+    new_dims.insert(new_dims.begin(), 1);
+    auto new_strides = strides_t(dest.strides());
+    new_strides.insert(new_strides.begin(), *new_strides.begin());
+    return tensor<T, Loc>(dest.data(), new_dims, new_strides);
 }
 
-template <template <class, loc_t> class TS, class DT>
-void __tensor_copy_sync(TS<DT, loc_t::local> &&dest,
-                        TS<DT, loc_t::device> &&src,
-                        [[maybe_unused]] thread_context &ctx) {
+template <class T, loc_t DestLoc, loc_t SrcLoc>
+void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
     assert(dest.dimension() == src.dimension());
     apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
           [&](gsl::span<const size_t> index) -> void {
@@ -33,58 +29,6 @@ void __tensor_copy_sync(TS<DT, loc_t::local> &&dest,
           });
 }
 
-template <template <class, loc_t> class TS, class DT>
-void __tensor_copy_sync(TS<DT, loc_t::shared> &&dest,
-                        TS<DT, loc_t::device> &&src,
-                        [[maybe_unused]] thread_context &ctx) {
-
-    __tdma_block_sync_apply(
-        [&dest, &src](int visited) -> void {
-            if (visited == 1) {
-                assert(dest.dimension() == src.dimension());
-                apply(gsl::make_span(src.dimension())
-                          .template as_span<const size_t>(),
-                      [&](gsl::span<const size_t> index) -> void {
-                          dest.data()[offset(dest.strides(), index)] =
-                              src.data()[offset(src.strides(), index)];
-                      });
-            }
-        },
-        ctx);
-}
-
-template <template <class, loc_t> class TS, class DT>
-void __tensor_copy_sync(TS<DT, loc_t::device> &&dest,
-                        TS<DT, loc_t::shared> &&src,
-                        [[maybe_unused]] thread_context &ctx) {
-
-    __tdma_block_sync_apply(
-        [&dest, &src](int visited) -> void {
-            if (visited == 1) {
-                assert(dest.dimension() == src.dimension());
-                apply(gsl::make_span(src.dimension())
-                          .template as_span<const size_t>(),
-                      [&](gsl::span<const size_t> index) -> void {
-                          dest.data()[offset(dest.strides(), index)] =
-                              src.data()[offset(src.strides(), index)];
-                      });
-            }
-        },
-        ctx);
-}
-
-template <template <class, loc_t> class TS, class DT>
-void __tensor_copy_sync(TS<DT, loc_t::shared> &&dest,
-                        TS<DT, loc_t::local> &&src,
-                        [[maybe_unused]] thread_context &ctx) {
-    assert(dest.dimension() == src.dimension());
-    apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
-          [&](gsl::span<const size_t> index) -> void {
-              dest.data(ctx.bid())[offset(dest.strides(), index)] =
-                  src.data()[offset(src.strides(), index)];
-          });
-}
-
 template <class T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
 void __tensor_binary_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
                           tensor<T, CLoc> &out,
@@ -117,6 +61,15 @@ void tensor_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
            a.strides(), b.dimension(), b.strides(), c.dimension(), c.strides());
 }
 
+template <typename T, loc_t ALoc, loc_t BLoc>
+void tensor_reduce_sync(tensor<T, ALoc> &input, tensor<T, BLoc> &output,
+                        reduce_op_t op, T init_value, dims_t axis,
+                        bool keep_dims) {
+    reduce(op, &init_value, input.cdata().data(), output.data().data(),
+           input.dimension(), axis, input.strides(), output.strides(),
+           keep_dims);
+}
+
 /**
  * @brief Block 级别的 mma，每个 thread 执行自己的 mma，最终 psum 累加写入
  * shared memory
@@ -159,18 +112,47 @@ void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
         ctx);
 }
 
-template <class T, loc_t DestLoc>
-void tdma_load_async(tensor<T, DestLoc> &dest, tensor<T, loc_t::device> &&src,
-                     thread_context &ctx) {
-    __tensor_copy_sync(std::forward<tensor<T, DestLoc>>(dest),
-                       std::forward<tensor<T, loc_t::device>>(src), ctx);
+template <class T>
+void tdma_load_async(tensor<T, loc_t::shared> &dest,
+                     tensor<T, loc_t::device> &&src, thread_context &ctx) {
+    __tdma_block_sync_apply(
+        [&](int visited) -> void {
+            if (visited == 1) {
+                __tensor_copy_sync(std::forward<tensor<T, loc_t::shared>>(dest),
+                                   std::forward<tensor<T, loc_t::device>>(src),
+                                   ctx);
+            }
+        },
+        ctx);
+}
+
+template <class T>
+void tdma_load_async(tensor<T, loc_t::local> &dest,
+                     tensor<T, loc_t::device> &&src,
+                     [[maybe_unused]] thread_context &ctx) {
+    __tensor_copy_sync(std::forward<tensor<T, loc_t::local>>(dest),
+                       std::forward<tensor<T, loc_t::device>>(src));
 }
 
-template <class T, loc_t SrcLoc>
-void tdma_store_async(tensor<T, SrcLoc> &src, tensor<T, loc_t::device> &&dest,
-                      thread_context &ctx) {
+template <class T>
+void tdma_store_async(tensor<T, loc_t::local> &src,
+                      tensor<T, loc_t::device> &&dest,
+                      [[maybe_unused]] thread_context &ctx) {
     __tensor_copy_sync(std::forward<tensor<T, loc_t::device>>(dest),
-                       std::forward<tensor<T, SrcLoc>>(src), ctx);
+                       std::forward<tensor<T, loc_t::local>>(src));
+}
+
+template <class T>
+void tdma_store_async(tensor<T, loc_t::shared> &src,
+                      tensor<T, loc_t::device> &&dest, thread_context &ctx) {
+    __tdma_block_sync_apply(
+        [&](int visited) -> void {
+            if (visited == 1) {
+                __tensor_copy_sync(std::forward<tensor<T, loc_t::device>>(dest),
+                                   std::forward<tensor<T, loc_t::shared>>(src));
+            }
+        },
+        ctx);
 }
 
 template <class T> void tdma_fill_async(tensor<T, loc_t::local> &src, T data) {
@@ -201,35 +183,59 @@ void tdma_reduce_async() {
     throw std::system_error(std::make_error_code(std::errc::not_supported));
 }
 
-enum class reduce_op_t : uint8_t {
-    SUM,
-};
-
 template <class T>
-void tdma_all_reduce_async(tensor<T, loc_t::local> &src, thread_context &ctx,
-                           reduce_op_t reduce_op = reduce_op_t::SUM) {
-    switch (reduce_op) {
-    case reduce_op_t::SUM: {
-        global_hardware_ctx->lock_all();
-        int visited = global_hardware_ctx->mark_all_visit(ctx.bid(), ctx.tid());
-        if (global_hardware_ctx->all_reduce_var == nullptr) {
-            global_hardware_ctx->all_reduce_var =
-                (void *)malloc(sizeof(tensor<T>));
-            auto reduce_tensor = tensor<T>(src.dimension());
-            tdma_fill_async(reduce_tensor, (T)0);
-            memcpy(global_hardware_ctx->all_reduce_var, &reduce_tensor,
-                   sizeof(tensor<T>));
-        }
-        auto reduce_tensor = (tensor<T> *)global_hardware_ctx->all_reduce_var;
-        __tensor_add_sync(src, *reduce_tensor, *reduce_tensor);
-        global_hardware_ctx->unlock_all();
-        global_hardware_ctx->wait_all_sync(visited);
-        break;
-    }
-    default:
-        throw std::system_error(std::make_error_code(std::errc::not_supported));
-        break;
-    }
+void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
+                           tensor<T, loc_t::local> &dest, reduce_op_t reduce_op,
+                           dims_t axis, thread_context &ctx) {
+    __tdma_all_sync_apply(
+        [&src, &ctx](int visited) -> void {
+            tensor<T> *gather_tensor = nullptr;
+            auto new_dims = dims_t(src.dimension());
+            new_dims.insert(new_dims.begin(), 32);
+            if (visited == 1) {
+                gather_tensor = new tensor<T>(new_dims);
+                global_hardware_ctx->global_var = (void *)gather_tensor;
+            } else {
+                gather_tensor =
+                    static_cast<tensor<T> *>(global_hardware_ctx->global_var);
+            }
+            dims_t begin(new_dims.size(), 0);
+            dims_t shape(new_dims);
+            begin[0] = ctx.bid() * CORES + ctx.tid();
+            shape[0] = 1;
+            __tensor_copy_sync<T, loc_t::local, loc_t::local>(
+                std::move((*gather_tensor)(begin, shape)),
+                std::move(unsqueeze(src)));
+        },
+        []() -> void {}, ctx);
+
+    __tdma_all_sync_apply(
+        [&]([[maybe_unused]] int visit) -> void {
+            tensor<T> *gather_tensor = nullptr;
+            tensor<T> *reduced_tensor = nullptr;
+            if (visit == 1) {
+                gather_tensor =
+                    static_cast<tensor<T> *>(global_hardware_ctx->global_var);
+                auto reduced_shape =
+                    get_reduced_shape(gather_tensor->dimension(), axis, false);
+                reduced_tensor = new tensor<T>(reduced_shape);
+                tensor_reduce_sync(*gather_tensor, *reduced_tensor, reduce_op,
+                                   (T)0, axis, false);
+                delete gather_tensor;
+                global_hardware_ctx->global_var = reduced_tensor;
+            } else {
+                reduced_tensor =
+                    static_cast<tensor<T> *>(global_hardware_ctx->global_var);
+                __tensor_copy_sync(std::move(dest), std::move(*reduced_tensor));
+            }
+        },
+        []() -> void {
+            auto reduced_tensor =
+                static_cast<tensor<T> *>(global_hardware_ctx->global_var);
+            delete reduced_tensor;
+            global_hardware_ctx->global_var = nullptr;
+        },
+        ctx);
 }
 
 void tdma_gather_async() {}
@@ -253,4 +259,16 @@ void __tdma_block_sync_apply(std::function<void(int)> func,
     func(visited);
     global_hardware_ctx->unlock_block(ctx.bid());
     global_hardware_ctx->wait_block_sync(ctx.bid(), visited);
+}
+
+void __tdma_all_sync_apply(std::function<void(int)> apply_func,
+                           std::function<void()> broadcast_func,
+                           thread_context &ctx) {
+    global_hardware_ctx->lock_all();
+    int visited = global_hardware_ctx->mark_all_visit(ctx.bid(), ctx.tid());
+    SPDLOG_DEBUG("__tdma_all_sync_apply bid {} tid {} visited {}\n", ctx.bid(),
+                 ctx.tid(), visited);
+    apply_func(visited);
+    global_hardware_ctx->unlock_all();
+    global_hardware_ctx->wait_all_sync(visited, broadcast_func);
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index 6d0a792881..b7a6170f72 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -22,10 +22,21 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
           strides_(get_default_strides(dims_)),
           size_(compute_size(dims_)) {
         parent_ = nullptr;
-        auto ptr = new T[size_];
+        auto ptr = new T[size_]();
         data_ = gsl::make_span(ptr, size_);
     }
 
+    tensor(gsl::span<T> data, dims_t dims, strides_t strides)
+        : data_(data),
+          parent_(data.data()),
+          dims_(dims),
+          strides_(strides),
+          size_(compute_size(dims_, strides_)) {
+        if (size_ != data_.size()) {
+            throw std::errc::invalid_argument;
+        }
+    }
+
     const dims_t &dimension() { return dims_; }
     const strides_t &strides() { return strides_; }
 
@@ -39,6 +50,10 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
                       dims_t(shapes.begin(), shapes.end()));
     }
 
+    tensor<T, Loc> operator()(dims_t begins, dims_t shapes) {
+        return tensor(this, begins, shapes);
+    }
+
     ~tensor() {
         if (parent_ == nullptr) {
             delete[] data_.data();
diff --git a/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp b/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
index 4878c3f00e..1d7a8472b9 100644
--- a/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
+++ b/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
@@ -84,9 +84,11 @@ int hardware_context::mark_block_visit(int bid, int tid) {
     return visited;
 }
 
-void hardware_context::wait_block_sync(int bid, int visited) {
+void hardware_context::wait_block_sync(int bid, int visited,
+                                       std::function<void()> callable) {
     pthread_mutex_lock(&impl_->block_conds[bid].mutex);
     if (visited == CORES) {
+        callable();
         impl_->reset_block_visited(bid);
         pthread_cond_broadcast(&impl_->block_conds[bid].cond);
     } else {
@@ -113,9 +115,11 @@ int hardware_context::mark_all_visit(int bid, int tid) {
     return visited;
 }
 
-void hardware_context::wait_all_sync(int visited) {
+void hardware_context::wait_all_sync(int visited,
+                                     std::function<void()> callable) {
     pthread_mutex_lock(&impl_->global_cond.mutex);
     if (visited == BLOCKS * CORES) {
+        callable();
         impl_->reset_global_visited();
         pthread_cond_broadcast(&impl_->global_cond.cond);
     } else {
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
index 8059af00b6..e8d5180a16 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
@@ -1,12 +1,13 @@
 import numpy as np
 
-X = np.random.rand(384,8192).astype(np.float32)
-WK = np.random.rand(64,8192,128).astype(np.float32) * 5 - 1
+X = np.random.rand(384, 8192).astype(np.float32)
+WK = np.random.rand(64, 8192, 128).astype(np.float32) * 5 - 1
 
 K = X @ WK
 
-
+Sum =np.sum(np.sum(WK, axis=0, keepdims=False), axis=0,keepdims=False)
 
 X.tofile("X.bin")
 WK.tofile("WK.bin")
-K.tofile("K.bin")
\ No newline at end of file
+K.tofile("K.bin")
+Sum.tofile("Sum.bin")
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index fce9775de4..2da04df5b1 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -22,8 +22,9 @@ static tensor<float> wkh({8, 2048, 128});
 // 2048 w-len per thread
 void stage1_kernel(
     // tensor<float, loc_t::device> &WQ,  /* 64, 8192, 128 */
-    tensor<float, loc_t::device> &WK, /* 64, 8192, 128 */
-    tensor<float, loc_t::device> &K   /* 64, 384, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &WK, /* 64, 8192, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &K,  /* 64, 384, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &Sum /* 128 */
     //  tensor<float, loc_t::device> &WV,  /* 64, 8192, 128 */
     //  tensor<float, loc_t::device> &WFC1 /* 384, 8192*/
 ) {
@@ -51,6 +52,15 @@ void stage1_kernel(
                           ctx); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
 
     tdma_store_async(kh, K({bid * 8, 0, 0}, {8, 384, 128}), ctx);
+
+    tensor<float> sum({128});
+    tensor_reduce_sync(wkh, sum, reduce_op_t::sum, 0.0f, dims_t({0, 1}), false);
+    tdma_all_reduce_async(sum, sum, reduce_op_t::sum, dims_t({0}), ctx);
+
+    if (bid == 0 && tid == 0) {
+        tdma_store_async(sum, std::move(Sum), ctx);
+    }
+
     // vh = tensor_block_mma_sync(
     //     xi, wvh); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
 
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
index 3729b4aed1..62e9675ae4 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
@@ -5,7 +5,7 @@
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(WK, K);                             \
+        block##b::thread##t::stage1_kernel(WK, K, Sum);                        \
         return arg;                                                            \
     }
 
@@ -17,6 +17,7 @@
 
 tensor<float, loc_t::device> WK({64, 8192, 128});
 tensor<float, loc_t::device> K({64, 384, 128});
+tensor<float, loc_t::device> Sum({128});
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
@@ -28,14 +29,14 @@ DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
 /**
- * @brief demo1 X.bin WK.bin K.bin
+ * @brief demo1 X.bin WK.bin K.bin Sum.bin
  *
  * @param argc
  * @param argv
  * @return int
  */
 int main([[maybe_unused]] int argc, char **argv) {
-    assert(argc == 4);
+    assert(argc == 5);
     spdlog::set_level(spdlog::level::debug);
     global_hardware_init();
 
@@ -43,6 +44,7 @@ int main([[maybe_unused]] int argc, char **argv) {
     auto src_X = read_file(std::string(argv[1]));
     auto src_WK = read_file(std::string(argv[2]));
     auto src_K = read_file(std::string(argv[3]));
+    auto src_Sum = read_file(std::string(argv[4]));
     span_copy(WK.data(), gsl::make_span(src_WK).as_span<float>());
     span_copy(block0::shared::X.data(), gsl::make_span(src_X).as_span<float>());
     span_copy(block1::shared::X.data(), gsl::make_span(src_X).as_span<float>());
@@ -128,5 +130,10 @@ int main([[maybe_unused]] int argc, char **argv) {
         cosine(K.data().begin(), gsl::make_span(src_K).as_span<float>().begin(),
                K.data().size());
     printf("K cosine %f\n", cos);
+
+    auto cos2 =
+        cosine(Sum.data().begin(), gsl::make_span(src_Sum).as_span<float>().begin(),
+               Sum.data().size());
+    printf("Sum cosine %f\n", cos2);
     return 0;
 }
\ No newline at end of file

From e83ae8f72e01378ab4b1ecdafadc042174e16169 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Wed, 16 Aug 2023 11:38:20 +0000
Subject: [PATCH 097/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
index 62e9675ae4..4920f9c79b 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
@@ -131,9 +131,9 @@ int main([[maybe_unused]] int argc, char **argv) {
                K.data().size());
     printf("K cosine %f\n", cos);
 
-    auto cos2 =
-        cosine(Sum.data().begin(), gsl::make_span(src_Sum).as_span<float>().begin(),
-               Sum.data().size());
+    auto cos2 = cosine(Sum.data().begin(),
+                       gsl::make_span(src_Sum).as_span<float>().begin(),
+                       Sum.data().size());
     printf("Sum cosine %f\n", cos2);
     return 0;
 }
\ No newline at end of file

From 4c85b18a8944fbc6116c7f30e6b6534558ae0de2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 16 Aug 2023 19:48:57 +0800
Subject: [PATCH 098/308] add comment

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 5b309ce633..529b21bbc0 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -183,6 +183,18 @@ void tdma_reduce_async() {
     throw std::system_error(std::make_error_code(std::errc::not_supported));
 }
 
+/**
+ * @brief reduce across BLOCKS * CORES
+ *  1. stack the src to gather tensor
+ *  2. reduce gather tensor
+ *  3. broadcast gather tensor to local tensor.
+ * @tparam T
+ * @param src local tensor
+ * @param dest local tensor
+ * @param reduce_op op
+ * @param axis axis of gather tensor, note gather tensor dims = [32,...]
+ * @param ctx
+ */
 template <class T>
 void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
                            tensor<T, loc_t::local> &dest, reduce_op_t reduce_op,
@@ -193,6 +205,9 @@ void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
             auto new_dims = dims_t(src.dimension());
             new_dims.insert(new_dims.begin(), 32);
             if (visited == 1) {
+                if (global_hardware_ctx->global_var != nullptr) {
+                    throw std::runtime_error(" the global var has been used!");
+                }
                 gather_tensor = new tensor<T>(new_dims);
                 global_hardware_ctx->global_var = (void *)gather_tensor;
             } else {

From 300f833e3389e3384476eec7737b498289a608d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 17 Aug 2023 16:02:53 +0800
Subject: [PATCH 099/308] add layer norm test

---
 .../src/runtime/cmodel/include/layernorm.h    |  13 +-
 .../cpu/src/runtime/cmodel/include/reduce.h   |  57 ++++++--
 modules/cpu/src/runtime/cmodel/include/tdma.h | 127 +++++++++---------
 .../src/runtime/cmodel/tests/demo1/golden.py  |  24 +++-
 .../src/runtime/cmodel/tests/demo1/kernel.h   |  59 ++++++--
 .../src/runtime/cmodel/tests/demo1/main.cpp   |  35 ++++-
 6 files changed, 212 insertions(+), 103 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index 52a13c2ae3..194d4beff4 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -4,12 +4,14 @@
 #include <riscv_vector.h>
 #endif
 
+namespace kernels {
+
 namespace {
 template <typename T>
-void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *gamma,
+void layernorm_naive_impl(T *input, const T *sum, T *sum_sqr, T *gamma,
                           T *beta, gsl::span<const size_t> input_shape,
                           [[maybe_unused]] gsl::span<const size_t> input_stride,
-                          T *eps, int32_t axis, int32_t norm_size) noexcept {
+                          T eps, int32_t axis, int32_t norm_size) noexcept {
     // only process continues tensor for now
     size_t outer_size = 1;
     for (auto i = 0; i < axis; i++) {
@@ -23,7 +25,7 @@ void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *gamma,
 
     for (size_t o = 0; o < outer_size; o++) {
         auto mean = sum[o] / norm_size;
-        auto sigma = std::sqrt(sum_sqr[o] / norm_size + eps);
+        auto sigma = std::sqrt(sum_sqr[o] / static_cast<T>(norm_size) + eps);
         for (size_t i = 0; i < inner_size; i++) {
             auto x = input + o * inner_size + i;
             *x = (*x - mean) / sigma * gamma[i] + beta[i];
@@ -107,7 +109,7 @@ void layernorm_rvv_impl(const T *input, const T *sum, T *sum_sqr, T *gamma,
 
 template <class T>
 void layernorm(T *input, T *sum, T *sum_sqr, T *gamma, T *beta,
-               dims_t input_dims, strides_t input_strides, T *eps, int32_t axis,
+               dims_t input_dims, strides_t input_strides, T eps, int32_t axis,
                int32_t norm_size) {
 #ifdef __riscv_vector
     return layernorm_rvv_impl(
@@ -122,4 +124,5 @@ void layernorm(T *input, T *sum, T *sum_sqr, T *gamma, T *beta,
         gsl::make_span(input_strides).template as_span<const size_t>(), eps,
         axis, norm_size);
 #endif
-}
\ No newline at end of file
+}
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/reduce.h b/modules/cpu/src/runtime/cmodel/include/reduce.h
index ca1f1f2008..1ca7592bbf 100644
--- a/modules/cpu/src/runtime/cmodel/include/reduce.h
+++ b/modules/cpu/src/runtime/cmodel/include/reduce.h
@@ -23,17 +23,32 @@ enum class reduce_op_t : uint8_t {
     max = 2,
     sum = 3,
     prod = 4,
+    sum_sqr = 5,
 };
 
+namespace kernels {
+
 namespace {
 template <class T> struct identity {
     T operator()(const T &src) const noexcept { return src; }
 };
 
+template <class TShape>
+size_t get_reduce_block_size(const TShape &in_shape, const TShape &axis) {
+    size_t size = 1;
+    for (size_t i = 0; i < in_shape.size(); i++) {
+        if (std::find(axis.begin(), axis.end(), i) != axis.end()) {
+            size *= in_shape[i];
+        }
+    }
+
+    return size;
+}
+
 template <class TReducer, class TPostProcess, class T>
-void reduce_impl(TReducer &&reducer, TPostProcess &&post_process, T init_value,
-                 const T *input, T *output, gsl::span<const size_t> in_shape,
-                 gsl::span<const size_t> axis,
+void reduce_impl(TReducer &&reducer, TPostProcess &&post_process,
+                 const T init_value, const T *input, T *output,
+                 gsl::span<const size_t> in_shape, gsl::span<const size_t> axis,
                  gsl::span<const size_t> in_strides,
                  gsl::span<const size_t> out_shape,
                  gsl::span<const size_t> out_strides, bool keep_dims) noexcept {
@@ -53,12 +68,12 @@ void reduce_impl(TReducer &&reducer, TPostProcess &&post_process, T init_value,
 }
 } // namespace
 
-// #define REDUCE_IMPL(_ty, op, reducer, post_process)                            \
-//     case op:                                                                   \
-//         return reduce_impl(reducer, post_process,                              \
-//                            SCALAR_CAST(_ty, init_value), IN_CAST(_ty, input),  \
-//                            OUT_CAST(_ty, output), in_shape, axis, in_strides,  \
-//                            out_shape, out_strides, keep_dims, context)
+#define REDUCE_IMPL(op, reducer, post_process)                                 \
+    case op:                                                                   \
+        return reduce_impl(reducer, post_process,                              \
+                           *reinterpret_cast<const T *>(init_value), input,    \
+                           output, in_shape, axis, in_strides, out_shape,      \
+                           out_strides, keep_dims)
 
 #define REDUCE_IMPL_NO_POST(op, reducer)                                       \
     case op:                                                                   \
@@ -128,14 +143,16 @@ void reduce(reduce_op_t op, const T *init_value, const T *input, T *output,
             gsl::span<const size_t> out_strides, bool keep_dims) noexcept {
     auto out_shape = get_reduced_shape(in_shape, axis, keep_dims);
     switch (op) {
-        // REDUCE_IMPL(_ty, reduce_op_t::mean, std::plus<T>(),
-        //             [block_size = (T)get_reduce_block_size(in_shape, axis)](
-        //                 T v) { return v / block_size; });
+        REDUCE_IMPL(reduce_op_t::mean, std::plus<T>(),
+                    [block_size = (T)get_reduce_block_size(in_shape, axis)](
+                        T v) { return v / block_size; });
         REDUCE_IMPL_NO_POST(reduce_op_t::min,
                             [](T a, T b) { return std::min(a, b); });
         REDUCE_IMPL_NO_POST(reduce_op_t::max,
                             [](T a, T b) { return std::max(a, b); });
         REDUCE_IMPL_NO_POST(reduce_op_t::sum, std::plus<T>());
+        REDUCE_IMPL_NO_POST(reduce_op_t::sum_sqr,
+                            [](T a, T b) { return a + (b * b); });
     case reduce_op_t::prod:
         return reduce_prod(reinterpret_cast<const T *>(input),
                            reinterpret_cast<T *>(output), in_shape, in_strides,
@@ -144,3 +161,19 @@ void reduce(reduce_op_t op, const T *init_value, const T *input, T *output,
         return;
     }
 }
+
+template <class T>
+void reduce_sum_and_sum_sqr(const T *input, T *sum, T *sum_sqr,
+                            gsl::span<const size_t> in_shape,
+                            gsl::span<const size_t> in_strides,
+                            gsl::span<const size_t> out_strides) {
+    auto init_v = (T)0;
+    kernels::reduce(reduce_op_t::sum, &init_v, input, sum, in_shape,
+                    dims_t({in_shape.size() - 1}), in_strides, out_strides,
+                    false);
+    kernels::reduce(reduce_op_t::sum_sqr, &init_v, input, sum_sqr, in_shape,
+                    dims_t({in_shape.size() - 1}), in_strides, out_strides,
+                    false);
+}
+
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 529b21bbc0..079c42e17b 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -65,9 +65,29 @@ template <typename T, loc_t ALoc, loc_t BLoc>
 void tensor_reduce_sync(tensor<T, ALoc> &input, tensor<T, BLoc> &output,
                         reduce_op_t op, T init_value, dims_t axis,
                         bool keep_dims) {
-    reduce(op, &init_value, input.cdata().data(), output.data().data(),
-           input.dimension(), axis, input.strides(), output.strides(),
-           keep_dims);
+    kernels::reduce(op, &init_value, input.cdata().data(), output.data().data(),
+                    input.dimension(), axis, input.strides(), output.strides(),
+                    keep_dims);
+}
+
+template <typename T, loc_t Loc>
+void tensor_layernorm_sync(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
+                           tensor<T, loc_t::local> &sum_sqr,
+                           tensor<T, loc_t::local> &gamma,
+                           tensor<T, loc_t::local> &beta, T eps, int32_t axis,
+                           int32_t norm_size) {
+    kernels::layernorm(input.data().data(), sum.data().data(),
+                       sum_sqr.data().data(), gamma.data().data(),
+                       beta.data().data(), input.dimension(), input.strides(),
+                       eps, axis, norm_size);
+}
+
+template <typename T, loc_t ALoc>
+void tensor_reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
+                           tensor<T, loc_t::local> &sum_sqr) {
+    kernels::reduce_sum_and_sum_sqr(a.cdata().data(), sum.data().data(),
+                                    sum_sqr.data().data(), a.dimension(),
+                                    a.strides(), sum.strides());
 }
 
 /**
@@ -112,53 +132,46 @@ void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
         ctx);
 }
 
-template <class T>
-void tdma_load_async(tensor<T, loc_t::shared> &dest,
-                     tensor<T, loc_t::device> &&src, thread_context &ctx) {
-    __tdma_block_sync_apply(
-        [&](int visited) -> void {
-            if (visited == 1) {
-                __tensor_copy_sync(std::forward<tensor<T, loc_t::shared>>(dest),
-                                   std::forward<tensor<T, loc_t::device>>(src),
-                                   ctx);
-            }
-        },
-        ctx);
+void __tdma_block_sync_apply(std::function<void(int)> func,
+                             thread_context &ctx) {
+    global_hardware_ctx->lock_block(ctx.bid());
+    int visited = global_hardware_ctx->mark_block_visit(ctx.bid(), ctx.tid());
+    SPDLOG_DEBUG("__tdma_block_sync_apply bid {} tid {} visited {}\n",
+                 ctx.bid(), ctx.tid(), visited);
+    func(visited);
+    global_hardware_ctx->unlock_block(ctx.bid());
+    global_hardware_ctx->wait_block_sync(ctx.bid(), visited);
 }
 
-template <class T>
-void tdma_load_async(tensor<T, loc_t::local> &dest,
-                     tensor<T, loc_t::device> &&src,
+void __tdma_all_sync_apply(std::function<void(int)> apply_func,
+                           std::function<void()> broadcast_func,
+                           thread_context &ctx) {
+    global_hardware_ctx->lock_all();
+    int visited = global_hardware_ctx->mark_all_visit(ctx.bid(), ctx.tid());
+    SPDLOG_DEBUG("__tdma_all_sync_apply bid {} tid {} visited {}\n", ctx.bid(),
+                 ctx.tid(), visited);
+    apply_func(visited);
+    global_hardware_ctx->unlock_all();
+    global_hardware_ctx->wait_all_sync(visited, broadcast_func);
+}
+
+template <class T, loc_t DestLoc>
+void tdma_load_async(tensor<T, DestLoc> &dest, tensor<T, loc_t::device> &&src,
                      [[maybe_unused]] thread_context &ctx) {
-    __tensor_copy_sync(std::forward<tensor<T, loc_t::local>>(dest),
+    __tensor_copy_sync(std::forward<tensor<T, DestLoc>>(dest),
                        std::forward<tensor<T, loc_t::device>>(src));
 }
 
-template <class T>
-void tdma_store_async(tensor<T, loc_t::local> &src,
-                      tensor<T, loc_t::device> &&dest,
+template <class T, loc_t SrcLoc>
+void tdma_store_async(tensor<T, SrcLoc> &src, tensor<T, loc_t::device> &&dest,
                       [[maybe_unused]] thread_context &ctx) {
     __tensor_copy_sync(std::forward<tensor<T, loc_t::device>>(dest),
-                       std::forward<tensor<T, loc_t::local>>(src));
+                       std::forward<tensor<T, SrcLoc>>(src));
 }
 
-template <class T>
-void tdma_store_async(tensor<T, loc_t::shared> &src,
-                      tensor<T, loc_t::device> &&dest, thread_context &ctx) {
-    __tdma_block_sync_apply(
-        [&](int visited) -> void {
-            if (visited == 1) {
-                __tensor_copy_sync(std::forward<tensor<T, loc_t::device>>(dest),
-                                   std::forward<tensor<T, loc_t::shared>>(src));
-            }
-        },
-        ctx);
-}
-
-template <class T> void tdma_fill_async(tensor<T, loc_t::local> &src, T data) {
-    apply(src.dimension(), [&](gsl::span<size_t> index) -> void {
-        src.data()[offset(src.strides(), index)] = data;
-    });
+template <class T> void tdma_fill_async(tensor<T, loc_t::local> &src, T value) {
+    __tensor_unary_sync<T, loc_t::local, loc_t::local>(
+        src, src, [&value]([[maybe_unused]] T a) -> T { return value; });
 }
 
 template <class T>
@@ -259,31 +272,15 @@ void tdma_all_gather_async() {}
 
 void tdma_scatter_async() {}
 
-void tdma_wait() {}
+/**
+ * @brief tdma inner block wait.
+ * 
+ * @param ctx 
+ */
+void tdma_wait(thread_context &ctx) {
+    __tdma_block_sync_apply([]([[maybe_unused]] int visited) -> void {}, ctx);
+}
 
 void tdma_cancel() {}
 
-void tdma_status() {}
-
-void __tdma_block_sync_apply(std::function<void(int)> func,
-                             thread_context &ctx) {
-    global_hardware_ctx->lock_block(ctx.bid());
-    int visited = global_hardware_ctx->mark_block_visit(ctx.bid(), ctx.tid());
-    SPDLOG_DEBUG("__tdma_block_sync_apply bid {} tid {} visited {}\n",
-                 ctx.bid(), ctx.tid(), visited);
-    func(visited);
-    global_hardware_ctx->unlock_block(ctx.bid());
-    global_hardware_ctx->wait_block_sync(ctx.bid(), visited);
-}
-
-void __tdma_all_sync_apply(std::function<void(int)> apply_func,
-                           std::function<void()> broadcast_func,
-                           thread_context &ctx) {
-    global_hardware_ctx->lock_all();
-    int visited = global_hardware_ctx->mark_all_visit(ctx.bid(), ctx.tid());
-    SPDLOG_DEBUG("__tdma_all_sync_apply bid {} tid {} visited {}\n", ctx.bid(),
-                 ctx.tid(), visited);
-    apply_func(visited);
-    global_hardware_ctx->unlock_all();
-    global_hardware_ctx->wait_all_sync(visited, broadcast_func);
-}
\ No newline at end of file
+void tdma_status() {}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
index e8d5180a16..038d6d68e0 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
@@ -1,6 +1,8 @@
 import numpy as np
-
-X = np.random.rand(384, 8192).astype(np.float32)
+from torch import nn
+import torch
+    
+X = np.ones_like( np.random.rand(384, 8192).astype(np.float32)  )*1.1
 WK = np.random.rand(64, 8192, 128).astype(np.float32) * 5 - 1
 
 K = X @ WK
@@ -11,3 +13,21 @@
 WK.tofile("WK.bin")
 K.tofile("K.bin")
 Sum.tofile("Sum.bin")
+
+# Activate module
+Norm = nn.LayerNorm([8192], elementwise_affine=False)(torch.from_numpy( X))
+Norm.detach().numpy().tofile('Norm.bin')
+
+RSums =[]
+for t in range(32):
+      RSums.append(X[:,t*256:(t+1)*256].sum(1,keepdims=False))
+RSum =  np.sum(np.array(RSums),axis=0,keepdims=False)
+      
+RSum.tofile('RSum.bin')
+
+RSumSqrs =[]
+for t in range(32):
+      RSumSqrs.append(np.square(X[:,t*256:(t+1)*256]).sum(1,keepdims=False))
+RSumSqr =  np.sum(np.array(RSumSqrs),axis=0,keepdims=False)
+      
+RSumSqr.tofile('RSumSqr.bin')
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index 2da04df5b1..b63e622609 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -22,9 +22,13 @@ static tensor<float> wkh({8, 2048, 128});
 // 2048 w-len per thread
 void stage1_kernel(
     // tensor<float, loc_t::device> &WQ,  /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &WK, /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &K,  /* 64, 384, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &Sum /* 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &WK,     /* 64, 8192, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &K,      /* 64, 384, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &Sum,    /* 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &RSum,   /* 384 */
+    [[maybe_unused]] tensor<float, loc_t::device> &RSumSqr, /* 384 */
+    [[maybe_unused]] tensor<float, loc_t::device> &Norm /* 384, 8192 */
+    // [[maybe_unused]] tensor<float, loc_t::device> &Norm /* 384,8192 */
     //  tensor<float, loc_t::device> &WV,  /* 64, 8192, 128 */
     //  tensor<float, loc_t::device> &WFC1 /* 384, 8192*/
 ) {
@@ -48,18 +52,49 @@ void stage1_kernel(
     //     tensor
     //                                          // 指令
 
-    tensor_block_mma_sync(xi, wkh, kh, false,
-                          ctx); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
+    // tensor_block_mma_sync(xi, wkh, kh, false,
+    //                       ctx); // [384, 2048] x [8, 2048, 64] = [8, 384,
+    //                       128]
+
+    // if (tid == 0) {
+    //     tdma_store_async(kh, K({bid * 8, 0, 0}, {8, 384, 128}), ctx);
+    // }
+    // tdma_wait(ctx);
+
+    // tensor<float> sum({128});
+    // tensor_reduce_sync(wkh, sum, reduce_op_t::sum, 0.0f, dims_t({0, 1}),
+    // false); tdma_all_reduce_async(sum, sum, reduce_op_t::sum, dims_t({0}),
+    // ctx);
+
+    // if (bid == 0 && tid == 0) {
+    //     tdma_store_async(sum, std::move(Sum), ctx);
+    // }
+
+    // X [384,8192] => separate to bid , tid
+    auto xj = X({0, (bid * CORES + tid) * 256}, {384, 256}); // [48,2048]
+    tensor<float> r_sum({384});
+    tensor<float> r_sum_sqr({384});
+    tensor_reduce_sum_sqr(xj, r_sum, r_sum_sqr);
+    tdma_all_reduce_async(r_sum, r_sum, reduce_op_t::sum, dims_t({0}), ctx);
+    tdma_all_reduce_async(r_sum_sqr, r_sum_sqr, reduce_op_t::sum, dims_t({0}),
+                          ctx);
+    if (bid == 0 && tid == 0) {
+        tdma_store_async(r_sum, std::move(RSum), ctx);
+        tdma_store_async(r_sum_sqr, std::move(RSumSqr), ctx);
+    }
 
-    tdma_store_async(kh, K({bid * 8, 0, 0}, {8, 384, 128}), ctx);
+    tensor<float> gamma({256});
+    tdma_fill_async(gamma, 1.0f);
+    tensor<float> beta({256});
+    tdma_fill_async(beta, 1.0f);
+    tensor_layernorm_sync(xj, r_sum, r_sum_sqr, gamma, beta, 1e-6f, 1, 8192);
+    tdma_store_async(xj, Norm({0, (bid * CORES + tid) * 256}, {384, 256}),
+                     ctx);
 
-    tensor<float> sum({128});
-    tensor_reduce_sync(wkh, sum, reduce_op_t::sum, 0.0f, dims_t({0, 1}), false);
-    tdma_all_reduce_async(sum, sum, reduce_op_t::sum, dims_t({0}), ctx);
+    // tensor_sum_sqr(xj, r_sum, r_sum_sqr);
 
-    if (bid == 0 && tid == 0) {
-        tdma_store_async(sum, std::move(Sum), ctx);
-    }
+    // tensor<float> layer_sum({8, 2048});
+    // tensor<float> layer_sum_sqr({8, 2048});
 
     // vh = tensor_block_mma_sync(
     //     xi, wvh); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
index 4920f9c79b..58294d2de0 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
@@ -5,7 +5,7 @@
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(WK, K, Sum);                        \
+        block##b::thread##t::stage1_kernel(WK, K, Sum, RSum, RSumSqr, Norm);   \
         return arg;                                                            \
     }
 
@@ -17,6 +17,9 @@
 
 tensor<float, loc_t::device> WK({64, 8192, 128});
 tensor<float, loc_t::device> K({64, 384, 128});
+tensor<float, loc_t::device> Norm({384, 8192});
+tensor<float, loc_t::device> RSum({384});
+tensor<float, loc_t::device> RSumSqr({384});
 tensor<float, loc_t::device> Sum({128});
 
 DEFINE_BFUNC(0)
@@ -29,14 +32,14 @@ DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
 /**
- * @brief demo1 X.bin WK.bin K.bin Sum.bin
+ * @brief demo1 X.bin WK.bin K.bin Sum.bin Norm.bin
  *
  * @param argc
  * @param argv
  * @return int
  */
 int main([[maybe_unused]] int argc, char **argv) {
-    assert(argc == 5);
+    assert(argc == 8);
     spdlog::set_level(spdlog::level::debug);
     global_hardware_init();
 
@@ -45,6 +48,9 @@ int main([[maybe_unused]] int argc, char **argv) {
     auto src_WK = read_file(std::string(argv[2]));
     auto src_K = read_file(std::string(argv[3]));
     auto src_Sum = read_file(std::string(argv[4]));
+    auto src_RSum = read_file(std::string(argv[5]));
+    auto src_RSumSqr = read_file(std::string(argv[6]));
+    auto src_Norm = read_file(std::string(argv[7]));
     span_copy(WK.data(), gsl::make_span(src_WK).as_span<float>());
     span_copy(block0::shared::X.data(), gsl::make_span(src_X).as_span<float>());
     span_copy(block1::shared::X.data(), gsl::make_span(src_X).as_span<float>());
@@ -131,9 +137,24 @@ int main([[maybe_unused]] int argc, char **argv) {
                K.data().size());
     printf("K cosine %f\n", cos);
 
-    auto cos2 = cosine(Sum.data().begin(),
-                       gsl::make_span(src_Sum).as_span<float>().begin(),
-                       Sum.data().size());
-    printf("Sum cosine %f\n", cos2);
+    cos = cosine(Sum.data().begin(),
+                 gsl::make_span(src_Sum).as_span<float>().begin(),
+                 Sum.data().size());
+    printf("Sum cosine %f\n", cos);
+
+    cos = cosine(RSum.data().begin(),
+                 gsl::make_span(src_RSum).as_span<float>().begin(),
+                 Sum.data().size());
+    printf("src_RSum cosine %f\n", cos);
+
+    cos = cosine(RSumSqr.data().begin(),
+                 gsl::make_span(src_RSumSqr).as_span<float>().begin(),
+                 Sum.data().size());
+    printf("RSumSqr cosine %f\n", cos);
+
+    cos = cosine(Norm.data().begin(),
+                 gsl::make_span(src_Norm).as_span<float>().begin(),
+                 Sum.data().size());
+    printf("Norm cosine %f\n", cos);
     return 0;
 }
\ No newline at end of file

From 6c10f33917cf1d2633ac4040985167b67eced0ef Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Thu, 17 Aug 2023 08:05:32 +0000
Subject: [PATCH 100/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/include/layernorm.h  |  4 ++--
 modules/cpu/src/runtime/cmodel/include/tdma.h       |  4 ++--
 modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h | 13 ++++++-------
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index 194d4beff4..e81d3719b4 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -8,8 +8,8 @@ namespace kernels {
 
 namespace {
 template <typename T>
-void layernorm_naive_impl(T *input, const T *sum, T *sum_sqr, T *gamma,
-                          T *beta, gsl::span<const size_t> input_shape,
+void layernorm_naive_impl(T *input, const T *sum, T *sum_sqr, T *gamma, T *beta,
+                          gsl::span<const size_t> input_shape,
                           [[maybe_unused]] gsl::span<const size_t> input_stride,
                           T eps, int32_t axis, int32_t norm_size) noexcept {
     // only process continues tensor for now
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 079c42e17b..ba49de6472 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -274,8 +274,8 @@ void tdma_scatter_async() {}
 
 /**
  * @brief tdma inner block wait.
- * 
- * @param ctx 
+ *
+ * @param ctx
  */
 void tdma_wait(thread_context &ctx) {
     __tdma_block_sync_apply([]([[maybe_unused]] int visited) -> void {}, ctx);
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index b63e622609..40c74c4591 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -22,12 +22,12 @@ static tensor<float> wkh({8, 2048, 128});
 // 2048 w-len per thread
 void stage1_kernel(
     // tensor<float, loc_t::device> &WQ,  /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &WK,     /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &K,      /* 64, 384, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &Sum,    /* 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &RSum,   /* 384 */
+    [[maybe_unused]] tensor<float, loc_t::device> &WK,      /* 64, 8192, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &K,       /* 64, 384, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &Sum,     /* 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &RSum,    /* 384 */
     [[maybe_unused]] tensor<float, loc_t::device> &RSumSqr, /* 384 */
-    [[maybe_unused]] tensor<float, loc_t::device> &Norm /* 384, 8192 */
+    [[maybe_unused]] tensor<float, loc_t::device> &Norm     /* 384, 8192 */
     // [[maybe_unused]] tensor<float, loc_t::device> &Norm /* 384,8192 */
     //  tensor<float, loc_t::device> &WV,  /* 64, 8192, 128 */
     //  tensor<float, loc_t::device> &WFC1 /* 384, 8192*/
@@ -88,8 +88,7 @@ void stage1_kernel(
     tensor<float> beta({256});
     tdma_fill_async(beta, 1.0f);
     tensor_layernorm_sync(xj, r_sum, r_sum_sqr, gamma, beta, 1e-6f, 1, 8192);
-    tdma_store_async(xj, Norm({0, (bid * CORES + tid) * 256}, {384, 256}),
-                     ctx);
+    tdma_store_async(xj, Norm({0, (bid * CORES + tid) * 256}, {384, 256}), ctx);
 
     // tensor_sum_sqr(xj, r_sum, r_sum_sqr);
 

From 09c5084caed7bc13fdc1d087f10b82d59099e4f9 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 17 Aug 2023 19:41:15 +0800
Subject: [PATCH 101/308] fix  layernorm

---
 modules/cpu/src/runtime/cmodel/include/hardware_context.h | 1 +
 modules/cpu/src/runtime/cmodel/include/layernorm.h        | 2 +-
 modules/cpu/src/runtime/cmodel/tests/demo1/golden.py      | 2 +-
 modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h       | 4 ++--
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_context.h b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
index 442160c2f0..73317d9176 100644
--- a/modules/cpu/src/runtime/cmodel/include/hardware_context.h
+++ b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
@@ -2,6 +2,7 @@
 
 #include <iostream>
 #include <memory>
+#include <functional>
 
 struct hardware_context_impl;
 
diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index e81d3719b4..988a7fbcb4 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -25,7 +25,7 @@ void layernorm_naive_impl(T *input, const T *sum, T *sum_sqr, T *gamma, T *beta,
 
     for (size_t o = 0; o < outer_size; o++) {
         auto mean = sum[o] / norm_size;
-        auto sigma = std::sqrt(sum_sqr[o] / static_cast<T>(norm_size) + eps);
+        auto sigma = std::sqrt(sum_sqr[o] - sum[o] * mean + eps);
         for (size_t i = 0; i < inner_size; i++) {
             auto x = input + o * inner_size + i;
             *x = (*x - mean) / sigma * gamma[i] + beta[i];
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
index 038d6d68e0..70ed08a2f2 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
@@ -2,7 +2,7 @@
 from torch import nn
 import torch
     
-X = np.ones_like( np.random.rand(384, 8192).astype(np.float32)  )*1.1
+X = np.random.rand(384, 8192).astype(np.float32)
 WK = np.random.rand(64, 8192, 128).astype(np.float32) * 5 - 1
 
 K = X @ WK
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index 40c74c4591..59df3a86bc 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -86,8 +86,8 @@ void stage1_kernel(
     tensor<float> gamma({256});
     tdma_fill_async(gamma, 1.0f);
     tensor<float> beta({256});
-    tdma_fill_async(beta, 1.0f);
-    tensor_layernorm_sync(xj, r_sum, r_sum_sqr, gamma, beta, 1e-6f, 1, 8192);
+    tdma_fill_async(beta, 0.0f);
+    tensor_layernorm_sync(xj, r_sum, r_sum_sqr, gamma, beta, 1e-5f, 1, 8192);
     tdma_store_async(xj, Norm({0, (bid * CORES + tid) * 256}, {384, 256}), ctx);
 
     // tensor_sum_sqr(xj, r_sum, r_sum_sqr);

From 897ce6da2cc7459d09487db9ae30899e47b5aadb Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Thu, 17 Aug 2023 11:44:00 +0000
Subject: [PATCH 102/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/include/hardware_context.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_context.h b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
index 73317d9176..646e9bdf27 100644
--- a/modules/cpu/src/runtime/cmodel/include/hardware_context.h
+++ b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
@@ -1,8 +1,8 @@
 #pragma once
 
+#include <functional>
 #include <iostream>
 #include <memory>
-#include <functional>
 
 struct hardware_context_impl;
 

From fd464c0c1fa91bc59ac04e56fada5f48e0a641ab Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 17 Aug 2023 20:09:24 +0800
Subject: [PATCH 103/308] fix layernorm

---
 modules/cpu/src/runtime/cmodel/include/layernorm.h  | 2 +-
 modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index 988a7fbcb4..a71a68b030 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -25,7 +25,7 @@ void layernorm_naive_impl(T *input, const T *sum, T *sum_sqr, T *gamma, T *beta,
 
     for (size_t o = 0; o < outer_size; o++) {
         auto mean = sum[o] / norm_size;
-        auto sigma = std::sqrt(sum_sqr[o] - sum[o] * mean + eps);
+        auto sigma = std::sqrt((sum_sqr[o] - sum[o] * mean) / norm_size + eps);
         for (size_t i = 0; i < inner_size; i++) {
             auto x = input + o * inner_size + i;
             *x = (*x - mean) / sigma * gamma[i] + beta[i];
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index 59df3a86bc..484a57a6a9 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -71,7 +71,8 @@ void stage1_kernel(
     // }
 
     // X [384,8192] => separate to bid , tid
-    auto xj = X({0, (bid * CORES + tid) * 256}, {384, 256}); // [48,2048]
+    tensor<float> xj({384, 256});
+    __tensor_copy_sync(std::move(xj), X({0, (bid * CORES + tid) * 256}, {384, 256}));
     tensor<float> r_sum({384});
     tensor<float> r_sum_sqr({384});
     tensor_reduce_sum_sqr(xj, r_sum, r_sum_sqr);

From 652b76e4fa7d092b6ece392c3ee461e89be02f08 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 17 Aug 2023 19:40:09 +0800
Subject: [PATCH 104/308] add demo2

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |   1 +
 .../cpu/src/runtime/cmodel/include/matmul.h   |  12 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h |  28 ++-
 .../runtime/cmodel/tests/demo2/cluster_def.h  | 171 ++++++++++++++++++
 .../src/runtime/cmodel/tests/demo2/golden.py  |  51 ++++++
 .../src/runtime/cmodel/tests/demo2/kernel.h   |  93 ++++++++++
 .../src/runtime/cmodel/tests/demo2/main.cpp   | 158 ++++++++++++++++
 .../runtime/cmodel/tests/demo2/shared_def.h   |   9 +
 8 files changed, 514 insertions(+), 9 deletions(-)
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo2/cluster_def.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo2/golden.py
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index 9508765184..da544fcf7a 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -19,3 +19,4 @@ function(add_test name test_path)
 endfunction(add_test)
 
 add_test(demo1 tests/demo1)
+add_test(demo2 tests/demo2)
diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
index e2d9a5d8c3..e5294f75e5 100644
--- a/modules/cpu/src/runtime/cmodel/include/matmul.h
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -96,12 +96,16 @@ void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                     T *values = new T[new_b_shape[4]]();
                     for (size_t k = 0; k < new_a_shape[4]; k++) {
                         for (size_t n = 0; n < new_b_shape[4]; n++) {
-                            values[n] += in_a_ptr[m * new_a_stride[3] + k] *
-                                         in_b_ptr[k * new_b_stride[3] + n];
+                            values[n] += in_a_ptr[m * new_a_stride[3] +
+                                                  k * new_a_stride[4]] *
+                                         in_b_ptr[k * new_b_stride[3] +
+                                                  n * new_b_stride[4]];
                         }
                     }
-                    std::copy_n(values, new_b_shape[4],
-                                out_ptr + m * new_out_stride[3]);
+                    for (size_t n = 0; n < new_b_shape[4]; n++) {
+                        out_ptr[m * new_out_stride[3] + n * new_out_stride[4]] =
+                            values[n];
+                    }
                     delete[] values;
                 }
             }
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index ba49de6472..667807826d 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -11,12 +11,23 @@
 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
 #include <spdlog/spdlog.h>
 
-template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &dest) {
-    auto new_dims = dims_t(dest.dimension());
+template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &src) {
+    auto new_dims = dims_t(src.dimension());
     new_dims.insert(new_dims.begin(), 1);
-    auto new_strides = strides_t(dest.strides());
+    auto new_strides = strides_t(src.strides());
     new_strides.insert(new_strides.begin(), *new_strides.begin());
-    return tensor<T, Loc>(dest.data(), new_dims, new_strides);
+    return tensor<T, Loc>(src.data(), new_dims, new_strides);
+}
+
+template <class T, loc_t Loc>
+tensor<T, Loc> view_transpose(tensor<T, Loc> &src, dims_t axes) {
+    auto new_dims = dims_t();
+    auto new_strides = dims_t();
+    for (auto axis : axes) {
+      new_dims.push_back(src.dimension()[axis]);
+      new_strides.push_back(src.strides()[axis]);
+    }
+    return tensor<T, Loc>(src.data(), new_dims, new_strides);
 }
 
 template <class T, loc_t DestLoc, loc_t SrcLoc>
@@ -283,4 +294,11 @@ void tdma_wait(thread_context &ctx) {
 
 void tdma_cancel() {}
 
-void tdma_status() {}
\ No newline at end of file
+void tdma_status() {}
+
+enum class sched_strategy_t:uint8_t{
+  pin_block_tensor,
+  normal
+};
+
+void set_sched_strategy([[maybe_unused]] sched_strategy_t sch) {}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/cluster_def.h b/modules/cpu/src/runtime/cmodel/tests/demo2/cluster_def.h
new file mode 100644
index 0000000000..8fd5d84ed7
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/cluster_def.h
@@ -0,0 +1,171 @@
+#pragma once
+#include <hardware_context.h>
+#include <tdma.h>
+
+namespace block0 {
+#include "shared_def.h"
+constexpr size_t bid = 0;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block0
+
+namespace block1 {
+#include "shared_def.h"
+constexpr size_t bid = 1;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block1
+
+namespace block2 {
+#include "shared_def.h"
+constexpr size_t bid = 2;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block2
+
+namespace block3 {
+#include "shared_def.h"
+constexpr size_t bid = 3;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block3
+
+namespace block4 {
+#include "shared_def.h"
+constexpr size_t bid = 4;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block4
+
+namespace block5 {
+#include "shared_def.h"
+constexpr size_t bid = 5;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block5
+
+namespace block6 {
+#include "shared_def.h"
+constexpr size_t bid = 6;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block6
+
+namespace block7 {
+#include "shared_def.h"
+constexpr size_t bid = 7;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block7
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py
new file mode 100644
index 0000000000..682dc2040c
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py
@@ -0,0 +1,51 @@
+import numpy as np
+from torch import nn
+import torch
+from scipy.special import softmax
+
+
+X = np.random.rand(384, 8192).astype(np.float32)
+WQ = np.random.rand(64, 8192, 128).astype(np.float32) * 5 - 1
+WK = np.random.rand(64, 8192, 128).astype(np.float32) * 5 - 1
+WV = np.random.rand(64, 8192, 128).astype(np.float32) * 5 - 1
+WM = np.random.rand(8192, 8192).astype(np.float32) * 5 - 1
+
+X.tofile('X.bin')
+WQ.tofile('WQ.bin')
+WK.tofile('WK.bin')
+WV.tofile('WV.bin')
+WM.tofile('WM.bin')
+
+
+Q = X @ WQ  # [64,384,128]
+K = X @ WK  # [64,384,128]
+V = X @ WV  # [64,384,128]
+
+QK = Q @ np.transpose(K, [0, 2, 1])  # [64,384,384]
+
+S = softmax(QK)  # [64,384,384]
+
+Y = np.transpose(S @ V, [1, 0, 2]).reshape([384, -1])  # [64,384,128]
+
+M = Y @ WM  # [384,8192]
+
+Norm = nn.LayerNorm([8192], elementwise_affine=False)(torch.from_numpy(X + M))
+Norm.detach().numpy().tofile('Norm.bin')
+
+
+# a = np.arange( 64 *384* 128).reshape([64, 384, 128])
+
+# b = np.transpose(a,[1,2,0])
+# fb = b.flatten()
+# fa = a.flatten()
+
+# newa = []
+# s0 = 384*128
+# s1 = 128
+# s2 = 1
+# for d1 in range(384):
+#   for d2 in range(128):
+#     for d0 in range(64):
+#       newa.append(fa[d0 * s0 + d1*s1 + d2*s2])
+
+# print(np.allclose(fb,np.array(newa) ))
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
new file mode 100644
index 0000000000..2ccd50a150
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
@@ -0,0 +1,93 @@
+// llama 65B
+// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
+// 1 chips, 8 blocks per chip, 4 threads per block
+
+// tensor<float, loc_t::shared> X({384, 8192});
+// tensor<float, loc_t::shared> kh({8, 384, 128}), vh({8, 384, 128}); //
+// [8, 384, 128] tensor<float, loc_t::shared> qkh({8, 384, 384});    //
+// [8, 384, 384] tensor<float, loc_t::shared> qkh({8, 384, 384});    //
+// [8, 384, 384]
+#include "thread_context.h"
+using namespace shared;
+
+static bool w_loaded;
+static tensor<float> wqh({8, 2048, 128});
+static tensor<float> wkh({8, 2048, 128});
+static tensor<float> wvh({8, 2048, 128}); // [8, 2048, 128]
+static tensor<float> wfc1ih({1024, 8192});
+static tensor<float> wfc2ih({1024, 8192}); // [1024, 8192]
+static tensor<float> yih({96, 1024});
+
+// 8 head per block
+// 2048 w-len per thread
+void stage1_kernel(
+    [[maybe_unused]] tensor<float, loc_t::device> &WQ, /* 64, 8192, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &WK, /* 64, 8192, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &WV, /* 64, 8192, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &WM  /* 8192, 8192 */
+) {
+    thread_context ctx(bid, tid);
+    // 1. Get xi
+    auto xi = X({0, tid * 2048}, {384, 2048}); // [384, 2048]
+
+    // 2. load wqh wkh wvh
+    if (!w_loaded) {
+        tdma_load_async(wqh, WQ({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
+        tdma_load_async(wkh, WK({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
+        tdma_load_async(wvh, WV({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
+        // tdma_load_async(wfc1ih, WFC1({bid * 1024, tid * 8192}, {1024,
+        // 8192}));
+        tdma_wait(ctx); // 等待 x, wqh, wkh, wvh ready
+        w_loaded = true;
+    }
+    // 3. compute k, v
+    set_sched_strategy(
+        sched_strategy_t::pin_block_tensor); // 仅在 block 内调度线程的 tensor
+                                             // 指令
+
+    // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
+    tensor_block_mma_sync(xi, wkh, kh, false, ctx);
+    // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
+    tensor_block_mma_sync(xi, wvh, vh, false, ctx);
+
+    // 4. compute qk
+    tensor<float> qih({8, 384, 128});
+    // [384, 2048] x [8, 2048, 128] = [8, 384, 128]
+    tensor_mma_sync(xi, wqh, qih);
+    // [8, 384, 128] x [8, 128, 384] = [8, 384, 384]
+    auto khT = view_transpose(kh, dims_t({0, 2, 1}));
+    tensor_block_mma_sync(qih, khT, qkh, false, ctx);
+
+    set_sched_strategy(sched_strategy_t::normal);
+}
+
+// 8 head per block
+// 96 seq-len per thread
+void stage2_kernel(tensor<float> &qkh) {
+    // 5. compute softmax
+    auto qkhi = qkh({bid * 8, tid * 96, 0}, {8, 96, 384});
+
+    tensor<float> sih({8, 96, 384});
+    sih = softmax(qkhi, 2);
+
+    // 6. compute y
+    tensor<float> yihT({8, 96, 128});
+    // [8, 96, 384] x [8, 384, 128] = [8, 96, 128]
+    tensor_mma_sync(sih, vh, yihT);
+    // 下面的 transpose 可以在计算 yih 的过程中通过指定输出 stride
+    // 无代价地做到。
+    /* [96, 8, 128] -> [96, 1024] */
+    yih = reshape(view_transpose(yihT, dims_t({1, 0, 2})), {96, 1024});
+
+    // 7. Add and sum & sqr
+    tensor<float> sum({96});
+    tensor<float> sum_sqr({96});
+    auto xi = X({tid * 96, bid * 1024}, {96, 1024}); // [96, 1024]
+    yih = add_and_sum_sqr(yih, xi, sum, sum_sqr);
+    __tdma_all_reduce_async(sum, sum_sqr,
+                            reduce_op_t::SUM); // All blocks & threads reduce
+    __tdma_wait();
+
+    // 8. compute LayerNorm
+    yih = layer_norm(yih, sum, sum_sqr); // [96, 1024]
+}
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
new file mode 100644
index 0000000000..a2e726348a
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
@@ -0,0 +1,158 @@
+#include "cluster_def.h"
+#include <io_utils.h>
+#include <runtime_utils.h>
+// #include <pthread.h>
+
+#define DEFINE_TFUNC(b, t)                                                     \
+    void *f_##b##_##t(void *arg) {                                             \
+        block##b::thread##t::stage1_kernel(WQ, WK, WV, WM);                        \
+        return arg;                                                            \
+    }
+
+#define DEFINE_BFUNC(b)                                                        \
+    DEFINE_TFUNC(b, 0)                                                         \
+    DEFINE_TFUNC(b, 1)                                                         \
+    DEFINE_TFUNC(b, 2)                                                         \
+    DEFINE_TFUNC(b, 3)
+
+tensor<float, loc_t::device> WQ({64, 8192, 128});
+tensor<float, loc_t::device> WK({64, 8192, 128});
+tensor<float, loc_t::device> WV({64, 8192, 128});
+tensor<float, loc_t::device> WM({8192, 8192});
+
+DEFINE_BFUNC(0)
+DEFINE_BFUNC(1)
+DEFINE_BFUNC(2)
+DEFINE_BFUNC(3)
+DEFINE_BFUNC(4)
+DEFINE_BFUNC(5)
+DEFINE_BFUNC(6)
+DEFINE_BFUNC(7)
+
+/**
+ * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
+ *
+ * @param argc
+ * @param argv
+ * @return int
+ */
+int main([[maybe_unused]] int argc, char **argv) {
+    // spdlog::set_level(spdlog::level::debug);
+    global_hardware_init();
+
+    /* fill tensor */
+    auto src_X = read_file(std::string(argv[1]));
+    auto src_WQ = read_file(std::string(argv[2]));
+    auto src_WK = read_file(std::string(argv[3]));
+    auto src_WV = read_file(std::string(argv[4]));
+    auto src_WM = read_file(std::string(argv[5]));
+    span_copy(WQ.data(), gsl::make_span(src_WQ).as_span<float>());
+    span_copy(WK.data(), gsl::make_span(src_WK).as_span<float>());
+    span_copy(WV.data(), gsl::make_span(src_WV).as_span<float>());
+    span_copy(WM.data(), gsl::make_span(src_WM).as_span<float>());
+    span_copy(block0::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block1::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block2::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block3::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block4::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block5::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block6::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block7::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+
+    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
+
+    pthread_create(&t_0_0, NULL, f_0_0, NULL);
+    pthread_create(&t_0_1, NULL, f_0_1, NULL);
+    pthread_create(&t_0_2, NULL, f_0_2, NULL);
+    pthread_create(&t_0_3, NULL, f_0_3, NULL);
+    pthread_create(&t_1_0, NULL, f_1_0, NULL);
+    pthread_create(&t_1_1, NULL, f_1_1, NULL);
+    pthread_create(&t_1_2, NULL, f_1_2, NULL);
+    pthread_create(&t_1_3, NULL, f_1_3, NULL);
+    pthread_create(&t_2_0, NULL, f_2_0, NULL);
+    pthread_create(&t_2_1, NULL, f_2_1, NULL);
+    pthread_create(&t_2_2, NULL, f_2_2, NULL);
+    pthread_create(&t_2_3, NULL, f_2_3, NULL);
+    pthread_create(&t_3_0, NULL, f_3_0, NULL);
+    pthread_create(&t_3_1, NULL, f_3_1, NULL);
+    pthread_create(&t_3_2, NULL, f_3_2, NULL);
+    pthread_create(&t_3_3, NULL, f_3_3, NULL);
+    pthread_create(&t_4_0, NULL, f_4_0, NULL);
+    pthread_create(&t_4_1, NULL, f_4_1, NULL);
+    pthread_create(&t_4_2, NULL, f_4_2, NULL);
+    pthread_create(&t_4_3, NULL, f_4_3, NULL);
+    pthread_create(&t_5_0, NULL, f_5_0, NULL);
+    pthread_create(&t_5_1, NULL, f_5_1, NULL);
+    pthread_create(&t_5_2, NULL, f_5_2, NULL);
+    pthread_create(&t_5_3, NULL, f_5_3, NULL);
+    pthread_create(&t_6_0, NULL, f_6_0, NULL);
+    pthread_create(&t_6_1, NULL, f_6_1, NULL);
+    pthread_create(&t_6_2, NULL, f_6_2, NULL);
+    pthread_create(&t_6_3, NULL, f_6_3, NULL);
+    pthread_create(&t_7_0, NULL, f_7_0, NULL);
+    pthread_create(&t_7_1, NULL, f_7_1, NULL);
+    pthread_create(&t_7_2, NULL, f_7_2, NULL);
+    pthread_create(&t_7_3, NULL, f_7_3, NULL);
+
+    pthread_join(t_0_0, NULL);
+    pthread_join(t_0_1, NULL);
+    pthread_join(t_0_2, NULL);
+    pthread_join(t_0_3, NULL);
+    pthread_join(t_1_0, NULL);
+    pthread_join(t_1_1, NULL);
+    pthread_join(t_1_2, NULL);
+    pthread_join(t_1_3, NULL);
+    pthread_join(t_2_0, NULL);
+    pthread_join(t_2_1, NULL);
+    pthread_join(t_2_2, NULL);
+    pthread_join(t_2_3, NULL);
+    pthread_join(t_3_0, NULL);
+    pthread_join(t_3_1, NULL);
+    pthread_join(t_3_2, NULL);
+    pthread_join(t_3_3, NULL);
+    pthread_join(t_4_0, NULL);
+    pthread_join(t_4_1, NULL);
+    pthread_join(t_4_2, NULL);
+    pthread_join(t_4_3, NULL);
+    pthread_join(t_5_0, NULL);
+    pthread_join(t_5_1, NULL);
+    pthread_join(t_5_2, NULL);
+    pthread_join(t_5_3, NULL);
+    pthread_join(t_6_0, NULL);
+    pthread_join(t_6_1, NULL);
+    pthread_join(t_6_2, NULL);
+    pthread_join(t_6_3, NULL);
+    pthread_join(t_7_0, NULL);
+    pthread_join(t_7_1, NULL);
+    pthread_join(t_7_2, NULL);
+    pthread_join(t_7_3, NULL);
+
+    // auto cos =
+    //     cosine(K.data().begin(), gsl::make_span(src_K).as_span<float>().begin(),
+    //            K.data().size());
+    // printf("K cosine %f\n", cos);
+
+    // cos = cosine(Sum.data().begin(),
+    //              gsl::make_span(src_Sum).as_span<float>().begin(),
+    //              Sum.data().size());
+    // printf("Sum cosine %f\n", cos);
+
+    // cos = cosine(RSum.data().begin(),
+    //              gsl::make_span(src_RSum).as_span<float>().begin(),
+    //              Sum.data().size());
+    // printf("src_RSum cosine %f\n", cos);
+
+    // cos = cosine(RSumSqr.data().begin(),
+    //              gsl::make_span(src_RSumSqr).as_span<float>().begin(),
+    //              Sum.data().size());
+    // printf("RSumSqr cosine %f\n", cos);
+
+    // cos = cosine(Norm.data().begin(),
+    //              gsl::make_span(src_Norm).as_span<float>().begin(),
+    //              Sum.data().size());
+    // printf("Norm cosine %f\n", cos);
+    return 0;
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h
new file mode 100644
index 0000000000..f3cfe35e85
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h
@@ -0,0 +1,9 @@
+#include <tdma.h>
+
+namespace shared {
+static tensor<float, loc_t::shared> X({384, 8192});
+static tensor<float, loc_t::shared> kh({8, 384, 128});
+static tensor<float, loc_t::shared> vh({8, 384, 128});  // []
+static tensor<float, loc_t::shared> qkh({8, 384, 384}); // []
+// static tensor<float, loc_t::shared> qkh({8, 384, 384}); // []
+} // namespace shared
\ No newline at end of file

From b9b291750edfc54030ae93572d9ce1c2f7f2cf15 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 17 Aug 2023 20:12:44 +0800
Subject: [PATCH 105/308] fix build / add view

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 26 +++++++----
 .../src/runtime/cmodel/include/transpose.h    | 46 +++++++++++++++++++
 .../src/runtime/cmodel/tests/demo2/kernel.h   | 24 ++++++----
 3 files changed, 78 insertions(+), 18 deletions(-)
 create mode 100644 modules/cpu/src/runtime/cmodel/include/transpose.h

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 667807826d..a04997c612 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -8,6 +8,7 @@
 #include <reduce.h>
 #include <tensor.h>
 #include <thread_context.h>
+#include <transpose.h>
 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
 #include <spdlog/spdlog.h>
 
@@ -20,16 +21,28 @@ template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &src) {
 }
 
 template <class T, loc_t Loc>
-tensor<T, Loc> view_transpose(tensor<T, Loc> &src, dims_t axes) {
+tensor<T, Loc> view_transpose(tensor<T, Loc> &src, dims_t perm) {
     auto new_dims = dims_t();
     auto new_strides = dims_t();
-    for (auto axis : axes) {
-      new_dims.push_back(src.dimension()[axis]);
-      new_strides.push_back(src.strides()[axis]);
+    for (auto axis : perm) {
+        new_dims.push_back(src.dimension()[axis]);
+        new_strides.push_back(src.strides()[axis]);
     }
     return tensor<T, Loc>(src.data(), new_dims, new_strides);
 }
 
+template <class T, loc_t Loc>
+tensor<T, Loc> view(tensor<T, Loc> &src, dims_t new_dims) {
+    return tensor<T, Loc>(src.data(), new_dims, get_default_strides(new_dims));
+}
+
+template <class T, loc_t Loc>
+void transpose(tensor<T, Loc> &src, tensor<T, Loc> &dest, dims_t perm) {
+    return kernels::transpose(src.cdata().data(), dest.data().data(),
+                              src.dimension(), perm, src.strides(),
+                              dest.strides());
+}
+
 template <class T, loc_t DestLoc, loc_t SrcLoc>
 void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
     assert(dest.dimension() == src.dimension());
@@ -296,9 +309,6 @@ void tdma_cancel() {}
 
 void tdma_status() {}
 
-enum class sched_strategy_t:uint8_t{
-  pin_block_tensor,
-  normal
-};
+enum class sched_strategy_t : uint8_t { pin_block_tensor, normal };
 
 void set_sched_strategy([[maybe_unused]] sched_strategy_t sch) {}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/transpose.h b/modules/cpu/src/runtime/cmodel/include/transpose.h
new file mode 100644
index 0000000000..c787f77d08
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/transpose.h
@@ -0,0 +1,46 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <apply.h>
+#include <gsl/gsl-lite.hpp>
+#include <runtime_utils.h>
+
+namespace kernels {
+
+namespace {
+template <class T>
+void transpose_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
+                    gsl::span<const size_t> perm,
+                    gsl::span<const size_t> in_strides,
+                    gsl::span<const size_t> out_strides) noexcept {
+    return apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        dims_t out_index(index.size());
+        for (size_t i = 0; i < index.size(); i++)
+            out_index[i] = index[perm[i]];
+        output[offset(out_strides, out_index)] =
+            input[offset(in_strides, index)];
+    });
+}
+
+} // namespace
+
+template <class T>
+void transpose(const T *src, T *dest, gsl::span<const size_t> in_shape,
+               gsl::span<const size_t> perm, gsl::span<const size_t> in_strides,
+               gsl::span<const size_t> out_strides) noexcept {
+    transpose_impl(src, dest, in_shape, perm, in_strides, out_strides);
+}
+
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
index 2ccd50a150..4db06ecfcb 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
@@ -64,11 +64,12 @@ void stage1_kernel(
 // 8 head per block
 // 96 seq-len per thread
 void stage2_kernel(tensor<float> &qkh) {
+    thread_context ctx(bid, tid);
     // 5. compute softmax
     auto qkhi = qkh({bid * 8, tid * 96, 0}, {8, 96, 384});
 
     tensor<float> sih({8, 96, 384});
-    sih = softmax(qkhi, 2);
+    // sih = softmax(qkhi, 2);
 
     // 6. compute y
     tensor<float> yihT({8, 96, 128});
@@ -77,17 +78,20 @@ void stage2_kernel(tensor<float> &qkh) {
     // 下面的 transpose 可以在计算 yih 的过程中通过指定输出 stride
     // 无代价地做到。
     /* [96, 8, 128] -> [96, 1024] */
-    yih = reshape(view_transpose(yihT, dims_t({1, 0, 2})), {96, 1024});
+    tensor<float> yih({96, 8, 128});
+    transpose(yihT, yih, dims_t({1, 0, 2}));
+    [[maybe_unused]] auto yihv = view(yih, dims_t({96, 1024}));
+    // yih = reshape(, {96, 1024});
 
     // 7. Add and sum & sqr
-    tensor<float> sum({96});
-    tensor<float> sum_sqr({96});
-    auto xi = X({tid * 96, bid * 1024}, {96, 1024}); // [96, 1024]
-    yih = add_and_sum_sqr(yih, xi, sum, sum_sqr);
-    __tdma_all_reduce_async(sum, sum_sqr,
-                            reduce_op_t::SUM); // All blocks & threads reduce
-    __tdma_wait();
+    // tensor<float> sum({96});
+    // tensor<float> sum_sqr({96});
+    // auto xi = X({tid * 96, bid * 1024}, {96, 1024}); // [96, 1024]
+    // yih = add_and_sum_sqr(yih, xi, sum, sum_sqr);
+    // __tdma_all_reduce_async(sum, sum_sqr,
+    //                         reduce_op_t::SUM); // All blocks & threads reduce
+    tdma_wait(ctx);
 
     // 8. compute LayerNorm
-    yih = layer_norm(yih, sum, sum_sqr); // [96, 1024]
+    // yih = layer_norm(yih, sum, sum_sqr); // [96, 1024]
 }

From 97ab7160da21b09c7561a2fbeaf702ba9fc34e54 Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Thu, 17 Aug 2023 12:13:03 +0000
Subject: [PATCH 106/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index 484a57a6a9..b4ed62a27c 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -72,7 +72,8 @@ void stage1_kernel(
 
     // X [384,8192] => separate to bid , tid
     tensor<float> xj({384, 256});
-    __tensor_copy_sync(std::move(xj), X({0, (bid * CORES + tid) * 256}, {384, 256}));
+    __tensor_copy_sync(std::move(xj),
+                       X({0, (bid * CORES + tid) * 256}, {384, 256}));
     tensor<float> r_sum({384});
     tensor<float> r_sum_sqr({384});
     tensor_reduce_sum_sqr(xj, r_sum, r_sum_sqr);

From 96698aa577ff90063e2a3e510161da11a65fa66b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 18 Aug 2023 11:55:42 +0800
Subject: [PATCH 107/308] update layernorm

---
 modules/cpu/src/runtime/cmodel/include/layernorm.h | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index a71a68b030..61ece903f2 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -25,7 +25,7 @@ void layernorm_naive_impl(T *input, const T *sum, T *sum_sqr, T *gamma, T *beta,
 
     for (size_t o = 0; o < outer_size; o++) {
         auto mean = sum[o] / norm_size;
-        auto sigma = std::sqrt((sum_sqr[o] - sum[o] * mean) / norm_size + eps);
+        auto sigma = std::sqrt(sum_sqr[o] / norm_size - mean * mean + eps);
         for (size_t i = 0; i < inner_size; i++) {
             auto x = input + o * inner_size + i;
             *x = (*x - mean) / sigma * gamma[i] + beta[i];
@@ -51,11 +51,13 @@ void layernorm_rvv_impl(const T *input, const T *sum, T *sum_sqr, T *gamma,
     }
 
     size_t vl;
+    float r_norm_size = 1.f / norm_size;
     float *sum_ptr = sum;
     float *sum_sqr_ptr = sum_sqr;
     std::vector<float> mean(outer_size, 0);
     std::vector<float> sigma(outer_size, 0);
     vfloat32m8_t vmean;
+    vfloat32m8_t vmean_sqr;
     vfloat32m8_t vsigma;
     size_t offset = 0;
     for (size_t o = outer_size; o > 0; o -= vl) {
@@ -63,12 +65,14 @@ void layernorm_rvv_impl(const T *input, const T *sum, T *sum_sqr, T *gamma,
 
         // mean
         vmean = vle32_v_f32m8(sum_ptr, vl);
-        vmean = vfdiv_vf_f32m8(vmean, norm_size);
+        vmean = vfmul_vf_f32m8(vmean, r_norm_size);
+        vmean_sqr = vfmul_vv_f32m8(vmean, vmean);
         vse32_v_f32m8(mean.data() + offset, vmean, vl);
 
         // sigma
         vsigma = vle32_v_f32m8(sum_sqr_ptr, vl);
-        vsigma = vfdiv_vf_f32m8(vsigma, norm_size);
+        vsigma = vfmul_vf_f32m8(vsigma, r_norm_size);
+        vsigma = vfsub_vv_f32m8(vsigma, vmean_sqr);
         vsigma = vfadd_vf_f32m8(vsigma, eps);
         vsigma = vfsqrt_v_f32m8(vsigma);
         vse32_v_f32m8(sigma.data() + offset, vsigma, vl);

From a8edb2cadeccf63782eba25ba6497ada21321b0d Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Fri, 18 Aug 2023 03:58:50 +0000
Subject: [PATCH 108/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
index a2e726348a..46f0654deb 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
@@ -5,7 +5,7 @@
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(WQ, WK, WV, WM);                        \
+        block##b::thread##t::stage1_kernel(WQ, WK, WV, WM);                    \
         return arg;                                                            \
     }
 
@@ -131,7 +131,8 @@ int main([[maybe_unused]] int argc, char **argv) {
     pthread_join(t_7_3, NULL);
 
     // auto cos =
-    //     cosine(K.data().begin(), gsl::make_span(src_K).as_span<float>().begin(),
+    //     cosine(K.data().begin(),
+    //     gsl::make_span(src_K).as_span<float>().begin(),
     //            K.data().size());
     // printf("K cosine %f\n", cos);
 

From ab64adc1483f0bf402ba301397c026740cbd9c65 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 18 Aug 2023 17:47:49 +0800
Subject: [PATCH 109/308] support layernorm of llama

---
 src/Nncase.Compiler/Compiler.cs               |  1 +
 src/Nncase.Core/IR/NN/Functional.cs           |  2 +-
 src/Nncase.Core/IR/NN/LayerNorm.cs            |  2 +
 src/Nncase.Evaluator/NN/LayerNorm.cs          | 11 ++--
 .../Rules/Neutral/FoldLayerNorm.cs            | 54 +++++++++++++++++++
 5 files changed, 65 insertions(+), 5 deletions(-)

diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 42528a76e0..643e7f5dbb 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -104,6 +104,7 @@ public void TargetIndependentPass(IPassManager passManager)
                 p.Add<Passes.Rules.Neutral.FoldLayerNormPattern2>();
                 p.Add<Passes.Rules.Neutral.FoldLayerNormPattern3>();
                 p.Add<Passes.Rules.Neutral.FoldLayerNormPattern4>();
+                p.Add<Passes.Rules.Neutral.FoldLayerNormPattern5>();
                 p.Add<Passes.Rules.Neutral.FoldGeluWithScale>();
                 p.Add<Passes.Rules.Neutral.FoldGeneralGelu>();
                 p.Add<Passes.Rules.Neutral.FoldSwishPattern1>();
diff --git a/src/Nncase.Core/IR/NN/Functional.cs b/src/Nncase.Core/IR/NN/Functional.cs
index a93a68e1fd..bc99c82c77 100644
--- a/src/Nncase.Core/IR/NN/Functional.cs
+++ b/src/Nncase.Core/IR/NN/Functional.cs
@@ -34,7 +34,7 @@ public static class NN
 
     public static Call BatchNormalization(Expr input, Expr scale, Expr bias, Expr input_mean, Expr input_var, Expr epsilon, Expr momentum) => new Call(new BatchNormalization(), input, scale, bias, input_mean, input_var, epsilon, momentum);
 
-    public static Call LayerNorm(int axis, float epsilon, Expr input, Expr scale, Expr bias) => new Call(new LayerNorm(axis, epsilon), input, scale, bias);
+    public static Call LayerNorm(int axis, float epsilon, Expr input, Expr scale, Expr bias, bool hasMean = true) => new Call(new LayerNorm(axis, epsilon, hasMean), input, scale, bias);
 
     public static Call BatchToSpace(Expr input, Expr blockShape, Expr crops) => new Call(new BatchToSpace(), input, blockShape, crops);
 
diff --git a/src/Nncase.Core/IR/NN/LayerNorm.cs b/src/Nncase.Core/IR/NN/LayerNorm.cs
index 2dff32f440..bbeeb7dec9 100644
--- a/src/Nncase.Core/IR/NN/LayerNorm.cs
+++ b/src/Nncase.Core/IR/NN/LayerNorm.cs
@@ -36,4 +36,6 @@ public sealed partial class LayerNorm : Op
     public int Axis { get; }
 
     public float Epsilon { get; }
+
+    public bool UseMean { get; }
 }
diff --git a/src/Nncase.Evaluator/NN/LayerNorm.cs b/src/Nncase.Evaluator/NN/LayerNorm.cs
index 4088d8f9e4..653692f5d0 100644
--- a/src/Nncase.Evaluator/NN/LayerNorm.cs
+++ b/src/Nncase.Evaluator/NN/LayerNorm.cs
@@ -23,7 +23,7 @@ public IValue Visit(IEvaluateContext context, LayerNorm layerNorm)
         var bias = context.GetOrtArgumentValue(layerNorm, LayerNorm.Bias);
 
         // return Value.FromTensor(OrtKI.LayerNormalization(input, scale, bias, layerNorm.Axis, layerNorm.Epsilon, 1));
-        return Value.FromTensor(LayerNormImpl(input.ToTensor(), scale.ToTensor(), bias.ToTensor(), layerNorm.Axis, layerNorm.Epsilon));
+        return Value.FromTensor(LayerNormImpl(input.ToTensor(), scale.ToTensor(), bias.ToTensor(), layerNorm.Axis, layerNorm.Epsilon, layerNorm.UseMean));
     }
 
     /// <inheritdoc/>
@@ -71,7 +71,7 @@ private IRType Visit(TensorType input)
     }
 
 #if true
-    private Tensor LayerNormImpl(Tensor input, Tensor scale, Tensor bias, int axis, float epsilon)
+    private Tensor LayerNormImpl(Tensor input, Tensor scale, Tensor bias, int axis, float epsilon, bool useMean = true)
     {
         int outputSize = 1;
         int innerSize = 1;
@@ -96,9 +96,12 @@ private Tensor LayerNormImpl(Tensor input, Tensor scale, Tensor bias, int axis,
         for (int batch = 0; batch < outputSize; batch++)
         {
             float mean1 = 0f;
-            for (int i = 0; i < innerSize; i++)
+            if (useMean)
             {
-                mean1 += inputArray[(i + (batch * innerSize)) % inputArray.Length] / innerSize;
+                for (int i = 0; i < innerSize; i++)
+                {
+                    mean1 += inputArray[(i + (batch * innerSize)) % inputArray.Length] / innerSize;
+                }
             }
 
             float[] sub = new float[innerSize];
diff --git a/src/Nncase.Passes/Rules/Neutral/FoldLayerNorm.cs b/src/Nncase.Passes/Rules/Neutral/FoldLayerNorm.cs
index 41b3a34979..c8df9e9e62 100644
--- a/src/Nncase.Passes/Rules/Neutral/FoldLayerNorm.cs
+++ b/src/Nncase.Passes/Rules/Neutral/FoldLayerNorm.cs
@@ -279,3 +279,57 @@ public sealed partial class FoldLayerNormPattern4 : RewriteRule<CallPattern>
         return null;
     }
 }
+
+// pattern from llama without mean and beta
+[RuleGenerator]
+public sealed partial class FoldLayerNormPattern5 : RewriteRule<CallPattern>
+{
+    /// <inheritdoc/>
+    public override CallPattern Pattern { get; } =
+        IsBinary(
+            "mulGamma",
+            "mulGammaCall",
+            BinaryOp.Mul,
+            IsTensorConst("gamma"),
+            IsBinary(
+                "mulX",
+                "mulXCall",
+                BinaryOp.Mul,
+                IsWildcard("input"),
+                IsBinary(
+                    "rsqrt",
+                    "rsqrtCall",
+                    BinaryOp.Div,
+                    IsTensorConst("one"),
+                    IsUnary(
+                        "sqrt",
+                        "sqrtCall",
+                        UnaryOp.Sqrt,
+                        IsBinary(
+                            "addEps",
+                            "addEpsCall",
+                            BinaryOp.Add,
+                            IsReduce(
+                                "rdVar",
+                                "rdVarCall",
+                                ReduceOp.Mean,
+                                IsBinary(
+                                        "pow2",
+                                        "pow2Call",
+                                        BinaryOp.Pow,
+                                        IsWildcard(),
+                                        IsTensorConst("two"))),
+                            IsTensorConst("eps"))))));
+
+    private Expr? GetReplace(Call pow2Call, TensorConst eps, TensorConst gamma, Expr input, TensorConst one, TensorConst two)
+    {
+        if (input == pow2Call[Binary.Lhs] && one.Value.Cast<float>()[0] == 1f && two.Value.Cast<float>()[0] == 2f)
+        {
+            var axis = pow2Call.CheckedShape.Count - gamma.CheckedShape.Count;
+            var beta = Tensor.FromScalar(0f, gamma.CheckedShape);
+            return LayerNorm(axis, eps.Value.Cast<float>()[0], input, gamma, beta, hasMean: false);
+        }
+
+        return null;
+    }
+}

From ea4ceb1d6b71189dc26eeb102b87025b2a260c5a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 18 Aug 2023 11:03:34 +0800
Subject: [PATCH 110/308] fix build

---
 .../src/runtime/cmodel/include/layernorm.h    |  4 +-
 .../cpu/src/runtime/cmodel/include/softmax.h  | 94 +++++++++++++++++++
 modules/cpu/src/runtime/cmodel/include/tdma.h | 18 ++++
 .../src/runtime/cmodel/tests/demo2/kernel.h   | 20 ++--
 4 files changed, 128 insertions(+), 8 deletions(-)
 create mode 100644 modules/cpu/src/runtime/cmodel/include/softmax.h

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index 61ece903f2..209398a522 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -28,7 +28,9 @@ void layernorm_naive_impl(T *input, const T *sum, T *sum_sqr, T *gamma, T *beta,
         auto sigma = std::sqrt(sum_sqr[o] / norm_size - mean * mean + eps);
         for (size_t i = 0; i < inner_size; i++) {
             auto x = input + o * inner_size + i;
-            *x = (*x - mean) / sigma * gamma[i] + beta[i];
+            *x = (*x - mean) / sigma *
+                     (gamma == nullptr ? static_cast<T>(1) : gamma[i]) +
+                 (beta == nullptr ? static_cast<T>(0) : beta[i]);
         }
     }
 }
diff --git a/modules/cpu/src/runtime/cmodel/include/softmax.h b/modules/cpu/src/runtime/cmodel/include/softmax.h
new file mode 100644
index 0000000000..6967b30ac1
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/softmax.h
@@ -0,0 +1,94 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <cmath>
+#include <runtime_utils.h>
+
+namespace kernels {
+
+namespace {
+// softmax(x) = exp(x - reduce_max(x)) / reduce_sum(exp(x - reduce_max(x)))
+template <typename T>
+void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
+                  gsl::span<const size_t> in_strides,
+                  gsl::span<const size_t> out_strides, int64_t axis, float beta,
+                  bool needLog = false) noexcept {
+    size_t positive_axis = axis < 0 ? in_shape.size() + axis : axis;
+    dims_t axes{positive_axis};
+
+    auto reduced_shape = get_reduced_shape(in_shape, axes, true);
+    auto reduced_strides = get_default_strides(reduced_shape);
+    auto reduced_size = compute_size(reduced_shape);
+    std::vector<T> tmp(reduced_size, std::numeric_limits<T>::lowest());
+
+    // reduce_max
+    (apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        auto in_idx = offset(in_strides, index);
+        const auto in = input[in_idx];
+
+        const auto out_index = get_reduced_offset(index, axes, true);
+        auto out_idx = offset(reduced_strides, out_index);
+        auto &out = tmp[out_idx];
+
+        out = std::max(in, out);
+    }));
+
+    // x - reduce_max
+    (apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        auto in_idx = offset(in_strides, index);
+        const auto in = input[in_idx];
+
+        const auto out_index = get_reduced_offset(index, axes, true);
+        auto max_idx = offset(reduced_strides, out_index);
+
+        auto out_idx = offset(out_strides, index);
+        output[out_idx] = (in - tmp[max_idx]) * beta;
+    }));
+
+    // exp(x - reduce_max) and sum
+    tmp.assign(tmp.size(), static_cast<T>(0));
+    (apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        auto in_idx = offset(out_strides, index);
+        const auto in = output[in_idx];
+
+        const auto out_index = get_reduced_offset(index, axes, true);
+        auto out_idx = offset(reduced_strides, out_index);
+        output[in_idx] = expf(in);
+        tmp[out_idx] += output[in_idx];
+    }));
+
+    // div
+    (apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        const auto in_index = get_reduced_offset(index, axes, true);
+        auto in_idx = offset(reduced_strides, in_index);
+        auto in = tmp[in_idx];
+
+        auto out_idx = offset(out_strides, index);
+        auto &out = output[out_idx];
+        out /= in;
+        if (needLog) {
+            out = std::log(out);
+        }
+    }));
+}
+} // namespace
+void softmax(const float *input, float *output,
+             gsl::span<const size_t> in_shape,
+             gsl::span<const size_t> in_strides,
+             gsl::span<const size_t> out_strides, int64_t axis, float beta,
+             bool needLog) noexcept {
+    return softmax_impl(input, output, in_shape, in_strides, out_strides, axis,
+                        beta, needLog);
+}
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index a04997c612..377a6fb75a 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -6,6 +6,7 @@
 #include <layernorm.h>
 #include <matmul.h>
 #include <reduce.h>
+#include <softmax.h>
 #include <tensor.h>
 #include <thread_context.h>
 #include <transpose.h>
@@ -43,6 +44,13 @@ void transpose(tensor<T, Loc> &src, tensor<T, Loc> &dest, dims_t perm) {
                               dest.strides());
 }
 
+template <loc_t SrcLoc, loc_t DestLoc>
+void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest,
+             int axis) {
+    kernels::softmax(src.cdata().data(), dest.data().data(), src.dimension(),
+                     src.strides(), dest.strides(), axis, 1.0f, false);
+}
+
 template <class T, loc_t DestLoc, loc_t SrcLoc>
 void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
     assert(dest.dimension() == src.dimension());
@@ -106,6 +114,16 @@ void tensor_layernorm_sync(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
                        eps, axis, norm_size);
 }
 
+template <typename T, loc_t Loc>
+void tensor_layernorm_sync(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
+                           tensor<T, loc_t::local> &sum_sqr, int32_t axis,
+                           int32_t norm_size) {
+    kernels::layernorm(input.data().data(), sum.data().data(),
+                       sum_sqr.data().data(), static_cast<T *>(nullptr),
+                       static_cast<T *>(nullptr), input.dimension(),
+                       input.strides(), static_cast<T>(1e-5), axis, norm_size);
+}
+
 template <typename T, loc_t ALoc>
 void tensor_reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
                            tensor<T, loc_t::local> &sum_sqr) {
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
index 4db06ecfcb..d5dc9a0c34 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
@@ -69,7 +69,7 @@ void stage2_kernel(tensor<float> &qkh) {
     auto qkhi = qkh({bid * 8, tid * 96, 0}, {8, 96, 384});
 
     tensor<float> sih({8, 96, 384});
-    // sih = softmax(qkhi, 2);
+    softmax(qkhi, sih, 2);
 
     // 6. compute y
     tensor<float> yihT({8, 96, 128});
@@ -80,17 +80,23 @@ void stage2_kernel(tensor<float> &qkh) {
     /* [96, 8, 128] -> [96, 1024] */
     tensor<float> yih({96, 8, 128});
     transpose(yihT, yih, dims_t({1, 0, 2}));
-    [[maybe_unused]] auto yihv = view(yih, dims_t({96, 1024}));
+    auto yihv = view(yih, dims_t({96, 1024}));
     // yih = reshape(, {96, 1024});
 
     // 7. Add and sum & sqr
-    // tensor<float> sum({96});
-    // tensor<float> sum_sqr({96});
-    // auto xi = X({tid * 96, bid * 1024}, {96, 1024}); // [96, 1024]
+    tensor<float> sum({96});
+    tensor<float> sum_sqr({96});
+    auto xi = X({tid * 96, bid * 1024}, {96, 1024}); // [96, 1024]
+    std::function<float(float, float)> f = [](float a, float b) -> float {
+        return a + b;
+    };
+    __tensor_binary_sync(xi, yihv, yihv, f);
     // yih = add_and_sum_sqr(yih, xi, sum, sum_sqr);
-    // __tdma_all_reduce_async(sum, sum_sqr,
-    //                         reduce_op_t::SUM); // All blocks & threads reduce
+    tensor_reduce_sum_sqr(yihv, sum, sum_sqr);
+    // __tdma_all_reduce_async(sum, sum_sqr); // All blocks & threads reduce
+    tdma_all_reduce_async(sum, sum, reduce_op_t::sum, dims_t({0}), ctx);
     tdma_wait(ctx);
+    tensor_layernorm_sync(yihv, sum, sum_sqr, 1, 8192);
 
     // 8. compute LayerNorm
     // yih = layer_norm(yih, sum, sum_sqr); // [96, 1024]

From e6611ca45ca3782c8b99e5779fdfb755d0e9dd7c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 18 Aug 2023 16:04:34 +0800
Subject: [PATCH 111/308] add demo2

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 100 ++++++++++++------
 .../src/runtime/cmodel/tests/demo1/kernel.h   |   7 +-
 .../src/runtime/cmodel/tests/demo2/golden.py  |   2 +-
 .../src/runtime/cmodel/tests/demo2/kernel.h   |  36 +++++--
 .../src/runtime/cmodel/tests/demo2/main.cpp   |  32 ++----
 .../runtime/cmodel/tests/demo2/shared_def.h   |   2 +-
 6 files changed, 109 insertions(+), 70 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 377a6fb75a..a1732261b9 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -37,6 +37,11 @@ tensor<T, Loc> view(tensor<T, Loc> &src, dims_t new_dims) {
     return tensor<T, Loc>(src.data(), new_dims, get_default_strides(new_dims));
 }
 
+template <class T, loc_t Loc>
+tensor<T, Loc> view(tensor<T, Loc> &src, dims_t new_dims, dims_t new_strides) {
+    return tensor<T, Loc>(src.data(), new_dims, new_strides);
+}
+
 template <class T, loc_t Loc>
 void transpose(tensor<T, Loc> &src, tensor<T, Loc> &dest, dims_t perm) {
     return kernels::transpose(src.cdata().data(), dest.data().data(),
@@ -238,27 +243,33 @@ void tdma_reduce_async() {
     throw std::system_error(std::make_error_code(std::errc::not_supported));
 }
 
+enum class reduce_strategy_t : uint8_t {
+    all,
+    by_block,
+};
+
 /**
  * @brief reduce across BLOCKS * CORES
- *  1. stack the src to gather tensor
- *  2. reduce gather tensor
+ *  1. stack the src to gather tensor, shape = [BLOCKS , CORES , ...]
+ *  2. reduce gather tensor, by_block mean axis 0, all mean axis [0,1]
  *  3. broadcast gather tensor to local tensor.
  * @tparam T
  * @param src local tensor
  * @param dest local tensor
  * @param reduce_op op
+ * @param strategy  all = reduce [8*4], pre_block = reduce [8*1] .
  * @param axis axis of gather tensor, note gather tensor dims = [32,...]
  * @param ctx
  */
 template <class T>
 void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
                            tensor<T, loc_t::local> &dest, reduce_op_t reduce_op,
-                           dims_t axis, thread_context &ctx) {
+                           reduce_strategy_t strategy, thread_context &ctx) {
     __tdma_all_sync_apply(
         [&src, &ctx](int visited) -> void {
             tensor<T> *gather_tensor = nullptr;
             auto new_dims = dims_t(src.dimension());
-            new_dims.insert(new_dims.begin(), 32);
+            new_dims.insert(new_dims.begin(), BLOCKS * CORES);
             if (visited == 1) {
                 if (global_hardware_ctx->global_var != nullptr) {
                     throw std::runtime_error(" the global var has been used!");
@@ -278,34 +289,63 @@ void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
                 std::move(unsqueeze(src)));
         },
         []() -> void {}, ctx);
-
-    __tdma_all_sync_apply(
-        [&]([[maybe_unused]] int visit) -> void {
-            tensor<T> *gather_tensor = nullptr;
-            tensor<T> *reduced_tensor = nullptr;
-            if (visit == 1) {
-                gather_tensor =
+    switch (strategy) {
+    case reduce_strategy_t::all:
+        __tdma_all_sync_apply(
+            [&]([[maybe_unused]] int visit) -> void {
+                tensor<T> *gather_tensor = nullptr;
+                tensor<T> *reduced_tensor = nullptr;
+                if (visit == 1) {
+                    gather_tensor = static_cast<tensor<T> *>(
+                        global_hardware_ctx->global_var);
+                    auto reduced_shape = get_reduced_shape(
+                        gather_tensor->dimension(), dims_t({0}), false);
+                    reduced_tensor = new tensor<T>(reduced_shape);
+                    tensor_reduce_sync(*gather_tensor, *reduced_tensor,
+                                       reduce_op, (T)0, dims_t({0}), false);
+                    delete gather_tensor;
+                    global_hardware_ctx->global_var = reduced_tensor;
+                } else {
+                    reduced_tensor = static_cast<tensor<T> *>(
+                        global_hardware_ctx->global_var);
+                    __tensor_copy_sync(std::move(dest),
+                                       std::move(*reduced_tensor));
+                }
+            },
+            []() -> void {
+                auto reduced_tensor =
                     static_cast<tensor<T> *>(global_hardware_ctx->global_var);
-                auto reduced_shape =
-                    get_reduced_shape(gather_tensor->dimension(), axis, false);
-                reduced_tensor = new tensor<T>(reduced_shape);
-                tensor_reduce_sync(*gather_tensor, *reduced_tensor, reduce_op,
-                                   (T)0, axis, false);
-                delete gather_tensor;
-                global_hardware_ctx->global_var = reduced_tensor;
-            } else {
-                reduced_tensor =
+                delete reduced_tensor;
+                global_hardware_ctx->global_var = nullptr;
+            },
+            ctx);
+        break;
+    case reduce_strategy_t::by_block:
+        __tdma_all_sync_apply(
+            [&]([[maybe_unused]] int visit) -> void {
+                tensor<T> *gather_tensor =
                     static_cast<tensor<T> *>(global_hardware_ctx->global_var);
-                __tensor_copy_sync(std::move(dest), std::move(*reduced_tensor));
-            }
-        },
-        []() -> void {
-            auto reduced_tensor =
-                static_cast<tensor<T> *>(global_hardware_ctx->global_var);
-            delete reduced_tensor;
-            global_hardware_ctx->global_var = nullptr;
-        },
-        ctx);
+                auto new_dims = dims_t(src.dimension());
+                new_dims.insert(new_dims.begin(), 8);
+                auto new_strides = dims_t(gather_tensor->strides());
+                new_strides[0] *= CORES;
+                auto viewed_gather_tensor =
+                    view(*gather_tensor, new_dims, new_strides);
+
+                tensor_reduce_sync(viewed_gather_tensor, dest, reduce_op,
+                                   static_cast<T>(0), dims_t({0}), false);
+            },
+            []() -> void {
+                auto reduced_tensor =
+                    static_cast<tensor<T> *>(global_hardware_ctx->global_var);
+                delete reduced_tensor;
+                global_hardware_ctx->global_var = nullptr;
+            },
+            ctx);
+        break;
+    default:
+        break;
+    }
 }
 
 void tdma_gather_async() {}
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index b4ed62a27c..10d716dade 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -77,9 +77,10 @@ void stage1_kernel(
     tensor<float> r_sum({384});
     tensor<float> r_sum_sqr({384});
     tensor_reduce_sum_sqr(xj, r_sum, r_sum_sqr);
-    tdma_all_reduce_async(r_sum, r_sum, reduce_op_t::sum, dims_t({0}), ctx);
-    tdma_all_reduce_async(r_sum_sqr, r_sum_sqr, reduce_op_t::sum, dims_t({0}),
-                          ctx);
+    tdma_all_reduce_async(r_sum, r_sum, reduce_op_t::sum,
+                          reduce_strategy_t::all, ctx);
+    tdma_all_reduce_async(r_sum_sqr, r_sum_sqr, reduce_op_t::sum,
+                          reduce_strategy_t::all, ctx);
     if (bid == 0 && tid == 0) {
         tdma_store_async(r_sum, std::move(RSum), ctx);
         tdma_store_async(r_sum_sqr, std::move(RSumSqr), ctx);
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py
index 682dc2040c..cd1a667bf4 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py
@@ -25,7 +25,7 @@
 
 S = softmax(QK)  # [64,384,384]
 
-Y = np.transpose(S @ V, [1, 0, 2]).reshape([384, -1])  # [64,384,128]
+Y = np.transpose(S @ V, [1, 0, 2]).reshape([384, -1])  # [64,384,128] ->  [64,8192]
 
 M = Y @ WM  # [384,8192]
 
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
index d5dc9a0c34..a057b40425 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
@@ -14,8 +14,9 @@ static bool w_loaded;
 static tensor<float> wqh({8, 2048, 128});
 static tensor<float> wkh({8, 2048, 128});
 static tensor<float> wvh({8, 2048, 128}); // [8, 2048, 128]
-static tensor<float> wfc1ih({1024, 8192});
-static tensor<float> wfc2ih({1024, 8192}); // [1024, 8192]
+static tensor<float> wm({1024, 8192});    // []
+// static tensor<float> wfc1ih({1024, 8192});
+// static tensor<float> wfc2ih({1024, 8192}); // [1024, 8192]
 static tensor<float> yih({96, 1024});
 
 // 8 head per block
@@ -35,6 +36,7 @@ void stage1_kernel(
         tdma_load_async(wqh, WQ({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
         tdma_load_async(wkh, WK({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
         tdma_load_async(wvh, WV({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
+        tdma_load_async(wm, WM({bid * 1024, 0}, {1024, 8192}), ctx);
         // tdma_load_async(wfc1ih, WFC1({bid * 1024, tid * 8192}, {1024,
         // 8192}));
         tdma_wait(ctx); // 等待 x, wqh, wkh, wvh ready
@@ -63,7 +65,9 @@ void stage1_kernel(
 
 // 8 head per block
 // 96 seq-len per thread
-void stage2_kernel(tensor<float> &qkh) {
+void stage2_kernel(
+    [[maybe_unused]] tensor<float, loc_t::device> &Norm /* 8192, 8192 */
+) {
     thread_context ctx(bid, tid);
     // 5. compute softmax
     auto qkhi = qkh({bid * 8, tid * 96, 0}, {8, 96, 384});
@@ -81,7 +85,16 @@ void stage2_kernel(tensor<float> &qkh) {
     tensor<float> yih({96, 8, 128});
     transpose(yihT, yih, dims_t({1, 0, 2}));
     auto yihv = view(yih, dims_t({96, 1024}));
-    // yih = reshape(, {96, 1024});
+
+    tensor<float> ym({96, 2048});
+
+    // [96,1024] * [1024,8192] -> [96, 8192]
+    //  @t, @b       @b, @l        @t, @l
+    // note 如添加上mm的, 此时wm的n不能在thread上切, 只能多算一部分,
+    // 计算结束后倒是可以继续在thread切.
+    tensor_mma_sync(yihv, wm, ym);
+    tdma_all_reduce_async(ym, ym, reduce_op_t::sum, reduce_strategy_t::by_block,
+                          ctx);
 
     // 7. Add and sum & sqr
     tensor<float> sum({96});
@@ -90,14 +103,17 @@ void stage2_kernel(tensor<float> &qkh) {
     std::function<float(float, float)> f = [](float a, float b) -> float {
         return a + b;
     };
-    __tensor_binary_sync(xi, yihv, yihv, f);
+    auto ym_b = ym({0, bid * 1024}, {96, 1024});
+    __tensor_binary_sync(xi, ym_b, ym_b, f);
     // yih = add_and_sum_sqr(yih, xi, sum, sum_sqr);
-    tensor_reduce_sum_sqr(yihv, sum, sum_sqr);
+    tensor_reduce_sum_sqr(ym_b, sum, sum_sqr);
     // __tdma_all_reduce_async(sum, sum_sqr); // All blocks & threads reduce
-    tdma_all_reduce_async(sum, sum, reduce_op_t::sum, dims_t({0}), ctx);
+    tdma_all_reduce_async(sum, sum, reduce_op_t::sum,
+                          reduce_strategy_t::by_block, ctx);
+    tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum,
+                          reduce_strategy_t::by_block, ctx);
     tdma_wait(ctx);
-    tensor_layernorm_sync(yihv, sum, sum_sqr, 1, 8192);
+    tensor_layernorm_sync(ym_b, sum, sum_sqr, 1, 8192);
 
-    // 8. compute LayerNorm
-    // yih = layer_norm(yih, sum, sum_sqr); // [96, 1024]
+    tdma_store_async(ym_b, Norm({tid * 96, bid * 1024}, {96, 1024}), ctx);
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
index 46f0654deb..a6b76e1bf8 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
@@ -6,6 +6,7 @@
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
         block##b::thread##t::stage1_kernel(WQ, WK, WV, WM);                    \
+        block##b::thread##t::stage2_kernel(Norm);                              \
         return arg;                                                            \
     }
 
@@ -19,6 +20,7 @@ tensor<float, loc_t::device> WQ({64, 8192, 128});
 tensor<float, loc_t::device> WK({64, 8192, 128});
 tensor<float, loc_t::device> WV({64, 8192, 128});
 tensor<float, loc_t::device> WM({8192, 8192});
+tensor<float, loc_t::device> Norm({384, 8192});
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
@@ -46,6 +48,7 @@ int main([[maybe_unused]] int argc, char **argv) {
     auto src_WK = read_file(std::string(argv[3]));
     auto src_WV = read_file(std::string(argv[4]));
     auto src_WM = read_file(std::string(argv[5]));
+    auto src_Norm = read_file(std::string(argv[6]));
     span_copy(WQ.data(), gsl::make_span(src_WQ).as_span<float>());
     span_copy(WK.data(), gsl::make_span(src_WK).as_span<float>());
     span_copy(WV.data(), gsl::make_span(src_WV).as_span<float>());
@@ -130,30 +133,9 @@ int main([[maybe_unused]] int argc, char **argv) {
     pthread_join(t_7_2, NULL);
     pthread_join(t_7_3, NULL);
 
-    // auto cos =
-    //     cosine(K.data().begin(),
-    //     gsl::make_span(src_K).as_span<float>().begin(),
-    //            K.data().size());
-    // printf("K cosine %f\n", cos);
-
-    // cos = cosine(Sum.data().begin(),
-    //              gsl::make_span(src_Sum).as_span<float>().begin(),
-    //              Sum.data().size());
-    // printf("Sum cosine %f\n", cos);
-
-    // cos = cosine(RSum.data().begin(),
-    //              gsl::make_span(src_RSum).as_span<float>().begin(),
-    //              Sum.data().size());
-    // printf("src_RSum cosine %f\n", cos);
-
-    // cos = cosine(RSumSqr.data().begin(),
-    //              gsl::make_span(src_RSumSqr).as_span<float>().begin(),
-    //              Sum.data().size());
-    // printf("RSumSqr cosine %f\n", cos);
-
-    // cos = cosine(Norm.data().begin(),
-    //              gsl::make_span(src_Norm).as_span<float>().begin(),
-    //              Sum.data().size());
-    // printf("Norm cosine %f\n", cos);
+    auto cos = cosine(Norm.data().begin(),
+                      gsl::make_span(src_Norm).as_span<float>().begin(),
+                      Norm.data().size());
+    printf("Norm cosine %f\n", cos);
     return 0;
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h
index f3cfe35e85..edcac3e61e 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h
@@ -5,5 +5,5 @@ static tensor<float, loc_t::shared> X({384, 8192});
 static tensor<float, loc_t::shared> kh({8, 384, 128});
 static tensor<float, loc_t::shared> vh({8, 384, 128});  // []
 static tensor<float, loc_t::shared> qkh({8, 384, 384}); // []
-// static tensor<float, loc_t::shared> qkh({8, 384, 384}); // []
+static tensor<float, loc_t::shared> mh({8, 384, 384}); // []
 } // namespace shared
\ No newline at end of file

From dc5714c90c0362d3a0d1e5e02a306665b47af905 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 18 Aug 2023 19:12:19 +0800
Subject: [PATCH 112/308] pass ym

---
 .../src/runtime/cmodel/tests/demo2/golden.py  | 28 ++++++-------------
 .../src/runtime/cmodel/tests/demo2/kernel.h   | 27 +++++++++++++-----
 .../src/runtime/cmodel/tests/demo2/main.cpp   | 25 +++++++++++++++--
 3 files changed, 51 insertions(+), 29 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py
index cd1a667bf4..724e0cae27 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py
@@ -23,29 +23,17 @@
 
 QK = Q @ np.transpose(K, [0, 2, 1])  # [64,384,384]
 
-S = softmax(QK)  # [64,384,384]
+QK.tofile("QKH.bin")
 
-Y = np.transpose(S @ V, [1, 0, 2]).reshape([384, -1])  # [64,384,128] ->  [64,8192]
-
-M = Y @ WM  # [384,8192]
-
-Norm = nn.LayerNorm([8192], elementwise_affine=False)(torch.from_numpy(X + M))
-Norm.detach().numpy().tofile('Norm.bin')
+S = softmax(QK,-1)  # [64,384,384]
 
+S.tofile("Softmax.bin")
 
-# a = np.arange( 64 *384* 128).reshape([64, 384, 128])
+Y = np.transpose(S @ V, [1, 0, 2]).reshape([384, -1])  # [64,384,128] ->  [64,8192]
 
-# b = np.transpose(a,[1,2,0])
-# fb = b.flatten()
-# fa = a.flatten()
+YM = Y @ WM  # [384,8192]
 
-# newa = []
-# s0 = 384*128
-# s1 = 128
-# s2 = 1
-# for d1 in range(384):
-#   for d2 in range(128):
-#     for d0 in range(64):
-#       newa.append(fa[d0 * s0 + d1*s1 + d2*s2])
+YM.tofile("YM.bin")
 
-# print(np.allclose(fb,np.array(newa) ))
\ No newline at end of file
+Norm = nn.LayerNorm([8192], elementwise_affine=False)(torch.from_numpy(X + YM))
+Norm.detach().numpy().tofile('Norm.bin')
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
index a057b40425..f8be44d844 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
@@ -25,7 +25,8 @@ void stage1_kernel(
     [[maybe_unused]] tensor<float, loc_t::device> &WQ, /* 64, 8192, 128 */
     [[maybe_unused]] tensor<float, loc_t::device> &WK, /* 64, 8192, 128 */
     [[maybe_unused]] tensor<float, loc_t::device> &WV, /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &WM  /* 8192, 8192 */
+    [[maybe_unused]] tensor<float, loc_t::device> &WM, /* 8192, 8192 */
+    [[maybe_unused]] tensor<float, loc_t::device> &QKH /* 64,384,384 */
 ) {
     thread_context ctx(bid, tid);
     // 1. Get xi
@@ -43,9 +44,9 @@ void stage1_kernel(
         w_loaded = true;
     }
     // 3. compute k, v
-    set_sched_strategy(
-        sched_strategy_t::pin_block_tensor); // 仅在 block 内调度线程的 tensor
-                                             // 指令
+    set_sched_strategy(sched_strategy_t::pin_block_tensor);
+    // 仅在 block 内调度线程的 tensor
+    // 指令
 
     // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
     tensor_block_mma_sync(xi, wkh, kh, false, ctx);
@@ -61,20 +62,29 @@ void stage1_kernel(
     tensor_block_mma_sync(qih, khT, qkh, false, ctx);
 
     set_sched_strategy(sched_strategy_t::normal);
+    if (tid == 0) {
+        tdma_store_async(qkh, QKH({bid * 8, 0, 0}, {8, 384, 384}), ctx);
+    }
+    tdma_wait(ctx);
 }
 
 // 8 head per block
 // 96 seq-len per thread
 void stage2_kernel(
-    [[maybe_unused]] tensor<float, loc_t::device> &Norm /* 8192, 8192 */
+    [[maybe_unused]] tensor<float, loc_t::device> &Norm,   /* 8192, 8192 */
+    [[maybe_unused]] tensor<float, loc_t::device> &Softmax, /* 64,384,384 */
+    [[maybe_unused]] tensor<float, loc_t::device> &YM      /* 384,8192 */
 ) {
     thread_context ctx(bid, tid);
     // 5. compute softmax
-    auto qkhi = qkh({bid * 8, tid * 96, 0}, {8, 96, 384});
+    auto qkhi = qkh({0, tid * 96, 0}, {8, 96, 384});
 
     tensor<float> sih({8, 96, 384});
     softmax(qkhi, sih, 2);
 
+    tdma_store_async(sih, Softmax({bid * 8, tid * 96, 0}, {8, 96, 384}), ctx);
+    tdma_wait(ctx);
+
     // 6. compute y
     tensor<float> yihT({8, 96, 128});
     // [8, 96, 384] x [8, 384, 128] = [8, 96, 128]
@@ -86,7 +96,7 @@ void stage2_kernel(
     transpose(yihT, yih, dims_t({1, 0, 2}));
     auto yihv = view(yih, dims_t({96, 1024}));
 
-    tensor<float> ym({96, 2048});
+    tensor<float> ym({96, 8192});
 
     // [96,1024] * [1024,8192] -> [96, 8192]
     //  @t, @b       @b, @l        @t, @l
@@ -95,6 +105,9 @@ void stage2_kernel(
     tensor_mma_sync(yihv, wm, ym);
     tdma_all_reduce_async(ym, ym, reduce_op_t::sum, reduce_strategy_t::by_block,
                           ctx);
+    if (bid == 0) {
+        tdma_store_async(ym, YM({tid * 96, 0}, {96, 8192}), ctx);
+    }
 
     // 7. Add and sum & sqr
     tensor<float> sum({96});
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
index a6b76e1bf8..ae4c92632c 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
@@ -5,8 +5,8 @@
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(WQ, WK, WV, WM);                    \
-        block##b::thread##t::stage2_kernel(Norm);                              \
+        block##b::thread##t::stage1_kernel(WQ, WK, WV, WM, QKH);               \
+        block##b::thread##t::stage2_kernel(Norm, Softmax, YM);                     \
         return arg;                                                            \
     }
 
@@ -20,6 +20,9 @@ tensor<float, loc_t::device> WQ({64, 8192, 128});
 tensor<float, loc_t::device> WK({64, 8192, 128});
 tensor<float, loc_t::device> WV({64, 8192, 128});
 tensor<float, loc_t::device> WM({8192, 8192});
+tensor<float, loc_t::device> QKH({64, 384, 384});
+tensor<float, loc_t::device> Softmax({64, 384, 384});
+tensor<float, loc_t::device> YM({384, 8192});
 tensor<float, loc_t::device> Norm({384, 8192});
 
 DEFINE_BFUNC(0)
@@ -49,6 +52,9 @@ int main([[maybe_unused]] int argc, char **argv) {
     auto src_WV = read_file(std::string(argv[4]));
     auto src_WM = read_file(std::string(argv[5]));
     auto src_Norm = read_file(std::string(argv[6]));
+    auto src_QKH = read_file(std::string(argv[7]));
+    auto src_Softmax = read_file(std::string(argv[8]));
+    auto src_YM = read_file(std::string(argv[9]));
     span_copy(WQ.data(), gsl::make_span(src_WQ).as_span<float>());
     span_copy(WK.data(), gsl::make_span(src_WK).as_span<float>());
     span_copy(WV.data(), gsl::make_span(src_WV).as_span<float>());
@@ -137,5 +143,20 @@ int main([[maybe_unused]] int argc, char **argv) {
                       gsl::make_span(src_Norm).as_span<float>().begin(),
                       Norm.data().size());
     printf("Norm cosine %f\n", cos);
+
+    cos = cosine(QKH.data().begin(),
+                 gsl::make_span(src_QKH).as_span<float>().begin(),
+                 QKH.data().size());
+    printf("QKH cosine %f\n", cos);
+
+    cos = cosine(Softmax.data().begin(),
+                 gsl::make_span(src_Softmax).as_span<float>().begin(),
+                 Softmax.data().size());
+    printf("Softmax cosine %f\n", cos);
+
+    cos = cosine(YM.data().begin(),
+                 gsl::make_span(src_YM).as_span<float>().begin(),
+                 YM.data().size());
+    printf("YM cosine %f\n", cos);
     return 0;
 }
\ No newline at end of file

From f2082041f1f8d9e88ddf0c3ffb52f8d9aa11b5c1 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Fri, 18 Aug 2023 11:20:32 +0000
Subject: [PATCH 113/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h     | 4 ++--
 modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp     | 2 +-
 modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
index f8be44d844..407ff94ebd 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
@@ -71,9 +71,9 @@ void stage1_kernel(
 // 8 head per block
 // 96 seq-len per thread
 void stage2_kernel(
-    [[maybe_unused]] tensor<float, loc_t::device> &Norm,   /* 8192, 8192 */
+    [[maybe_unused]] tensor<float, loc_t::device> &Norm,    /* 8192, 8192 */
     [[maybe_unused]] tensor<float, loc_t::device> &Softmax, /* 64,384,384 */
-    [[maybe_unused]] tensor<float, loc_t::device> &YM      /* 384,8192 */
+    [[maybe_unused]] tensor<float, loc_t::device> &YM       /* 384,8192 */
 ) {
     thread_context ctx(bid, tid);
     // 5. compute softmax
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
index ae4c92632c..ccc96c1d98 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
@@ -6,7 +6,7 @@
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
         block##b::thread##t::stage1_kernel(WQ, WK, WV, WM, QKH);               \
-        block##b::thread##t::stage2_kernel(Norm, Softmax, YM);                     \
+        block##b::thread##t::stage2_kernel(Norm, Softmax, YM);                 \
         return arg;                                                            \
     }
 
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h
index edcac3e61e..8dbca0cd80 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h
@@ -5,5 +5,5 @@ static tensor<float, loc_t::shared> X({384, 8192});
 static tensor<float, loc_t::shared> kh({8, 384, 128});
 static tensor<float, loc_t::shared> vh({8, 384, 128});  // []
 static tensor<float, loc_t::shared> qkh({8, 384, 384}); // []
-static tensor<float, loc_t::shared> mh({8, 384, 384}); // []
+static tensor<float, loc_t::shared> mh({8, 384, 384});  // []
 } // namespace shared
\ No newline at end of file

From 16ec3b95ee7a25edca6d516ad59dde62f8219f5a Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Mon, 21 Aug 2023 10:02:29 +0800
Subject: [PATCH 114/308] pass demo2

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |  5 +-
 .../cpu/src/runtime/cmodel/include/io_utils.h |  7 ++
 .../src/runtime/cmodel/include/layernorm.h    | 74 ++++++++++++-------
 modules/cpu/src/runtime/cmodel/include/tdma.h |  9 ++-
 .../src/runtime/cmodel/tests/demo2/main.cpp   | 14 ++--
 5 files changed, 74 insertions(+), 35 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index da544fcf7a..aee0c67f77 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -4,6 +4,9 @@ add_library(cpu_cmodel STATIC
 
 target_include_directories(cpu_cmodel PUBLIC include)
 target_link_libraries(cpu_cmodel PUBLIC fmt::fmt spdlog::spdlog)
+if(NOT APPLE AND NOT MSVC)
+  target_link_libraries(cpu_cmodel PRIVATE rt)
+endif()
 set_target_properties(cpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
         
 add_executable(cpu_cmodel_cli src/cpu_cmodel.cpp ../shared_memory.cpp)
@@ -15,7 +18,7 @@ install(TARGETS cpu_cmodel_cli COMPONENT nncase-runtime)
 
 function(add_test name test_path)
   add_executable(${name} "${test_path}/main.cpp")
-  target_link_libraries(${name} cpu_cmodel spdlogd)
+  target_link_libraries(${name} cpu_cmodel spdlog::spdlog)
 endfunction(add_test)
 
 add_test(demo1 tests/demo1)
diff --git a/modules/cpu/src/runtime/cmodel/include/io_utils.h b/modules/cpu/src/runtime/cmodel/include/io_utils.h
index 937e025848..d016bccb6c 100644
--- a/modules/cpu/src/runtime/cmodel/include/io_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/io_utils.h
@@ -18,4 +18,11 @@ inline std::vector<uint8_t> read_file(const std::filesystem::path &filename) {
     if (!infile.good())
         throw std::runtime_error("Cannot open file: " + filename.string());
     return read_stream(infile);
+}
+
+template <class T>
+inline void to_file(gsl::span<T> src, const std::filesystem::path &filename) {
+    std::ofstream ofile(filename.string(), std::ios::binary | std::ios::out);
+    ofile.write(src.template as_span<const char>().data(), src.size_bytes());
+    ofile.close();
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index 209398a522..725b80019f 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -1,4 +1,5 @@
 #include "runtime_utils.h"
+#include <apply.h>
 #include <cmath>
 #ifdef __riscv_vector
 #include <riscv_vector.h>
@@ -10,29 +11,47 @@ namespace {
 template <typename T>
 void layernorm_naive_impl(T *input, const T *sum, T *sum_sqr, T *gamma, T *beta,
                           gsl::span<const size_t> input_shape,
-                          [[maybe_unused]] gsl::span<const size_t> input_stride,
-                          T eps, int32_t axis, int32_t norm_size) noexcept {
-    // only process continues tensor for now
-    size_t outer_size = 1;
-    for (auto i = 0; i < axis; i++) {
-        outer_size *= input_shape[i];
-    }
-
-    size_t inner_size = 1;
-    for (auto i = axis; i < input_shape.size(); i++) {
-        inner_size *= input_shape[i];
-    }
-
-    for (size_t o = 0; o < outer_size; o++) {
-        auto mean = sum[o] / norm_size;
-        auto sigma = std::sqrt(sum_sqr[o] / norm_size - mean * mean + eps);
-        for (size_t i = 0; i < inner_size; i++) {
-            auto x = input + o * inner_size + i;
-            *x = (*x - mean) / sigma *
-                     (gamma == nullptr ? static_cast<T>(1) : gamma[i]) +
-                 (beta == nullptr ? static_cast<T>(0) : beta[i]);
-        }
-    }
+                          gsl::span<const size_t> input_stride,
+                          [[maybe_unused]] gsl::span<const size_t> sum_strides,
+                          gsl::span<const size_t> gamma_strides, T eps,
+                          int32_t axis, int32_t norm_size) noexcept {
+    apply(input_shape, [&](gsl::span<const size_t> input_index) -> void {
+        //  input_index
+        auto o_offset = offset(sum_strides, input_index.subspan(0, axis));
+        // auto o_offset = input_index[0];
+        auto mean = sum[o_offset] / norm_size;
+        auto sigma =
+            std::sqrt(sum_sqr[o_offset] / norm_size - mean * mean + eps);
+
+        auto input_offset = offset(input_stride, input_index);
+        auto in_offset = offset(gamma_strides, input_index.subspan(axis));
+        input[input_offset] =
+            (input[input_offset] - mean) / sigma *
+                (gamma == nullptr ? static_cast<T>(1) : gamma[in_offset]) +
+            (beta == nullptr ? static_cast<T>(0) : beta[in_offset]);
+    });
+
+    // // only process continues tensor for now
+    // size_t outer_size = 1;
+    // for (auto i = 0; i < axis; i++) {
+    //     outer_size *= input_shape[i];
+    // }
+
+    // size_t inner_size = 1;
+    // for (auto i = axis; i < input_shape.size(); i++) {
+    //     inner_size *= input_shape[i];
+    // }
+
+    // for (size_t o = 0; o < outer_size; o++) {
+    //     auto mean = sum[o] / norm_size;
+    //     auto sigma = std::sqrt(sum_sqr[o] / norm_size - mean * mean + eps);
+    //     for (size_t i = 0; i < inner_size; i++) {
+    //         auto x = input + o * inner_size + i;
+    //         *x = (*x - mean) / sigma *
+    //                  (gamma == nullptr ? static_cast<T>(1) : gamma[i]) +
+    //              (beta == nullptr ? static_cast<T>(0) : beta[i]);
+    //     }
+    // }
 }
 
 #ifdef __riscv_vector
@@ -115,8 +134,9 @@ void layernorm_rvv_impl(const T *input, const T *sum, T *sum_sqr, T *gamma,
 
 template <class T>
 void layernorm(T *input, T *sum, T *sum_sqr, T *gamma, T *beta,
-               dims_t input_dims, strides_t input_strides, T eps, int32_t axis,
-               int32_t norm_size) {
+               dims_t input_dims, strides_t input_strides,
+               strides_t sum_strides, strides_t gamma_strides, T eps,
+               int32_t axis, int32_t norm_size) {
 #ifdef __riscv_vector
     return layernorm_rvv_impl(
         input, sum, sum_sqr, gamma, beta,
@@ -127,7 +147,9 @@ void layernorm(T *input, T *sum, T *sum_sqr, T *gamma, T *beta,
     return layernorm_naive_impl(
         input, sum, sum_sqr, gamma, beta,
         gsl::make_span(input_dims).template as_span<const size_t>(),
-        gsl::make_span(input_strides).template as_span<const size_t>(), eps,
+        gsl::make_span(input_strides).template as_span<const size_t>(),
+        gsl::make_span(sum_strides).template as_span<const size_t>(),
+        gsl::make_span(gamma_strides).template as_span<const size_t>(), eps,
         axis, norm_size);
 #endif
 }
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index a1732261b9..45a3517824 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -113,10 +113,14 @@ void tensor_layernorm_sync(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
                            tensor<T, loc_t::local> &gamma,
                            tensor<T, loc_t::local> &beta, T eps, int32_t axis,
                            int32_t norm_size) {
+    assert(sum.strides() == sum_sqr.strides());
+    assert(is_contiguous(sum.dimension(), sum.strides()));
+    assert(gamma.strides() == beta.strides());
+    assert(is_contiguous(gamma.dimension(), gamma.strides()));
     kernels::layernorm(input.data().data(), sum.data().data(),
                        sum_sqr.data().data(), gamma.data().data(),
                        beta.data().data(), input.dimension(), input.strides(),
-                       eps, axis, norm_size);
+                       sum.strides(), gamma.strides(), eps, axis, norm_size);
 }
 
 template <typename T, loc_t Loc>
@@ -126,7 +130,8 @@ void tensor_layernorm_sync(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
     kernels::layernorm(input.data().data(), sum.data().data(),
                        sum_sqr.data().data(), static_cast<T *>(nullptr),
                        static_cast<T *>(nullptr), input.dimension(),
-                       input.strides(), static_cast<T>(1e-5), axis, norm_size);
+                       input.strides(), sum.strides(), dims_t({}),
+                       static_cast<T>(1e-5), axis, norm_size);
 }
 
 template <typename T, loc_t ALoc>
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
index ccc96c1d98..193af3b0ce 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
@@ -139,12 +139,7 @@ int main([[maybe_unused]] int argc, char **argv) {
     pthread_join(t_7_2, NULL);
     pthread_join(t_7_3, NULL);
 
-    auto cos = cosine(Norm.data().begin(),
-                      gsl::make_span(src_Norm).as_span<float>().begin(),
-                      Norm.data().size());
-    printf("Norm cosine %f\n", cos);
-
-    cos = cosine(QKH.data().begin(),
+    auto cos = cosine(QKH.data().begin(),
                  gsl::make_span(src_QKH).as_span<float>().begin(),
                  QKH.data().size());
     printf("QKH cosine %f\n", cos);
@@ -158,5 +153,12 @@ int main([[maybe_unused]] int argc, char **argv) {
                  gsl::make_span(src_YM).as_span<float>().begin(),
                  YM.data().size());
     printf("YM cosine %f\n", cos);
+
+    to_file(Norm.data(),"ONorm.bin");
+
+    cos = cosine(Norm.data().begin(),
+                      gsl::make_span(src_Norm).as_span<float>().begin(),
+                      Norm.data().size());
+    printf("Norm cosine %f\n", cos);
     return 0;
 }
\ No newline at end of file

From b3bea7bae9780a5e2bcb63c9cbfced77b8cbfc34 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 21 Aug 2023 17:01:56 +0800
Subject: [PATCH 115/308] fix onnx external data importer

---
 src/Nncase.Importer/Onnx/DataGatter.cs |  6 +++---
 tests/onnx_test_runner.py              | 12 ++++++++----
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/Nncase.Importer/Onnx/DataGatter.cs b/src/Nncase.Importer/Onnx/DataGatter.cs
index 8001655a67..0cd5da981c 100644
--- a/src/Nncase.Importer/Onnx/DataGatter.cs
+++ b/src/Nncase.Importer/Onnx/DataGatter.cs
@@ -105,7 +105,7 @@ private Tensor GetTensor(TensorProto tensor)
         var externalDataCount = tensor.ExternalData.Count;
         if (externalDataCount != 0)
         {
-            if (externalDataCount < 3 && externalDataCount > 5)
+            if (externalDataCount < 1 || externalDataCount > 5)
             {
                 throw new NotSupportedException("NotSupport ExternalData format, only support location, offset, length, checksum");
             }
@@ -113,9 +113,9 @@ private Tensor GetTensor(TensorProto tensor)
             var parent = Directory.GetParent(CompileSession.CompileOptions.InputFile)?.FullName;
             var externalData = tensor.ExternalData;
             var location = Path.Join(parent, externalData[0].Value);
-            var offset = long.Parse(externalData[1].Value);
-            var length = int.Parse(externalData[2].Value);
+            var offset = externalDataCount > 1L ? long.Parse(externalData[1].Value) : 0;
             using var br = new BinaryReader(new FileStream(location, FileMode.Open));
+            var length = externalDataCount > 1 ? int.Parse(externalData[2].Value) : (int)br.BaseStream.Length;
             br.BaseStream.Seek(offset, SeekOrigin.Begin);
             var buffer = br.ReadBytes(length);
             return Tensor.FromBytes(type, buffer, shape);
diff --git a/tests/onnx_test_runner.py b/tests/onnx_test_runner.py
index acbd16ed9a..06fb2e0483 100644
--- a/tests/onnx_test_runner.py
+++ b/tests/onnx_test_runner.py
@@ -1,4 +1,4 @@
-from onnx import version_converter, helper
+from onnx import version_converter, helper, external_data_helper
 import onnxsim
 import onnxruntime as ort
 import onnx
@@ -46,14 +46,18 @@ def run(self, model_file):
         if self.case_dir != os.path.dirname(model_file):
             new_file = os.path.join(self.case_dir, 'test.onnx')
             shutil.copy(model_file, new_file)
-            if os.path.exists(model_file + "_data"):
-                shutil.copy(model_file + "_data", self.case_dir)
+            for tensor in external_data_helper._get_all_tensors(onnx.load(model_file, load_external_data = False)):
+                if external_data_helper.uses_external_data(tensor):
+                    info = external_data_helper.ExternalDataInfo(tensor)
+                    file_location = external_data_helper._sanitize_path(info.location)
+                    external_data_file_path = os.path.join(os.path.dirname(model_file), file_location)
+                    shutil.copy(external_data_file_path, self.case_dir)
             model_file = new_file
 
         if not self.inputs:
             self.parse_model(model_file)
 
-        model_file = self.do_preprocess(model_file)
+        # model_file = self.do_preprocess(model_file)
 
         super().run(model_file)
 

From ab5e4679baa30a7be8fde2b1e06ab04952dae465 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 22 Aug 2023 11:24:36 +0800
Subject: [PATCH 116/308] fuse MHA of llama

---
 .../Passes/Rules/MHAFusion.cs                 | 113 +++++++++++++++++-
 src/Nncase.Compiler/Compiler.cs               |   4 +-
 2 files changed, 113 insertions(+), 4 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index 476b9ab2e1..0dba69af87 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -76,17 +76,124 @@ private static Pattern CreatePattern()
         var v41 = IsCall("v41", IsOp<Binary>(), IsVArgs(v40, v2));
         var v42 = IsTensorConst("v42");
         var v43 = IsTensorConst("v43");
-        var v44 = IsCall("ln", IsOp<LayerNorm>(), IsVArgs(v41, v42, v43));
+        var v44 = IsCall("root", IsOp<LayerNorm>(), IsVArgs(v41, v42, v43));
         return v44;
     }
 
-    private Call? GetReplace(Call ln, Expr x, Expr mask)
+    private Call? GetReplace(Call root, Expr x, Expr mask)
     {
         var newInputs = new List<Expr>();
         newInputs.Add(new Var(x.CheckedType!));
         newInputs.Add(new Var(mask.CheckedType!));
 
-        var callFusion = new Call(new Fusion("MHA1", $"{ln.Target.GetType().Name}", "cpu", ln, newInputs.OfType<Var>().ToArray()), x, mask);
+        var callFusion = new Call(new Fusion("MHA1", $"{root.Target.GetType().Name}", "cpu", root, newInputs.OfType<Var>().ToArray()), x, mask);
         return callFusion;
     }
 }
+
+// pattern for LLaMA-65B
+[RuleGenerator]
+public sealed partial class FuseMHA2 : FusionMaker
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern => CreatePattern();
+
+    private static Pattern CreatePattern()
+    {
+        var v0 = IsWildcard("hidden_in");
+
+        var v1 = IsTensorConst("v1");
+        var v2 = IsTensorConst("v2");
+        var v3 = IsCall("v3", IsOp<LayerNorm>(), IsVArgs(v0,v1,v2));
+        var v4 = IsTensorConst("v4");
+        var v5 = IsCall("v5", IsOp<MatMul>(), IsVArgs(v3,v4));
+        var v6 = IsTensorConst("v6");
+        var v7 = IsCall("v7", IsOp<Reshape>(), IsVArgs(v5,v6));
+        var v8 = IsTensorConst("v8");
+        var v9 = IsCall("v9", IsOp<Transpose>(), IsVArgs(v7,v8));
+        var v10 = IsTensorConst("v10");
+        var v11 = IsTensorConst("v11");
+        var v12 = IsWildcard("position_ids");
+
+        var v13 = IsCall("v13", IsOp<Gather>(), IsVArgs(v10,v11,v12));
+        var v14 = IsTensorConst("v14");
+        var v15 = IsCall("v15", IsOp<Reshape>(), IsVArgs(v13,v14));
+        var v16 = IsCall("v16", IsOp<Binary>(), IsVArgs(v9,v15));
+        var v17 = IsTensorConst("v17");
+        var v18 = IsTensorConst("v18");
+        var v19 = IsTensorConst("v19");
+        var v20 = IsTensorConst("v20");
+        var v21 = IsCall("v21", IsOp<Slice>(), IsVArgs(v9,v17,v18,v19,v20));
+        var v22 = IsCall("v22", IsOp<Unary>(), IsVArgs(v21));
+        var v23 = IsTensorConst("v23");
+        var v24 = IsCall("v24", IsOp<Slice>(), IsVArgs(v9,v23,v17,v19,v20));
+        var v25 = IsTuple("v25", IsVArgs(v22,v24));
+
+        var v26 = IsTensorConst("v26");
+        var v27 = IsCall("v27", IsOp<Concat>(), IsVArgs(v25,v26));
+        var v28 = IsTensorConst("v28");
+        var v29 = IsCall("v29", IsOp<Gather>(), IsVArgs(v28,v11,v12));
+        var v30 = IsCall("v30", IsOp<Reshape>(), IsVArgs(v29,v14));
+        var v31 = IsCall("v31", IsOp<Binary>(), IsVArgs(v27,v30));
+        var v32 = IsCall("v32", IsOp<Binary>(), IsVArgs(v16,v31));
+        var v33 = IsTensorConst("v33");
+        var v34 = IsCall("v34", IsOp<MatMul>(), IsVArgs(v3,v33));
+        var v35 = IsCall("v35", IsOp<Reshape>(), IsVArgs(v34,v6));
+        var v36 = IsCall("v36", IsOp<Transpose>(), IsVArgs(v35,v8));
+        var v37 = IsCall("v37", IsOp<Binary>(), IsVArgs(v36,v15));
+        var v38 = IsCall("v38", IsOp<Slice>(), IsVArgs(v36,v17,v18,v19,v20));
+        var v39 = IsCall("v39", IsOp<Unary>(), IsVArgs(v38));
+        var v40 = IsCall("v40", IsOp<Slice>(), IsVArgs(v36,v23,v17,v19,v20));
+        var v41 = IsTuple("v41", IsVArgs(v39,v40));
+
+        var v42 = IsCall("v42", IsOp<Concat>(), IsVArgs(v41,v26));
+        var v43 = IsCall("v43", IsOp<Binary>(), IsVArgs(v42,v30));
+        var v44 = IsCall("v44", IsOp<Binary>(), IsVArgs(v37,v43));
+        var v45 = IsTensorConst("v45");
+        var v46 = IsCall("v46", IsOp<Transpose>(), IsVArgs(v44,v45));
+        var v47 = IsCall("v47", IsOp<MatMul>(), IsVArgs(v32,v46));
+        var v48 = IsTensorConst("v48");
+        var v49 = IsCall("v49", IsOp<Binary>(), IsVArgs(v47,v48));
+        var v50 = IsWildcard("attn_mask");
+
+        var v51 = IsCall("v51", IsOp<Binary>(), IsVArgs(v49,v50));
+        var v52 = IsCall("v52", IsOp<Softmax>(), IsVArgs(v51,v26));
+        var v53 = IsTensorConst("v53");
+        var v54 = IsCall("v54", IsOp<MatMul>(), IsVArgs(v3,v53));
+        var v55 = IsCall("v55", IsOp<Reshape>(), IsVArgs(v54,v6));
+        var v56 = IsCall("v56", IsOp<Transpose>(), IsVArgs(v55,v8));
+        var v57 = IsCall("v57", IsOp<MatMul>(), IsVArgs(v52,v56));
+        var v58 = IsCall("v58", IsOp<Transpose>(), IsVArgs(v57,v8));
+        var v59 = IsTensorConst("v59");
+        var v60 = IsCall("v60", IsOp<Reshape>(), IsVArgs(v58,v59));
+        var v61 = IsTensorConst("v61");
+        var v62 = IsCall("v62", IsOp<MatMul>(), IsVArgs(v60,v61));
+        var v63 = IsCall("v63", IsOp<Binary>(), IsVArgs(v0,v62));
+        var v64 = IsCall("v64", IsOp<LayerNorm>(), IsVArgs(v63,v1,v2));
+        var v65 = IsTensorConst("v65");
+        var v66 = IsCall("v66", IsOp<MatMul>(), IsVArgs(v64,v65));
+        var v67 = IsCall("v67", IsOp<Swish>(), IsVArgs(v66));
+        var v68 = IsTensorConst("v68");
+        var v69 = IsCall("v69", IsOp<MatMul>(), IsVArgs(v64,v68));
+        var v70 = IsCall("v70", IsOp<Binary>(), IsVArgs(v67,v69));
+        var v71 = IsTensorConst("v71");
+        var v72 = IsCall("v72", IsOp<MatMul>(), IsVArgs(v70,v71));
+        var v73 = IsCall("root", IsOp<Binary>(), IsVArgs(v63,v72));
+
+        return v73;
+    }
+
+        private Call? GetReplace(Call root, Expr hidden_in, Expr position_ids, Expr attn_mask)
+    {
+        var newInputs = new List<Expr>();
+        newInputs.Add(new Var(hidden_in.CheckedType!));
+        newInputs.Add(new Var(position_ids.CheckedType!));
+        newInputs.Add(new Var(attn_mask.CheckedType!));
+
+        var callFusion = new Call(new Fusion("MHA2", $"{root.Target.GetType().Name}", "cpu", root, newInputs.OfType<Var>().ToArray()), hidden_in, position_ids, attn_mask);
+        return callFusion;
+    }
+}
+
+
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 643e7f5dbb..2495955d07 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -98,6 +98,7 @@ public void TargetIndependentPass(IPassManager passManager)
 
         passManager.AddWithName<DataflowPass>("SqueezeShape").Configure(p =>
             {
+                p.Add<Passes.Rules.Neutral.FoldNopCast>();
                 p.Add<Passes.Rules.Neutral.SqueezeTransposeShape>();
                 p.Add<Passes.Rules.Neutral.Squeeze5DTranspose>();
                 p.Add<Passes.Rules.Neutral.FoldLayerNormPattern1>();
@@ -158,7 +159,8 @@ public void TargetIndependentPass(IPassManager passManager)
 
         passManager.AddWithName<DataflowPass>("MHAFusion").Configure(p =>
         {
-            // p.Add<Passes.Rules.FuseMHA1>();
+            p.Add<Passes.Rules.FuseMHA1>();
+            p.Add<Passes.Rules.FuseMHA2>();
         });
 
         _compileSession.Target.RegisterTargetInDependentPass(passManager, _compileSession.CompileOptions);

From 1d2ae1b3e95d6ed651f168290be5d12d73e1319b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 23 Aug 2023 10:32:49 +0800
Subject: [PATCH 117/308] add more cpu kernels

---
 .../cpu/src/runtime/cmodel/include/binary.h   | 92 +++++++++++++++++++
 .../cpu/src/runtime/cmodel/include/gather.h   | 74 +++++++++++++++
 .../runtime/cmodel/include/runtime_types.h    | 45 +++++++++
 .../runtime/cmodel/include/runtime_utils.h    |  2 +
 .../cpu/src/runtime/cmodel/include/slice.h    | 67 ++++++++++++++
 modules/cpu/src/runtime/cmodel/include/tdma.h |  6 ++
 .../cpu/src/runtime/cmodel/include/unary.h    | 81 ++++++++++++++++
 7 files changed, 367 insertions(+)
 create mode 100644 modules/cpu/src/runtime/cmodel/include/binary.h
 create mode 100644 modules/cpu/src/runtime/cmodel/include/gather.h
 create mode 100644 modules/cpu/src/runtime/cmodel/include/slice.h
 create mode 100644 modules/cpu/src/runtime/cmodel/include/unary.h

diff --git a/modules/cpu/src/runtime/cmodel/include/binary.h b/modules/cpu/src/runtime/cmodel/include/binary.h
new file mode 100644
index 0000000000..4ab9eb5b1d
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/binary.h
@@ -0,0 +1,92 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <apply.h>
+#include <gsl/gsl-lite.hpp>
+#include <runtime_utils.h>
+
+namespace kernels {
+
+namespace {
+template <class T, class TOp>
+void binary_impl(TOp &&op, const T *lhs, const T *rhs, T *output,
+                 gsl::span<const size_t> lhs_shape,
+                 gsl::span<const size_t> lhs_strides,
+                 gsl::span<const size_t> rhs_shape,
+                 gsl::span<const size_t> rhs_strides,
+                 gsl::span<const size_t> out_shape,
+                 gsl::span<const size_t> out_strides) noexcept {
+    if (is_scalar(out_shape)) {
+        output[0] = op(lhs[0], rhs[0]);
+        return;
+    }
+    return apply(out_shape, [&](gsl::span<const size_t> index) -> void {
+        const auto lhs_index = get_reduced_offset(index, lhs_shape);
+        const auto rhs_index = get_reduced_offset(index, rhs_shape);
+        const auto a = lhs[offset(lhs_strides, lhs_index)];
+        const auto b = rhs[offset(rhs_strides, rhs_index)];
+        output[offset(out_strides, index)] = op(a, b);
+        return;
+    });
+}
+
+#define BINARY_IMPL_OP(op, funct)                                              \
+    case binary_op_t::op:                                                      \
+        return binary_impl(funct, lhs, rhs, output, lhs_shape, lhs_strides,    \
+                           rhs_shape, rhs_strides, out_shape, out_strides)
+
+template <class T>
+void binary_impl(binary_op_t op, const T *lhs, const T *rhs, T *output,
+                 gsl::span<const size_t> lhs_shape,
+                 gsl::span<const size_t> lhs_strides,
+                 gsl::span<const size_t> rhs_shape,
+                 gsl::span<const size_t> rhs_strides,
+                 gsl::span<const size_t> out_shape,
+                 gsl::span<const size_t> out_strides) {
+    switch (op) {
+        BINARY_IMPL_OP(add, std::plus<T>());
+        BINARY_IMPL_OP(sub, std::minus<T>());
+        BINARY_IMPL_OP(mul, std::multiplies<T>());
+        BINARY_IMPL_OP(div, std::divides<T>());
+        BINARY_IMPL_OP(min, [](T a, T b) { return std::min(a, b); });
+        BINARY_IMPL_OP(max, [](T a, T b) { return std::max(a, b); });
+        BINARY_IMPL_OP(pow, [](T a, T b) { return std::pow(a, b); });
+        BINARY_IMPL_OP(mod, [](T a, T b) { return std::fmod(a, b); });
+        BINARY_IMPL_OP(logical_and,
+                       [](T a, T b) { return static_cast<T>(a && b); });
+        BINARY_IMPL_OP(logical_or,
+                       [](T a, T b) { return static_cast<T>(a || b); });
+        BINARY_IMPL_OP(logical_xor,
+                       [](T a, T b) { return static_cast<T>(a ^ b); });
+    default:
+        throw "Unsupported Binary Op!";
+    }
+}
+
+} // namespace
+
+template <class T>
+void binary(binary_op_t op, const T *lhs, const T *rhs, T *output,
+            gsl::span<const size_t> lhs_shape,
+            gsl::span<const size_t> lhs_strides,
+            gsl::span<const size_t> rhs_shape,
+            gsl::span<const size_t> rhs_strides,
+            gsl::span<const size_t> out_shape,
+            gsl::span<const size_t> out_strides) noexcept {
+    binary_impl(op, lhs, rhs, output, lhs_shape, lhs_strides, rhs_shape,
+                rhs_strides, out_shape, out_strides);
+}
+
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/gather.h b/modules/cpu/src/runtime/cmodel/include/gather.h
new file mode 100644
index 0000000000..fd5ef81564
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/gather.h
@@ -0,0 +1,74 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <apply.h>
+#include <gsl/gsl-lite.hpp>
+#include <runtime_utils.h>
+
+namespace kernels {
+
+namespace {
+template <class T, class IndicesT>
+void gather_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
+                 gsl::span<const size_t> out_shape,
+                 gsl::span<const size_t> in_strides,
+                 gsl::span<const size_t> out_strides, const IndicesT *indices,
+                 gsl::span<const size_t> indices_shape, size_t axis) noexcept {
+    // scalar
+    if (out_shape.size() == 0) {
+        *output = input[indices[0]];
+        return;
+    }
+
+    apply(out_shape, [&](gsl::span<const size_t> out_index) -> void {
+        // select batch
+        // [out_index.begin(), out_index.begin() + axis]
+        dims_t in_index(in_shape.size());
+        size_t i_index = 0;
+        for (; i_index < static_cast<size_t>(axis); ++i_index) {
+            in_index[i_index] = out_index[i_index];
+        }
+
+        // which index to be used in indices
+        dims_t indices_index(out_index.begin() + axis,
+                             out_index.begin() + axis + indices_shape.size());
+        auto indices_offset =
+            offset(get_default_strides(indices_shape), indices_index);
+        // select sub block in dim axis
+        in_index[i_index] = indices[indices_offset];
+        ++i_index;
+
+        // select position in sub block
+        for (auto o_index = axis + indices_shape.size();
+             o_index < out_index.size(); ++o_index, ++i_index) {
+            in_index[i_index] = out_index[o_index];
+        }
+        output[offset(out_strides, out_index)] =
+            input[offset(in_strides, in_index)];
+    });
+}
+} // namespace
+
+template <class T, class IndicesT>
+void gather(const T *input, T *output, gsl::span<const size_t> in_shape,
+            gsl::span<const size_t> in_strides,
+            gsl::span<const size_t> out_shape,
+            gsl::span<const size_t> out_strides, const IndicesT *indices,
+            gsl::span<const size_t> indices_shape, size_t axis) noexcept {
+    gather_impl(input, output, in_shape, out_shape, in_strides, out_strides,
+                indices, indices_shape, axis);
+}
+
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_types.h b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
index bfe9fecd67..efded76316 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_types.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
@@ -3,3 +3,48 @@
 
 using dims_t = itlib::small_vector<size_t, 8>;
 using strides_t = itlib::small_vector<size_t, 8>;
+using axes_t = itlib::small_vector<int64_t, 8>;
+
+enum class unary_op_t : uint8_t {
+    abs = 0,
+    acos = 1,
+    acosh = 2,
+    asin = 3,
+    asinh = 4,
+    ceil = 5,
+    cos = 6,
+    cosh = 7,
+    exp = 8,
+    floor = 9,
+    log = 10,
+    neg = 11,
+    round = 12,
+    rsqrt = 13,
+    sin = 14,
+    sinh = 15,
+    sign = 16,
+    sqrt = 17,
+    square = 18,
+    tanh = 19,
+    bitwise_not = 20,
+    logical_not = 21,
+};
+
+enum class binary_op_t : uint8_t {
+    add = 0,
+    sub = 1,
+    mul = 2,
+    div = 3,
+    mod = 4,
+    min = 5,
+    max = 6,
+    pow = 7,
+    bitwise_and = 8,
+    bitwise_or = 9,
+    bitwise_xor = 10,
+    logical_and = 11,
+    logical_or = 12,
+    logical_xor = 13,
+    left_shift = 14,
+    right_shift = 15,
+};
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 3831c91958..35846c8e3a 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -82,6 +82,8 @@ inline bool is_shape_equal(const dims_t &a, const dims_t &b) {
     return true;
 }
 
+inline bool is_scalar(gsl::span<const size_t> t) noexcept { return t.empty(); }
+
 inline dims_t to_nd(dims_t in_shape, size_t n) {
     auto size = n - in_shape.size();
     for (size_t i = 0; i < size; ++i) {
diff --git a/modules/cpu/src/runtime/cmodel/include/slice.h b/modules/cpu/src/runtime/cmodel/include/slice.h
new file mode 100644
index 0000000000..d0815d1c8c
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/slice.h
@@ -0,0 +1,67 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <apply.h>
+#include <gsl/gsl-lite.hpp>
+#include <runtime_utils.h>
+
+namespace kernels {
+
+namespace {
+template <class T>
+void slice_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
+                gsl::span<const size_t> in_strides,
+                gsl::span<const size_t> out_strides,
+                gsl::span<const int64_t> &begins,
+                gsl::span<const int64_t> &ends,
+                gsl::span<const int64_t> &strides) noexcept {
+    apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        dims_t out_index(index.size());
+        for (size_t i = 0; i < index.size(); i++) {
+            const auto stride = strides[i];
+            if (stride > 0) {
+                if ((int32_t)index[i] < begins[i] ||
+                    index[i] >= static_cast<size_t>(ends[i]))
+                    return;
+            } else {
+                if ((int32_t)index[i] <= ends[i] ||
+                    (int32_t)index[i] > begins[i])
+                    return;
+            }
+
+            auto out_div =
+                div((int32_t)(index[i] - begins[i]), (int32_t)strides[i]);
+            if (out_div.rem)
+                return;
+            out_index[i] = (size_t)out_div.quot;
+        }
+
+        output[offset(out_strides, out_index)] =
+            input[offset(in_strides, index)];
+    });
+}
+} // namespace
+
+template <class T>
+void slice(const T *input, T *output, gsl::span<const size_t> in_shape,
+           gsl::span<const size_t> in_strides,
+           gsl::span<const size_t> out_strides, gsl::span<const int64_t> begins,
+           gsl::span<const int64_t> ends,
+           gsl::span<const int64_t> strides) noexcept {
+    slice_impl(input, output, in_shape, in_strides, out_strides, begins, ends,
+               strides);
+}
+
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 45a3517824..9405b7736a 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -21,6 +21,12 @@ template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &src) {
     return tensor<T, Loc>(src.data(), new_dims, new_strides);
 }
 
+template <class T, loc_t Loc>
+tensor<T, Loc> reshape(tensor<T, Loc> &src, gsl::span<size_t> new_shape) {
+    assert(compute_size(src.dimension()) == compute_size(new_shape));
+    return tensor<T, Loc>(src.data(), new_shape, get_default_strides(new_shape));
+}
+
 template <class T, loc_t Loc>
 tensor<T, Loc> view_transpose(tensor<T, Loc> &src, dims_t perm) {
     auto new_dims = dims_t();
diff --git a/modules/cpu/src/runtime/cmodel/include/unary.h b/modules/cpu/src/runtime/cmodel/include/unary.h
new file mode 100644
index 0000000000..94c1a893bf
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/unary.h
@@ -0,0 +1,81 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <apply.h>
+#include <gsl/gsl-lite.hpp>
+#include <runtime_utils.h>
+
+namespace kernels {
+
+namespace {
+template <class T, class TOp>
+void unary_impl(TOp &&op, const T *input, T *output,
+                gsl::span<const size_t> input_strides,
+                gsl::span<const size_t> out_shape,
+                gsl::span<const size_t> out_strides) noexcept {
+    apply(out_shape, [&](gsl::span<const size_t> index) -> void {
+        const auto v = input[offset(input_strides, index)];
+        output[offset(out_strides, index)] = (T)op(v);
+    });
+}
+
+#define UNARY_IMPL_OP(op, callable)                                            \
+    case unary_op_t::op:                                                       \
+        return unary_impl(callable, input, output, input_strides, out_shape,   \
+                          out_strides)
+
+template <class T>
+void unary_impl(unary_op_t op, const T *input, T *output,
+                gsl::span<const size_t> input_strides,
+                gsl::span<const size_t> out_shape,
+                gsl::span<const size_t> out_strides) noexcept {
+    switch (op) {
+        UNARY_IMPL_OP(abs, fabsf);
+        UNARY_IMPL_OP(acos, acosf);
+        UNARY_IMPL_OP(acosh, acoshf);
+        UNARY_IMPL_OP(asin, asinf);
+        UNARY_IMPL_OP(asinh, asinhf);
+        UNARY_IMPL_OP(ceil, ceilf);
+        UNARY_IMPL_OP(cos, cosf);
+        UNARY_IMPL_OP(cosh, coshf);
+        UNARY_IMPL_OP(exp, expf);
+        UNARY_IMPL_OP(floor, floorf);
+        UNARY_IMPL_OP(log, logf);
+        UNARY_IMPL_OP(logical_not, [](float v) { return !v; });
+        UNARY_IMPL_OP(neg, std::negate<float>());
+        UNARY_IMPL_OP(round, [](float v) { return round(v); });
+        UNARY_IMPL_OP(rsqrt, [](float v) { return 1.f / sqrtf(v); });
+        UNARY_IMPL_OP(sign, [](float v) { return (0.f < v) - (v < 0.f); });
+        UNARY_IMPL_OP(sin, sinf);
+        UNARY_IMPL_OP(sinh, sinhf);
+        UNARY_IMPL_OP(sqrt, sqrtf);
+        UNARY_IMPL_OP(square, [](float v) { return v * v; });
+        UNARY_IMPL_OP(tanh, tanhf);
+    default:
+        return;
+    }
+}
+
+} // namespace
+
+template <class T>
+void unary(unary_op_t op, const T *input, T *output,
+           gsl::span<const size_t> in_strides,
+           gsl::span<const size_t> out_shape,
+           gsl::span<const size_t> out_strides) noexcept {
+    unary_impl(op, input, output, in_strides, out_shape, out_strides);
+}
+
+} // namespace kernels
\ No newline at end of file

From b08a96e26a8ff21667bc5968670b7d2d9a18e468 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 23 Aug 2023 14:44:03 +0800
Subject: [PATCH 118/308] update MHA fusion

---
 .../Passes/Rules/MHAFusion.cs                 | 151 +++++++++++-------
 1 file changed, 93 insertions(+), 58 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index 0dba69af87..4cdcd6064a 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reactive;
 using System.Text;
 using System.Threading.Tasks;
 using Nncase.IR;
@@ -20,7 +21,30 @@
 
 namespace Nncase.Passes.Rules;
 
-// pattern from BERT
+/// <summary>
+/// MHA Merger for all.
+/// </summary>
+public sealed class MHAMerger : ExprCloner<Unit>
+{
+    private readonly IReadOnlyDictionary<Expr, Var> _multiVarMap;
+
+    public MHAMerger(IReadOnlyDictionary<Expr, Var> multiVarMap)
+    {
+        _multiVarMap = multiVarMap;
+    }
+
+    protected override Expr VisitLeafVar(Var expr, Unit context)
+    {
+        if (_multiVarMap.TryGetValue(expr, out var newVar))
+        {
+            return newVar;
+        }
+
+        throw new InvalidOperationException();
+    }
+}
+
+// pattern from BERT base
 [RuleGenerator]
 public sealed partial class FuseMHA1 : FusionMaker
 {
@@ -82,11 +106,13 @@ private static Pattern CreatePattern()
 
     private Call? GetReplace(Call root, Expr x, Expr mask)
     {
-        var newInputs = new List<Expr>();
-        newInputs.Add(new Var(x.CheckedType!));
-        newInputs.Add(new Var(mask.CheckedType!));
+        var newInputs = new List<Expr>
+        {
+            new Var(x.CheckedType!),
+            new Var(mask.CheckedType!),
+        };
 
-        var callFusion = new Call(new Fusion("MHA1", $"{root.Target.GetType().Name}", "cpu", root, newInputs.OfType<Var>().ToArray()), x, mask);
+        var callFusion = new Call(new Fusion("MHABertBase", $"{root.Target.GetType().Name}", "cpu", root, newInputs.OfType<Var>().ToArray()), x, mask);
         return callFusion;
     }
 }
@@ -105,95 +131,104 @@ private static Pattern CreatePattern()
 
         var v1 = IsTensorConst("v1");
         var v2 = IsTensorConst("v2");
-        var v3 = IsCall("v3", IsOp<LayerNorm>(), IsVArgs(v0,v1,v2));
+        var v3 = IsCall("v3", IsOp<LayerNorm>(), IsVArgs(v0, v1, v2));
         var v4 = IsTensorConst("v4");
-        var v5 = IsCall("v5", IsOp<MatMul>(), IsVArgs(v3,v4));
+        var v5 = IsCall("v5", IsOp<MatMul>(), IsVArgs(v3, v4));
         var v6 = IsTensorConst("v6");
-        var v7 = IsCall("v7", IsOp<Reshape>(), IsVArgs(v5,v6));
+        var v7 = IsCall("v7", IsOp<Reshape>(), IsVArgs(v5, v6));
         var v8 = IsTensorConst("v8");
-        var v9 = IsCall("v9", IsOp<Transpose>(), IsVArgs(v7,v8));
+        var v9 = IsCall("v9", IsOp<Transpose>(), IsVArgs(v7, v8));
         var v10 = IsTensorConst("v10");
         var v11 = IsTensorConst("v11");
         var v12 = IsWildcard("position_ids");
 
-        var v13 = IsCall("v13", IsOp<Gather>(), IsVArgs(v10,v11,v12));
+        var v13 = IsCall("v13", IsOp<Gather>(), IsVArgs(v10, v11, v12));
         var v14 = IsTensorConst("v14");
-        var v15 = IsCall("v15", IsOp<Reshape>(), IsVArgs(v13,v14));
-        var v16 = IsCall("v16", IsOp<Binary>(), IsVArgs(v9,v15));
+        var v15 = IsCall("v15", IsOp<Reshape>(), IsVArgs(v13, v14));
+        var v16 = IsCall("v16", IsOp<Binary>(), IsVArgs(v9, v15));
         var v17 = IsTensorConst("v17");
         var v18 = IsTensorConst("v18");
         var v19 = IsTensorConst("v19");
         var v20 = IsTensorConst("v20");
-        var v21 = IsCall("v21", IsOp<Slice>(), IsVArgs(v9,v17,v18,v19,v20));
+        var v21 = IsCall("v21", IsOp<Slice>(), IsVArgs(v9, v17, v18, v19, v20));
         var v22 = IsCall("v22", IsOp<Unary>(), IsVArgs(v21));
         var v23 = IsTensorConst("v23");
-        var v24 = IsCall("v24", IsOp<Slice>(), IsVArgs(v9,v23,v17,v19,v20));
-        var v25 = IsTuple("v25", IsVArgs(v22,v24));
+        var v24 = IsCall("v24", IsOp<Slice>(), IsVArgs(v9, v23, v17, v19, v20));
+        var v25 = IsTuple("v25", IsVArgs(v22, v24));
 
         var v26 = IsTensorConst("v26");
-        var v27 = IsCall("v27", IsOp<Concat>(), IsVArgs(v25,v26));
+        var v27 = IsCall("v27", IsOp<Concat>(), IsVArgs(v25, v26));
         var v28 = IsTensorConst("v28");
-        var v29 = IsCall("v29", IsOp<Gather>(), IsVArgs(v28,v11,v12));
-        var v30 = IsCall("v30", IsOp<Reshape>(), IsVArgs(v29,v14));
-        var v31 = IsCall("v31", IsOp<Binary>(), IsVArgs(v27,v30));
-        var v32 = IsCall("v32", IsOp<Binary>(), IsVArgs(v16,v31));
+        var v29 = IsCall("v29", IsOp<Gather>(), IsVArgs(v28, v11, v12));
+        var v30 = IsCall("v30", IsOp<Reshape>(), IsVArgs(v29, v14));
+        var v31 = IsCall("v31", IsOp<Binary>(), IsVArgs(v27, v30));
+        var v32 = IsCall("v32", IsOp<Binary>(), IsVArgs(v16, v31));
         var v33 = IsTensorConst("v33");
-        var v34 = IsCall("v34", IsOp<MatMul>(), IsVArgs(v3,v33));
-        var v35 = IsCall("v35", IsOp<Reshape>(), IsVArgs(v34,v6));
-        var v36 = IsCall("v36", IsOp<Transpose>(), IsVArgs(v35,v8));
-        var v37 = IsCall("v37", IsOp<Binary>(), IsVArgs(v36,v15));
-        var v38 = IsCall("v38", IsOp<Slice>(), IsVArgs(v36,v17,v18,v19,v20));
+        var v34 = IsCall("v34", IsOp<MatMul>(), IsVArgs(v3, v33));
+        var v35 = IsCall("v35", IsOp<Reshape>(), IsVArgs(v34, v6));
+        var v36 = IsCall("v36", IsOp<Transpose>(), IsVArgs(v35, v8));
+        var v37 = IsCall("v37", IsOp<Binary>(), IsVArgs(v36, v15));
+        var v38 = IsCall("v38", IsOp<Slice>(), IsVArgs(v36, v17, v18, v19, v20));
         var v39 = IsCall("v39", IsOp<Unary>(), IsVArgs(v38));
-        var v40 = IsCall("v40", IsOp<Slice>(), IsVArgs(v36,v23,v17,v19,v20));
-        var v41 = IsTuple("v41", IsVArgs(v39,v40));
+        var v40 = IsCall("v40", IsOp<Slice>(), IsVArgs(v36, v23, v17, v19, v20));
+        var v41 = IsTuple("v41", IsVArgs(v39, v40));
 
-        var v42 = IsCall("v42", IsOp<Concat>(), IsVArgs(v41,v26));
-        var v43 = IsCall("v43", IsOp<Binary>(), IsVArgs(v42,v30));
-        var v44 = IsCall("v44", IsOp<Binary>(), IsVArgs(v37,v43));
+        var v42 = IsCall("v42", IsOp<Concat>(), IsVArgs(v41, v26));
+        var v43 = IsCall("v43", IsOp<Binary>(), IsVArgs(v42, v30));
+        var v44 = IsCall("v44", IsOp<Binary>(), IsVArgs(v37, v43));
         var v45 = IsTensorConst("v45");
-        var v46 = IsCall("v46", IsOp<Transpose>(), IsVArgs(v44,v45));
-        var v47 = IsCall("v47", IsOp<MatMul>(), IsVArgs(v32,v46));
+        var v46 = IsCall("v46", IsOp<Transpose>(), IsVArgs(v44, v45));
+        var v47 = IsCall("v47", IsOp<MatMul>(), IsVArgs(v32, v46));
         var v48 = IsTensorConst("v48");
-        var v49 = IsCall("v49", IsOp<Binary>(), IsVArgs(v47,v48));
+        var v49 = IsCall("v49", IsOp<Binary>(), IsVArgs(v47, v48));
         var v50 = IsWildcard("attn_mask");
 
-        var v51 = IsCall("v51", IsOp<Binary>(), IsVArgs(v49,v50));
-        var v52 = IsCall("v52", IsOp<Softmax>(), IsVArgs(v51,v26));
+        var v51 = IsCall("v51", IsOp<Binary>(), IsVArgs(v49, v50));
+        var v52 = IsCall("v52", IsOp<Softmax>(), IsVArgs(v51, v26));
         var v53 = IsTensorConst("v53");
-        var v54 = IsCall("v54", IsOp<MatMul>(), IsVArgs(v3,v53));
-        var v55 = IsCall("v55", IsOp<Reshape>(), IsVArgs(v54,v6));
-        var v56 = IsCall("v56", IsOp<Transpose>(), IsVArgs(v55,v8));
-        var v57 = IsCall("v57", IsOp<MatMul>(), IsVArgs(v52,v56));
-        var v58 = IsCall("v58", IsOp<Transpose>(), IsVArgs(v57,v8));
+        var v54 = IsCall("v54", IsOp<MatMul>(), IsVArgs(v3, v53));
+        var v55 = IsCall("v55", IsOp<Reshape>(), IsVArgs(v54, v6));
+        var v56 = IsCall("v56", IsOp<Transpose>(), IsVArgs(v55, v8));
+        var v57 = IsCall("v57", IsOp<MatMul>(), IsVArgs(v52, v56));
+        var v58 = IsCall("v58", IsOp<Transpose>(), IsVArgs(v57, v8));
         var v59 = IsTensorConst("v59");
-        var v60 = IsCall("v60", IsOp<Reshape>(), IsVArgs(v58,v59));
+        var v60 = IsCall("v60", IsOp<Reshape>(), IsVArgs(v58, v59));
         var v61 = IsTensorConst("v61");
-        var v62 = IsCall("v62", IsOp<MatMul>(), IsVArgs(v60,v61));
-        var v63 = IsCall("v63", IsOp<Binary>(), IsVArgs(v0,v62));
-        var v64 = IsCall("v64", IsOp<LayerNorm>(), IsVArgs(v63,v1,v2));
+        var v62 = IsCall("v62", IsOp<MatMul>(), IsVArgs(v60, v61));
+        var v63 = IsCall("v63", IsOp<Binary>(), IsVArgs(v0, v62));
+        var v64 = IsCall("v64", IsOp<LayerNorm>(), IsVArgs(v63, v1, v2));
         var v65 = IsTensorConst("v65");
-        var v66 = IsCall("v66", IsOp<MatMul>(), IsVArgs(v64,v65));
+        var v66 = IsCall("v66", IsOp<MatMul>(), IsVArgs(v64, v65));
         var v67 = IsCall("v67", IsOp<Swish>(), IsVArgs(v66));
         var v68 = IsTensorConst("v68");
-        var v69 = IsCall("v69", IsOp<MatMul>(), IsVArgs(v64,v68));
-        var v70 = IsCall("v70", IsOp<Binary>(), IsVArgs(v67,v69));
+        var v69 = IsCall("v69", IsOp<MatMul>(), IsVArgs(v64, v68));
+        var v70 = IsCall("v70", IsOp<Binary>(), IsVArgs(v67, v69));
         var v71 = IsTensorConst("v71");
-        var v72 = IsCall("v72", IsOp<MatMul>(), IsVArgs(v70,v71));
-        var v73 = IsCall("root", IsOp<Binary>(), IsVArgs(v63,v72));
+        var v72 = IsCall("v72", IsOp<MatMul>(), IsVArgs(v70, v71));
+        var v73 = IsCall("root", IsOp<Binary>(), IsVArgs(v63, v72));
 
         return v73;
     }
 
-        private Call? GetReplace(Call root, Expr hidden_in, Expr position_ids, Expr attn_mask)
+    private Call? GetReplace(Call root, Expr hidden_in, Expr position_ids, Expr attn_mask)
     {
-        var newInputs = new List<Expr>();
-        newInputs.Add(new Var(hidden_in.CheckedType!));
-        newInputs.Add(new Var(position_ids.CheckedType!));
-        newInputs.Add(new Var(attn_mask.CheckedType!));
-
-        var callFusion = new Call(new Fusion("MHA2", $"{root.Target.GetType().Name}", "cpu", root, newInputs.OfType<Var>().ToArray()), hidden_in, position_ids, attn_mask);
+        var newInputs = new List<Expr>
+        {
+            new Var(hidden_in.CheckedType!),
+            new Var(position_ids.CheckedType!),
+            new Var(attn_mask.CheckedType!),
+        };
+
+        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
+        {
+            { hidden_in, (Var)newInputs[0] },
+            { position_ids, (Var)newInputs[1] },
+            { attn_mask, (Var)newInputs[2] },
+        };
+        var merger = new MHAMerger(multiVarMap);
+        var clonedRoot = merger.Clone(root, default);
+
+        var callFusion = new Call(new Fusion("MHALLaMA65B", $"{root.Target.GetType().Name}", "cpu", clonedRoot, newInputs.OfType<Var>().ToArray()), hidden_in, position_ids, attn_mask);
         return callFusion;
     }
 }
-
-

From 09a2666f6cd980e7f90e75e4fd8855652f30ec00 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 24 Aug 2023 11:41:16 +0800
Subject: [PATCH 119/308] reorder MHA weights

---
 .../Passes/Rules/MHACombine.cs                |  70 ++++++++++
 .../Passes/Rules/MHAFusion.cs                 | 129 +++++++++---------
 src/Nncase.Compiler/Compiler.cs               |   2 +
 3 files changed, 136 insertions(+), 65 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs
new file mode 100644
index 0000000000..017b1ffd61
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs
@@ -0,0 +1,70 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.CPU;
+using Nncase.IR.Math;
+using Nncase.IR.NN;
+using Nncase.IR.Tensors;
+using Nncase.Passes.Rules.Neutral;
+using Nncase.PatternMatch;
+using Nncase.Targets;
+using static Nncase.IR.TypePatternUtility;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.F.Tensors;
+using static Nncase.PatternMatch.Utility;
+using static Nncase.Utilities.ReplaceUtility;
+
+using Nncase.IR.F;
+
+namespace Nncase.Passes.Rules;
+
+
+/// <summary>
+/// Convert QKV computation to MHA style.
+/// </summary>
+[RuleGenerator]
+public sealed partial class MHACombine : IRewriteRule
+{
+	public IPattern Pattern { get; } =
+        IsTranspose(
+		"tp",
+		"tpCall",
+		_ => true,
+		IsReshape(
+			"rshape",
+			"rshapeCall",
+			_ => true,
+			IsMatMul(
+				"mm",
+				"mmCall",
+				_ => true,
+				IsWildcard("x"),
+			IsTensorConst("w")),
+			IsTensorConst("newShape")),
+		IsTensorConst("perm")) with {TypePattern = HasFixedShape()};
+
+	private Expr? GetReplace(Expr x, Call mmCall, Call rshapeCall, Call tpCall, TensorConst w, TensorConst newShape, TensorConst perm)
+	{
+		var mmOutShape = mmCall.CheckedShape.ToValueArray();
+		var wReshape = newShape.Value.ToArray<int>().TakeLast(2).ToArray();
+
+		// TODO: add more patterns, only llama65b for now
+		if (perm.CheckedShape.Size == 4
+			&& perm.Value.ToArray<int>().SequenceEqual(new[] { 0, 2, 1, 3 })
+		 	&& wReshape.Aggregate(1, (x, y) => x * y) == mmOutShape[^1]
+		 	&& (mmOutShape.Length == 2 || (mmOutShape.Length == 3 && mmOutShape[0] == 1)))
+		{
+			var newW = Tensors.Transpose(Tensors.Reshape(w, new[] { -1, wReshape[0], wReshape[1] }), new[] { 1, 0, 2 });
+			var newMm = Tensors.MatMul(Tensors.Unsqueeze(x, new[] { 1 }), newW);
+			return newMm;
+		}
+		return null;
+	}
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index 4cdcd6064a..b5fb4d042b 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -133,81 +133,80 @@ private static Pattern CreatePattern()
         var v2 = IsTensorConst("v2");
         var v3 = IsCall("v3", IsOp<LayerNorm>(), IsVArgs(v0, v1, v2));
         var v4 = IsTensorConst("v4");
-        var v5 = IsCall("v5", IsOp<MatMul>(), IsVArgs(v3, v4));
+        var v5 = IsCall("v5", IsOp<Unsqueeze>(), IsVArgs(v3, v4));
         var v6 = IsTensorConst("v6");
-        var v7 = IsCall("v7", IsOp<Reshape>(), IsVArgs(v5, v6));
+        var v7 = IsCall("v7", IsOp<MatMul>(), IsVArgs(v5, v6));
         var v8 = IsTensorConst("v8");
-        var v9 = IsCall("v9", IsOp<Transpose>(), IsVArgs(v7, v8));
-        var v10 = IsTensorConst("v10");
-        var v11 = IsTensorConst("v11");
-        var v12 = IsWildcard("position_ids");
+        var v9 = IsTensorConst("v9");
+        var v10 = IsWildcard("position_ids");
 
-        var v13 = IsCall("v13", IsOp<Gather>(), IsVArgs(v10, v11, v12));
-        var v14 = IsTensorConst("v14");
-        var v15 = IsCall("v15", IsOp<Reshape>(), IsVArgs(v13, v14));
-        var v16 = IsCall("v16", IsOp<Binary>(), IsVArgs(v9, v15));
+        var v11 = IsCall("v11", IsOp<Gather>(), IsVArgs(v8, v9, v10));
+        var v12 = IsTensorConst("v12");
+        var v13 = IsCall("v13", IsOp<Reshape>(), IsVArgs(v11, v12));
+        var v14 = IsCall("v14", IsOp<Binary>(), IsVArgs(v7, v13));
+        var v15 = IsTensorConst("v15");
+        var v16 = IsTensorConst("v16");
         var v17 = IsTensorConst("v17");
         var v18 = IsTensorConst("v18");
-        var v19 = IsTensorConst("v19");
-        var v20 = IsTensorConst("v20");
-        var v21 = IsCall("v21", IsOp<Slice>(), IsVArgs(v9, v17, v18, v19, v20));
-        var v22 = IsCall("v22", IsOp<Unary>(), IsVArgs(v21));
-        var v23 = IsTensorConst("v23");
-        var v24 = IsCall("v24", IsOp<Slice>(), IsVArgs(v9, v23, v17, v19, v20));
-        var v25 = IsTuple("v25", IsVArgs(v22, v24));
+        var v19 = IsCall("v19", IsOp<Slice>(), IsVArgs(v7, v15, v16, v17, v18));
+        var v20 = IsCall("v20", IsOp<Unary>(), IsVArgs(v19));
+        var v21 = IsTensorConst("v21");
+        var v22 = IsCall("v22", IsOp<Slice>(), IsVArgs(v7, v21, v15, v17, v18));
+        var v23 = IsTuple("v23", IsVArgs(v20, v22));
 
+        var v24 = IsTensorConst("v24");
+        var v25 = IsCall("v25", IsOp<Concat>(), IsVArgs(v23, v24));
         var v26 = IsTensorConst("v26");
-        var v27 = IsCall("v27", IsOp<Concat>(), IsVArgs(v25, v26));
-        var v28 = IsTensorConst("v28");
-        var v29 = IsCall("v29", IsOp<Gather>(), IsVArgs(v28, v11, v12));
-        var v30 = IsCall("v30", IsOp<Reshape>(), IsVArgs(v29, v14));
-        var v31 = IsCall("v31", IsOp<Binary>(), IsVArgs(v27, v30));
-        var v32 = IsCall("v32", IsOp<Binary>(), IsVArgs(v16, v31));
+        var v27 = IsCall("v27", IsOp<Gather>(), IsVArgs(v26, v9, v10));
+        var v28 = IsCall("v28", IsOp<Reshape>(), IsVArgs(v27, v12));
+        var v29 = IsCall("v29", IsOp<Binary>(), IsVArgs(v25, v28));
+        var v30 = IsCall("v30", IsOp<Binary>(), IsVArgs(v14, v29));
+        var v31 = IsTensorConst("v31");
+        var v32 = IsCall("v32", IsOp<Unsqueeze>(), IsVArgs(v3, v31));
         var v33 = IsTensorConst("v33");
-        var v34 = IsCall("v34", IsOp<MatMul>(), IsVArgs(v3, v33));
-        var v35 = IsCall("v35", IsOp<Reshape>(), IsVArgs(v34, v6));
-        var v36 = IsCall("v36", IsOp<Transpose>(), IsVArgs(v35, v8));
-        var v37 = IsCall("v37", IsOp<Binary>(), IsVArgs(v36, v15));
-        var v38 = IsCall("v38", IsOp<Slice>(), IsVArgs(v36, v17, v18, v19, v20));
-        var v39 = IsCall("v39", IsOp<Unary>(), IsVArgs(v38));
-        var v40 = IsCall("v40", IsOp<Slice>(), IsVArgs(v36, v23, v17, v19, v20));
-        var v41 = IsTuple("v41", IsVArgs(v39, v40));
-
-        var v42 = IsCall("v42", IsOp<Concat>(), IsVArgs(v41, v26));
-        var v43 = IsCall("v43", IsOp<Binary>(), IsVArgs(v42, v30));
-        var v44 = IsCall("v44", IsOp<Binary>(), IsVArgs(v37, v43));
-        var v45 = IsTensorConst("v45");
-        var v46 = IsCall("v46", IsOp<Transpose>(), IsVArgs(v44, v45));
-        var v47 = IsCall("v47", IsOp<MatMul>(), IsVArgs(v32, v46));
-        var v48 = IsTensorConst("v48");
-        var v49 = IsCall("v49", IsOp<Binary>(), IsVArgs(v47, v48));
-        var v50 = IsWildcard("attn_mask");
+        var v34 = IsCall("v34", IsOp<MatMul>(), IsVArgs(v32, v33));
+        var v35 = IsCall("v35", IsOp<Binary>(), IsVArgs(v34, v13));
+        var v36 = IsCall("v36", IsOp<Slice>(), IsVArgs(v34, v15, v16, v17, v18));
+        var v37 = IsCall("v37", IsOp<Unary>(), IsVArgs(v36));
+        var v38 = IsCall("v38", IsOp<Slice>(), IsVArgs(v34, v21, v15, v17, v18));
+        var v39 = IsTuple("v39", IsVArgs(v37, v38));
+
+        var v40 = IsCall("v40", IsOp<Concat>(), IsVArgs(v39, v24));
+        var v41 = IsCall("v41", IsOp<Binary>(), IsVArgs(v40, v28));
+        var v42 = IsCall("v42", IsOp<Binary>(), IsVArgs(v35, v41));
+        var v43 = IsTensorConst("v43");
+        var v44 = IsCall("v44", IsOp<Transpose>(), IsVArgs(v42, v43));
+        var v45 = IsCall("v45", IsOp<MatMul>(), IsVArgs(v30, v44));
+        var v46 = IsTensorConst("v46");
+        var v47 = IsCall("v47", IsOp<Binary>(), IsVArgs(v45, v46));
+        var v48 = IsWildcard("attn_mask");
 
-        var v51 = IsCall("v51", IsOp<Binary>(), IsVArgs(v49, v50));
-        var v52 = IsCall("v52", IsOp<Softmax>(), IsVArgs(v51, v26));
+        var v49 = IsCall("v49", IsOp<Binary>(), IsVArgs(v47, v48));
+        var v50 = IsCall("v50", IsOp<Softmax>(), IsVArgs(v49, v24));
+        var v51 = IsTensorConst("v51");
+        var v52 = IsCall("v52", IsOp<Unsqueeze>(), IsVArgs(v3, v51));
         var v53 = IsTensorConst("v53");
-        var v54 = IsCall("v54", IsOp<MatMul>(), IsVArgs(v3, v53));
-        var v55 = IsCall("v55", IsOp<Reshape>(), IsVArgs(v54, v6));
-        var v56 = IsCall("v56", IsOp<Transpose>(), IsVArgs(v55, v8));
-        var v57 = IsCall("v57", IsOp<MatMul>(), IsVArgs(v52, v56));
-        var v58 = IsCall("v58", IsOp<Transpose>(), IsVArgs(v57, v8));
-        var v59 = IsTensorConst("v59");
-        var v60 = IsCall("v60", IsOp<Reshape>(), IsVArgs(v58, v59));
-        var v61 = IsTensorConst("v61");
-        var v62 = IsCall("v62", IsOp<MatMul>(), IsVArgs(v60, v61));
-        var v63 = IsCall("v63", IsOp<Binary>(), IsVArgs(v0, v62));
-        var v64 = IsCall("v64", IsOp<LayerNorm>(), IsVArgs(v63, v1, v2));
-        var v65 = IsTensorConst("v65");
-        var v66 = IsCall("v66", IsOp<MatMul>(), IsVArgs(v64, v65));
-        var v67 = IsCall("v67", IsOp<Swish>(), IsVArgs(v66));
-        var v68 = IsTensorConst("v68");
-        var v69 = IsCall("v69", IsOp<MatMul>(), IsVArgs(v64, v68));
-        var v70 = IsCall("v70", IsOp<Binary>(), IsVArgs(v67, v69));
-        var v71 = IsTensorConst("v71");
-        var v72 = IsCall("v72", IsOp<MatMul>(), IsVArgs(v70, v71));
-        var v73 = IsCall("root", IsOp<Binary>(), IsVArgs(v63, v72));
-
-        return v73;
+        var v54 = IsCall("v54", IsOp<MatMul>(), IsVArgs(v52, v53));
+        var v55 = IsCall("v55", IsOp<MatMul>(), IsVArgs(v50, v54));
+        var v56 = IsTensorConst("v56");
+        var v57 = IsCall("v57", IsOp<Transpose>(), IsVArgs(v55, v56));
+        var v58 = IsTensorConst("v58");
+        var v59 = IsCall("v59", IsOp<Reshape>(), IsVArgs(v57, v58));
+        var v60 = IsTensorConst("v60");
+        var v61 = IsCall("v61", IsOp<MatMul>(), IsVArgs(v59, v60));
+        var v62 = IsCall("v62", IsOp<Binary>(), IsVArgs(v0, v61));
+        var v63 = IsCall("v63", IsOp<LayerNorm>(), IsVArgs(v62, v1, v2));
+        var v64 = IsTensorConst("v64");
+        var v65 = IsCall("v65", IsOp<MatMul>(), IsVArgs(v63, v64));
+        var v66 = IsCall("v66", IsOp<Swish>(), IsVArgs(v65));
+        var v67 = IsTensorConst("v67");
+        var v68 = IsCall("v68", IsOp<MatMul>(), IsVArgs(v63, v67));
+        var v69 = IsCall("v69", IsOp<Binary>(), IsVArgs(v66, v68));
+        var v70 = IsTensorConst("v70");
+        var v71 = IsCall("v71", IsOp<MatMul>(), IsVArgs(v69, v70));
+        var v72 = IsCall("root", IsOp<Binary>(), IsVArgs(v62, v71));
+
+        return v72;
     }
 
     private Call? GetReplace(Call root, Expr hidden_in, Expr position_ids, Expr attn_mask)
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 2495955d07..1df91dbecc 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -159,6 +159,8 @@ public void TargetIndependentPass(IPassManager passManager)
 
         passManager.AddWithName<DataflowPass>("MHAFusion").Configure(p =>
         {
+            p.Add<Passes.Rules.MHACombine>();
+            p.Add<Passes.Rules.Neutral.FoldConstCall>();
             p.Add<Passes.Rules.FuseMHA1>();
             p.Add<Passes.Rules.FuseMHA2>();
         });

From 1c2a937114199ae93d87505c73e0f27fcee1eea9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 24 Aug 2023 11:14:47 +0800
Subject: [PATCH 120/308] add demo3

---
 .../cpu/src/runtime/cmodel/include/binary.h   |  13 +-
 .../cpu/src/runtime/cmodel/include/concat.h   |  55 ++++++
 .../runtime/cmodel/include/runtime_types.h    |   1 +
 modules/cpu/src/runtime/cmodel/include/tdma.h | 125 +++++++------
 .../src/runtime/cmodel/tests/demo1/kernel.h   |   4 +-
 .../src/runtime/cmodel/tests/demo2/kernel.h   |  15 +-
 .../runtime/cmodel/tests/demo3/cluster_def.h  | 171 ++++++++++++++++++
 .../src/runtime/cmodel/tests/demo3/golden.py  |  67 +++++++
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 117 ++++++++++++
 .../src/runtime/cmodel/tests/demo3/main.cpp   | 164 +++++++++++++++++
 .../runtime/cmodel/tests/demo3/shared_def.h   |   9 +
 11 files changed, 667 insertions(+), 74 deletions(-)
 create mode 100644 modules/cpu/src/runtime/cmodel/include/concat.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo3/cluster_def.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h

diff --git a/modules/cpu/src/runtime/cmodel/include/binary.h b/modules/cpu/src/runtime/cmodel/include/binary.h
index 4ab9eb5b1d..c7184f0762 100644
--- a/modules/cpu/src/runtime/cmodel/include/binary.h
+++ b/modules/cpu/src/runtime/cmodel/include/binary.h
@@ -60,16 +60,17 @@ void binary_impl(binary_op_t op, const T *lhs, const T *rhs, T *output,
         BINARY_IMPL_OP(sub, std::minus<T>());
         BINARY_IMPL_OP(mul, std::multiplies<T>());
         BINARY_IMPL_OP(div, std::divides<T>());
+        BINARY_IMPL_OP(idenity_a, [](T a, [[maybe_unused]] T b) { return a; });
         BINARY_IMPL_OP(min, [](T a, T b) { return std::min(a, b); });
         BINARY_IMPL_OP(max, [](T a, T b) { return std::max(a, b); });
         BINARY_IMPL_OP(pow, [](T a, T b) { return std::pow(a, b); });
         BINARY_IMPL_OP(mod, [](T a, T b) { return std::fmod(a, b); });
-        BINARY_IMPL_OP(logical_and,
-                       [](T a, T b) { return static_cast<T>(a && b); });
-        BINARY_IMPL_OP(logical_or,
-                       [](T a, T b) { return static_cast<T>(a || b); });
-        BINARY_IMPL_OP(logical_xor,
-                       [](T a, T b) { return static_cast<T>(a ^ b); });
+        // BINARY_IMPL_OP(logical_and,
+        //                [](T a, T b) { return static_cast<T>(a && b); });
+        // BINARY_IMPL_OP(logical_or,
+        //                [](T a, T b) { return static_cast<T>(a || b); });
+        // BINARY_IMPL_OP(logical_xor,
+        //                [](T a, T b) { return static_cast<T>(a ^ b); });
     default:
         throw "Unsupported Binary Op!";
     }
diff --git a/modules/cpu/src/runtime/cmodel/include/concat.h b/modules/cpu/src/runtime/cmodel/include/concat.h
new file mode 100644
index 0000000000..3122c10341
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/concat.h
@@ -0,0 +1,55 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "runtime_utils.h"
+
+namespace kernels {
+
+namespace {
+std::pair<size_t, size_t>
+find_input_id_and_index(size_t index,
+                        gsl::span<const size_t> concat_dims) noexcept {
+    size_t input_id;
+    for (input_id = 0;; input_id++) {
+        auto input_dim = concat_dims[input_id];
+        if (index < input_dim)
+            break;
+        index -= input_dim;
+    }
+
+    return std::make_pair(input_id, index);
+}
+
+} // namespace
+
+template <class T>
+void concat(gsl::span<const gsl::byte *const> inputs, T *output,
+                 gsl::span<const size_t> out_shape,
+                 gsl::span<const strides_t> &in_strides,
+                 gsl::span<const size_t> out_strides, size_t axis,
+                 gsl::span<const size_t> concat_dims) noexcept {
+    return apply(out_shape, [&](gsl::span<const size_t> out_index) -> void {
+        auto in_id_index =
+            find_input_id_and_index(out_index[axis], concat_dims);
+        auto input = reinterpret_cast<const T *>(inputs[in_id_index.first]);
+        auto &sel_in_strides = in_strides[in_id_index.first];
+        dims_t in_index(out_index);
+        in_index[axis] = in_id_index.second;
+
+        output[offset(out_strides, out_index)] =
+            input[offset(sel_in_strides, in_index)];
+    });
+}
+
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_types.h b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
index efded76316..d71de1a12d 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_types.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
@@ -47,4 +47,5 @@ enum class binary_op_t : uint8_t {
     logical_xor = 13,
     left_shift = 14,
     right_shift = 15,
+    idenity_a = 16,
 };
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 9405b7736a..f45de1a0ea 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -1,6 +1,8 @@
 #pragma once
 #include <apply.h>
+#include <binary.h>
 #include <cassert>
+#include <concat.h>
 #include <functional>
 #include <hardware_context.h>
 #include <layernorm.h>
@@ -10,6 +12,7 @@
 #include <tensor.h>
 #include <thread_context.h>
 #include <transpose.h>
+#include <unary.h>
 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
 #include <spdlog/spdlog.h>
 
@@ -21,12 +24,6 @@ template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &src) {
     return tensor<T, Loc>(src.data(), new_dims, new_strides);
 }
 
-template <class T, loc_t Loc>
-tensor<T, Loc> reshape(tensor<T, Loc> &src, gsl::span<size_t> new_shape) {
-    assert(compute_size(src.dimension()) == compute_size(new_shape));
-    return tensor<T, Loc>(src.data(), new_shape, get_default_strides(new_shape));
-}
-
 template <class T, loc_t Loc>
 tensor<T, Loc> view_transpose(tensor<T, Loc> &src, dims_t perm) {
     auto new_dims = dims_t();
@@ -73,52 +70,47 @@ void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
 }
 
 template <class T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-void __tensor_binary_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
-                          tensor<T, CLoc> &out,
-                          std::function<T(T a, T b)> callable) {
-    assert(a.dimension() == b.dimension());
-    assert(a.dimension() == out.dimension());
-    apply(gsl::make_span(a.dimension()).template as_span<const size_t>(),
-          [&](gsl::span<const size_t> index) -> void {
-              out.data()[offset(out.strides(), index)] =
-                  callable(a.data()[offset(a.strides(), index)],
-                           b.data()[offset(b.strides(), index)]);
-          });
+void binary(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &out,
+            binary_op_t op) {
+    kernels::binary(
+        op, a.cdata().data(), b.cdata().data(), out.data().data(),
+        gsl::make_span(a.dimension()).template as_span<const size_t>(),
+        gsl::make_span(a.strides()).template as_span<const size_t>(),
+        gsl::make_span(b.dimension()).template as_span<const size_t>(),
+        gsl::make_span(b.strides()).template as_span<const size_t>(),
+        gsl::make_span(out.dimension()).template as_span<const size_t>(),
+        gsl::make_span(out.strides()).template as_span<const size_t>());
 }
 
 template <class T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-void __tensor_unary_sync(tensor<T, ALoc> &a, tensor<T, CLoc> &out,
-                         std::function<T(T a)> callable) {
-    assert(a.dimension() == out.dimension());
-    apply(gsl::make_span(a.dimension()).template as_span<const size_t>(),
-          [&](gsl::span<const size_t> index) -> void {
-              out.data()[offset(out.strides(), index)] =
-                  callable(a.data()[offset(a.strides(), index)]);
-          });
+void unary(tensor<T, ALoc> &a, tensor<T, CLoc> &out, unary_op_t op) {
+    kernels::unary(
+        op, a.cdata().data(), out.data().data(),
+        gsl::make_span(a.strides()).template as_span<const size_t>(),
+        gsl::make_span(out.dimension()).template as_span<const size_t>(),
+        gsl::make_span(out.strides()).template as_span<const size_t>());
 }
 
 template <typename T, loc_t ALoc, loc_t BLoc>
-void tensor_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
-                     tensor<T, loc_t::local> &c) {
+void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
+            tensor<T, loc_t::local> &c) {
     matmul(a.cdata().data(), b.cdata().data(), c.data().data(), a.dimension(),
            a.strides(), b.dimension(), b.strides(), c.dimension(), c.strides());
 }
 
 template <typename T, loc_t ALoc, loc_t BLoc>
-void tensor_reduce_sync(tensor<T, ALoc> &input, tensor<T, BLoc> &output,
-                        reduce_op_t op, T init_value, dims_t axis,
-                        bool keep_dims) {
+void reduce(tensor<T, ALoc> &input, tensor<T, BLoc> &output, reduce_op_t op,
+            T init_value, dims_t axis, bool keep_dims) {
     kernels::reduce(op, &init_value, input.cdata().data(), output.data().data(),
                     input.dimension(), axis, input.strides(), output.strides(),
                     keep_dims);
 }
 
 template <typename T, loc_t Loc>
-void tensor_layernorm_sync(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
-                           tensor<T, loc_t::local> &sum_sqr,
-                           tensor<T, loc_t::local> &gamma,
-                           tensor<T, loc_t::local> &beta, T eps, int32_t axis,
-                           int32_t norm_size) {
+void layernorm(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
+               tensor<T, loc_t::local> &sum_sqr, tensor<T, loc_t::local> &gamma,
+               tensor<T, loc_t::local> &beta, T eps, int32_t axis,
+               int32_t norm_size) {
     assert(sum.strides() == sum_sqr.strides());
     assert(is_contiguous(sum.dimension(), sum.strides()));
     assert(gamma.strides() == beta.strides());
@@ -130,9 +122,9 @@ void tensor_layernorm_sync(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
 }
 
 template <typename T, loc_t Loc>
-void tensor_layernorm_sync(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
-                           tensor<T, loc_t::local> &sum_sqr, int32_t axis,
-                           int32_t norm_size) {
+void layernorm(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
+               tensor<T, loc_t::local> &sum_sqr, int32_t axis,
+               int32_t norm_size) {
     kernels::layernorm(input.data().data(), sum.data().data(),
                        sum_sqr.data().data(), static_cast<T *>(nullptr),
                        static_cast<T *>(nullptr), input.dimension(),
@@ -141,13 +133,34 @@ void tensor_layernorm_sync(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
 }
 
 template <typename T, loc_t ALoc>
-void tensor_reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
-                           tensor<T, loc_t::local> &sum_sqr) {
+void reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
+                    tensor<T, loc_t::local> &sum_sqr) {
     kernels::reduce_sum_and_sum_sqr(a.cdata().data(), sum.data().data(),
                                     sum_sqr.data().data(), a.dimension(),
                                     a.strides(), sum.strides());
 }
 
+template <typename T, loc_t BLoc>
+void concat(std::initializer_list<tensor<T, loc_t::local>> inits,
+            tensor<T, BLoc> &output, size_t axis) {
+    std::vector<const gsl::byte *const> inputs(inits.size());
+    std::vector<strides_t> in_strides(inits.size());
+    auto concat_dims = dims_t(inits.size(), 1);
+    for (size_t i = 0; i < inits.size(); ++i) {
+        if (inits[i].dimension().size() != 0) {
+            concat_dims[i] = inits[i].dimension()[axis];
+        }
+    }
+
+    for (auto &in : inits) {
+        inputs.push_back((const gsl::byte *const)(in.data().data()));
+        in_strides.push_back(in.strides());
+    }
+
+    kernels::concat(inputs, output.data().data(), output.dimension(),
+                    in_strides, output.strides(), axis, concat_dims);
+}
+
 /**
  * @brief Block 级别的 mma，每个 thread 执行自己的 mma，最终 psum 累加写入
  * shared memory
@@ -166,24 +179,20 @@ void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
                            tensor<T, loc_t::shared> &c, bool load_psum,
                            thread_context &ctx) {
     tensor<T> tmp(c.dimension());
-    tensor_mma_sync(a, b, tmp);
+    matmul(a, b, tmp);
 
     __tdma_block_sync_apply(
         [&](int visited) -> void {
             if (load_psum) {
-                __tensor_binary_sync<T, loc_t::local, loc_t::shared,
-                                     loc_t::shared>(
-                    tmp, c, c, [](T _a, T _b) -> T { return _a + _b; });
+                binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
+                    tmp, c, c, binary_op_t::add);
             } else {
                 if (visited == 1) {
-                    __tensor_binary_sync<T, loc_t::local, loc_t::shared,
-                                         loc_t::shared>(
-                        tmp, c, c,
-                        [](T _a, [[maybe_unused]] T _b) -> T { return _a; });
+                    binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
+                        tmp, c, c, binary_op_t::add);
                 } else {
-                    __tensor_binary_sync<T, loc_t::local, loc_t::shared,
-                                         loc_t::shared>(
-                        tmp, c, c, [](T _a, T _b) -> T { return _a + _b; });
+                    binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
+                        tmp, c, c, binary_op_t::add);
                 }
             }
         },
@@ -228,8 +237,10 @@ void tdma_store_async(tensor<T, SrcLoc> &src, tensor<T, loc_t::device> &&dest,
 }
 
 template <class T> void tdma_fill_async(tensor<T, loc_t::local> &src, T value) {
-    __tensor_unary_sync<T, loc_t::local, loc_t::local>(
-        src, src, [&value]([[maybe_unused]] T a) -> T { return value; });
+    apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
+          [&](gsl::span<const size_t> index) -> void {
+              src.data()[offset(src.strides(), index)] = value;
+          });
 }
 
 template <class T>
@@ -312,8 +323,8 @@ void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
                     auto reduced_shape = get_reduced_shape(
                         gather_tensor->dimension(), dims_t({0}), false);
                     reduced_tensor = new tensor<T>(reduced_shape);
-                    tensor_reduce_sync(*gather_tensor, *reduced_tensor,
-                                       reduce_op, (T)0, dims_t({0}), false);
+                    reduce(*gather_tensor, *reduced_tensor, reduce_op, (T)0,
+                           dims_t({0}), false);
                     delete gather_tensor;
                     global_hardware_ctx->global_var = reduced_tensor;
                 } else {
@@ -343,8 +354,8 @@ void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
                 auto viewed_gather_tensor =
                     view(*gather_tensor, new_dims, new_strides);
 
-                tensor_reduce_sync(viewed_gather_tensor, dest, reduce_op,
-                                   static_cast<T>(0), dims_t({0}), false);
+                reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
+                       dims_t({0}), false);
             },
             []() -> void {
                 auto reduced_tensor =
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index 10d716dade..2762c943b8 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -76,7 +76,7 @@ void stage1_kernel(
                        X({0, (bid * CORES + tid) * 256}, {384, 256}));
     tensor<float> r_sum({384});
     tensor<float> r_sum_sqr({384});
-    tensor_reduce_sum_sqr(xj, r_sum, r_sum_sqr);
+    reduce_sum_sqr(xj, r_sum, r_sum_sqr);
     tdma_all_reduce_async(r_sum, r_sum, reduce_op_t::sum,
                           reduce_strategy_t::all, ctx);
     tdma_all_reduce_async(r_sum_sqr, r_sum_sqr, reduce_op_t::sum,
@@ -90,7 +90,7 @@ void stage1_kernel(
     tdma_fill_async(gamma, 1.0f);
     tensor<float> beta({256});
     tdma_fill_async(beta, 0.0f);
-    tensor_layernorm_sync(xj, r_sum, r_sum_sqr, gamma, beta, 1e-5f, 1, 8192);
+    layernorm(xj, r_sum, r_sum_sqr, gamma, beta, 1e-5f, 1, 8192);
     tdma_store_async(xj, Norm({0, (bid * CORES + tid) * 256}, {384, 256}), ctx);
 
     // tensor_sum_sqr(xj, r_sum, r_sum_sqr);
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
index 407ff94ebd..be1819265a 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
@@ -56,7 +56,7 @@ void stage1_kernel(
     // 4. compute qk
     tensor<float> qih({8, 384, 128});
     // [384, 2048] x [8, 2048, 128] = [8, 384, 128]
-    tensor_mma_sync(xi, wqh, qih);
+    matmul(xi, wqh, qih);
     // [8, 384, 128] x [8, 128, 384] = [8, 384, 384]
     auto khT = view_transpose(kh, dims_t({0, 2, 1}));
     tensor_block_mma_sync(qih, khT, qkh, false, ctx);
@@ -88,7 +88,7 @@ void stage2_kernel(
     // 6. compute y
     tensor<float> yihT({8, 96, 128});
     // [8, 96, 384] x [8, 384, 128] = [8, 96, 128]
-    tensor_mma_sync(sih, vh, yihT);
+    matmul(sih, vh, yihT);
     // 下面的 transpose 可以在计算 yih 的过程中通过指定输出 stride
     // 无代价地做到。
     /* [96, 8, 128] -> [96, 1024] */
@@ -102,7 +102,7 @@ void stage2_kernel(
     //  @t, @b       @b, @l        @t, @l
     // note 如添加上mm的, 此时wm的n不能在thread上切, 只能多算一部分,
     // 计算结束后倒是可以继续在thread切.
-    tensor_mma_sync(yihv, wm, ym);
+    matmul(yihv, wm, ym);
     tdma_all_reduce_async(ym, ym, reduce_op_t::sum, reduce_strategy_t::by_block,
                           ctx);
     if (bid == 0) {
@@ -113,20 +113,17 @@ void stage2_kernel(
     tensor<float> sum({96});
     tensor<float> sum_sqr({96});
     auto xi = X({tid * 96, bid * 1024}, {96, 1024}); // [96, 1024]
-    std::function<float(float, float)> f = [](float a, float b) -> float {
-        return a + b;
-    };
     auto ym_b = ym({0, bid * 1024}, {96, 1024});
-    __tensor_binary_sync(xi, ym_b, ym_b, f);
+    binary(xi, ym_b, ym_b, binary_op_t::add);
     // yih = add_and_sum_sqr(yih, xi, sum, sum_sqr);
-    tensor_reduce_sum_sqr(ym_b, sum, sum_sqr);
+    reduce_sum_sqr(ym_b, sum, sum_sqr);
     // __tdma_all_reduce_async(sum, sum_sqr); // All blocks & threads reduce
     tdma_all_reduce_async(sum, sum, reduce_op_t::sum,
                           reduce_strategy_t::by_block, ctx);
     tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum,
                           reduce_strategy_t::by_block, ctx);
     tdma_wait(ctx);
-    tensor_layernorm_sync(ym_b, sum, sum_sqr, 1, 8192);
+    layernorm(ym_b, sum, sum_sqr, 1, 8192);
 
     tdma_store_async(ym_b, Norm({tid * 96, bid * 1024}, {96, 1024}), ctx);
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/cluster_def.h b/modules/cpu/src/runtime/cmodel/tests/demo3/cluster_def.h
new file mode 100644
index 0000000000..8fd5d84ed7
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/cluster_def.h
@@ -0,0 +1,171 @@
+#pragma once
+#include <hardware_context.h>
+#include <tdma.h>
+
+namespace block0 {
+#include "shared_def.h"
+constexpr size_t bid = 0;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block0
+
+namespace block1 {
+#include "shared_def.h"
+constexpr size_t bid = 1;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block1
+
+namespace block2 {
+#include "shared_def.h"
+constexpr size_t bid = 2;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block2
+
+namespace block3 {
+#include "shared_def.h"
+constexpr size_t bid = 3;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block3
+
+namespace block4 {
+#include "shared_def.h"
+constexpr size_t bid = 4;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block4
+
+namespace block5 {
+#include "shared_def.h"
+constexpr size_t bid = 5;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block5
+
+namespace block6 {
+#include "shared_def.h"
+constexpr size_t bid = 6;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block6
+
+namespace block7 {
+#include "shared_def.h"
+constexpr size_t bid = 7;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block7
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
new file mode 100644
index 0000000000..8a4188b79c
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
@@ -0,0 +1,67 @@
+import numpy as np
+from torch import nn
+import torch
+from scipy.special import softmax
+def layernorm(x:np.ndarray):
+    return nn.LayerNorm([x.shape[-1]], elementwise_affine=False)(torch.from_numpy(x)).detach().numpy()
+
+def swish(x:np.ndarray):
+    return x / (1 + np.exp(-x))
+
+
+hidden_in = np.random.rand(1, 384, 8192).astype(np.float32)
+attn_mask = np.random.rand(1, 1, 384, 384).astype(np.float32)
+position_ids = np.random.randint(0, 384, [1, 384])
+
+# np.random.rand(8192).astype(np.float32), np.random.rand(8192).astype(np.float32)
+v0 = layernorm(hidden_in) # f32[1,384,8192]
+v1 = (v0 @ np.random.rand(8192,8192).astype(np.float32)) # f32[1,384,8192]
+v2 = np.reshape(v1, [1,384,64,128]) # f32[1,384,64,128]
+v3 = np.transpose(v2, [0,2,1,3]) # f32[1,64,384,128]
+v4 = np.random.rand(384,128).astype(np.float32)[position_ids] #Gather(np.random.rand(384,128).astype(np.float32), 0, position_ids) # f32[1,384,128]
+v5 = np.reshape(v4, [1,1,384,128] ) # f32[1,1,384,128]
+v6 = (v3 * v5) # f32[1,64,384,128]
+v7 = v3[:,:,:,64:] # Slice(v3, const(i64[1] : {64L}), const(i64[1] : {9223372036854775807}), 3, 1) # f32[1,64,384,64]
+v8 = -(v7) # f32[1,64,384,64]
+v9 = v3[:,:,:,0:64] # Slice(v3, 0, 64, 3, 1) # f32[1,64,384,64]
+v10 = (v8, v9) # (f32[1,64,384,64], f32[1,64,384,64])
+
+v11 = np.concatenate(v10, -1) # f32[1,64,384,128]
+v12 = np.random.rand(384,128).astype(np.float32)[position_ids] #Gather(np.random.rand(384,128).astype(np.float32),0, position_ids) # f32[1,384,128]
+v13 = np.reshape(v12, [1,1,384,128]) # f32[1,1,384,128]
+v14 = (v11 * v13) # f32[1,64,384,128]
+v15 = (v6 + v14) # f32[1,64,384,128]
+v16 = (v0 @ np.random.rand(8192,8192).astype(np.float32)) # f32[1,384,8192]
+v17 = np.reshape(v16, [1,384,64,128]) # f32[1,384,64,128]
+v18 = np.transpose(v17, [0,2,1,3]) # f32[1,64,384,128]
+v19 = (v18 * v5) # f32[1,64,384,128]
+v20 = v18[:,:,:,64:] # Slice(v18, 64, 9223372036854775807, 3, 1) # f32[1,64,384,64]
+v21 = -(v20) # f32[1,64,384,64]
+v22 = v18[:,:,:,0:64]# Slice(v18, 0, 64, 3, 1) # f32[1,64,384,64]
+v23 = (v21, v22) # (f32[1,64,384,64], f32[1,64,384,64])
+
+v24 = np.concatenate(v23, -1) # f32[1,64,384,128]
+v25 = (v24 * v13) # f32[1,64,384,128]
+v26 = (v19 + v25) # f32[1,64,384,128]
+v27 = np.transpose(v26, [0,1,3,2]) # f32[1,64,128,384]
+v28 = (v15 @ v27) # f32[1,64,384,384]
+v29 = (v28/ 11.31370) # f32[1,64,384,384]
+v30 = (v29 + attn_mask) # f32[1,64,384,384]
+v31 = softmax(v30, -1) # f32[1,64,384,384]
+v32 = (v0 @ np.random.rand(8192,8192).astype(np.float32)) # f32[1,384,8192]
+v33 = np.reshape(v32, [1,384,64,128]) # f32[1,384,64,128]
+v34 = np.transpose(v33, [0,2,1,3]) # f32[1,64,384,128]
+v35 = (v31 @ v34) # f32[1,64,384,128]
+v36 = np.transpose(v35, [0,2,1,3]) # f32[1,384,64,128]
+v37 = np.reshape(v36, [1,384,8192]) # f32[1,384,8192]
+v38 = (v37 @ np.random.rand(8192,8192).astype(np.float32)) # f32[1,384,8192]
+v39 = (hidden_in + v38) # f32[1,384,8192]
+# np.random.rand(8192).astype(np.float32), np.random.rand(8192).astype(np.float32)
+v40 = layernorm(v39) # f32[1,384,8192]
+v41 = (v40 @ np.random.rand(8192,22016).astype(np.float32)) # f32[1,384,22016]
+v42 = swish(v41) # f32[1,384,22016]
+v43 = (v40 @ np.random.rand(8192,22016).astype(np.float32)) # f32[1,384,22016]
+v44 = (v42 * v43) # f32[1,384,22016]
+v45 = (v44 @ np.random.rand(22016,8192).astype(np.float32)) # f32[1,384,8192]
+v46 = (v39 + v45) # f32[1,384,8192]
+v46.tofile("")
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
new file mode 100644
index 0000000000..1a5f054ac6
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -0,0 +1,117 @@
+// llama 65B
+// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
+// 1 chips, 8 blocks per chip, 4 threads per block
+
+#include "thread_context.h"
+using namespace shared;
+
+static bool w_loaded;
+
+// 8 head per block
+// 2048 w-len per thread
+void stage1_kernel(
+    [[maybe_unused]] tensor<float, loc_t::device> &WQ, /* 64, 8192, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &WK, /* 64, 8192, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &WV, /* 64, 8192, 128 */
+    [[maybe_unused]] tensor<float, loc_t::device> &WM, /* 8192, 8192 */
+    [[maybe_unused]] tensor<float, loc_t::device> &QKH /* 64,384,384 */
+) {
+    thread_context ctx(bid, tid);
+    // 1. Get xi
+    auto xi = X({0, tid * 2048}, {384, 2048}); // [384, 2048]
+
+    // 2. load wqh wkh wvh
+    if (!w_loaded) {
+        tdma_load_async(wqh, WQ({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
+        tdma_load_async(wkh, WK({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
+        tdma_load_async(wvh, WV({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
+        tdma_load_async(wm, WM({bid * 1024, 0}, {1024, 8192}), ctx);
+        // tdma_load_async(wfc1ih, WFC1({bid * 1024, tid * 8192}, {1024,
+        // 8192}));
+        tdma_wait(ctx); // 等待 x, wqh, wkh, wvh ready
+        w_loaded = true;
+    }
+    // 3. compute k, v
+    set_sched_strategy(sched_strategy_t::pin_block_tensor);
+    // 仅在 block 内调度线程的 tensor
+    // 指令
+
+    // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
+    tensor_block_mma_sync(xi, wkh, kh, false, ctx);
+    // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
+    tensor_block_mma_sync(xi, wvh, vh, false, ctx);
+
+    // 4. compute qk
+    tensor<float> qih({8, 384, 128});
+    // [384, 2048] x [8, 2048, 128] = [8, 384, 128]
+    matmul(xi, wqh, qih);
+    // [8, 384, 128] x [8, 128, 384] = [8, 384, 384]
+    auto khT = view_transpose(kh, dims_t({0, 2, 1}));
+    tensor_block_mma_sync(qih, khT, qkh, false, ctx);
+
+    set_sched_strategy(sched_strategy_t::normal);
+    if (tid == 0) {
+        tdma_store_async(qkh, QKH({bid * 8, 0, 0}, {8, 384, 384}), ctx);
+    }
+    tdma_wait(ctx);
+}
+
+// 8 head per block
+// 96 seq-len per thread
+void stage2_kernel(
+    [[maybe_unused]] tensor<float, loc_t::device> &Norm,    /* 8192, 8192 */
+    [[maybe_unused]] tensor<float, loc_t::device> &Softmax, /* 64,384,384 */
+    [[maybe_unused]] tensor<float, loc_t::device> &YM       /* 384,8192 */
+) {
+    thread_context ctx(bid, tid);
+    // 5. compute softmax
+    auto qkhi = qkh({0, tid * 96, 0}, {8, 96, 384});
+
+    tensor<float> sih({8, 96, 384});
+    softmax(qkhi, sih, 2);
+
+    tdma_store_async(sih, Softmax({bid * 8, tid * 96, 0}, {8, 96, 384}), ctx);
+    tdma_wait(ctx);
+
+    // 6. compute y
+    tensor<float> yihT({8, 96, 128});
+    // [8, 96, 384] x [8, 384, 128] = [8, 96, 128]
+    matmul(sih, vh, yihT);
+    // 下面的 transpose 可以在计算 yih 的过程中通过指定输出 stride
+    // 无代价地做到。
+    /* [96, 8, 128] -> [96, 1024] */
+    tensor<float> yih({96, 8, 128});
+    transpose(yihT, yih, dims_t({1, 0, 2}));
+    auto yihv = view(yih, dims_t({96, 1024}));
+
+    tensor<float> ym({96, 8192});
+
+    // [96,1024] * [1024,8192] -> [96, 8192]
+    //  @t, @b       @b, @l        @t, @l
+    // note 如添加上mm的, 此时wm的n不能在thread上切, 只能多算一部分,
+    // 计算结束后倒是可以继续在thread切.
+    matmul(yihv, wm, ym);
+    tdma_all_reduce_async(ym, ym, reduce_op_t::sum, reduce_strategy_t::by_block,
+                          ctx);
+    if (bid == 0) {
+        tdma_store_async(ym, YM({tid * 96, 0}, {96, 8192}), ctx);
+    }
+
+    // 7. Add and sum & sqr
+    tensor<float> sum({96});
+    tensor<float> sum_sqr({96});
+    auto xi = X({tid * 96, bid * 1024}, {96, 1024}); // [96, 1024]
+    auto ym_b = ym({0, bid * 1024}, {96, 1024});
+    binary(xi, ym_b, ym_b, binary_op_t::add);
+    // yih = add_and_sum_sqr(yih, xi, sum, sum_sqr);
+    reduce_sum_sqr(ym_b, sum, sum_sqr);
+    // __tdma_all_reduce_async(sum, sum_sqr); // All blocks & threads reduce
+    tdma_all_reduce_async(sum, sum, reduce_op_t::sum,
+                          reduce_strategy_t::by_block, ctx);
+    tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum,
+                          reduce_strategy_t::by_block, ctx);
+    tdma_wait(ctx);
+    layernorm(ym_b, sum, sum_sqr, 1, 8192);
+
+    tdma_store_async(ym_b, Norm({tid * 96, bid * 1024}, {96, 1024}), ctx);
+}
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
new file mode 100644
index 0000000000..193af3b0ce
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -0,0 +1,164 @@
+#include "cluster_def.h"
+#include <io_utils.h>
+#include <runtime_utils.h>
+// #include <pthread.h>
+
+#define DEFINE_TFUNC(b, t)                                                     \
+    void *f_##b##_##t(void *arg) {                                             \
+        block##b::thread##t::stage1_kernel(WQ, WK, WV, WM, QKH);               \
+        block##b::thread##t::stage2_kernel(Norm, Softmax, YM);                 \
+        return arg;                                                            \
+    }
+
+#define DEFINE_BFUNC(b)                                                        \
+    DEFINE_TFUNC(b, 0)                                                         \
+    DEFINE_TFUNC(b, 1)                                                         \
+    DEFINE_TFUNC(b, 2)                                                         \
+    DEFINE_TFUNC(b, 3)
+
+tensor<float, loc_t::device> WQ({64, 8192, 128});
+tensor<float, loc_t::device> WK({64, 8192, 128});
+tensor<float, loc_t::device> WV({64, 8192, 128});
+tensor<float, loc_t::device> WM({8192, 8192});
+tensor<float, loc_t::device> QKH({64, 384, 384});
+tensor<float, loc_t::device> Softmax({64, 384, 384});
+tensor<float, loc_t::device> YM({384, 8192});
+tensor<float, loc_t::device> Norm({384, 8192});
+
+DEFINE_BFUNC(0)
+DEFINE_BFUNC(1)
+DEFINE_BFUNC(2)
+DEFINE_BFUNC(3)
+DEFINE_BFUNC(4)
+DEFINE_BFUNC(5)
+DEFINE_BFUNC(6)
+DEFINE_BFUNC(7)
+
+/**
+ * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
+ *
+ * @param argc
+ * @param argv
+ * @return int
+ */
+int main([[maybe_unused]] int argc, char **argv) {
+    // spdlog::set_level(spdlog::level::debug);
+    global_hardware_init();
+
+    /* fill tensor */
+    auto src_X = read_file(std::string(argv[1]));
+    auto src_WQ = read_file(std::string(argv[2]));
+    auto src_WK = read_file(std::string(argv[3]));
+    auto src_WV = read_file(std::string(argv[4]));
+    auto src_WM = read_file(std::string(argv[5]));
+    auto src_Norm = read_file(std::string(argv[6]));
+    auto src_QKH = read_file(std::string(argv[7]));
+    auto src_Softmax = read_file(std::string(argv[8]));
+    auto src_YM = read_file(std::string(argv[9]));
+    span_copy(WQ.data(), gsl::make_span(src_WQ).as_span<float>());
+    span_copy(WK.data(), gsl::make_span(src_WK).as_span<float>());
+    span_copy(WV.data(), gsl::make_span(src_WV).as_span<float>());
+    span_copy(WM.data(), gsl::make_span(src_WM).as_span<float>());
+    span_copy(block0::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block1::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block2::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block3::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block4::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block5::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block6::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    span_copy(block7::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+
+    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
+
+    pthread_create(&t_0_0, NULL, f_0_0, NULL);
+    pthread_create(&t_0_1, NULL, f_0_1, NULL);
+    pthread_create(&t_0_2, NULL, f_0_2, NULL);
+    pthread_create(&t_0_3, NULL, f_0_3, NULL);
+    pthread_create(&t_1_0, NULL, f_1_0, NULL);
+    pthread_create(&t_1_1, NULL, f_1_1, NULL);
+    pthread_create(&t_1_2, NULL, f_1_2, NULL);
+    pthread_create(&t_1_3, NULL, f_1_3, NULL);
+    pthread_create(&t_2_0, NULL, f_2_0, NULL);
+    pthread_create(&t_2_1, NULL, f_2_1, NULL);
+    pthread_create(&t_2_2, NULL, f_2_2, NULL);
+    pthread_create(&t_2_3, NULL, f_2_3, NULL);
+    pthread_create(&t_3_0, NULL, f_3_0, NULL);
+    pthread_create(&t_3_1, NULL, f_3_1, NULL);
+    pthread_create(&t_3_2, NULL, f_3_2, NULL);
+    pthread_create(&t_3_3, NULL, f_3_3, NULL);
+    pthread_create(&t_4_0, NULL, f_4_0, NULL);
+    pthread_create(&t_4_1, NULL, f_4_1, NULL);
+    pthread_create(&t_4_2, NULL, f_4_2, NULL);
+    pthread_create(&t_4_3, NULL, f_4_3, NULL);
+    pthread_create(&t_5_0, NULL, f_5_0, NULL);
+    pthread_create(&t_5_1, NULL, f_5_1, NULL);
+    pthread_create(&t_5_2, NULL, f_5_2, NULL);
+    pthread_create(&t_5_3, NULL, f_5_3, NULL);
+    pthread_create(&t_6_0, NULL, f_6_0, NULL);
+    pthread_create(&t_6_1, NULL, f_6_1, NULL);
+    pthread_create(&t_6_2, NULL, f_6_2, NULL);
+    pthread_create(&t_6_3, NULL, f_6_3, NULL);
+    pthread_create(&t_7_0, NULL, f_7_0, NULL);
+    pthread_create(&t_7_1, NULL, f_7_1, NULL);
+    pthread_create(&t_7_2, NULL, f_7_2, NULL);
+    pthread_create(&t_7_3, NULL, f_7_3, NULL);
+
+    pthread_join(t_0_0, NULL);
+    pthread_join(t_0_1, NULL);
+    pthread_join(t_0_2, NULL);
+    pthread_join(t_0_3, NULL);
+    pthread_join(t_1_0, NULL);
+    pthread_join(t_1_1, NULL);
+    pthread_join(t_1_2, NULL);
+    pthread_join(t_1_3, NULL);
+    pthread_join(t_2_0, NULL);
+    pthread_join(t_2_1, NULL);
+    pthread_join(t_2_2, NULL);
+    pthread_join(t_2_3, NULL);
+    pthread_join(t_3_0, NULL);
+    pthread_join(t_3_1, NULL);
+    pthread_join(t_3_2, NULL);
+    pthread_join(t_3_3, NULL);
+    pthread_join(t_4_0, NULL);
+    pthread_join(t_4_1, NULL);
+    pthread_join(t_4_2, NULL);
+    pthread_join(t_4_3, NULL);
+    pthread_join(t_5_0, NULL);
+    pthread_join(t_5_1, NULL);
+    pthread_join(t_5_2, NULL);
+    pthread_join(t_5_3, NULL);
+    pthread_join(t_6_0, NULL);
+    pthread_join(t_6_1, NULL);
+    pthread_join(t_6_2, NULL);
+    pthread_join(t_6_3, NULL);
+    pthread_join(t_7_0, NULL);
+    pthread_join(t_7_1, NULL);
+    pthread_join(t_7_2, NULL);
+    pthread_join(t_7_3, NULL);
+
+    auto cos = cosine(QKH.data().begin(),
+                 gsl::make_span(src_QKH).as_span<float>().begin(),
+                 QKH.data().size());
+    printf("QKH cosine %f\n", cos);
+
+    cos = cosine(Softmax.data().begin(),
+                 gsl::make_span(src_Softmax).as_span<float>().begin(),
+                 Softmax.data().size());
+    printf("Softmax cosine %f\n", cos);
+
+    cos = cosine(YM.data().begin(),
+                 gsl::make_span(src_YM).as_span<float>().begin(),
+                 YM.data().size());
+    printf("YM cosine %f\n", cos);
+
+    to_file(Norm.data(),"ONorm.bin");
+
+    cos = cosine(Norm.data().begin(),
+                      gsl::make_span(src_Norm).as_span<float>().begin(),
+                      Norm.data().size());
+    printf("Norm cosine %f\n", cos);
+    return 0;
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
new file mode 100644
index 0000000000..8dbca0cd80
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
@@ -0,0 +1,9 @@
+#include <tdma.h>
+
+namespace shared {
+static tensor<float, loc_t::shared> X({384, 8192});
+static tensor<float, loc_t::shared> kh({8, 384, 128});
+static tensor<float, loc_t::shared> vh({8, 384, 128});  // []
+static tensor<float, loc_t::shared> qkh({8, 384, 384}); // []
+static tensor<float, loc_t::shared> mh({8, 384, 384});  // []
+} // namespace shared
\ No newline at end of file

From 64158a50df6edfd4e47404876b66305939258e43 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 25 Aug 2023 14:40:55 +0800
Subject: [PATCH 121/308] add demo3 compute statge 1

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |   1 +
 .../cpu/src/runtime/cmodel/include/matmul.h   |   5 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h |  72 ++++++++-
 .../src/runtime/cmodel/tests/demo3/golden.py  | 108 +++++++-------
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 140 +++++-------------
 .../src/runtime/cmodel/tests/demo3/main.cpp   |  76 +++-------
 .../runtime/cmodel/tests/demo3/shared_def.h   |   6 +-
 7 files changed, 189 insertions(+), 219 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index aee0c67f77..be86f9b262 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -23,3 +23,4 @@ endfunction(add_test)
 
 add_test(demo1 tests/demo1)
 add_test(demo2 tests/demo2)
+add_test(demo3 tests/demo3)
diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
index e5294f75e5..9aeb902448 100644
--- a/modules/cpu/src/runtime/cmodel/include/matmul.h
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -1,5 +1,7 @@
 #include "runtime_utils.h"
 
+namespace kernels {
+
 namespace {
 template <typename T>
 void matmul_unit_impl(const T *input_a, const T *input_b, T *output,
@@ -138,4 +140,5 @@ void matmul(const T *input_a, const T *input_b, T *output, dims_t in_a_dims,
             gsl::make_span(output_dims).template as_span<const size_t>(),
             gsl::make_span(output_strides).template as_span<const size_t>());
     }
-}
\ No newline at end of file
+}
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index f45de1a0ea..2d3498b7de 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -4,6 +4,7 @@
 #include <cassert>
 #include <concat.h>
 #include <functional>
+#include <gather.h>
 #include <hardware_context.h>
 #include <layernorm.h>
 #include <matmul.h>
@@ -94,8 +95,9 @@ void unary(tensor<T, ALoc> &a, tensor<T, CLoc> &out, unary_op_t op) {
 template <typename T, loc_t ALoc, loc_t BLoc>
 void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
             tensor<T, loc_t::local> &c) {
-    matmul(a.cdata().data(), b.cdata().data(), c.data().data(), a.dimension(),
-           a.strides(), b.dimension(), b.strides(), c.dimension(), c.strides());
+    kernels::matmul(a.cdata().data(), b.cdata().data(), c.data().data(),
+                    a.dimension(), a.strides(), b.dimension(), b.strides(),
+                    c.dimension(), c.strides());
 }
 
 template <typename T, loc_t ALoc, loc_t BLoc>
@@ -106,6 +108,15 @@ void reduce(tensor<T, ALoc> &input, tensor<T, BLoc> &output, reduce_op_t op,
                     keep_dims);
 }
 
+template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
+void gather(tensor<T, ALoc> &input, tensor<int64_t, BLoc> &indices,
+            tensor<T, CLoc> &output, int axis) {
+    kernels::gather<T, int64_t>(
+        input.cdata().data(), output.data().data(), input.dimension(),
+        input.strides(), output.dimension(), output.strides(),
+        indices.data().data(), indices.dimension(), axis);
+}
+
 template <typename T, loc_t Loc>
 void layernorm(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
                tensor<T, loc_t::local> &sum_sqr, tensor<T, loc_t::local> &gamma,
@@ -261,8 +272,56 @@ void tdma_load_broadcast_async([[maybe_unused]] tensor<T, Dest> &dest,
     throw std::system_error(std::make_error_code(std::errc::not_supported));
 }
 
-void tdma_reduce_async() {
-    throw std::system_error(std::make_error_code(std::errc::not_supported));
+template <class T>
+void tdma_reduce_async(tensor<T, loc_t::local> &src,
+                       tensor<T, loc_t::local> &dest, reduce_op_t reduce_op,
+                       thread_context &ctx) {
+    __tdma_all_sync_apply(
+        [&src, &ctx](int visited) -> void {
+            tensor<T> *gather_tensor = nullptr;
+            auto new_dims = dims_t(src.dimension());
+            new_dims.insert(new_dims.begin(), BLOCKS * CORES);
+            if (visited == 1) {
+                if (global_hardware_ctx->global_var != nullptr) {
+                    throw std::runtime_error(" the global var has been used!");
+                }
+                gather_tensor = new tensor<T>(new_dims);
+                global_hardware_ctx->global_var = (void *)gather_tensor;
+            } else {
+                gather_tensor =
+                    static_cast<tensor<T> *>(global_hardware_ctx->global_var);
+            }
+            dims_t begin(new_dims.size(), 0);
+            dims_t shape(new_dims);
+            begin[0] = ctx.bid() * CORES + ctx.tid();
+            shape[0] = 1;
+            __tensor_copy_sync<T, loc_t::local, loc_t::local>(
+                std::move((*gather_tensor)(begin, shape)),
+                std::move(unsqueeze(src)));
+        },
+        []() -> void {}, ctx);
+
+    __tdma_all_sync_apply(
+        [&]([[maybe_unused]] int visit) -> void {
+            tensor<T> *gather_tensor =
+                static_cast<tensor<T> *>(global_hardware_ctx->global_var);
+            auto new_dims = dims_t(src.dimension());
+            new_dims[0] = CORES;
+            auto viewed_gather_tensor =
+                tensor<T>(gather_tensor->data().subspan(
+                              ctx.bid() * CORES * gather_tensor->strides()[0]),
+                          new_dims, gather_tensor->strides());
+
+            reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
+                   dims_t({0}), false);
+        },
+        []() -> void {
+            auto reduced_tensor =
+                static_cast<tensor<T> *>(global_hardware_ctx->global_var);
+            delete reduced_tensor;
+            global_hardware_ctx->global_var = nullptr;
+        },
+        ctx);
 }
 
 enum class reduce_strategy_t : uint8_t {
@@ -279,7 +338,8 @@ enum class reduce_strategy_t : uint8_t {
  * @param src local tensor
  * @param dest local tensor
  * @param reduce_op op
- * @param strategy  all = reduce [8*4], pre_block = reduce [8*1] .
+ * @param strategy  all = reduce [8*4], out=[0], pre_block = reduce [8*1],
+ * out=[4] .
  * @param axis axis of gather tensor, note gather tensor dims = [32,...]
  * @param ctx
  */
@@ -348,7 +408,7 @@ void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
                 tensor<T> *gather_tensor =
                     static_cast<tensor<T> *>(global_hardware_ctx->global_var);
                 auto new_dims = dims_t(src.dimension());
-                new_dims.insert(new_dims.begin(), 8);
+                new_dims.insert(new_dims.begin(), BLOCKS);
                 auto new_strides = dims_t(gather_tensor->strides());
                 new_strides[0] *= CORES;
                 auto viewed_gather_tensor =
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
index 8a4188b79c..dd5d5176d6 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
@@ -12,56 +12,58 @@ def swish(x:np.ndarray):
 hidden_in = np.random.rand(1, 384, 8192).astype(np.float32)
 attn_mask = np.random.rand(1, 1, 384, 384).astype(np.float32)
 position_ids = np.random.randint(0, 384, [1, 384])
-
-# np.random.rand(8192).astype(np.float32), np.random.rand(8192).astype(np.float32)
-v0 = layernorm(hidden_in) # f32[1,384,8192]
-v1 = (v0 @ np.random.rand(8192,8192).astype(np.float32)) # f32[1,384,8192]
-v2 = np.reshape(v1, [1,384,64,128]) # f32[1,384,64,128]
-v3 = np.transpose(v2, [0,2,1,3]) # f32[1,64,384,128]
-v4 = np.random.rand(384,128).astype(np.float32)[position_ids] #Gather(np.random.rand(384,128).astype(np.float32), 0, position_ids) # f32[1,384,128]
-v5 = np.reshape(v4, [1,1,384,128] ) # f32[1,1,384,128]
-v6 = (v3 * v5) # f32[1,64,384,128]
-v7 = v3[:,:,:,64:] # Slice(v3, const(i64[1] : {64L}), const(i64[1] : {9223372036854775807}), 3, 1) # f32[1,64,384,64]
-v8 = -(v7) # f32[1,64,384,64]
-v9 = v3[:,:,:,0:64] # Slice(v3, 0, 64, 3, 1) # f32[1,64,384,64]
-v10 = (v8, v9) # (f32[1,64,384,64], f32[1,64,384,64])
-
-v11 = np.concatenate(v10, -1) # f32[1,64,384,128]
-v12 = np.random.rand(384,128).astype(np.float32)[position_ids] #Gather(np.random.rand(384,128).astype(np.float32),0, position_ids) # f32[1,384,128]
-v13 = np.reshape(v12, [1,1,384,128]) # f32[1,1,384,128]
-v14 = (v11 * v13) # f32[1,64,384,128]
-v15 = (v6 + v14) # f32[1,64,384,128]
-v16 = (v0 @ np.random.rand(8192,8192).astype(np.float32)) # f32[1,384,8192]
-v17 = np.reshape(v16, [1,384,64,128]) # f32[1,384,64,128]
-v18 = np.transpose(v17, [0,2,1,3]) # f32[1,64,384,128]
-v19 = (v18 * v5) # f32[1,64,384,128]
-v20 = v18[:,:,:,64:] # Slice(v18, 64, 9223372036854775807, 3, 1) # f32[1,64,384,64]
-v21 = -(v20) # f32[1,64,384,64]
-v22 = v18[:,:,:,0:64]# Slice(v18, 0, 64, 3, 1) # f32[1,64,384,64]
-v23 = (v21, v22) # (f32[1,64,384,64], f32[1,64,384,64])
-
-v24 = np.concatenate(v23, -1) # f32[1,64,384,128]
-v25 = (v24 * v13) # f32[1,64,384,128]
-v26 = (v19 + v25) # f32[1,64,384,128]
-v27 = np.transpose(v26, [0,1,3,2]) # f32[1,64,128,384]
-v28 = (v15 @ v27) # f32[1,64,384,384]
-v29 = (v28/ 11.31370) # f32[1,64,384,384]
-v30 = (v29 + attn_mask) # f32[1,64,384,384]
-v31 = softmax(v30, -1) # f32[1,64,384,384]
-v32 = (v0 @ np.random.rand(8192,8192).astype(np.float32)) # f32[1,384,8192]
-v33 = np.reshape(v32, [1,384,64,128]) # f32[1,384,64,128]
-v34 = np.transpose(v33, [0,2,1,3]) # f32[1,64,384,128]
-v35 = (v31 @ v34) # f32[1,64,384,128]
-v36 = np.transpose(v35, [0,2,1,3]) # f32[1,384,64,128]
-v37 = np.reshape(v36, [1,384,8192]) # f32[1,384,8192]
-v38 = (v37 @ np.random.rand(8192,8192).astype(np.float32)) # f32[1,384,8192]
-v39 = (hidden_in + v38) # f32[1,384,8192]
-# np.random.rand(8192).astype(np.float32), np.random.rand(8192).astype(np.float32)
-v40 = layernorm(v39) # f32[1,384,8192]
-v41 = (v40 @ np.random.rand(8192,22016).astype(np.float32)) # f32[1,384,22016]
-v42 = swish(v41) # f32[1,384,22016]
-v43 = (v40 @ np.random.rand(8192,22016).astype(np.float32)) # f32[1,384,22016]
-v44 = (v42 * v43) # f32[1,384,22016]
-v45 = (v44 @ np.random.rand(22016,8192).astype(np.float32)) # f32[1,384,8192]
-v46 = (v39 + v45) # f32[1,384,8192]
-v46.tofile("")
\ No newline at end of file
+v0_gamma [8192] [8192] 
+v0_beta [8192] [8192] 
+v37_gamma [8192] [8192] 
+v37_beta [8192] [8192] 
+v2_w [64, 8192, 128] [8@b, 2048@t, 128] 
+v3_data [384, 128] [384, 128] 
+v11_data [384, 128] [384, 128] 
+v16_w [64, 8192, 128] [8@b, 2048@t, 128] 
+v31_w [64, 8192, 128] [8@b, 2048@t, 128] 
+v35_w [8192, 8192] [1024@b, 2048@t] 
+v38_w [8192, 22016] [1024@b, 5504@t] 
+v40_w [8192, 22016] [1024@b, 5504@t] 
+v42_w [22016, 8192] [2752@b, 2048@t] 
+v0 = nn.functional.layer_norm(var_5, [8192], self.v0_gamma, self.v0_beta) # v0 [1, 384, 8192] [1, 48@b, 8192] 
+v1 = flow.unsqueeze(v0, 1)  # v1 [1, 1, 384, 8192] [1, 1, 48@b, 8192] 
+v2 = flow.matmul(v1, self.v2_w)  # v2 [1, 64, 384, 128] [1, 8@b, 384, 128] 
+v3 = self.v3_data[var_6]  # Gather(const(f32[384,128]), const(i64 : 0), )# v3 [1, 384, 128] [1, 384, 128] 
+v4 = flow.reshape(v3, [1, 1, 384, 128])  # v4 [1, 1, 384, 128] [1, 1, 384, 128] 
+v5 = flow.mul(v2, v4)  # v5 [1, 64, 384, 128] [1, 8@b, 384, 128] 
+v6 = v2[:, :, :, 64:]  # v6 [1, 64, 384, 64] [1, 8@b, 384, 64] 
+v7 = -v6  # v7 [1, 64, 384, 64] [1, 8@b, 384, 16@t] 
+v8 = v2[:, :, :, :64]  # v8 [1, 64, 384, 64] [1, 8@b, 384, 64] 
+v10 = flow.concat(v9, -1)  # v10 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
+v11 = self.v11_data[var_6] # v11 [1, 384, 128] [1, 384, 128] 
+v12 = flow.reshape(v11, [1, 1, 384, 128])  # v12 [1, 1, 384, 128] [1, 1, 384, 128] 
+v13 = flow.mul(v10, v12)  # v13 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
+v14 = flow.add(v5, v13)  # v14 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
+v15 = flow.unsqueeze(v0, 1)  # v15 [1, 1, 384, 8192] [1, 1, 48@b, 8192] 
+v16 = flow.matmul(v15, self.v16_w)  # v16 [1, 64, 384, 128] [1, 8@b, 384, 128] 
+v17 = flow.mul(v16, v4)  # v17 [1, 64, 384, 128] [1, 8@b, 384, 128] 
+v18 = v16[:, :, :, 64:] # v18 [1, 64, 384, 64] [1, 8@b, 384, 64] 
+v19 = flow.neg(v18)  # v19 [1, 64, 384, 64] [1, 8@b, 384, 16@t] 
+v20 = v16[:, :, :, 0:64] # v20 [1, 64, 384, 64] [1, 8@b, 384, 64] 
+v22 = flow.concat(v21, -1)  # v22 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
+v23 = flow.mul(v22, v12)  # v23 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
+v24 = flow.add(v17, v23)  # v24 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
+v25 = flow.transpose(v24, [0, 1, 3, 2])  # v25 [1, 64, 128, 384] [1, 8@b, 128, 96@t] 
+v26 = flow.matmul(v14, v25)  # v26 [1, 64, 384, 384] [1, 8@b, 384, 384] 
+v27 = flow.div(v26, 11.313708)  # v27 [1, 64, 384, 384] [1, 8@b, 384, 384] 
+v28 = flow.add(v27, var_7)  # v28 [1, 64, 384, 384] [1, 8@b, 384, 384] 
+v29 = flow.softmax(v28, -1)  # v29 [1, 64, 384, 384] [1, 8@b, 96@t, 384] 
+v30 = flow.unsqueeze(v0, 1)  # v30 [1, 1, 384, 8192] [1, 1, 48@b, 8192] 
+v31 = flow.matmul(v30, self.v31_w)  # v31 [1, 64, 384, 128] [1, 8@b, 384, 128] 
+v32 = flow.matmul(v29, v31)  # v32 [1, 64, 384, 128] [1, 8@b, 384, 128] 
+v33 = flow.transpose(v32, [0, 2, 1, 3])  # v33 [1, 384, 64, 128] [1, 384, 8@b, 128] 
+v34 = flow.reshape(v33, [1, 384, 8192]) # v34 [1, 384, 8192] [1, 384, 1024@b] 
+v35 = flow.matmul(v34, self.v35_w) # v35 [1, 384, 8192] [1, 384, 8192] 
+v36 = flow.add(var_5, v35) # v36 [1, 384, 8192] [1, 12@b@t, 8192] 
+v37 = nn.functional.layer_norm(v36, [8192], self.v37_gamma, self.v37_beta) # v37 [1, 384, 8192] [1, 12@b@t, 8192] 
+v38 = flow.matmul(v37, self.v38_w) # v38 [1, 384, 22016] [1, 384, 5504@t] 
+v39 = nn.functional.silu(v38) # v39 [1, 384, 22016] [1, 48@b, 5504@t] 
+v40 = flow.matmul(v37, self.v40_w) # v40 [1, 384, 22016] [1, 384, 5504@t] 
+v41 = flow.mul(v39, v40) # v41 [1, 384, 22016] [1, 384, 5504@t] 
+v42 = flow.matmul(v41, self.v42_w) # v42 [1, 384, 8192] [1, 384, 8192] 
+v43 = flow.add(v36, v42) # v43 [1, 384, 8192] [1, 12@b@t, 8192] 
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index 1a5f054ac6..1572c9a14b 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -6,112 +6,48 @@
 using namespace shared;
 
 static bool w_loaded;
-
-// 8 head per block
-// 2048 w-len per thread
-void stage1_kernel(
-    [[maybe_unused]] tensor<float, loc_t::device> &WQ, /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &WK, /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &WV, /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &WM, /* 8192, 8192 */
-    [[maybe_unused]] tensor<float, loc_t::device> &QKH /* 64,384,384 */
+static tensor<float> v2_w({8, 2048, 128});
+static tensor<float> v3_data({384, 128});
+static tensor<int64_t> position_ids({1, 384});
+
+void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
+                   tensor<float, loc_t::device> &V0_gamma,
+                   tensor<float, loc_t::device> &V0_beta,
+                   tensor<float, loc_t::device> &V2_w,    /* [64, 8192, 128] */
+                   tensor<float, loc_t::device> &V3_data, /* [384, 128] */
+                   tensor<int64_t, loc_t::device> &Position_ids /* [1,384] */
 ) {
     thread_context ctx(bid, tid);
-    // 1. Get xi
-    auto xi = X({0, tid * 2048}, {384, 2048}); // [384, 2048]
+    tensor<float> v0_gamma({2048});
+    tensor<float> v0_beta({2048});
+    tensor<float> v0({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t]  */
 
-    // 2. load wqh wkh wvh
     if (!w_loaded) {
-        tdma_load_async(wqh, WQ({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
-        tdma_load_async(wkh, WK({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
-        tdma_load_async(wvh, WV({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
-        tdma_load_async(wm, WM({bid * 1024, 0}, {1024, 8192}), ctx);
-        // tdma_load_async(wfc1ih, WFC1({bid * 1024, tid * 8192}, {1024,
-        // 8192}));
-        tdma_wait(ctx); // 等待 x, wqh, wkh, wvh ready
-        w_loaded = true;
-    }
-    // 3. compute k, v
-    set_sched_strategy(sched_strategy_t::pin_block_tensor);
-    // 仅在 block 内调度线程的 tensor
-    // 指令
-
-    // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
-    tensor_block_mma_sync(xi, wkh, kh, false, ctx);
-    // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
-    tensor_block_mma_sync(xi, wvh, vh, false, ctx);
-
-    // 4. compute qk
-    tensor<float> qih({8, 384, 128});
-    // [384, 2048] x [8, 2048, 128] = [8, 384, 128]
-    matmul(xi, wqh, qih);
-    // [8, 384, 128] x [8, 128, 384] = [8, 384, 384]
-    auto khT = view_transpose(kh, dims_t({0, 2, 1}));
-    tensor_block_mma_sync(qih, khT, qkh, false, ctx);
-
-    set_sched_strategy(sched_strategy_t::normal);
-    if (tid == 0) {
-        tdma_store_async(qkh, QKH({bid * 8, 0, 0}, {8, 384, 384}), ctx);
-    }
-    tdma_wait(ctx);
-}
-
-// 8 head per block
-// 96 seq-len per thread
-void stage2_kernel(
-    [[maybe_unused]] tensor<float, loc_t::device> &Norm,    /* 8192, 8192 */
-    [[maybe_unused]] tensor<float, loc_t::device> &Softmax, /* 64,384,384 */
-    [[maybe_unused]] tensor<float, loc_t::device> &YM       /* 384,8192 */
-) {
-    thread_context ctx(bid, tid);
-    // 5. compute softmax
-    auto qkhi = qkh({0, tid * 96, 0}, {8, 96, 384});
-
-    tensor<float> sih({8, 96, 384});
-    softmax(qkhi, sih, 2);
-
-    tdma_store_async(sih, Softmax({bid * 8, tid * 96, 0}, {8, 96, 384}), ctx);
-    tdma_wait(ctx);
-
-    // 6. compute y
-    tensor<float> yihT({8, 96, 128});
-    // [8, 96, 384] x [8, 384, 128] = [8, 96, 128]
-    matmul(sih, vh, yihT);
-    // 下面的 transpose 可以在计算 yih 的过程中通过指定输出 stride
-    // 无代价地做到。
-    /* [96, 8, 128] -> [96, 1024] */
-    tensor<float> yih({96, 8, 128});
-    transpose(yihT, yih, dims_t({1, 0, 2}));
-    auto yihv = view(yih, dims_t({96, 1024}));
-
-    tensor<float> ym({96, 8192});
-
-    // [96,1024] * [1024,8192] -> [96, 8192]
-    //  @t, @b       @b, @l        @t, @l
-    // note 如添加上mm的, 此时wm的n不能在thread上切, 只能多算一部分,
-    // 计算结束后倒是可以继续在thread切.
-    matmul(yihv, wm, ym);
-    tdma_all_reduce_async(ym, ym, reduce_op_t::sum, reduce_strategy_t::by_block,
-                          ctx);
-    if (bid == 0) {
-        tdma_store_async(ym, YM({tid * 96, 0}, {96, 8192}), ctx);
+        tdma_load_async(v0_gamma, V0_gamma({tid * 2048}, {2048}), ctx);
+        tdma_load_async(v0_beta, V0_beta({tid * 2048}, {2048}), ctx);
+        tdma_load_async(v2_w, V2_w({8 * bid, 2048 * tid, 0}, {8, 2048, 128}),
+                        ctx);
+        tdma_load_async(v3_data, std::move(V3_data), ctx);
+        tdma_load_async(position_ids, std::move(Position_ids), ctx);
+
+        tdma_wait(ctx);
     }
 
-    // 7. Add and sum & sqr
-    tensor<float> sum({96});
-    tensor<float> sum_sqr({96});
-    auto xi = X({tid * 96, bid * 1024}, {96, 1024}); // [96, 1024]
-    auto ym_b = ym({0, bid * 1024}, {96, 1024});
-    binary(xi, ym_b, ym_b, binary_op_t::add);
-    // yih = add_and_sum_sqr(yih, xi, sum, sum_sqr);
-    reduce_sum_sqr(ym_b, sum, sum_sqr);
-    // __tdma_all_reduce_async(sum, sum_sqr); // All blocks & threads reduce
-    tdma_all_reduce_async(sum, sum, reduce_op_t::sum,
-                          reduce_strategy_t::by_block, ctx);
-    tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum,
-                          reduce_strategy_t::by_block, ctx);
-    tdma_wait(ctx);
-    layernorm(ym_b, sum, sum_sqr, 1, 8192);
-
-    tdma_store_async(ym_b, Norm({tid * 96, bid * 1024}, {96, 1024}), ctx);
+    tdma_load_async(v0, Hidden_in({0, bid * 48, tid * 2048}, {1, 48, 2048}),
+                    ctx);
+    {
+        tensor<float> v0_sum({1, 48});
+        tensor<float> v0_sum_sqr({1, 48});
+        reduce_sum_sqr(v0, v0_sum, v0_sum_sqr);
+        tdma_reduce_async(v0_sum, v0_sum, reduce_op_t::sum, ctx);
+        tdma_reduce_async(v0_sum_sqr, v0_sum_sqr, reduce_op_t::sum, ctx);
+        layernorm(v0, v0_sum, v0_sum_sqr, 2, 8192);
+    } // v0 [1, 384, 8192] [1, 48@b, 8192]
+
+    auto v1 = unsqueeze(v0); // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
+    /* 这里如果V2不shared的话可以只做thread间的reduce */
+    tensor_block_mma_sync(v1, v2_w, V2, false, ctx);
+
+    tensor<float> v3({1, 384, 128}); //
+    gather(v3_data, position_ids, v3, 1);
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index 193af3b0ce..10ec6aa7ad 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -5,8 +5,8 @@
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(WQ, WK, WV, WM, QKH);               \
-        block##b::thread##t::stage2_kernel(Norm, Softmax, YM);                 \
+        block##b::thread##t::stage1_kernel(Hidden_in, V0_gamma, V0_beta, V2_w, \
+                                           V3_data, Position_ids);             \
         return arg;                                                            \
     }
 
@@ -16,14 +16,12 @@
     DEFINE_TFUNC(b, 2)                                                         \
     DEFINE_TFUNC(b, 3)
 
-tensor<float, loc_t::device> WQ({64, 8192, 128});
-tensor<float, loc_t::device> WK({64, 8192, 128});
-tensor<float, loc_t::device> WV({64, 8192, 128});
-tensor<float, loc_t::device> WM({8192, 8192});
-tensor<float, loc_t::device> QKH({64, 384, 384});
-tensor<float, loc_t::device> Softmax({64, 384, 384});
-tensor<float, loc_t::device> YM({384, 8192});
-tensor<float, loc_t::device> Norm({384, 8192});
+tensor<float, loc_t::device> Hidden_in({1, 384, 8192});
+tensor<float, loc_t::device> V0_gamma({8192});
+tensor<float, loc_t::device> V0_beta({8192});
+tensor<float, loc_t::device> V2_w({64, 8192, 128});
+tensor<float, loc_t::device> V3_data({384, 128});
+tensor<int64_t, loc_t::device> Position_ids({1, 384});
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
@@ -34,6 +32,12 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
+#define LOAD_FILE(name, i, type)                                               \
+    {                                                                          \
+        auto src_##name = read_file(std::string(argv[(i)]));                   \
+        span_copy(name.data(), gsl::make_span(src_##name).as_span<type>());  \
+    }
+
 /**
  * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
  *
@@ -45,28 +49,12 @@ int main([[maybe_unused]] int argc, char **argv) {
     // spdlog::set_level(spdlog::level::debug);
     global_hardware_init();
 
-    /* fill tensor */
-    auto src_X = read_file(std::string(argv[1]));
-    auto src_WQ = read_file(std::string(argv[2]));
-    auto src_WK = read_file(std::string(argv[3]));
-    auto src_WV = read_file(std::string(argv[4]));
-    auto src_WM = read_file(std::string(argv[5]));
-    auto src_Norm = read_file(std::string(argv[6]));
-    auto src_QKH = read_file(std::string(argv[7]));
-    auto src_Softmax = read_file(std::string(argv[8]));
-    auto src_YM = read_file(std::string(argv[9]));
-    span_copy(WQ.data(), gsl::make_span(src_WQ).as_span<float>());
-    span_copy(WK.data(), gsl::make_span(src_WK).as_span<float>());
-    span_copy(WV.data(), gsl::make_span(src_WV).as_span<float>());
-    span_copy(WM.data(), gsl::make_span(src_WM).as_span<float>());
-    span_copy(block0::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block1::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block2::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block3::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block4::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block5::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block6::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block7::shared::X.data(), gsl::make_span(src_X).as_span<float>());
+    LOAD_FILE(Hidden_in, 1, float);
+    LOAD_FILE(V0_gamma, 2, float);
+    LOAD_FILE(V0_beta, 3, float);
+    LOAD_FILE(V2_w, 4, float);
+    LOAD_FILE(V3_data, 5, float);
+    LOAD_FILE(Position_ids, 6, int64_t);
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
@@ -139,26 +127,10 @@ int main([[maybe_unused]] int argc, char **argv) {
     pthread_join(t_7_2, NULL);
     pthread_join(t_7_3, NULL);
 
-    auto cos = cosine(QKH.data().begin(),
-                 gsl::make_span(src_QKH).as_span<float>().begin(),
-                 QKH.data().size());
-    printf("QKH cosine %f\n", cos);
-
-    cos = cosine(Softmax.data().begin(),
-                 gsl::make_span(src_Softmax).as_span<float>().begin(),
-                 Softmax.data().size());
-    printf("Softmax cosine %f\n", cos);
-
-    cos = cosine(YM.data().begin(),
-                 gsl::make_span(src_YM).as_span<float>().begin(),
-                 YM.data().size());
-    printf("YM cosine %f\n", cos);
-
-    to_file(Norm.data(),"ONorm.bin");
+    // auto cos = cosine(QKH.data().begin(),
+    //                   gsl::make_span(src_QKH).as_span<float>().begin(),
+    //                   QKH.data().size());
+    // printf("QKH cosine %f\n", cos);
 
-    cos = cosine(Norm.data().begin(),
-                      gsl::make_span(src_Norm).as_span<float>().begin(),
-                      Norm.data().size());
-    printf("Norm cosine %f\n", cos);
     return 0;
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
index 8dbca0cd80..3290f722b7 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
@@ -1,9 +1,5 @@
 #include <tdma.h>
 
 namespace shared {
-static tensor<float, loc_t::shared> X({384, 8192});
-static tensor<float, loc_t::shared> kh({8, 384, 128});
-static tensor<float, loc_t::shared> vh({8, 384, 128});  // []
-static tensor<float, loc_t::shared> qkh({8, 384, 384}); // []
-static tensor<float, loc_t::shared> mh({8, 384, 384});  // []
+tensor<float, loc_t::shared> V2({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
 } // namespace shared
\ No newline at end of file

From f081f323c499e344e54aeb25a7c4b8742e5e41b0 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 25 Aug 2023 15:05:10 +0800
Subject: [PATCH 122/308] fix build

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 2d3498b7de..0fcd19be90 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -154,7 +154,7 @@ void reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
 template <typename T, loc_t BLoc>
 void concat(std::initializer_list<tensor<T, loc_t::local>> inits,
             tensor<T, BLoc> &output, size_t axis) {
-    std::vector<const gsl::byte *const> inputs(inits.size());
+    itlib::small_vector<const gsl::byte *const, 8> inputs(inits.size());
     std::vector<strides_t> in_strides(inits.size());
     auto concat_dims = dims_t(inits.size(), 1);
     for (size_t i = 0; i < inits.size(); ++i) {

From f7370e215fd4002028d4cfaa909df05113acb151 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 25 Aug 2023 18:40:26 +0800
Subject: [PATCH 123/308] fix __tdma_all_sync_apply

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 0fcd19be90..0de1f70f34 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -305,11 +305,11 @@ void tdma_reduce_async(tensor<T, loc_t::local> &src,
         [&]([[maybe_unused]] int visit) -> void {
             tensor<T> *gather_tensor =
                 static_cast<tensor<T> *>(global_hardware_ctx->global_var);
-            auto new_dims = dims_t(src.dimension());
+            auto new_dims = dims_t(gather_tensor->dimension());
             new_dims[0] = CORES;
             auto viewed_gather_tensor =
                 tensor<T>(gather_tensor->data().subspan(
-                              ctx.bid() * CORES * gather_tensor->strides()[0]),
+                              ctx.bid() * CORES * gather_tensor->strides()[0], CORES * gather_tensor->strides()[0]),
                           new_dims, gather_tensor->strides());
 
             reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),

From afdd14fe03996dbef9d67e4f1bc00336c9513aae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 25 Aug 2023 18:45:31 +0800
Subject: [PATCH 124/308] add to v35

---
 modules/cpu/src/runtime/cmodel/include/tdma.h |   8 +-
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 127 +++++++++++++++++-
 .../src/runtime/cmodel/tests/demo3/main.cpp   |  39 ++++--
 .../runtime/cmodel/tests/demo3/shared_def.h   |  16 ++-
 4 files changed, 166 insertions(+), 24 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 2d3498b7de..d672e955b0 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -83,8 +83,8 @@ void binary(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &out,
         gsl::make_span(out.strides()).template as_span<const size_t>());
 }
 
-template <class T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-void unary(tensor<T, ALoc> &a, tensor<T, CLoc> &out, unary_op_t op) {
+template <class T, loc_t ALoc, loc_t BLoc>
+void unary(tensor<T, ALoc> &a, tensor<T, BLoc> &out, unary_op_t op) {
     kernels::unary(
         op, a.cdata().data(), out.data().data(),
         gsl::make_span(a.strides()).template as_span<const size_t>(),
@@ -92,9 +92,9 @@ void unary(tensor<T, ALoc> &a, tensor<T, CLoc> &out, unary_op_t op) {
         gsl::make_span(out.strides()).template as_span<const size_t>());
 }
 
-template <typename T, loc_t ALoc, loc_t BLoc>
+template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
 void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
-            tensor<T, loc_t::local> &c) {
+            tensor<T, CLoc> &c) {
     kernels::matmul(a.cdata().data(), b.cdata().data(), c.data().data(),
                     a.dimension(), a.strides(), b.dimension(), b.strides(),
                     c.dimension(), c.strides());
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index 1572c9a14b..f4191636ed 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -7,14 +7,23 @@ using namespace shared;
 
 static bool w_loaded;
 static tensor<float> v2_w({8, 2048, 128});
+static tensor<float> v16_w({8, 2048, 128});
+static tensor<float> v31_w({8, 2048, 128});
+static tensor<float> v35_w({1024, 2048});
 static tensor<float> v3_data({384, 128});
+static tensor<float> v11_data({384, 128});
 static tensor<int64_t> position_ids({1, 384});
 
 void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
-                   tensor<float, loc_t::device> &V0_gamma,
-                   tensor<float, loc_t::device> &V0_beta,
-                   tensor<float, loc_t::device> &V2_w,    /* [64, 8192, 128] */
-                   tensor<float, loc_t::device> &V3_data, /* [384, 128] */
+                   tensor<float, loc_t::device> &V0_gamma,  /* [8192] */
+                   tensor<float, loc_t::device> &V0_beta,   /* [8192] */
+                   tensor<float, loc_t::device> &V2_w,     /* [64, 8192, 128] */
+                   tensor<float, loc_t::device> &V16_w,    /* [64, 8192, 128] */
+                   tensor<float, loc_t::device> &V31_w,    /* [64, 8192, 128] */
+                   tensor<float, loc_t::device> &V35_w,    /* [8192, 8192] */
+                   tensor<float, loc_t::device> &V3_data,  /* [384, 128] */
+                   tensor<float, loc_t::device> &V11_data, /* [384, 128] */
+                   tensor<float, loc_t::device> &Attn_mask, /* [1,1,384,384] */
                    tensor<int64_t, loc_t::device> &Position_ids /* [1,384] */
 ) {
     thread_context ctx(bid, tid);
@@ -22,13 +31,26 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
     tensor<float> v0_beta({2048});
     tensor<float> v0({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t]  */
 
+    tensor<float> attn_mask(
+        {1, 1, 384, 384}); /* [1,1,384,384] [1,1,96@t,96@t] */
+
     if (!w_loaded) {
         tdma_load_async(v0_gamma, V0_gamma({tid * 2048}, {2048}), ctx);
         tdma_load_async(v0_beta, V0_beta({tid * 2048}, {2048}), ctx);
         tdma_load_async(v2_w, V2_w({8 * bid, 2048 * tid, 0}, {8, 2048, 128}),
                         ctx);
+        tdma_load_async(v16_w, V16_w({8 * bid, 2048 * tid, 0}, {8, 2048, 128}),
+                        ctx);
+        tdma_load_async(v31_w, V31_w({8 * bid, 2048 * tid, 0}, {8, 2048, 128}),
+                        ctx);
+        tdma_load_async(v35_w, V35_w({1024 * bid, 2048 * tid}, {1024, 2048}),
+                        ctx);
         tdma_load_async(v3_data, std::move(V3_data), ctx);
+        tdma_load_async(v11_data, std::move(V11_data), ctx);
         tdma_load_async(position_ids, std::move(Position_ids), ctx);
+        tdma_load_async(attn_mask,
+                        Attn_mask({0, 0, tid * 96, tid * 96}, {1, 1, 96, 96}),
+                        ctx);
 
         tdma_wait(ctx);
     }
@@ -49,5 +71,100 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
     tensor_block_mma_sync(v1, v2_w, V2, false, ctx);
 
     tensor<float> v3({1, 384, 128}); //
-    gather(v3_data, position_ids, v3, 1);
+    gather(v3_data, position_ids, v3, 0);
+
+    auto v4 = unsqueeze(v3); /* 1, 1, 384, 128 */
+
+    tensor<float> v5({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+    binary(V2, v4, v5, binary_op_t::mul);
+
+    auto v6 =
+        V2({0, 0, 0, 64}, {1, 8, 384, 64}); //[1, 64, 384, 64] [1, 8@b, 384, 64]
+    auto v7 = v6;
+    if (tid == 0) {
+        /* V2 is shared, so don't need perfrom on each thread. */
+        unary(v6, v7, unary_op_t::neg);
+    }
+    tdma_wait(ctx);
+
+    // auto v8 = v2({0, 0, 0, 0}, {1, 8, 384, 64}); //[1, 64, 384, 64] [1, 8@b,
+    // 384, 64]@shared
+    /* v10 为concat(v7,v8), 实际来源于V2，因此无需实际动作 */
+    // [1, 64, 384, 128] [1, 8@b, 384, 128]@shared ->
+    // [1, 8@b, 96@t, 128]@shared here can resplit .
+    auto v10 = V2({0, 0, tid * 96, 0}, {1, 8, 96, 128});
+
+    tensor<float> v11({1, 384, 128}); //[1, 384, 128] [1, 384, 128]
+    gather(v11_data, position_ids, v11, 0);
+    auto v12 = unsqueeze(v11); // [1, 1, 384, 128] [1, 1, 384, 128]
+
+    tensor<float> v13({1, 8, 96, 128}); // [1, 64, 384, 128] [1, 8@b, 96@t, 128]
+    binary(v10, v12, v13, binary_op_t::mul);
+
+    tensor<float> v14({1, 8, 96, 128}); // [1, 64, 384, 128] [1, 8@b, 96@t, 128]
+    binary(v5, v13, v14, binary_op_t::add);
+
+    // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
+    tensor<float> v15 = v0({0, bid * 48, tid * 2048}, {1, 48, 2048});
+
+    tensor_block_mma_sync(v15, v16_w, V16, false, ctx);
+    tensor<float> v17({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+    binary(V16, v4, v17, binary_op_t ::mul);
+
+    // [1, 64, 384, 64] [1, 8@b, 384, 64]@shared
+    auto v18 = V16({0, 0, 0, 64}, {1, 8, 384, 64});
+    if (tid == 0) {
+        unary(v18, v18, unary_op_t::neg);
+    }
+    tdma_wait(ctx);
+
+    //[1, 64, 384, 128] [1, 8@b, 96@t, 128]@shared
+    auto v22 = V16({0, 0, tid * 96, 0}, {1, 8, 96, 128});
+
+    // [1, 64, 384, 128] [1, 8@b, 96@t, 128]@shared
+    tensor<float> v23({1, 8, 96, 128});
+    binary(v22, v12, v23, binary_op_t::mul);
+
+    // [1, 64, 384, 128] [1, 8@b, 96@t, 128]
+    tensor<float> v24({1, 8, 96, 128});
+    binary(v17, v23, v24, binary_op_t::add);
+
+    // [1, 64, 128, 384] [1, 8@b, 128, 96@t]
+    tensor<float> v25({1, 8, 128, 96});
+    transpose(v24, v25, dims_t({0, 1, 3, 2}));
+
+    // [1, 8@b, 96@t, 128] @  [1, 8@b, 128, 96@t] => [1, 8@b, 96@t, 96@t]
+    auto v26 = V26({0, 0, tid * 96, tid * 96}, {1, 8, 96, 96});
+    matmul(v14, v25, v26);
+
+    // [1, 64, 384, 384] [1, 8@b, 96@t, 96@t] @shared
+    auto v27 = v26;
+    auto v26_c = tensor<float>({1, 1, 1, 1});
+    tdma_fill_async(v26_c, 11.313708f);
+    binary(v26, v26_c, v27, binary_op_t::div);
+
+    // [1, 64, 384, 384] [1, 8@b, 96@t, 96@t] @shared
+    auto v28 = v27;
+    binary(v27, attn_mask, v28, binary_op_t::div);
+
+    // resplit need sync.
+    tdma_wait(ctx);
+    auto v28_1 = V26({0, 0, tid * 96, 0}, {1, 8, 96, 384});
+    tensor<float> v29({1, 8, 96, 384}); //[1, 64, 384, 384] [1, 8@b, 96@t, 384]
+    softmax(v28_1, v29, 3);
+
+    //  [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
+    auto v30 = unsqueeze(v0);
+
+    tensor_block_mma_sync(v30, v31_w, V31, false, ctx);
+
+    // [1, 8@b, 384, 128]@local @ [1, 8@b, 384, 128]@shared
+    // [1, 64, 384, 128] [1, 8@b, 384, 128]
+    if (tid == 0) {
+        matmul(v29, V31, V32);
+        // V33 [1, 384, 64, 128] [1, 384, 8@b, 128]@shared
+        transpose(V32, V33, dims_t({0, 2, 1, 3}));
+    }
+    tdma_wait(ctx);
+    // auto v34 =
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index 10ec6aa7ad..456f531f9d 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -6,7 +6,8 @@
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
         block##b::thread##t::stage1_kernel(Hidden_in, V0_gamma, V0_beta, V2_w, \
-                                           V3_data, Position_ids);             \
+                                           V16_w, V31_w, V35_w, V3_data,       \
+                                           V11_data, Attn_mask, Position_ids); \
         return arg;                                                            \
     }
 
@@ -16,12 +17,17 @@
     DEFINE_TFUNC(b, 2)                                                         \
     DEFINE_TFUNC(b, 3)
 
-tensor<float, loc_t::device> Hidden_in({1, 384, 8192});
-tensor<float, loc_t::device> V0_gamma({8192});
-tensor<float, loc_t::device> V0_beta({8192});
-tensor<float, loc_t::device> V2_w({64, 8192, 128});
-tensor<float, loc_t::device> V3_data({384, 128});
-tensor<int64_t, loc_t::device> Position_ids({1, 384});
+static tensor<float, loc_t::device> Hidden_in({1, 384, 8192});
+static tensor<float, loc_t::device> V0_gamma({8192});
+static tensor<float, loc_t::device> V0_beta({8192});
+static tensor<float, loc_t::device> V2_w({64, 8192, 128});
+static tensor<float, loc_t::device> V16_w({64, 8192, 128});
+static tensor<float, loc_t::device> V31_w({64, 8192, 128});
+static tensor<float, loc_t::device> V35_w({8192, 8192});
+static tensor<float, loc_t::device> V3_data({384, 128});
+static tensor<float, loc_t::device> V11_data({384, 128});
+static tensor<float, loc_t::device> Attn_mask({1, 1, 384, 384});
+static tensor<int64_t, loc_t::device> Position_ids({1, 384});
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
@@ -35,7 +41,7 @@ DEFINE_BFUNC(7)
 #define LOAD_FILE(name, i, type)                                               \
     {                                                                          \
         auto src_##name = read_file(std::string(argv[(i)]));                   \
-        span_copy(name.data(), gsl::make_span(src_##name).as_span<type>());  \
+        span_copy(name.data(), gsl::make_span(src_##name).as_span<type>());    \
     }
 
 /**
@@ -49,12 +55,17 @@ int main([[maybe_unused]] int argc, char **argv) {
     // spdlog::set_level(spdlog::level::debug);
     global_hardware_init();
 
-    LOAD_FILE(Hidden_in, 1, float);
-    LOAD_FILE(V0_gamma, 2, float);
-    LOAD_FILE(V0_beta, 3, float);
-    LOAD_FILE(V2_w, 4, float);
-    LOAD_FILE(V3_data, 5, float);
-    LOAD_FILE(Position_ids, 6, int64_t);
+    LOAD_FILE(Hidden_in, 0, float)
+    LOAD_FILE(V0_gamma, 1, float)
+    LOAD_FILE(V0_beta, 2, float)
+    LOAD_FILE(V2_w, 3, float)
+    LOAD_FILE(V16_w, 4, float)
+    LOAD_FILE(V31_w, 5, float)
+    LOAD_FILE(V35_w, 6, float)
+    LOAD_FILE(V3_data, 7, float)
+    LOAD_FILE(V11_data, 8, float)
+    LOAD_FILE(Attn_mask, 9, float)
+    LOAD_FILE(Position_ids, 10, int64_t)
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
index 3290f722b7..c7f91c012e 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
@@ -1,5 +1,19 @@
 #include <tdma.h>
 
 namespace shared {
-tensor<float, loc_t::shared> V2({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+static tensor<float, loc_t::shared>
+    V2({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+static tensor<float, loc_t::shared>
+    V16({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+static tensor<float, loc_t::shared>
+    V26({1, 8, 384, 384}); // [1, 64, 384, 128] [1, 8@b, 384, 384]
+
+static tensor<float, loc_t::shared>
+    V31({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+
+static tensor<float, loc_t::shared>
+    V32({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+static tensor<float, loc_t::shared>
+    V33({1, 384, 8, 128}); // [1, 384, 64, 128] [1, 384, 8@b, 128]
+
 } // namespace shared
\ No newline at end of file

From 812b795854de505a7c06e47081b4b3a029178cfd Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 25 Aug 2023 19:06:15 +0800
Subject: [PATCH 125/308] dump const

---
 .../Passes/Rules/DumpConst.cs                 | 125 ++++++++++++++++++
 src/Nncase.Compiler/Compiler.cs               |   3 +
 2 files changed, 128 insertions(+)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/DumpConst.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/DumpConst.cs b/modules/Nncase.Modules.CPU/Passes/Rules/DumpConst.cs
new file mode 100644
index 0000000000..ff18ef592a
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/DumpConst.cs
@@ -0,0 +1,125 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.CPU;
+using Nncase.IR.Math;
+using Nncase.IR.NN;
+using Nncase.IR.Tensors;
+using Nncase.Passes.Rules.Neutral;
+using Nncase.PatternMatch;
+using Nncase.Targets;
+using static Nncase.IR.TypePatternUtility;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.F.NN;
+using static Nncase.PatternMatch.F.Tensors;
+using static Nncase.PatternMatch.Utility;
+using static Nncase.Utilities.ReplaceUtility;
+
+using Nncase.IR.F;
+using Nncase.Diagnostics;
+using System.Diagnostics.SymbolStore;
+
+namespace Nncase.Passes.Rules;
+
+
+/// <summary>
+/// Dump Weights of MM.
+/// </summary>
+[RuleGenerator]
+public sealed partial class DumpMM : IRewriteRule
+{
+	public IPattern Pattern { get; } =
+			IsMatMul(
+				"mm",
+				"mmCall",
+				_ => true,
+				IsWildcard("x"),
+			IsTensorConst("w"));
+
+
+	private Expr? GetReplace(Expr x, Call mmCall, TensorConst w)
+	{
+		var name = mmCall.Metadata.OutputNames?[0].Replace('/', '_') + "_weights.bin";
+		var dir = DumpScope.Current.Directory;
+		Directory.CreateDirectory(dir);
+		using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name), FileMode.Create)))
+		{
+			bw.Write(w.Value.BytesBuffer);
+		}
+
+		return null;
+	}
+}
+
+/// <summary>
+/// Dump Consts of layernorm.
+/// </summary>
+[RuleGenerator]
+public sealed partial class DumpLayerNorm : IRewriteRule
+{
+	public IPattern Pattern { get; } =
+			IsLayerNorm(
+				"ln",
+				"lnCall",
+				_ => true,
+				IsWildcard("x"),
+			IsTensorConst("scale"),
+			IsTensorConst("bias"));
+
+
+	private Expr? GetReplace(Call lnCall, TensorConst scale, TensorConst bias)
+	{
+		var name = lnCall.Metadata.OutputNames?[0].Replace('/', '_');
+		var dir = DumpScope.Current.Directory;
+		Directory.CreateDirectory(dir);
+
+		using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name + "_scale.bin"), FileMode.Create)))
+		{
+			bw.Write(scale.Value.BytesBuffer);
+		}
+
+		using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name + "_bias.bin"), FileMode.Create)))
+		{
+			bw.Write(bias.Value.BytesBuffer);
+		}
+
+		return null;
+	}
+}
+
+/// <summary>
+/// Dump Consts of Gather.
+/// </summary>
+[RuleGenerator]
+public sealed partial class DumpGather : IRewriteRule
+{
+	public IPattern Pattern { get; } =
+			IsGather(
+				"gather",
+				"gatherCall",
+				_ => true,
+			IsTensorConst("data"),
+				IsWildcard("index"));
+
+
+	private Expr? GetReplace(Call gatherCall, TensorConst data)
+	{
+		var name = gatherCall.Metadata.OutputNames?[0].Replace('/', '_') + "_data.bin";
+		var dir = DumpScope.Current.Directory;
+		Directory.CreateDirectory(dir);
+
+		using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name), FileMode.Create)))
+		{
+			bw.Write(data.Value.BytesBuffer);
+		}
+
+		return null;
+	}
+}
\ No newline at end of file
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 1df91dbecc..3a29679c27 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -161,6 +161,9 @@ public void TargetIndependentPass(IPassManager passManager)
         {
             p.Add<Passes.Rules.MHACombine>();
             p.Add<Passes.Rules.Neutral.FoldConstCall>();
+            // p.Add<Passes.Rules.DumpMM>();
+            // p.Add<Passes.Rules.DumpLayerNorm>();
+            // p.Add<Passes.Rules.DumpGather>();
             p.Add<Passes.Rules.FuseMHA1>();
             p.Add<Passes.Rules.FuseMHA2>();
         });

From 6bb9f710ab915c99c46e0bd66d859b7ecf595b3a Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 25 Aug 2023 19:06:32 +0800
Subject: [PATCH 126/308] update demo3 golden

---
 .../src/runtime/cmodel/tests/demo3/golden.py  | 140 ++++++++++--------
 1 file changed, 80 insertions(+), 60 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
index dd5d5176d6..42f72d7c62 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
@@ -2,68 +2,88 @@
 from torch import nn
 import torch
 from scipy.special import softmax
-def layernorm(x:np.ndarray):
-    return nn.LayerNorm([x.shape[-1]], elementwise_affine=False)(torch.from_numpy(x)).detach().numpy()
+import os
+
+def layernorm(x:np.ndarray, gamma:np.ndarray, beta:np.ndarray):
+    return nn.functional.layer_norm(torch.from_numpy(x), [x.shape[-1]], torch.from_numpy(gamma), torch.from_numpy(beta)).detach().numpy()
 
 def swish(x:np.ndarray):
     return x / (1 + np.exp(-x))
 
+def gather(data:np.ndarray, axis:int, indices:np.ndarray):
+    return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
+
+const_dir = "/compiler/huochenghai/GNNE/rebuild-ir/nncase/modules/cpu/src/runtime/cmodel/tests/demo3/golden/"
+
+hidden_in = np.reshape(np.fromfile(os.path.join(const_dir,"input_0_0.bin"), dtype=np.float32), (1, 384, 8192))
+attn_mask = np.reshape(np.fromfile(os.path.join(const_dir,"input_1_0.bin"), dtype=np.float32), (1, 1, 384, 384))
+position_ids = np.reshape(np.fromfile(os.path.join(const_dir,"input_2_0.bin"), dtype=np.int64), (1, 384))
+
+input_ln_gamma = np.reshape(np.fromfile(os.path.join(const_dir,"_input_layernorm_Mul_1_output_0_scale.bin"), dtype=np.float32), (8192))
+input_ln_beta = np.reshape(np.fromfile(os.path.join(const_dir,"_input_layernorm_Mul_1_output_0_bias.bin"), dtype=np.float32), (8192))
+
+gather1_data = np.reshape(np.fromfile(os.path.join(const_dir, "_self_attn_Gather_7_output_0_data.bin"), dtype=np.float32), (384,128))
+gather2_data = np.reshape(np.fromfile(os.path.join(const_dir, "_self_attn_Gather_8_output_0_data.bin"), dtype=np.float32), (384,128))
+
+WQ = np.reshape(np.fromfile(os.path.join(const_dir,"_self_attn_Transpose_output_0_weights.bin"), dtype=np.float32), (64, 8192, 128))
+WK = np.reshape(np.fromfile(os.path.join(const_dir,"_self_attn_Transpose_1_output_0_weights.bin"), dtype=np.float32), (64, 8192, 128))
+WV = np.reshape(np.fromfile(os.path.join(const_dir,"_self_attn_Transpose_2_output_0_weights.bin"), dtype=np.float32), (64, 8192, 128))
+WO = np.reshape(np.fromfile(os.path.join(const_dir,"_self_attn_o_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (8192, 8192))
+
+post_ln_gamma = np.reshape(np.fromfile(os.path.join(const_dir,"_post_attention_layernorm_Mul_1_output_0_scale.bin"), dtype=np.float32), (8192))
+post_ln_beta = np.reshape(np.fromfile(os.path.join(const_dir,"_post_attention_layernorm_Mul_1_output_0_bias.bin"), dtype=np.float32), (8192))
+
+mlp_gate_weights = np.reshape(np.fromfile(os.path.join(const_dir,"_mlp_gate_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (8192, 22016))
+mlp_up_weights = np.reshape(np.fromfile(os.path.join(const_dir,"_mlp_up_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (8192, 22016))
+mlp_down_weights = np.reshape(np.fromfile(os.path.join(const_dir,"_mlp_down_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (22016, 8192))
+
+# np.random.rand(8192).astype(np.float32), np.random.rand(8192).astype(np.float32)
+v0 = layernorm(hidden_in, input_ln_gamma, input_ln_beta) # f32[1,384,8192]
+v0.tofile("v0.bin")
+v1 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
+v2 = (v1 @ WQ) # f32[1,64,384,128]
+v3 = gather1_data[position_ids] # f32[1,384,128]
+v4 = np.reshape(v3, (1,1,384,128))
+v5 = v2 * v4 # f32[1,64,384,128]
+v6 = v2[:,:,:,64:] # Slice(v3, const(i64[1] : {64L}), const(i64[1] : {9223372036854775807}), 3, 1) # f32[1,64,384,64]
+v7 = -(v6) # f32[1,64,384,64]
+v8 = v2[:,:,:,0:64] # Slice(v3, 0, 64, 3, 1) # f32[1,64,384,64]
+v9 = (v7, v8) # (f32[1,64,384,64], f32[1,64,384,64]
+
+v10 = np.concatenate(v9, -1) # f32[1,64,384,128]
+v11 = gather2_data[position_ids] # f32[1,384,128]
+v12 = np.reshape(v11, (1,1,384,128))
+v13 = v10 * v12 # f32[1,64,384,128]
+v14 = v5 + v13 # f32[1,64,384,128]
+v15 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
+v16 = (v15 @ WK) # f32[1,64,384,128]
+v17 = v16 * v4 # f32[1,64,384,128]
+v18 = v16[:,:,:,64:] # Slice(v3, const(i64[1] : {64L}), const(i64[1] : {9223372036854775807}), 3, 1) # f32[1,64,384,64]
+v19 = -(v18) # f32[1,64,384,64]
+v20 = v16[:,:,:,0:64] # Slice(v3, 0, 64, 3, 1) # f32[1,64,384,64]
+v21 = (v19, v20) # (f32[1,64,384,64], f32[1,64,384,64])
+
+v22 = np.concatenate(v21, -1) # f32[1,64,384,128]
+v23 = v22 * v12 # f32[1,64,384,128]
+v24 = v17 + v23 # f32[1,64,384,128]
+v25 = np.transpose(v24, [0,1,3,2]) # f32[1,64,128,384]
+v26 = v14 @ v25 # f32[1,64,384,384]
+v27 = (v26/ 11.31370) # f32[1,64,384,384]
+v28 = v27 + attn_mask # f32[1,64,384,384]
+v29 = softmax(v28, -1) # f32[1,64,384,384]
+v30 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
+v31 = (v30 @ WV) # f32[1,64,384,128]
+v32 = v29 @ v31 # f32[1,64,384,128]
+v33 = np.transpose(v32, [0,2,1,3]) # f32[1,384,64,128]
+v34 = np.reshape(v33, [1,384,8192]) # f32[1,384,8192]
+v35 = v34 @ WO # f32[1,384,8192]
+v36 = (hidden_in + v35) # f32[1,384,8192]
+v37 = layernorm(v36, post_ln_gamma, post_ln_beta) # f32[1,384,8192]
+v38 = v37 @ mlp_gate_weights # f32[1,384,22016]
+v39 = swish(v38) # f32[1,384,22016]
+v40 = v37 @ mlp_up_weights # f32[1,384,22016]
+v41 = v39 * v40 # f32[1,384,22016]
+v42 = v41 @ mlp_down_weights # f32[1,384,8192]
+v43 = v36 + v42 # f32[1,384,8192]
 
-hidden_in = np.random.rand(1, 384, 8192).astype(np.float32)
-attn_mask = np.random.rand(1, 1, 384, 384).astype(np.float32)
-position_ids = np.random.randint(0, 384, [1, 384])
-v0_gamma [8192] [8192] 
-v0_beta [8192] [8192] 
-v37_gamma [8192] [8192] 
-v37_beta [8192] [8192] 
-v2_w [64, 8192, 128] [8@b, 2048@t, 128] 
-v3_data [384, 128] [384, 128] 
-v11_data [384, 128] [384, 128] 
-v16_w [64, 8192, 128] [8@b, 2048@t, 128] 
-v31_w [64, 8192, 128] [8@b, 2048@t, 128] 
-v35_w [8192, 8192] [1024@b, 2048@t] 
-v38_w [8192, 22016] [1024@b, 5504@t] 
-v40_w [8192, 22016] [1024@b, 5504@t] 
-v42_w [22016, 8192] [2752@b, 2048@t] 
-v0 = nn.functional.layer_norm(var_5, [8192], self.v0_gamma, self.v0_beta) # v0 [1, 384, 8192] [1, 48@b, 8192] 
-v1 = flow.unsqueeze(v0, 1)  # v1 [1, 1, 384, 8192] [1, 1, 48@b, 8192] 
-v2 = flow.matmul(v1, self.v2_w)  # v2 [1, 64, 384, 128] [1, 8@b, 384, 128] 
-v3 = self.v3_data[var_6]  # Gather(const(f32[384,128]), const(i64 : 0), )# v3 [1, 384, 128] [1, 384, 128] 
-v4 = flow.reshape(v3, [1, 1, 384, 128])  # v4 [1, 1, 384, 128] [1, 1, 384, 128] 
-v5 = flow.mul(v2, v4)  # v5 [1, 64, 384, 128] [1, 8@b, 384, 128] 
-v6 = v2[:, :, :, 64:]  # v6 [1, 64, 384, 64] [1, 8@b, 384, 64] 
-v7 = -v6  # v7 [1, 64, 384, 64] [1, 8@b, 384, 16@t] 
-v8 = v2[:, :, :, :64]  # v8 [1, 64, 384, 64] [1, 8@b, 384, 64] 
-v10 = flow.concat(v9, -1)  # v10 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
-v11 = self.v11_data[var_6] # v11 [1, 384, 128] [1, 384, 128] 
-v12 = flow.reshape(v11, [1, 1, 384, 128])  # v12 [1, 1, 384, 128] [1, 1, 384, 128] 
-v13 = flow.mul(v10, v12)  # v13 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
-v14 = flow.add(v5, v13)  # v14 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
-v15 = flow.unsqueeze(v0, 1)  # v15 [1, 1, 384, 8192] [1, 1, 48@b, 8192] 
-v16 = flow.matmul(v15, self.v16_w)  # v16 [1, 64, 384, 128] [1, 8@b, 384, 128] 
-v17 = flow.mul(v16, v4)  # v17 [1, 64, 384, 128] [1, 8@b, 384, 128] 
-v18 = v16[:, :, :, 64:] # v18 [1, 64, 384, 64] [1, 8@b, 384, 64] 
-v19 = flow.neg(v18)  # v19 [1, 64, 384, 64] [1, 8@b, 384, 16@t] 
-v20 = v16[:, :, :, 0:64] # v20 [1, 64, 384, 64] [1, 8@b, 384, 64] 
-v22 = flow.concat(v21, -1)  # v22 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
-v23 = flow.mul(v22, v12)  # v23 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
-v24 = flow.add(v17, v23)  # v24 [1, 64, 384, 128] [1, 8@b, 96@t, 128] 
-v25 = flow.transpose(v24, [0, 1, 3, 2])  # v25 [1, 64, 128, 384] [1, 8@b, 128, 96@t] 
-v26 = flow.matmul(v14, v25)  # v26 [1, 64, 384, 384] [1, 8@b, 384, 384] 
-v27 = flow.div(v26, 11.313708)  # v27 [1, 64, 384, 384] [1, 8@b, 384, 384] 
-v28 = flow.add(v27, var_7)  # v28 [1, 64, 384, 384] [1, 8@b, 384, 384] 
-v29 = flow.softmax(v28, -1)  # v29 [1, 64, 384, 384] [1, 8@b, 96@t, 384] 
-v30 = flow.unsqueeze(v0, 1)  # v30 [1, 1, 384, 8192] [1, 1, 48@b, 8192] 
-v31 = flow.matmul(v30, self.v31_w)  # v31 [1, 64, 384, 128] [1, 8@b, 384, 128] 
-v32 = flow.matmul(v29, v31)  # v32 [1, 64, 384, 128] [1, 8@b, 384, 128] 
-v33 = flow.transpose(v32, [0, 2, 1, 3])  # v33 [1, 384, 64, 128] [1, 384, 8@b, 128] 
-v34 = flow.reshape(v33, [1, 384, 8192]) # v34 [1, 384, 8192] [1, 384, 1024@b] 
-v35 = flow.matmul(v34, self.v35_w) # v35 [1, 384, 8192] [1, 384, 8192] 
-v36 = flow.add(var_5, v35) # v36 [1, 384, 8192] [1, 12@b@t, 8192] 
-v37 = nn.functional.layer_norm(v36, [8192], self.v37_gamma, self.v37_beta) # v37 [1, 384, 8192] [1, 12@b@t, 8192] 
-v38 = flow.matmul(v37, self.v38_w) # v38 [1, 384, 22016] [1, 384, 5504@t] 
-v39 = nn.functional.silu(v38) # v39 [1, 384, 22016] [1, 48@b, 5504@t] 
-v40 = flow.matmul(v37, self.v40_w) # v40 [1, 384, 22016] [1, 384, 5504@t] 
-v41 = flow.mul(v39, v40) # v41 [1, 384, 22016] [1, 384, 5504@t] 
-v42 = flow.matmul(v41, self.v42_w) # v42 [1, 384, 8192] [1, 384, 8192] 
-v43 = flow.add(v36, v42) # v43 [1, 384, 8192] [1, 12@b@t, 8192] 
+# v46.tofile("")
\ No newline at end of file

From cdacd6bf2b05d5be764565ec15c32cd30631dc40 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 28 Aug 2023 12:22:59 +0800
Subject: [PATCH 127/308] compiled

---
 .../src/runtime/cmodel/include/layernorm.h    | 16 ++--
 .../runtime/cmodel/include/runtime_types.h    |  1 +
 modules/cpu/src/runtime/cmodel/include/tdma.h | 49 ++++++------
 .../cpu/src/runtime/cmodel/include/unary.h    |  1 +
 .../src/runtime/cmodel/tests/demo1/kernel.h   |  2 +-
 .../src/runtime/cmodel/tests/demo2/kernel.h   |  2 +-
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 80 ++++++++++++++++++-
 .../src/runtime/cmodel/tests/demo3/main.cpp   | 36 +++++----
 .../runtime/cmodel/tests/demo3/shared_def.h   |  7 ++
 9 files changed, 144 insertions(+), 50 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index 725b80019f..b85cd2148a 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -9,9 +9,11 @@ namespace kernels {
 
 namespace {
 template <typename T>
-void layernorm_naive_impl(T *input, const T *sum, T *sum_sqr, T *gamma, T *beta,
+void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *output,
+                          T *gamma, T *beta,
                           gsl::span<const size_t> input_shape,
                           gsl::span<const size_t> input_stride,
+                          gsl::span<const size_t> output_stride,
                           [[maybe_unused]] gsl::span<const size_t> sum_strides,
                           gsl::span<const size_t> gamma_strides, T eps,
                           int32_t axis, int32_t norm_size) noexcept {
@@ -25,7 +27,7 @@ void layernorm_naive_impl(T *input, const T *sum, T *sum_sqr, T *gamma, T *beta,
 
         auto input_offset = offset(input_stride, input_index);
         auto in_offset = offset(gamma_strides, input_index.subspan(axis));
-        input[input_offset] =
+        output[offset(output_stride, input_index)] =
             (input[input_offset] - mean) / sigma *
                 (gamma == nullptr ? static_cast<T>(1) : gamma[in_offset]) +
             (beta == nullptr ? static_cast<T>(0) : beta[in_offset]);
@@ -133,10 +135,11 @@ void layernorm_rvv_impl(const T *input, const T *sum, T *sum_sqr, T *gamma,
 } // namespace
 
 template <class T>
-void layernorm(T *input, T *sum, T *sum_sqr, T *gamma, T *beta,
+void layernorm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
                dims_t input_dims, strides_t input_strides,
-               strides_t sum_strides, strides_t gamma_strides, T eps,
-               int32_t axis, int32_t norm_size) {
+               strides_t output_strides, strides_t sum_strides,
+               strides_t gamma_strides, T eps, int32_t axis,
+               int32_t norm_size) {
 #ifdef __riscv_vector
     return layernorm_rvv_impl(
         input, sum, sum_sqr, gamma, beta,
@@ -145,9 +148,10 @@ void layernorm(T *input, T *sum, T *sum_sqr, T *gamma, T *beta,
         axis, norm_size);
 #else
     return layernorm_naive_impl(
-        input, sum, sum_sqr, gamma, beta,
+        input, sum, sum_sqr, output, gamma, beta,
         gsl::make_span(input_dims).template as_span<const size_t>(),
         gsl::make_span(input_strides).template as_span<const size_t>(),
+        gsl::make_span(output_strides).template as_span<const size_t>(),
         gsl::make_span(sum_strides).template as_span<const size_t>(),
         gsl::make_span(gamma_strides).template as_span<const size_t>(), eps,
         axis, norm_size);
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_types.h b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
index d71de1a12d..0fa69d7913 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_types.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
@@ -28,6 +28,7 @@ enum class unary_op_t : uint8_t {
     tanh = 19,
     bitwise_not = 20,
     logical_not = 21,
+    swish = 22
 };
 
 enum class binary_op_t : uint8_t {
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 568e0abe71..730aa04e72 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -93,8 +93,7 @@ void unary(tensor<T, ALoc> &a, tensor<T, BLoc> &out, unary_op_t op) {
 }
 
 template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
-            tensor<T, CLoc> &c) {
+void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &c) {
     kernels::matmul(a.cdata().data(), b.cdata().data(), c.data().data(),
                     a.dimension(), a.strides(), b.dimension(), b.strides(),
                     c.dimension(), c.strides());
@@ -117,30 +116,32 @@ void gather(tensor<T, ALoc> &input, tensor<int64_t, BLoc> &indices,
         indices.data().data(), indices.dimension(), axis);
 }
 
-template <typename T, loc_t Loc>
-void layernorm(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
-               tensor<T, loc_t::local> &sum_sqr, tensor<T, loc_t::local> &gamma,
-               tensor<T, loc_t::local> &beta, T eps, int32_t axis,
-               int32_t norm_size) {
+template <typename T, loc_t ALoc, loc_t BLoc>
+void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
+               tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
+               tensor<T, loc_t::local> &gamma, tensor<T, loc_t::local> &beta,
+               T eps, int32_t axis, int32_t norm_size) {
     assert(sum.strides() == sum_sqr.strides());
     assert(is_contiguous(sum.dimension(), sum.strides()));
     assert(gamma.strides() == beta.strides());
     assert(is_contiguous(gamma.dimension(), gamma.strides()));
-    kernels::layernorm(input.data().data(), sum.data().data(),
-                       sum_sqr.data().data(), gamma.data().data(),
-                       beta.data().data(), input.dimension(), input.strides(),
+    kernels::layernorm(input.cdata().data(), sum.data().data(),
+                       sum_sqr.data().data(), output.data().data(),
+                       gamma.data().data(), beta.data().data(),
+                       input.dimension(), input.strides(), output.strides(),
                        sum.strides(), gamma.strides(), eps, axis, norm_size);
 }
 
-template <typename T, loc_t Loc>
-void layernorm(tensor<T, Loc> &input, tensor<T, loc_t::local> &sum,
-               tensor<T, loc_t::local> &sum_sqr, int32_t axis,
-               int32_t norm_size) {
-    kernels::layernorm(input.data().data(), sum.data().data(),
-                       sum_sqr.data().data(), static_cast<T *>(nullptr),
-                       static_cast<T *>(nullptr), input.dimension(),
-                       input.strides(), sum.strides(), dims_t({}),
-                       static_cast<T>(1e-5), axis, norm_size);
+template <typename T, loc_t ALoc, loc_t BLoc>
+void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
+               tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
+               int32_t axis, int32_t norm_size) {
+    kernels::layernorm(input.cdata().data(), sum.data().data(),
+                       sum_sqr.data().data(), output.data().data(),
+                       static_cast<T *>(nullptr), static_cast<T *>(nullptr),
+                       input.dimension(), input.strides(), output.strides(),
+                       sum.strides(), dims_t({}), static_cast<T>(1e-5), axis,
+                       norm_size);
 }
 
 template <typename T, loc_t ALoc>
@@ -343,10 +344,10 @@ enum class reduce_strategy_t : uint8_t {
  * @param axis axis of gather tensor, note gather tensor dims = [32,...]
  * @param ctx
  */
-template <class T>
-void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
-                           tensor<T, loc_t::local> &dest, reduce_op_t reduce_op,
-                           reduce_strategy_t strategy, thread_context &ctx) {
+template <class T, loc_t ALoc, loc_t BLoc>
+void tdma_all_reduce_async(tensor<T, ALoc> &src, tensor<T, BLoc> &dest,
+                           reduce_op_t reduce_op, reduce_strategy_t strategy,
+                           thread_context &ctx) {
     __tdma_all_sync_apply(
         [&src, &ctx](int visited) -> void {
             tensor<T> *gather_tensor = nullptr;
@@ -366,7 +367,7 @@ void tdma_all_reduce_async(tensor<T, loc_t::local> &src,
             dims_t shape(new_dims);
             begin[0] = ctx.bid() * CORES + ctx.tid();
             shape[0] = 1;
-            __tensor_copy_sync<T, loc_t::local, loc_t::local>(
+            __tensor_copy_sync<T, loc_t::local, ALoc>(
                 std::move((*gather_tensor)(begin, shape)),
                 std::move(unsqueeze(src)));
         },
diff --git a/modules/cpu/src/runtime/cmodel/include/unary.h b/modules/cpu/src/runtime/cmodel/include/unary.h
index 94c1a893bf..bf1f825999 100644
--- a/modules/cpu/src/runtime/cmodel/include/unary.h
+++ b/modules/cpu/src/runtime/cmodel/include/unary.h
@@ -63,6 +63,7 @@ void unary_impl(unary_op_t op, const T *input, T *output,
         UNARY_IMPL_OP(sqrt, sqrtf);
         UNARY_IMPL_OP(square, [](float v) { return v * v; });
         UNARY_IMPL_OP(tanh, tanhf);
+        UNARY_IMPL_OP(swish, [](float x) { return x / (1 + exp(-x)); });
     default:
         return;
     }
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
index 2762c943b8..452a98cd90 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
@@ -90,7 +90,7 @@ void stage1_kernel(
     tdma_fill_async(gamma, 1.0f);
     tensor<float> beta({256});
     tdma_fill_async(beta, 0.0f);
-    layernorm(xj, r_sum, r_sum_sqr, gamma, beta, 1e-5f, 1, 8192);
+    layernorm(xj, r_sum, r_sum_sqr, xj, gamma, beta, 1e-5f, 1, 8192);
     tdma_store_async(xj, Norm({0, (bid * CORES + tid) * 256}, {384, 256}), ctx);
 
     // tensor_sum_sqr(xj, r_sum, r_sum_sqr);
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
index be1819265a..32b9938c28 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
@@ -123,7 +123,7 @@ void stage2_kernel(
     tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum,
                           reduce_strategy_t::by_block, ctx);
     tdma_wait(ctx);
-    layernorm(ym_b, sum, sum_sqr, 1, 8192);
+    layernorm(ym_b, sum, sum_sqr, ym_b, 1, 8192);
 
     tdma_store_async(ym_b, Norm({tid * 96, bid * 1024}, {96, 1024}), ctx);
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index f4191636ed..4664207170 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -13,6 +13,9 @@ static tensor<float> v35_w({1024, 2048});
 static tensor<float> v3_data({384, 128});
 static tensor<float> v11_data({384, 128});
 static tensor<int64_t> position_ids({1, 384});
+static tensor<float> v38_w({2048, 22016});
+static tensor<float> v40_w({2048, 22016});
+static tensor<float> v42_w({5504, 8192});
 
 void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
                    tensor<float, loc_t::device> &V0_gamma,  /* [8192] */
@@ -24,12 +27,17 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
                    tensor<float, loc_t::device> &V3_data,  /* [384, 128] */
                    tensor<float, loc_t::device> &V11_data, /* [384, 128] */
                    tensor<float, loc_t::device> &Attn_mask, /* [1,1,384,384] */
-                   tensor<int64_t, loc_t::device> &Position_ids /* [1,384] */
+                   tensor<float, loc_t::device> &V38_w,     /* [8192, 22016] */
+                   tensor<float, loc_t::device> &V40_w,     /* [8192, 22016] */
+                   tensor<float, loc_t::device> &V42_w,     /* [22016, 8192] */
+                   tensor<int64_t, loc_t::device> &Position_ids, /* [1,384] */
+                   tensor<float, loc_t::device> &Output /* [1,384,8192] */
 ) {
     thread_context ctx(bid, tid);
     tensor<float> v0_gamma({2048});
     tensor<float> v0_beta({2048});
-    tensor<float> v0({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t]  */
+    tensor<float> v0({1, 48, 2048});    /* [1, 384, 8192] [1, 48@b, 2048@t]  */
+    tensor<float> var_5({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t]  */
 
     tensor<float> attn_mask(
         {1, 1, 384, 384}); /* [1,1,384,384] [1,1,96@t,96@t] */
@@ -45,6 +53,9 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
                         ctx);
         tdma_load_async(v35_w, V35_w({1024 * bid, 2048 * tid}, {1024, 2048}),
                         ctx);
+        tdma_load_async(v38_w, V38_w({2048 * tid, 22016}, {2048, 22016}), ctx);
+        tdma_load_async(v40_w, V40_w({2048 * tid, 22016}, {2048, 22016}), ctx);
+        tdma_load_async(v42_w, V42_w({5504 * tid, 8192}, {5504, 8192}), ctx);
         tdma_load_async(v3_data, std::move(V3_data), ctx);
         tdma_load_async(v11_data, std::move(V11_data), ctx);
         tdma_load_async(position_ids, std::move(Position_ids), ctx);
@@ -63,7 +74,7 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
         reduce_sum_sqr(v0, v0_sum, v0_sum_sqr);
         tdma_reduce_async(v0_sum, v0_sum, reduce_op_t::sum, ctx);
         tdma_reduce_async(v0_sum_sqr, v0_sum_sqr, reduce_op_t::sum, ctx);
-        layernorm(v0, v0_sum, v0_sum_sqr, 2, 8192);
+        layernorm(v0, v0_sum, v0_sum_sqr, v0, 2, 8192);
     } // v0 [1, 384, 8192] [1, 48@b, 8192]
 
     auto v1 = unsqueeze(v0); // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
@@ -166,5 +177,66 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
         transpose(V32, V33, dims_t({0, 2, 1, 3}));
     }
     tdma_wait(ctx);
-    // auto v34 =
+    // [1, 384, 8192] [1, 96@t, 1024@b] @shared
+    auto v34 = view(V33, {1, 384, 1024})({0, tid * 96, 0}, {1, 96, 1024});
+
+    //[1, 96@t, 1024@b]@shared x [1024@b, 2048@t]@shared -> [1, 96@t,
+    // 2048@t]@shared.
+    auto v35 = V35({0, tid * 96, tid * 2048}, {1, 96, 2048});
+    matmul(v34, v35_w, v35);
+    /* need a all reduce for each block shared tensor */
+    tdma_all_reduce_async(v35, v35, reduce_op_t::sum,
+                          reduce_strategy_t::by_block, ctx);
+    //  note now resplit V35 here.
+    tdma_load_async(var_5, Hidden_in({0, bid * 48, tid * 2048}, {1, 48, 2048}),
+                    ctx);
+    tensor<float> v36({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t] */
+    auto v35_1 = V35({0, bid * 48, tid * 2048}, {1, 48, 2048});
+    binary(var_5, v35_1, v36, binary_op_t::add);
+
+    tensor<float> v37({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t] */
+    {
+        tensor<float> v36_sum({1, 48});
+        tensor<float> v36_sum_sqr({1, 48});
+        reduce_sum_sqr(v36, v36_sum, v36_sum_sqr);
+        tdma_reduce_async(v36_sum, v36_sum, reduce_op_t::sum, ctx);
+        tdma_reduce_async(v36_sum_sqr, v36_sum_sqr, reduce_op_t::sum, ctx);
+        layernorm(v36, v36_sum, v36_sum_sqr, v37, 2, 8192);
+    }
+    /* [1, 48@b, 2048@t] @ [2048@t, 22016] ->  v38 [1, 384, 22016] [1, 48@b,
+     * 22016]@shared */
+    tensor_block_mma_sync(v37, v38_w, V38, false, ctx);
+
+    /*  [1, 384, 22016] [1, 48@b, 5504@t] @ shared */
+    auto v39 = V38({0, 0, 5504 * tid}, {1, 48, 5504});
+    unary(v39, v39, unary_op_t::swish);
+
+    /* [1, 384, 8192]    @ [8192, 22016] -> [1, 384, 22016]
+       [1, 48@b, 2048@t] @  [2048@t, 22016] -> [1, 48@b, 22016] @shared
+    */
+    tensor_block_mma_sync(v37, v40_w, V40, false, ctx);
+    /*
+    [1, 384, 22016] X  [1, 384, 22016] -> [1, 384, 22016]
+    [1, 48@b, 5504@t] @ shared X [1, 48@b, 5504@t] @shared -> [1, 48@b, 5504@t]
+    @local
+    */
+    tensor<float> v41({1, 48, 5504});
+    auto v40 = V40({0, 0, 5504 * tid}, {1, 48, 5504});
+    binary(v39, v40, v41, binary_op_t::mul);
+
+    /*
+      [1, 384, 22016] @ [22016, 8192] -> [1, 384, 8192]
+      [1, 48@b, 5504@t] @ [5504@t, 8192] -> [1, 48@b, 8192] @shared
+    */
+    tensor_block_mma_sync(v41, v42_w, V42, false, ctx);
+
+    /*
+      [1, 384, 8192] + [1, 384, 8192] -> [1, 384, 8192]
+      [1, 48@b, 2048@t] + [1, 48@b, 2048@t] @shared -> [1, 48@b, 2048@t]
+    */
+    tensor<float> v43({1, 48, 2048});
+    auto v42 = V42({0, 0, 2048 * tid}, {0, 0, 2048});
+    binary(v36, v42, v43, binary_op_t::add);
+    tdma_store_async(v42, Output({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
+                     ctx);
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index 456f531f9d..7cb89b9fe3 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -5,9 +5,9 @@
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(Hidden_in, V0_gamma, V0_beta, V2_w, \
-                                           V16_w, V31_w, V35_w, V3_data,       \
-                                           V11_data, Attn_mask, Position_ids); \
+        block##b::thread##t::stage1_kernel(                                    \
+            Hidden_in, V0_gamma, V0_beta, V2_w, V16_w, V31_w, V35_w, V3_data,  \
+            V11_data, Attn_mask, V38_w, V40_w, V42_w, Position_ids, Output);   \
         return arg;                                                            \
     }
 
@@ -27,7 +27,11 @@ static tensor<float, loc_t::device> V35_w({8192, 8192});
 static tensor<float, loc_t::device> V3_data({384, 128});
 static tensor<float, loc_t::device> V11_data({384, 128});
 static tensor<float, loc_t::device> Attn_mask({1, 1, 384, 384});
+static tensor<float, loc_t::device> V38_w({8192, 22016});
+static tensor<float, loc_t::device> V40_w({8192, 22016});
+static tensor<float, loc_t::device> V42_w({22016, 8192});
 static tensor<int64_t, loc_t::device> Position_ids({1, 384});
+static tensor<float, loc_t::device> Output({1, 384, 8192});
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
@@ -55,17 +59,21 @@ int main([[maybe_unused]] int argc, char **argv) {
     // spdlog::set_level(spdlog::level::debug);
     global_hardware_init();
 
-    LOAD_FILE(Hidden_in, 0, float)
-    LOAD_FILE(V0_gamma, 1, float)
-    LOAD_FILE(V0_beta, 2, float)
-    LOAD_FILE(V2_w, 3, float)
-    LOAD_FILE(V16_w, 4, float)
-    LOAD_FILE(V31_w, 5, float)
-    LOAD_FILE(V35_w, 6, float)
-    LOAD_FILE(V3_data, 7, float)
-    LOAD_FILE(V11_data, 8, float)
-    LOAD_FILE(Attn_mask, 9, float)
-    LOAD_FILE(Position_ids, 10, int64_t)
+    LOAD_FILE(Hidden_in, 1, float);
+    LOAD_FILE(V0_gamma, 2, float);
+    LOAD_FILE(V0_beta, 3, float);
+    LOAD_FILE(V2_w, 4, float);
+    LOAD_FILE(V16_w, 5, float);
+    LOAD_FILE(V31_w, 6, float);
+    LOAD_FILE(V35_w, 7, float);
+    LOAD_FILE(V3_data, 8, float);
+    LOAD_FILE(V11_data, 9, float);
+    LOAD_FILE(Attn_mask, 10, float);
+    LOAD_FILE(V38_w, 11, float);
+    LOAD_FILE(V40_w, 12, float);
+    LOAD_FILE(V42_w, 13, float);
+    LOAD_FILE(Position_ids, 14, int64_t);
+    LOAD_FILE(Output, 15, float);
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
index c7f91c012e..780c4b7ebb 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
@@ -16,4 +16,11 @@ static tensor<float, loc_t::shared>
 static tensor<float, loc_t::shared>
     V33({1, 384, 8, 128}); // [1, 384, 64, 128] [1, 384, 8@b, 128]
 
+static tensor<float, loc_t::shared> V35({1, 96, 2048}); // [1, 384, 8192]
+
+static tensor<float, loc_t::shared> V38({1, 48, 22016}); // [1, 384, 8192] [1, 48@b, 22016]
+
+static tensor<float, loc_t::shared> V40({1, 48, 22016}); // [1, 384, 8192] [1, 48@b, 22016]
+
+static tensor<float, loc_t::shared> V42({1, 48, 8192}); // [1, 384, 8192] [1, 48@b, 8192]
 } // namespace shared
\ No newline at end of file

From 3f9805ce9d3a734fa3a7b7b5b8291e68cf1e8734 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 28 Aug 2023 14:58:39 +0800
Subject: [PATCH 128/308] support multiple output compare

---
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 34 +++++++++++--------
 .../src/runtime/cmodel/tests/demo3/main.cpp   | 24 +++++++++----
 2 files changed, 37 insertions(+), 21 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index 4664207170..b18fc9bacf 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -17,21 +17,23 @@ static tensor<float> v38_w({2048, 22016});
 static tensor<float> v40_w({2048, 22016});
 static tensor<float> v42_w({5504, 8192});
 
-void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
-                   tensor<float, loc_t::device> &V0_gamma,  /* [8192] */
-                   tensor<float, loc_t::device> &V0_beta,   /* [8192] */
-                   tensor<float, loc_t::device> &V2_w,     /* [64, 8192, 128] */
-                   tensor<float, loc_t::device> &V16_w,    /* [64, 8192, 128] */
-                   tensor<float, loc_t::device> &V31_w,    /* [64, 8192, 128] */
-                   tensor<float, loc_t::device> &V35_w,    /* [8192, 8192] */
-                   tensor<float, loc_t::device> &V3_data,  /* [384, 128] */
-                   tensor<float, loc_t::device> &V11_data, /* [384, 128] */
-                   tensor<float, loc_t::device> &Attn_mask, /* [1,1,384,384] */
-                   tensor<float, loc_t::device> &V38_w,     /* [8192, 22016] */
-                   tensor<float, loc_t::device> &V40_w,     /* [8192, 22016] */
-                   tensor<float, loc_t::device> &V42_w,     /* [22016, 8192] */
-                   tensor<int64_t, loc_t::device> &Position_ids, /* [1,384] */
-                   tensor<float, loc_t::device> &Output /* [1,384,8192] */
+void stage1_kernel(
+    tensor<float, loc_t::device> &Hidden_in,              /* [1, 384, 8192] */
+    tensor<float, loc_t::device> &V0_gamma,               /* [8192] */
+    tensor<float, loc_t::device> &V0_beta,                /* [8192] */
+    tensor<float, loc_t::device> &V2_w,                   /* [64, 8192, 128] */
+    tensor<float, loc_t::device> &V16_w,                  /* [64, 8192, 128] */
+    tensor<float, loc_t::device> &V31_w,                  /* [64, 8192, 128] */
+    tensor<float, loc_t::device> &V35_w,                  /* [8192, 8192] */
+    tensor<float, loc_t::device> &V3_data,                /* [384, 128] */
+    tensor<float, loc_t::device> &V11_data,               /* [384, 128] */
+    tensor<float, loc_t::device> &Attn_mask,              /* [1,1,384,384] */
+    tensor<float, loc_t::device> &V38_w,                  /* [8192, 22016] */
+    tensor<float, loc_t::device> &V40_w,                  /* [8192, 22016] */
+    tensor<float, loc_t::device> &V42_w,                  /* [22016, 8192] */
+    tensor<int64_t, loc_t::device> &Position_ids,         /* [1,384] */
+    tensor<float, loc_t::device> &Output,                 /* [1,384,8192] */
+    [[maybe_unused]] std::vector<tensor<float, loc_t::device>> &ImmOutputs /* [1,384,8192] */
 ) {
     thread_context ctx(bid, tid);
     tensor<float> v0_gamma({2048});
@@ -75,6 +77,8 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
         tdma_reduce_async(v0_sum, v0_sum, reduce_op_t::sum, ctx);
         tdma_reduce_async(v0_sum_sqr, v0_sum_sqr, reduce_op_t::sum, ctx);
         layernorm(v0, v0_sum, v0_sum_sqr, v0, 2, 8192);
+        tdma_store_async(v0, ImmOutputs[0]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
+                     ctx);
     } // v0 [1, 384, 8192] [1, 48@b, 8192]
 
     auto v1 = unsqueeze(v0); // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index 7cb89b9fe3..ff80a78a2d 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -7,7 +7,8 @@
     void *f_##b##_##t(void *arg) {                                             \
         block##b::thread##t::stage1_kernel(                                    \
             Hidden_in, V0_gamma, V0_beta, V2_w, V16_w, V31_w, V35_w, V3_data,  \
-            V11_data, Attn_mask, V38_w, V40_w, V42_w, Position_ids, Output);   \
+            V11_data, Attn_mask, V38_w, V40_w, V42_w, Position_ids, Output,    \
+            ImmOutputs);                                                       \
         return arg;                                                            \
     }
 
@@ -33,6 +34,11 @@ static tensor<float, loc_t::device> V42_w({22016, 8192});
 static tensor<int64_t, loc_t::device> Position_ids({1, 384});
 static tensor<float, loc_t::device> Output({1, 384, 8192});
 
+static std::vector<tensor<float, loc_t::device>> goldenImmOutputs;
+
+static std::vector<tensor<float, loc_t::device>> ImmOutputs{
+    tensor<float, loc_t::device>({1, 384, 8192})};
+
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
 DEFINE_BFUNC(2)
@@ -73,7 +79,12 @@ int main([[maybe_unused]] int argc, char **argv) {
     LOAD_FILE(V40_w, 12, float);
     LOAD_FILE(V42_w, 13, float);
     LOAD_FILE(Position_ids, 14, int64_t);
-    LOAD_FILE(Output, 15, float);
+
+    goldenImmOutputs.push_back(tensor<float, loc_t::device>({1, 384, 8192}));
+    for (auto o = 0; o < goldenImmOutputs.size(); o++) {
+        auto output = goldenImmOutputs[o];
+        LOAD_FILE(output, 15 + o, float);
+    }
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
@@ -146,10 +157,11 @@ int main([[maybe_unused]] int argc, char **argv) {
     pthread_join(t_7_2, NULL);
     pthread_join(t_7_3, NULL);
 
-    // auto cos = cosine(QKH.data().begin(),
-    //                   gsl::make_span(src_QKH).as_span<float>().begin(),
-    //                   QKH.data().size());
-    // printf("QKH cosine %f\n", cos);
+    for (auto o = 0; o < ImmOutputs.size(); o++) {
+        auto cos = cosine(ImmOutputs[o].data().begin(), goldenImmOutputs[o].data().begin(),
+                          goldenImmOutputs[o].data().size());
+        printf("input layernorm cosine %f\n", cos);
+    }
 
     return 0;
 }
\ No newline at end of file

From fc8b6634772fbf4f179afe9fda90ea983481eb67 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 28 Aug 2023 16:18:12 +0800
Subject: [PATCH 129/308] fix MHA kernel

---
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 47 ++++++++++---------
 .../src/runtime/cmodel/tests/demo3/main.cpp   | 19 ++++----
 2 files changed, 35 insertions(+), 31 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index b18fc9bacf..f821b3733d 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -18,23 +18,22 @@ static tensor<float> v40_w({2048, 22016});
 static tensor<float> v42_w({5504, 8192});
 
 void stage1_kernel(
-    tensor<float, loc_t::device> &Hidden_in,              /* [1, 384, 8192] */
-    tensor<float, loc_t::device> &V0_gamma,               /* [8192] */
-    tensor<float, loc_t::device> &V0_beta,                /* [8192] */
-    tensor<float, loc_t::device> &V2_w,                   /* [64, 8192, 128] */
-    tensor<float, loc_t::device> &V16_w,                  /* [64, 8192, 128] */
-    tensor<float, loc_t::device> &V31_w,                  /* [64, 8192, 128] */
-    tensor<float, loc_t::device> &V35_w,                  /* [8192, 8192] */
-    tensor<float, loc_t::device> &V3_data,                /* [384, 128] */
-    tensor<float, loc_t::device> &V11_data,               /* [384, 128] */
-    tensor<float, loc_t::device> &Attn_mask,              /* [1,1,384,384] */
-    tensor<float, loc_t::device> &V38_w,                  /* [8192, 22016] */
-    tensor<float, loc_t::device> &V40_w,                  /* [8192, 22016] */
-    tensor<float, loc_t::device> &V42_w,                  /* [22016, 8192] */
-    tensor<int64_t, loc_t::device> &Position_ids,         /* [1,384] */
-    tensor<float, loc_t::device> &Output,                 /* [1,384,8192] */
-    [[maybe_unused]] std::vector<tensor<float, loc_t::device>> &ImmOutputs /* [1,384,8192] */
-) {
+    tensor<float, loc_t::device> &Hidden_in,               /* [1, 384, 8192] */
+    tensor<float, loc_t::device> &V0_gamma,                /* [8192] */
+    tensor<float, loc_t::device> &V0_beta,                 /* [8192] */
+    tensor<float, loc_t::device> &V2_w,                    /* [64, 8192, 128] */
+    tensor<float, loc_t::device> &V16_w,                   /* [64, 8192, 128] */
+    tensor<float, loc_t::device> &V31_w,                   /* [64, 8192, 128] */
+    tensor<float, loc_t::device> &V35_w,                   /* [8192, 8192] */
+    tensor<float, loc_t::device> &V3_data,                 /* [384, 128] */
+    tensor<float, loc_t::device> &V11_data,                /* [384, 128] */
+    tensor<float, loc_t::device> &Attn_mask,               /* [1,1,384,384] */
+    tensor<float, loc_t::device> &V38_w,                   /* [8192, 22016] */
+    tensor<float, loc_t::device> &V40_w,                   /* [8192, 22016] */
+    tensor<float, loc_t::device> &V42_w,                   /* [22016, 8192] */
+    tensor<int64_t, loc_t::device> &Position_ids,          /* [1,384] */
+    [[maybe_unused]] tensor<float, loc_t::device> &Output, /* [1,384,8192] */
+    [[maybe_unused]] tensor<float, loc_t::device> *ImmOutputs) {
     thread_context ctx(bid, tid);
     tensor<float> v0_gamma({2048});
     tensor<float> v0_beta({2048});
@@ -42,7 +41,7 @@ void stage1_kernel(
     tensor<float> var_5({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t]  */
 
     tensor<float> attn_mask(
-        {1, 1, 384, 384}); /* [1,1,384,384] [1,1,96@t,96@t] */
+        {1, 1, 96, 96}); /* [1,1,384,384] [1,1,96@t,96@t] */
 
     if (!w_loaded) {
         tdma_load_async(v0_gamma, V0_gamma({tid * 2048}, {2048}), ctx);
@@ -55,9 +54,9 @@ void stage1_kernel(
                         ctx);
         tdma_load_async(v35_w, V35_w({1024 * bid, 2048 * tid}, {1024, 2048}),
                         ctx);
-        tdma_load_async(v38_w, V38_w({2048 * tid, 22016}, {2048, 22016}), ctx);
-        tdma_load_async(v40_w, V40_w({2048 * tid, 22016}, {2048, 22016}), ctx);
-        tdma_load_async(v42_w, V42_w({5504 * tid, 8192}, {5504, 8192}), ctx);
+        tdma_load_async(v38_w, V38_w({2048 * tid, 0}, {2048, 22016}), ctx);
+        tdma_load_async(v40_w, V40_w({2048 * tid, 0}, {2048, 22016}), ctx);
+        tdma_load_async(v42_w, V42_w({5504 * tid, 0}, {5504, 8192}), ctx);
         tdma_load_async(v3_data, std::move(V3_data), ctx);
         tdma_load_async(v11_data, std::move(V11_data), ctx);
         tdma_load_async(position_ids, std::move(Position_ids), ctx);
@@ -77,10 +76,11 @@ void stage1_kernel(
         tdma_reduce_async(v0_sum, v0_sum, reduce_op_t::sum, ctx);
         tdma_reduce_async(v0_sum_sqr, v0_sum_sqr, reduce_op_t::sum, ctx);
         layernorm(v0, v0_sum, v0_sum_sqr, v0, 2, 8192);
-        tdma_store_async(v0, ImmOutputs[0]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
-                     ctx);
+        tdma_store_async(
+            v0, ImmOutputs[0]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
     } // v0 [1, 384, 8192] [1, 48@b, 8192]
 
+#if 0
     auto v1 = unsqueeze(v0); // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
     /* 这里如果V2不shared的话可以只做thread间的reduce */
     tensor_block_mma_sync(v1, v2_w, V2, false, ctx);
@@ -243,4 +243,5 @@ void stage1_kernel(
     binary(v36, v42, v43, binary_op_t::add);
     tdma_store_async(v42, Output({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
                      ctx);
+#endif
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index ff80a78a2d..e537f92bf5 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -34,9 +34,11 @@ static tensor<float, loc_t::device> V42_w({22016, 8192});
 static tensor<int64_t, loc_t::device> Position_ids({1, 384});
 static tensor<float, loc_t::device> Output({1, 384, 8192});
 
-static std::vector<tensor<float, loc_t::device>> goldenImmOutputs;
+const int OutNum = 1;
+static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
+    tensor<float, loc_t::device>({1, 384, 8192})};
 
-static std::vector<tensor<float, loc_t::device>> ImmOutputs{
+static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 384, 8192})};
 
 DEFINE_BFUNC(0)
@@ -80,10 +82,10 @@ int main([[maybe_unused]] int argc, char **argv) {
     LOAD_FILE(V42_w, 13, float);
     LOAD_FILE(Position_ids, 14, int64_t);
 
-    goldenImmOutputs.push_back(tensor<float, loc_t::device>({1, 384, 8192}));
-    for (auto o = 0; o < goldenImmOutputs.size(); o++) {
-        auto output = goldenImmOutputs[o];
-        LOAD_FILE(output, 15 + o, float);
+    for (auto o = 0; o < OutNum; o++) {
+        auto src_output = read_file(std::string(argv[(15 + o)]));
+        span_copy(goldenImmOutputs[o].data(),
+                  gsl::make_span(src_output).as_span<float>());
     }
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
@@ -157,8 +159,9 @@ int main([[maybe_unused]] int argc, char **argv) {
     pthread_join(t_7_2, NULL);
     pthread_join(t_7_3, NULL);
 
-    for (auto o = 0; o < ImmOutputs.size(); o++) {
-        auto cos = cosine(ImmOutputs[o].data().begin(), goldenImmOutputs[o].data().begin(),
+    for (auto o = 0; o < OutNum; o++) {
+        auto cos = cosine(ImmOutputs[o].data().begin(),
+                          goldenImmOutputs[o].data().begin(),
                           goldenImmOutputs[o].data().size());
         printf("input layernorm cosine %f\n", cos);
     }

From a1f21c520a7036b970646a8bd40a8e0d017c2fc4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 28 Aug 2023 16:21:51 +0800
Subject: [PATCH 130/308] resplit v2

---
 .../cpu/src/runtime/cmodel/tests/demo3/kernel.h    | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index f821b3733d..9f7c84c48f 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -82,15 +82,25 @@ void stage1_kernel(
 
 #if 0
     auto v1 = unsqueeze(v0); // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
-    /* 这里如果V2不shared的话可以只做thread间的reduce */
+    /* 
+      [1, 1, 384, 8192]    @ [64, 8192, 128]  -> [1, 64, 384, 128]
+      [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1, 64, 48@b, 128] @ shared
+     */
     tensor_block_mma_sync(v1, v2_w, V2, false, ctx);
 
-    tensor<float> v3({1, 384, 128}); //
+    tensor<float> v3({1, 384, 128});
+    /* 
+      [384, 128][[1, 384]]  -> [1, 384, 128]
+    */
     gather(v3_data, position_ids, v3, 0);
 
     auto v4 = unsqueeze(v3); /* 1, 1, 384, 128 */
 
     tensor<float> v5({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+    /*
+      [1, 64, 384, 128]           X   [1, 1, 384, 128] ->  [1, 64, 384, 128]
+      [1, 64, 48@b, 128] @ shared X   [1, 1, 384, 128] ->  [1, 64, 384, 128]
+    */
     binary(V2, v4, v5, binary_op_t::mul);
 
     auto v6 =

From 99b28754fe1e71d462507eef3326732df866ce5d Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 28 Aug 2023 16:42:21 +0800
Subject: [PATCH 131/308] fix MHA kernel

---
 modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h     | 9 ++++++---
 modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp     | 8 +++++---
 modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h | 2 +-
 3 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index f821b3733d..25639c1af7 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -6,7 +6,7 @@
 using namespace shared;
 
 static bool w_loaded;
-static tensor<float> v2_w({8, 2048, 128});
+static tensor<float> v2_w({64, 2048, 128});
 static tensor<float> v16_w({8, 2048, 128});
 static tensor<float> v31_w({8, 2048, 128});
 static tensor<float> v35_w({1024, 2048});
@@ -46,7 +46,7 @@ void stage1_kernel(
     if (!w_loaded) {
         tdma_load_async(v0_gamma, V0_gamma({tid * 2048}, {2048}), ctx);
         tdma_load_async(v0_beta, V0_beta({tid * 2048}, {2048}), ctx);
-        tdma_load_async(v2_w, V2_w({8 * bid, 2048 * tid, 0}, {8, 2048, 128}),
+        tdma_load_async(v2_w, V2_w({0, 2048 * tid, 0}, {64, 2048, 128}),
                         ctx);
         tdma_load_async(v16_w, V16_w({8 * bid, 2048 * tid, 0}, {8, 2048, 128}),
                         ctx);
@@ -80,11 +80,14 @@ void stage1_kernel(
             v0, ImmOutputs[0]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
     } // v0 [1, 384, 8192] [1, 48@b, 8192]
 
-#if 0
     auto v1 = unsqueeze(v0); // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
     /* 这里如果V2不shared的话可以只做thread间的reduce */
     tensor_block_mma_sync(v1, v2_w, V2, false, ctx);
+    if (tid ==0 )
+    tdma_store_async(
+            V2, ImmOutputs[1]({0, 0, 48 * bid, 0}, {1, 64, 48, 128}), ctx);
 
+#if 0
     tensor<float> v3({1, 384, 128}); //
     gather(v3_data, position_ids, v3, 0);
 
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index e537f92bf5..6436f7d964 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -34,12 +34,14 @@ static tensor<float, loc_t::device> V42_w({22016, 8192});
 static tensor<int64_t, loc_t::device> Position_ids({1, 384});
 static tensor<float, loc_t::device> Output({1, 384, 8192});
 
-const int OutNum = 1;
+const int OutNum = 2;
 static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
-    tensor<float, loc_t::device>({1, 384, 8192})};
+    tensor<float, loc_t::device>({1, 384, 8192}),
+    tensor<float, loc_t::device>({1, 64, 384, 128})};
 
 static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
-    tensor<float, loc_t::device>({1, 384, 8192})};
+    tensor<float, loc_t::device>({1, 384, 8192}),
+    tensor<float, loc_t::device>({1, 64, 384, 128})};
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
index 780c4b7ebb..7de5351d93 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
@@ -2,7 +2,7 @@
 
 namespace shared {
 static tensor<float, loc_t::shared>
-    V2({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+    V2({1, 64, 48, 128}); // [1, 64, 384, 128] [1, 64, 48@b, 128]
 static tensor<float, loc_t::shared>
     V16({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
 static tensor<float, loc_t::shared>

From 0b81dba2543fe889bf1ced4b6aa23e260a8d4a2b Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Mon, 28 Aug 2023 20:07:09 +0800
Subject: [PATCH 132/308] to v26

---
 .../src/runtime/cmodel/tests/demo3/golden.py  |   7 +-
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 173 +++++++++++-------
 .../src/runtime/cmodel/tests/demo3/main.cpp   |  21 ++-
 .../runtime/cmodel/tests/demo3/shared_def.h   |  21 ++-
 4 files changed, 149 insertions(+), 73 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
index 42f72d7c62..0e8c9582f1 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
@@ -13,7 +13,7 @@ def swish(x:np.ndarray):
 def gather(data:np.ndarray, axis:int, indices:np.ndarray):
     return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
 
-const_dir = "/compiler/huochenghai/GNNE/rebuild-ir/nncase/modules/cpu/src/runtime/cmodel/tests/demo3/golden/"
+const_dir = "/root/workspace/golden"
 
 hidden_in = np.reshape(np.fromfile(os.path.join(const_dir,"input_0_0.bin"), dtype=np.float32), (1, 384, 8192))
 attn_mask = np.reshape(np.fromfile(os.path.join(const_dir,"input_1_0.bin"), dtype=np.float32), (1, 1, 384, 384))
@@ -42,9 +42,12 @@ def gather(data:np.ndarray, axis:int, indices:np.ndarray):
 v0.tofile("v0.bin")
 v1 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
 v2 = (v1 @ WQ) # f32[1,64,384,128]
+v2.tofile("v2.bin")
 v3 = gather1_data[position_ids] # f32[1,384,128]
+v3.tofile("v3.bin")
 v4 = np.reshape(v3, (1,1,384,128))
 v5 = v2 * v4 # f32[1,64,384,128]
+v5.tofile("v5.bin")
 v6 = v2[:,:,:,64:] # Slice(v3, const(i64[1] : {64L}), const(i64[1] : {9223372036854775807}), 3, 1) # f32[1,64,384,64]
 v7 = -(v6) # f32[1,64,384,64]
 v8 = v2[:,:,:,0:64] # Slice(v3, 0, 64, 3, 1) # f32[1,64,384,64]
@@ -55,6 +58,7 @@ def gather(data:np.ndarray, axis:int, indices:np.ndarray):
 v12 = np.reshape(v11, (1,1,384,128))
 v13 = v10 * v12 # f32[1,64,384,128]
 v14 = v5 + v13 # f32[1,64,384,128]
+v14.tofile("v14.bin")
 v15 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
 v16 = (v15 @ WK) # f32[1,64,384,128]
 v17 = v16 * v4 # f32[1,64,384,128]
@@ -68,6 +72,7 @@ def gather(data:np.ndarray, axis:int, indices:np.ndarray):
 v24 = v17 + v23 # f32[1,64,384,128]
 v25 = np.transpose(v24, [0,1,3,2]) # f32[1,64,128,384]
 v26 = v14 @ v25 # f32[1,64,384,384]
+v26.tofile("v26.bin")
 v27 = (v26/ 11.31370) # f32[1,64,384,384]
 v28 = v27 + attn_mask # f32[1,64,384,384]
 v29 = softmax(v28, -1) # f32[1,64,384,384]
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index 7e3f3c4511..4dc4d7f9e5 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -7,12 +7,12 @@ using namespace shared;
 
 static bool w_loaded;
 static tensor<float> v2_w({64, 2048, 128});
-static tensor<float> v16_w({8, 2048, 128});
+static tensor<float> v16_w({64, 2048, 128});
 static tensor<float> v31_w({8, 2048, 128});
 static tensor<float> v35_w({1024, 2048});
-static tensor<float> v3_data({384, 128});
-static tensor<float> v11_data({384, 128});
-static tensor<int64_t> position_ids({1, 384});
+static tensor<float> v3_data({384, 32});
+static tensor<float> v11_data({384, 32});
+static tensor<int64_t> position_ids({1, 48});
 static tensor<float> v38_w({2048, 22016});
 static tensor<float> v40_w({2048, 22016});
 static tensor<float> v42_w({5504, 8192});
@@ -33,6 +33,7 @@ void stage1_kernel(
     tensor<float, loc_t::device> &V42_w,                   /* [22016, 8192] */
     tensor<int64_t, loc_t::device> &Position_ids,          /* [1,384] */
     [[maybe_unused]] tensor<float, loc_t::device> &Output, /* [1,384,8192] */
+    tensor<float, loc_t::device> &V25,
     [[maybe_unused]] tensor<float, loc_t::device> *ImmOutputs) {
     thread_context ctx(bid, tid);
     tensor<float> v0_gamma({2048});
@@ -40,16 +41,13 @@ void stage1_kernel(
     tensor<float> v0({1, 48, 2048});    /* [1, 384, 8192] [1, 48@b, 2048@t]  */
     tensor<float> var_5({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t]  */
 
-    tensor<float> attn_mask(
-        {1, 1, 96, 96}); /* [1,1,384,384] [1,1,96@t,96@t] */
+    tensor<float> attn_mask({1, 1, 96, 96}); /* [1,1,384,384] [1,1,96@t,96@t] */
 
     if (!w_loaded) {
         tdma_load_async(v0_gamma, V0_gamma({tid * 2048}, {2048}), ctx);
         tdma_load_async(v0_beta, V0_beta({tid * 2048}, {2048}), ctx);
-        tdma_load_async(v2_w, V2_w({0, 2048 * tid, 0}, {64, 2048, 128}),
-                        ctx);
-        tdma_load_async(v16_w, V16_w({8 * bid, 2048 * tid, 0}, {8, 2048, 128}),
-                        ctx);
+        tdma_load_async(v2_w, V2_w({0, 2048 * tid, 0}, {64, 2048, 128}), ctx);
+        tdma_load_async(v16_w, V16_w({0, 2048 * tid, 0}, {64, 2048, 128}), ctx);
         tdma_load_async(v31_w, V31_w({8 * bid, 2048 * tid, 0}, {8, 2048, 128}),
                         ctx);
         tdma_load_async(v35_w, V35_w({1024 * bid, 2048 * tid}, {1024, 2048}),
@@ -57,9 +55,10 @@ void stage1_kernel(
         tdma_load_async(v38_w, V38_w({2048 * tid, 0}, {2048, 22016}), ctx);
         tdma_load_async(v40_w, V40_w({2048 * tid, 0}, {2048, 22016}), ctx);
         tdma_load_async(v42_w, V42_w({5504 * tid, 0}, {5504, 8192}), ctx);
-        tdma_load_async(v3_data, std::move(V3_data), ctx);
-        tdma_load_async(v11_data, std::move(V11_data), ctx);
-        tdma_load_async(position_ids, std::move(Position_ids), ctx);
+        tdma_load_async(v3_data, V3_data({0, 32 * tid}, {384, 32}), ctx);
+        tdma_load_async(v11_data, V11_data({0, 32 * tid}, {384, 32}), ctx);
+        tdma_load_async(position_ids, Position_ids({0, 48 * bid}, {1, 48}),
+                        ctx);
         tdma_load_async(attn_mask,
                         Attn_mask({0, 0, tid * 96, tid * 96}, {1, 1, 96, 96}),
                         ctx);
@@ -81,86 +80,136 @@ void stage1_kernel(
     } // v0 [1, 384, 8192] [1, 48@b, 8192]
 
     auto v1 = unsqueeze(v0); // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
-    /* 
+    /*
       [1, 1, 384, 8192]    @ [64, 8192, 128]  -> [1, 64, 384, 128]
       [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1, 64, 48@b, 128] @ shared
      */
     tensor_block_mma_sync(v1, v2_w, V2, false, ctx);
-    if (tid ==0 )
-    tdma_store_async(
+    if (tid == 0) {
+        tdma_store_async(
             V2, ImmOutputs[1]({0, 0, 48 * bid, 0}, {1, 64, 48, 128}), ctx);
+    }
+    __tdma_all_sync_apply([]([[maybe_unused]] int v) -> void {},
+                          []() -> void {}, ctx); /* for store */
 
-#if 0
-    tensor<float> v3({1, 384, 128}); //
+    /*
+      [384, 128][[1, 384]] -> [1, 384, 128]
+      [384, 32@t][[1, 48@b]] -> [1, 48@b, 32@t]
+    */
+    tensor<float> v3({1, 48, 32});
     gather(v3_data, position_ids, v3, 0);
+    tdma_store_async(v3, ImmOutputs[4]({0, 48 * bid, 32 * tid}, {1, 48, 32}),
+                     ctx);
 
-    auto v4 = unsqueeze(v3); /* 1, 1, 384, 128 */
+    auto v4 = unsqueeze(v3); /* 1, 1, 48, 32 */
 
-    tensor<float> v5({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
     /*
       [1, 64, 384, 128]           X   [1, 1, 384, 128] ->  [1, 64, 384, 128]
-      [1, 64, 48@b, 128] @ shared X   [1, 1, 384, 128] ->  [1, 64, 384, 128]
+      [1, 64, 48@b, 32@t] @ shared X   [1, 1, 48@b, 32@t] ->  [1, 64, 48@b,
+      32@t] @ shared
     */
-    binary(V2, v4, v5, binary_op_t::mul);
+    auto v5_ = V5({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    auto v2_ = V2({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    binary(v2_, v4, v5_, binary_op_t::mul);
+    __tdma_all_sync_apply([]([[maybe_unused]] int v) -> void {},
+                          []() -> void {}, ctx); /* for store */
+    tdma_store_async(
+        v5_, ImmOutputs[2]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}), ctx);
 
-    auto v6 =
-        V2({0, 0, 0, 64}, {1, 8, 384, 64}); //[1, 64, 384, 64] [1, 8@b, 384, 64]
+    auto v6 = V2({0, 16 * tid, 0, 64}, {1, 16, 48, 64});
     auto v7 = v6;
-    if (tid == 0) {
-        /* V2 is shared, so don't need perfrom on each thread. */
-        unary(v6, v7, unary_op_t::neg);
-    }
-    tdma_wait(ctx);
+    /*
+      [1, 64, 384, 64:] -> [1, 64, 384, 64:]
+      [1, 64, 48@b, 64] ->  [1, 16@t, 48@b, 64]
+    */
+    unary(v6, v7, unary_op_t::neg);
 
-    // auto v8 = v2({0, 0, 0, 0}, {1, 8, 384, 64}); //[1, 64, 384, 64] [1, 8@b,
-    // 384, 64]@shared
     /* v10 为concat(v7,v8), 实际来源于V2，因此无需实际动作 */
-    // [1, 64, 384, 128] [1, 8@b, 384, 128]@shared ->
-    // [1, 8@b, 96@t, 128]@shared here can resplit .
-    auto v10 = V2({0, 0, tid * 96, 0}, {1, 8, 96, 128});
+    auto v10 = V2({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
 
-    tensor<float> v11({1, 384, 128}); //[1, 384, 128] [1, 384, 128]
+    /*
+      [384, 128][[1, 384]] -> [1, 384, 128]
+      [384, 32@t][[1, 48@b]] -> [1, 48@b, 32@t]
+    */
+    tensor<float> v11({1, 48, 32});
     gather(v11_data, position_ids, v11, 0);
-    auto v12 = unsqueeze(v11); // [1, 1, 384, 128] [1, 1, 384, 128]
-
-    tensor<float> v13({1, 8, 96, 128}); // [1, 64, 384, 128] [1, 8@b, 96@t, 128]
-    binary(v10, v12, v13, binary_op_t::mul);
+    auto v12 = unsqueeze(v11); // [1, 1, 384, 128] [1, 1, 48@b, 32@t]
 
-    tensor<float> v14({1, 8, 96, 128}); // [1, 64, 384, 128] [1, 8@b, 96@t, 128]
-    binary(v5, v13, v14, binary_op_t::add);
+    /*
+      [1, 64, 384, 128]           X   [1, 1, 384, 128] ->  [1, 64, 384, 128]
+      [1, 64, 48@b, 32@t] @ shared X   [1, 1, 48@b, 32@t] ->  [1, 64, 48@b,
+      32@t] @ shared
+    */
+    auto v13_ = V13({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    // auto v2_ = V2({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    binary(v2_, v12, v13_, binary_op_t::mul);
 
-    // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
-    tensor<float> v15 = v0({0, bid * 48, tid * 2048}, {1, 48, 2048});
+    __tdma_all_sync_apply([]([[maybe_unused]] int v) -> void {},
+                          []() -> void {}, ctx); /* wait v5,v13 */
+    /*
+    [1, 64, 384, 128] + [1, 64, 384, 128] -> [1, 64, 384, 128]
+    [1, 64, 48@b, 32@t] + [1, 64, 48@b, 32@t] -> [1, 64, 48@b, 32@t]
+    */
+    tensor<float> v14({1, 16, 48, 32});
+    auto v5__ = V5({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    auto v13__ = V13({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    binary(v5__, v13__, v14, binary_op_t::add);
+    tdma_store_async(
+        v14, ImmOutputs[3]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}), ctx);
 
+    tensor<float> v15 = v0;
+    /*
+      [1,1,384,8192] @ [64, 8192, 128] -> [1,64,384,128]
+      [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1,64,48@b,128]@shared
+    */
     tensor_block_mma_sync(v15, v16_w, V16, false, ctx);
-    tensor<float> v17({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
-    binary(V16, v4, v17, binary_op_t ::mul);
 
-    // [1, 64, 384, 64] [1, 8@b, 384, 64]@shared
-    auto v18 = V16({0, 0, 0, 64}, {1, 8, 384, 64});
-    if (tid == 0) {
-        unary(v18, v18, unary_op_t::neg);
-    }
-    tdma_wait(ctx);
+    /*
+      [1,64,384,128] X [1,64,384,128] -> [1,64,384,128]
+      [1,64,48@b,32@t]@shared X [1,1,48@b,32@t] ->  [1,64,48@b,32@t]
+    */
+    tensor<float> v17({1, 64, 48, 32});
+    binary(V16, v4, v17, binary_op_t ::mul);
 
-    //[1, 64, 384, 128] [1, 8@b, 96@t, 128]@shared
-    auto v22 = V16({0, 0, tid * 96, 0}, {1, 8, 96, 128});
+    auto v18 = V16({0, 16 * tid, 0, 64}, {1, 16, 48, 64});
+    /*
+      [1, 64, 384, 64:] -> [1, 64, 384, 64:]
+      [1, 64, 48@b, 64]@shared ->  [1, 16@t, 48@b, 64]@shared
+    */
+    unary(v18, v18, unary_op_t::neg);
 
-    // [1, 64, 384, 128] [1, 8@b, 96@t, 128]@shared
-    tensor<float> v23({1, 8, 96, 128});
+    /*
+      [1,64,384,128] x [1,1,384,128] ->  [1,64,384,128]
+      [1, 64, 48@b, 32@t]@shared x [1, 1, 48@b, 32@t] -> [1, 64, 48@b, 32@t]
+    */
+    tensor<float> v23({1, 64, 48, 32});
+    auto v22 = V16({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     binary(v22, v12, v23, binary_op_t::mul);
 
-    // [1, 64, 384, 128] [1, 8@b, 96@t, 128]
-    tensor<float> v24({1, 8, 96, 128});
+    tensor<float> v24({1, 64, 48, 32});
+    /*
+      [1,64,384,128] + [1,1,384,128] ->  [1,64,384,128]
+      [1, 64, 48@b, 32@t] + [1, 1, 48@b, 32@t] -> [1, 64, 48@b, 32@t]
+    */
     binary(v17, v23, v24, binary_op_t::add);
 
-    // [1, 64, 128, 384] [1, 8@b, 128, 96@t]
-    tensor<float> v25({1, 8, 128, 96});
+    tensor<float> v25({1, 64, 32, 48});
     transpose(v24, v25, dims_t({0, 1, 3, 2}));
+    tdma_store_async(v25, V25({0, 0, 32 * tid, 48 * bid}, {1, 64, 32, 48}),
+                     ctx);
+    __tdma_all_sync_apply([]([[maybe_unused]] int v) -> void {},
+                          []() -> void {}, ctx); /* for store */
 
-    // [1, 8@b, 96@t, 128] @  [1, 8@b, 128, 96@t] => [1, 8@b, 96@t, 96@t]
-    auto v26 = V26({0, 0, tid * 96, tid * 96}, {1, 8, 96, 96});
-    matmul(v14, v25, v26);
+    /*
+      [1, 64, 384, 128] @ [1, 64, 128, 384] -> [1, 64, 384, 384]
+      [1, 64, 48@b, 32@t] @ [1, 64, 32@t, 384] -> [1, 64, 48@b, 384]
+    */
+    tensor<float> v25_1({1, 64, 32, 384});
+    tdma_load_async(v25_1, V25({0, 0, 32 * tid, 384}, {1, 64, 32, 384}), ctx);
+    tensor_block_mma_sync(v14, v25_1, V26, false, ctx);
+    tdma_store_async(V26, ImmOutputs[5]({0, 0, 0, 96 * tid}, {1, 64, 48, 96}),
+                     ctx);
+#if 0
 
     // [1, 64, 384, 384] [1, 8@b, 96@t, 96@t] @shared
     auto v27 = v26;
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index 6436f7d964..ff9ac6088b 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -8,7 +8,7 @@
         block##b::thread##t::stage1_kernel(                                    \
             Hidden_in, V0_gamma, V0_beta, V2_w, V16_w, V31_w, V35_w, V3_data,  \
             V11_data, Attn_mask, V38_w, V40_w, V42_w, Position_ids, Output,    \
-            ImmOutputs);                                                       \
+            V25, ImmOutputs);                                                   \
         return arg;                                                            \
     }
 
@@ -33,15 +33,26 @@ static tensor<float, loc_t::device> V40_w({8192, 22016});
 static tensor<float, loc_t::device> V42_w({22016, 8192});
 static tensor<int64_t, loc_t::device> Position_ids({1, 384});
 static tensor<float, loc_t::device> Output({1, 384, 8192});
+static tensor<float, loc_t::device> V25({1, 64, 128, 384});
 
-const int OutNum = 2;
+constexpr int OutNum = 6;
 static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 384, 8192}),
-    tensor<float, loc_t::device>({1, 64, 384, 128})};
+    tensor<float, loc_t::device>({1, 64, 384, 128}),
+    tensor<float, loc_t::device>({1, 64, 384, 128}),
+    tensor<float, loc_t::device>({1, 64, 384, 128}),
+    tensor<float, loc_t::device>({1, 384, 128}),
+    tensor<float, loc_t::device>({1, 64, 384, 384}),
+};
 
 static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 384, 8192}),
-    tensor<float, loc_t::device>({1, 64, 384, 128})};
+    tensor<float, loc_t::device>({1, 64, 384, 128}),
+    tensor<float, loc_t::device>({1, 64, 384, 128}),
+    tensor<float, loc_t::device>({1, 64, 384, 128}),
+    tensor<float, loc_t::device>({1, 384, 128}),
+    tensor<float, loc_t::device>({1, 64, 384, 384}),
+};
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
@@ -165,7 +176,7 @@ int main([[maybe_unused]] int argc, char **argv) {
         auto cos = cosine(ImmOutputs[o].data().begin(),
                           goldenImmOutputs[o].data().begin(),
                           goldenImmOutputs[o].data().size());
-        printf("input layernorm cosine %f\n", cos);
+        printf("%s cosine %f\n", argv[15 + o], cos);
     }
 
     return 0;
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
index 7de5351d93..5da6684129 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
@@ -3,10 +3,18 @@
 namespace shared {
 static tensor<float, loc_t::shared>
     V2({1, 64, 48, 128}); // [1, 64, 384, 128] [1, 64, 48@b, 128]
+
+static tensor<float, loc_t::shared> V5({1, 64, 48, 128});
+
+static tensor<float, loc_t::shared> V13({1, 64, 48, 128});
+
+static tensor<float, loc_t::shared>
+    V16({1, 64, 48, 128}); // [1, 64, 48, 128] [1, 64, 48@b, 128]
+
 static tensor<float, loc_t::shared>
-    V16({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+    V25({1, 64, 128, 384}); // [1, 64, 384, 128] [1, 8@b, 384, 384]
 static tensor<float, loc_t::shared>
-    V26({1, 8, 384, 384}); // [1, 64, 384, 128] [1, 8@b, 384, 384]
+    V26({1, 64, 48, 384}); // [1, 64, 384, 128] [1, 8@b, 384, 384]
 
 static tensor<float, loc_t::shared>
     V31({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
@@ -18,9 +26,12 @@ static tensor<float, loc_t::shared>
 
 static tensor<float, loc_t::shared> V35({1, 96, 2048}); // [1, 384, 8192]
 
-static tensor<float, loc_t::shared> V38({1, 48, 22016}); // [1, 384, 8192] [1, 48@b, 22016]
+static tensor<float, loc_t::shared>
+    V38({1, 48, 22016}); // [1, 384, 8192] [1, 48@b, 22016]
 
-static tensor<float, loc_t::shared> V40({1, 48, 22016}); // [1, 384, 8192] [1, 48@b, 22016]
+static tensor<float, loc_t::shared>
+    V40({1, 48, 22016}); // [1, 384, 8192] [1, 48@b, 22016]
 
-static tensor<float, loc_t::shared> V42({1, 48, 8192}); // [1, 384, 8192] [1, 48@b, 8192]
+static tensor<float, loc_t::shared>
+    V42({1, 48, 8192}); // [1, 384, 8192] [1, 48@b, 8192]
 } // namespace shared
\ No newline at end of file

From 6684eb3060e3d5f3af7c6d468318d3e993a15042 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Tue, 29 Aug 2023 10:52:57 +0800
Subject: [PATCH 133/308] push

---
 modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h | 10 ++++++----
 modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp | 12 ++++++------
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index 4dc4d7f9e5..d72feb9a36 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -150,7 +150,7 @@ void stage1_kernel(
     [1, 64, 384, 128] + [1, 64, 384, 128] -> [1, 64, 384, 128]
     [1, 64, 48@b, 32@t] + [1, 64, 48@b, 32@t] -> [1, 64, 48@b, 32@t]
     */
-    tensor<float> v14({1, 16, 48, 32});
+    tensor<float> v14({1, 64, 48, 32});
     auto v5__ = V5({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     auto v13__ = V13({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     binary(v5__, v13__, v14, binary_op_t::add);
@@ -205,10 +205,12 @@ void stage1_kernel(
       [1, 64, 48@b, 32@t] @ [1, 64, 32@t, 384] -> [1, 64, 48@b, 384]
     */
     tensor<float> v25_1({1, 64, 32, 384});
-    tdma_load_async(v25_1, V25({0, 0, 32 * tid, 384}, {1, 64, 32, 384}), ctx);
+    tdma_load_async(v25_1, V25({0, 0, 32 * tid, 0}, {1, 64, 32, 384}), ctx);
     tensor_block_mma_sync(v14, v25_1, V26, false, ctx);
-    tdma_store_async(V26, ImmOutputs[5]({0, 0, 0, 96 * tid}, {1, 64, 48, 96}),
-                     ctx);
+    if (tid == 0) {
+        tdma_store_async(
+            V26, ImmOutputs[5]({0, 0, 48 * bid, 0}, {1, 64, 48, 384}), ctx);
+    }
 #if 0
 
     // [1, 64, 384, 384] [1, 8@b, 96@t, 96@t] @shared
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index ff9ac6088b..9938fe615f 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -37,12 +37,12 @@ static tensor<float, loc_t::device> V25({1, 64, 128, 384});
 
 constexpr int OutNum = 6;
 static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
-    tensor<float, loc_t::device>({1, 384, 8192}),
-    tensor<float, loc_t::device>({1, 64, 384, 128}),
-    tensor<float, loc_t::device>({1, 64, 384, 128}),
-    tensor<float, loc_t::device>({1, 64, 384, 128}),
-    tensor<float, loc_t::device>({1, 384, 128}),
-    tensor<float, loc_t::device>({1, 64, 384, 384}),
+    tensor<float, loc_t::device>({1, 384, 8192}),    // v0
+    tensor<float, loc_t::device>({1, 64, 384, 128}), // v2
+    tensor<float, loc_t::device>({1, 64, 384, 128}), // v5
+    tensor<float, loc_t::device>({1, 64, 384, 128}), // v14
+    tensor<float, loc_t::device>({1, 384, 128}),     // v3
+    tensor<float, loc_t::device>({1, 64, 384, 384}), // v26
 };
 
 static tensor<float, loc_t::device> ImmOutputs[OutNum] = {

From 89f238ef18ac6df37a2e493075b2162993a9b165 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Tue, 29 Aug 2023 11:32:53 +0800
Subject: [PATCH 134/308] fix double free

---
 modules/cpu/src/runtime/cmodel/include/tensor.h     | 2 ++
 modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h | 4 ++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index b7a6170f72..7bc684ee14 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -16,6 +16,8 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
 
   public:
     using value_type = T;
+    tensor(tensor<T, Loc> &) = delete;
+    tensor &operator=(tensor<T, Loc> &) = delete;
 
     tensor(dims_t dims)
         : dims_(dims),
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index d72feb9a36..02cfe803f8 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -117,7 +117,7 @@ void stage1_kernel(
         v5_, ImmOutputs[2]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}), ctx);
 
     auto v6 = V2({0, 16 * tid, 0, 64}, {1, 16, 48, 64});
-    auto v7 = v6;
+    auto &v7 = v6;
     /*
       [1, 64, 384, 64:] -> [1, 64, 384, 64:]
       [1, 64, 48@b, 64] ->  [1, 16@t, 48@b, 64]
@@ -157,7 +157,7 @@ void stage1_kernel(
     tdma_store_async(
         v14, ImmOutputs[3]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}), ctx);
 
-    tensor<float> v15 = v0;
+    tensor<float> &v15 = v0;
     /*
       [1,1,384,8192] @ [64, 8192, 128] -> [1,64,384,128]
       [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1,64,48@b,128]@shared

From 6ab10dd35797843ad299523d72003fd2cec4ab06 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 29 Aug 2023 13:47:17 +0800
Subject: [PATCH 135/308] fix mha kernel

---
 modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index 02cfe803f8..42f6479272 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -33,7 +33,7 @@ void stage1_kernel(
     tensor<float, loc_t::device> &V42_w,                   /* [22016, 8192] */
     tensor<int64_t, loc_t::device> &Position_ids,          /* [1,384] */
     [[maybe_unused]] tensor<float, loc_t::device> &Output, /* [1,384,8192] */
-    tensor<float, loc_t::device> &V25,
+    [[maybe_unused]] tensor<float, loc_t::device> &V25,
     [[maybe_unused]] tensor<float, loc_t::device> *ImmOutputs) {
     thread_context ctx(bid, tid);
     tensor<float> v0_gamma({2048});
@@ -169,7 +169,9 @@ void stage1_kernel(
       [1,64,48@b,32@t]@shared X [1,1,48@b,32@t] ->  [1,64,48@b,32@t]
     */
     tensor<float> v17({1, 64, 48, 32});
-    binary(V16, v4, v17, binary_op_t ::mul);
+    auto v16 = V16({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    binary(v16, v4, v17, binary_op_t ::mul);
+    tdma_wait(ctx);
 
     auto v18 = V16({0, 16 * tid, 0, 64}, {1, 16, 48, 64});
     /*

From 83a1f04f55dcca7d9e7e0e5c91b799f42980cc8c Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Tue, 29 Aug 2023 13:47:56 +0800
Subject: [PATCH 136/308] fix  V35

---
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 99 +++++++++++--------
 .../src/runtime/cmodel/tests/demo3/main.cpp   |  3 +-
 .../runtime/cmodel/tests/demo3/shared_def.h   | 10 +-
 3 files changed, 67 insertions(+), 45 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index 02cfe803f8..4d23ec9ff9 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -8,8 +8,8 @@ using namespace shared;
 static bool w_loaded;
 static tensor<float> v2_w({64, 2048, 128});
 static tensor<float> v16_w({64, 2048, 128});
-static tensor<float> v31_w({8, 2048, 128});
-static tensor<float> v35_w({1024, 2048});
+static tensor<float> v31_w({64, 2048, 128});
+static tensor<float> v35_w({2048, 8192});
 static tensor<float> v3_data({384, 32});
 static tensor<float> v11_data({384, 32});
 static tensor<int64_t> position_ids({1, 48});
@@ -33,7 +33,7 @@ void stage1_kernel(
     tensor<float, loc_t::device> &V42_w,                   /* [22016, 8192] */
     tensor<int64_t, loc_t::device> &Position_ids,          /* [1,384] */
     [[maybe_unused]] tensor<float, loc_t::device> &Output, /* [1,384,8192] */
-    tensor<float, loc_t::device> &V25,
+    tensor<float, loc_t::device> &V25, tensor<float, loc_t::device> &GV31,
     [[maybe_unused]] tensor<float, loc_t::device> *ImmOutputs) {
     thread_context ctx(bid, tid);
     tensor<float> v0_gamma({2048});
@@ -41,17 +41,15 @@ void stage1_kernel(
     tensor<float> v0({1, 48, 2048});    /* [1, 384, 8192] [1, 48@b, 2048@t]  */
     tensor<float> var_5({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t]  */
 
-    tensor<float> attn_mask({1, 1, 96, 96}); /* [1,1,384,384] [1,1,96@t,96@t] */
+    tensor<float> attn_mask({1, 1, 48, 384});
 
     if (!w_loaded) {
         tdma_load_async(v0_gamma, V0_gamma({tid * 2048}, {2048}), ctx);
         tdma_load_async(v0_beta, V0_beta({tid * 2048}, {2048}), ctx);
         tdma_load_async(v2_w, V2_w({0, 2048 * tid, 0}, {64, 2048, 128}), ctx);
         tdma_load_async(v16_w, V16_w({0, 2048 * tid, 0}, {64, 2048, 128}), ctx);
-        tdma_load_async(v31_w, V31_w({8 * bid, 2048 * tid, 0}, {8, 2048, 128}),
-                        ctx);
-        tdma_load_async(v35_w, V35_w({1024 * bid, 2048 * tid}, {1024, 2048}),
-                        ctx);
+        tdma_load_async(v31_w, V31_w({0, 2048 * tid, 0}, {64, 2048, 128}), ctx);
+        tdma_load_async(v35_w, V35_w({2048 * tid, 0}, {2048, 8192}), ctx);
         tdma_load_async(v38_w, V38_w({2048 * tid, 0}, {2048, 22016}), ctx);
         tdma_load_async(v40_w, V40_w({2048 * tid, 0}, {2048, 22016}), ctx);
         tdma_load_async(v42_w, V42_w({5504 * tid, 0}, {5504, 8192}), ctx);
@@ -60,8 +58,7 @@ void stage1_kernel(
         tdma_load_async(position_ids, Position_ids({0, 48 * bid}, {1, 48}),
                         ctx);
         tdma_load_async(attn_mask,
-                        Attn_mask({0, 0, tid * 96, tid * 96}, {1, 1, 96, 96}),
-                        ctx);
+                        Attn_mask({0, 0, 48 * bid, 0}, {1, 1, 48, 384}), ctx);
 
         tdma_wait(ctx);
     }
@@ -202,7 +199,7 @@ void stage1_kernel(
 
     /*
       [1, 64, 384, 128] @ [1, 64, 128, 384] -> [1, 64, 384, 384]
-      [1, 64, 48@b, 32@t] @ [1, 64, 32@t, 384] -> [1, 64, 48@b, 384]
+      [1, 64, 48@b, 32@t] @ [1, 64, 32@t, 384] -> [1, 64, 48@b, 384]@shared
     */
     tensor<float> v25_1({1, 64, 32, 384});
     tdma_load_async(v25_1, V25({0, 0, 32 * tid, 0}, {1, 64, 32, 384}), ctx);
@@ -211,44 +208,68 @@ void stage1_kernel(
         tdma_store_async(
             V26, ImmOutputs[5]({0, 0, 48 * bid, 0}, {1, 64, 48, 384}), ctx);
     }
-#if 0
 
-    // [1, 64, 384, 384] [1, 8@b, 96@t, 96@t] @shared
-    auto v27 = v26;
+    /* [1, 64, 384, 384]           / 11.31370  -> [1, 64, 384, 384]
+       [1, 16@t, 48@b, 384]@shared   / 11.31370 -> [1, 16@t, 48@b, 384]@shared
+    */
+    auto v27 = V26({0, 16 * tid, 0, 0}, {1, 16, 48, 384});
     auto v26_c = tensor<float>({1, 1, 1, 1});
     tdma_fill_async(v26_c, 11.313708f);
-    binary(v26, v26_c, v27, binary_op_t::div);
-
-    // [1, 64, 384, 384] [1, 8@b, 96@t, 96@t] @shared
-    auto v28 = v27;
-    binary(v27, attn_mask, v28, binary_op_t::div);
+    binary(v27, v26_c, v27, binary_op_t::div);
 
-    // resplit need sync.
-    tdma_wait(ctx);
-    auto v28_1 = V26({0, 0, tid * 96, 0}, {1, 8, 96, 384});
-    tensor<float> v29({1, 8, 96, 384}); //[1, 64, 384, 384] [1, 8@b, 96@t, 384]
-    softmax(v28_1, v29, 3);
+    /* [1, 64, 384, 384] + [1,1,384,384] -> [1, 64, 384, 384]
+       [1, 16@t, 48@b, 384]@shared + [1, 1, 48@b, 384] -> [1, 16@t, 48@b,
+       384]@shared
+    */
+    auto &v28 = v27;
+    binary(v27, attn_mask, v28, binary_op_t::add);
 
-    //  [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
-    auto v30 = unsqueeze(v0);
+    /*
+      [1, 64, 384, 384] -> [1, 64, 384, 384]
+      [1, 16@t, 48@b, 384]@shared -> [1, 16@t, 48@b, 384]
+    */
+    tensor<float> v29({1, 16, 48, 384}); //[1, 64, 384, 384] [1, 8@b, 96@t, 384]
+    softmax(v28, v29, 3);
 
+    /*
+      [1,1,384,8192] @ [64, 8192, 128] -> [1,64,384,128]
+      [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1, 64, 48@b, 128]@shared
+    */
+    auto &v30 = v1;
     tensor_block_mma_sync(v30, v31_w, V31, false, ctx);
 
-    // [1, 8@b, 384, 128]@local @ [1, 8@b, 384, 128]@shared
-    // [1, 64, 384, 128] [1, 8@b, 384, 128]
-    if (tid == 0) {
-        matmul(v29, V31, V32);
-        // V33 [1, 384, 64, 128] [1, 384, 8@b, 128]@shared
-        transpose(V32, V33, dims_t({0, 2, 1, 3}));
-    }
+    /* need resplit V */
+    auto v31 = V31({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
+    tdma_store_async(V31, GV31({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}),
+                     ctx);
+
+    /*
+      [1,64,384,384] @ [1,64,384,128] ->  [1,64,384,128]
+      [1, 16@t, 48@b, 384] @ [1, 16@t, 384, 128] -> [1, 16@t, 48@b, 128]@shared
+    */
+    tensor<float> v31_resplit({1, 16, 384, 128});
+    tdma_load_async(v31_resplit, GV31({0, 16 * tid, 0, 0}, {1, 16, 384, 128}),
+                    ctx);
+    auto v32 = V32({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
+    matmul(v29, V31, v32);
     tdma_wait(ctx);
-    // [1, 384, 8192] [1, 96@t, 1024@b] @shared
-    auto v34 = view(V33, {1, 384, 1024})({0, tid * 96, 0}, {1, 96, 1024});
 
-    //[1, 96@t, 1024@b]@shared x [1024@b, 2048@t]@shared -> [1, 96@t,
-    // 2048@t]@shared.
-    auto v35 = V35({0, tid * 96, tid * 2048}, {1, 96, 2048});
-    matmul(v34, v35_w, v35);
+    /*
+      [1, 64, 384, 128] -> [1, 384, 64, 128]
+      [1, 64, 48@b, 128]@shared -> [1, 48@b, 64, 128]@shared
+     */
+    auto v33 = V33({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
+    transpose(v32, v33, {0, 2, 1, 3});
+
+    /*
+    [1, 384, 8192] @ [8192, 8192] -> [1,384,8192]
+    [1, 48@b, 2048@t]@shared @ [2048@t, 8192] -> [1, 48@b, 8192]@shared
+     */
+    auto V34 = view(V33, {1, 48, 8192});
+    auto v34 = V34({0, 0, 2048 * tid}, {1, 48, 2048});
+    tensor_block_mma_sync(v34, v35_w, V35, false, ctx);
+
+#if 0
     /* need a all reduce for each block shared tensor */
     tdma_all_reduce_async(v35, v35, reduce_op_t::sum,
                           reduce_strategy_t::by_block, ctx);
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index 9938fe615f..208008b970 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -8,7 +8,7 @@
         block##b::thread##t::stage1_kernel(                                    \
             Hidden_in, V0_gamma, V0_beta, V2_w, V16_w, V31_w, V35_w, V3_data,  \
             V11_data, Attn_mask, V38_w, V40_w, V42_w, Position_ids, Output,    \
-            V25, ImmOutputs);                                                   \
+            V25, GV31,ImmOutputs);                                                  \
         return arg;                                                            \
     }
 
@@ -34,6 +34,7 @@ static tensor<float, loc_t::device> V42_w({22016, 8192});
 static tensor<int64_t, loc_t::device> Position_ids({1, 384});
 static tensor<float, loc_t::device> Output({1, 384, 8192});
 static tensor<float, loc_t::device> V25({1, 64, 128, 384});
+static tensor<float, loc_t::device> GV31({1, 64, 384, 128});
 
 constexpr int OutNum = 6;
 static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
index 5da6684129..0e9c8d924d 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
@@ -14,17 +14,17 @@ static tensor<float, loc_t::shared>
 static tensor<float, loc_t::shared>
     V25({1, 64, 128, 384}); // [1, 64, 384, 128] [1, 8@b, 384, 384]
 static tensor<float, loc_t::shared>
-    V26({1, 64, 48, 384}); // [1, 64, 384, 128] [1, 8@b, 384, 384]
+    V26({1, 64, 48, 384}); // [1, 64, 384, 128] [1, 64, 48@b, 384]
 
 static tensor<float, loc_t::shared>
-    V31({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+    V31({1, 64, 48, 128}); // [1, 64, 384, 128] [1, 64, 48@b, 128]
 
 static tensor<float, loc_t::shared>
-    V32({1, 8, 384, 128}); // [1, 64, 384, 128] [1, 8@b, 384, 128]
+    V32({1, 64, 48, 128}); // [1, 64, 384, 128] [1, 64, 48@b, 128]
 static tensor<float, loc_t::shared>
-    V33({1, 384, 8, 128}); // [1, 384, 64, 128] [1, 384, 8@b, 128]
+    V33({1, 48, 64, 128}); // [1, 384, 64, 128] [1, 48@b, 64, 128]
 
-static tensor<float, loc_t::shared> V35({1, 96, 2048}); // [1, 384, 8192]
+static tensor<float, loc_t::shared> V35({1, 48, 8192}); // [1, 384, 8192]
 
 static tensor<float, loc_t::shared>
     V38({1, 48, 22016}); // [1, 384, 8192] [1, 48@b, 22016]

From 36876777a40deb99eb00730a3dfb8e22b57efde9 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Tue, 29 Aug 2023 14:09:59 +0800
Subject: [PATCH 137/308] fix all

---
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 28 +++++++++++--------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index f28cc00b80..a712744ec1 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -271,16 +271,15 @@ void stage1_kernel(
     auto v34 = V34({0, 0, 2048 * tid}, {1, 48, 2048});
     tensor_block_mma_sync(v34, v35_w, V35, false, ctx);
 
-#if 0
-    /* need a all reduce for each block shared tensor */
-    tdma_all_reduce_async(v35, v35, reduce_op_t::sum,
-                          reduce_strategy_t::by_block, ctx);
-    //  note now resplit V35 here.
+    /*
+    [1,384,8192] +  [1,384,8192]  -> [1,384,8192]
+    [1, 48@b, 2048@tid]@shared +  [1, 48@b, 2048@tid] -> [1, 48@b, 2048@tid]
+     */
     tdma_load_async(var_5, Hidden_in({0, bid * 48, tid * 2048}, {1, 48, 2048}),
                     ctx);
+    auto v35 = V35({0, bid * 48, tid * 2048}, {1, 48, 2048});
     tensor<float> v36({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t] */
-    auto v35_1 = V35({0, bid * 48, tid * 2048}, {1, 48, 2048});
-    binary(var_5, v35_1, v36, binary_op_t::add);
+    binary(var_5, v35, v36, binary_op_t::add);
 
     tensor<float> v37({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t] */
     {
@@ -291,11 +290,16 @@ void stage1_kernel(
         tdma_reduce_async(v36_sum_sqr, v36_sum_sqr, reduce_op_t::sum, ctx);
         layernorm(v36, v36_sum, v36_sum_sqr, v37, 2, 8192);
     }
-    /* [1, 48@b, 2048@t] @ [2048@t, 22016] ->  v38 [1, 384, 22016] [1, 48@b,
-     * 22016]@shared */
+    /*
+      [1,384,8192] @ [8192, 22016] -> [1,384, 22016]
+      [1, 48@b, 2048@t] @ [2048@t, 22016] -> [1, 48@b, 22016]@shared
+    */
     tensor_block_mma_sync(v37, v38_w, V38, false, ctx);
 
-    /*  [1, 384, 22016] [1, 48@b, 5504@t] @ shared */
+    /*
+      [1,384, 22016] -> [1,384, 22016]
+      [1, 48@b, 5504@t]@shared -> [1, 48@b, 5504@t]@shared
+    */
     auto v39 = V38({0, 0, 5504 * tid}, {1, 48, 5504});
     unary(v39, v39, unary_op_t::swish);
 
@@ -305,8 +309,7 @@ void stage1_kernel(
     tensor_block_mma_sync(v37, v40_w, V40, false, ctx);
     /*
     [1, 384, 22016] X  [1, 384, 22016] -> [1, 384, 22016]
-    [1, 48@b, 5504@t] @ shared X [1, 48@b, 5504@t] @shared -> [1, 48@b, 5504@t]
-    @local
+    [1, 48@b, 5504@t]@shared X [1,48@b,5504@t]@shared -> [1, 48@b, 5504@t]@local
     */
     tensor<float> v41({1, 48, 5504});
     auto v40 = V40({0, 0, 5504 * tid}, {1, 48, 5504});
@@ -327,5 +330,6 @@ void stage1_kernel(
     binary(v36, v42, v43, binary_op_t::add);
     tdma_store_async(v42, Output({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
                      ctx);
+#if 0
 #endif
 }

From 78379bb47f2f33d6c2315eff3053ec40f0e521ea Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 29 Aug 2023 15:12:44 +0800
Subject: [PATCH 138/308] support rmsnrom

---
 modules/cpu/src/runtime/cmodel/include/layernorm.h | 10 +++++++---
 .../cpu/src/runtime/cmodel/tests/demo3/golden.py   | 14 ++++++++++----
 .../cpu/src/runtime/cmodel/tests/demo3/kernel.h    |  4 ++--
 3 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index b85cd2148a..b646a2b7b8 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -16,12 +16,16 @@ void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *output,
                           gsl::span<const size_t> output_stride,
                           [[maybe_unused]] gsl::span<const size_t> sum_strides,
                           gsl::span<const size_t> gamma_strides, T eps,
-                          int32_t axis, int32_t norm_size) noexcept {
+                          int32_t axis, int32_t norm_size,
+                          bool rms_norm = false) noexcept {
     apply(input_shape, [&](gsl::span<const size_t> input_index) -> void {
         //  input_index
         auto o_offset = offset(sum_strides, input_index.subspan(0, axis));
         // auto o_offset = input_index[0];
         auto mean = sum[o_offset] / norm_size;
+        if (rms_norm) {
+            mean = 0;
+        }
         auto sigma =
             std::sqrt(sum_sqr[o_offset] / norm_size - mean * mean + eps);
 
@@ -139,7 +143,7 @@ void layernorm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
                dims_t input_dims, strides_t input_strides,
                strides_t output_strides, strides_t sum_strides,
                strides_t gamma_strides, T eps, int32_t axis,
-               int32_t norm_size) {
+               int32_t norm_size, bool rms_norm = false) {
 #ifdef __riscv_vector
     return layernorm_rvv_impl(
         input, sum, sum_sqr, gamma, beta,
@@ -154,7 +158,7 @@ void layernorm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
         gsl::make_span(output_strides).template as_span<const size_t>(),
         gsl::make_span(sum_strides).template as_span<const size_t>(),
         gsl::make_span(gamma_strides).template as_span<const size_t>(), eps,
-        axis, norm_size);
+        axis, norm_size, rms_norm);
 #endif
 }
 } // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
index 0e8c9582f1..045c09abfa 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
@@ -4,6 +4,12 @@
 from scipy.special import softmax
 import os
 
+def rmsnorm(x:np.ndarray, gamma:np.ndarray, beta:np.ndarray, eps=1e-05):
+    x = torch.from_numpy(x)
+    output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
+    output = output * torch.from_numpy(gamma) + torch.from_numpy(beta)
+    return output.detach().numpy()
+
 def layernorm(x:np.ndarray, gamma:np.ndarray, beta:np.ndarray):
     return nn.functional.layer_norm(torch.from_numpy(x), [x.shape[-1]], torch.from_numpy(gamma), torch.from_numpy(beta)).detach().numpy()
 
@@ -13,7 +19,7 @@ def swish(x:np.ndarray):
 def gather(data:np.ndarray, axis:int, indices:np.ndarray):
     return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
 
-const_dir = "/root/workspace/golden"
+const_dir = "/compiler/huochenghai/GNNE/rebuild-ir/nncase/modules/cpu/src/runtime/cmodel/tests/demo3/golden"
 
 hidden_in = np.reshape(np.fromfile(os.path.join(const_dir,"input_0_0.bin"), dtype=np.float32), (1, 384, 8192))
 attn_mask = np.reshape(np.fromfile(os.path.join(const_dir,"input_1_0.bin"), dtype=np.float32), (1, 1, 384, 384))
@@ -38,7 +44,7 @@ def gather(data:np.ndarray, axis:int, indices:np.ndarray):
 mlp_down_weights = np.reshape(np.fromfile(os.path.join(const_dir,"_mlp_down_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (22016, 8192))
 
 # np.random.rand(8192).astype(np.float32), np.random.rand(8192).astype(np.float32)
-v0 = layernorm(hidden_in, input_ln_gamma, input_ln_beta) # f32[1,384,8192]
+v0 = rmsnorm(hidden_in, input_ln_gamma, input_ln_beta) # f32[1,384,8192]
 v0.tofile("v0.bin")
 v1 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
 v2 = (v1 @ WQ) # f32[1,64,384,128]
@@ -83,7 +89,7 @@ def gather(data:np.ndarray, axis:int, indices:np.ndarray):
 v34 = np.reshape(v33, [1,384,8192]) # f32[1,384,8192]
 v35 = v34 @ WO # f32[1,384,8192]
 v36 = (hidden_in + v35) # f32[1,384,8192]
-v37 = layernorm(v36, post_ln_gamma, post_ln_beta) # f32[1,384,8192]
+v37 = rmsnorm(v36, post_ln_gamma, post_ln_beta) # f32[1,384,8192]
 v38 = v37 @ mlp_gate_weights # f32[1,384,22016]
 v39 = swish(v38) # f32[1,384,22016]
 v40 = v37 @ mlp_up_weights # f32[1,384,22016]
@@ -91,4 +97,4 @@ def gather(data:np.ndarray, axis:int, indices:np.ndarray):
 v42 = v41 @ mlp_down_weights # f32[1,384,8192]
 v43 = v36 + v42 # f32[1,384,8192]
 
-# v46.tofile("")
\ No newline at end of file
+v43.tofile("v43.bin")
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index 42f6479272..aa48f33b17 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -74,7 +74,7 @@ void stage1_kernel(
         reduce_sum_sqr(v0, v0_sum, v0_sum_sqr);
         tdma_reduce_async(v0_sum, v0_sum, reduce_op_t::sum, ctx);
         tdma_reduce_async(v0_sum_sqr, v0_sum_sqr, reduce_op_t::sum, ctx);
-        layernorm(v0, v0_sum, v0_sum_sqr, v0, 2, 8192);
+        layernorm(v0, v0_sum, v0_sum_sqr, v0, 2, 8192, true);
         tdma_store_async(
             v0, ImmOutputs[0]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
     } // v0 [1, 384, 8192] [1, 48@b, 8192]
@@ -268,7 +268,7 @@ void stage1_kernel(
         reduce_sum_sqr(v36, v36_sum, v36_sum_sqr);
         tdma_reduce_async(v36_sum, v36_sum, reduce_op_t::sum, ctx);
         tdma_reduce_async(v36_sum_sqr, v36_sum_sqr, reduce_op_t::sum, ctx);
-        layernorm(v36, v36_sum, v36_sum_sqr, v37, 2, 8192);
+        layernorm(v36, v36_sum, v36_sum_sqr, v37, 2, 8192, true);
     }
     /* [1, 48@b, 2048@t] @ [2048@t, 22016] ->  v38 [1, 384, 22016] [1, 48@b,
      * 22016]@shared */

From 66f08f7dc0b560eb350167188fbbe2d29477fec8 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Tue, 29 Aug 2023 17:01:38 +0800
Subject: [PATCH 139/308] fix v22

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 24 +++++++++------
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 30 ++++++++++++-------
 .../src/runtime/cmodel/tests/demo3/main.cpp   |  4 ++-
 3 files changed, 37 insertions(+), 21 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 730aa04e72..94e746d3fd 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -120,28 +120,28 @@ template <typename T, loc_t ALoc, loc_t BLoc>
 void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
                tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
                tensor<T, loc_t::local> &gamma, tensor<T, loc_t::local> &beta,
-               T eps, int32_t axis, int32_t norm_size) {
+               T eps, int32_t axis, int32_t norm_size, bool rms_norm = false) {
     assert(sum.strides() == sum_sqr.strides());
     assert(is_contiguous(sum.dimension(), sum.strides()));
     assert(gamma.strides() == beta.strides());
     assert(is_contiguous(gamma.dimension(), gamma.strides()));
-    kernels::layernorm(input.cdata().data(), sum.data().data(),
-                       sum_sqr.data().data(), output.data().data(),
-                       gamma.data().data(), beta.data().data(),
-                       input.dimension(), input.strides(), output.strides(),
-                       sum.strides(), gamma.strides(), eps, axis, norm_size);
+    kernels::layernorm(
+        input.cdata().data(), sum.data().data(), sum_sqr.data().data(),
+        output.data().data(), gamma.data().data(), beta.data().data(),
+        input.dimension(), input.strides(), output.strides(), sum.strides(),
+        gamma.strides(), eps, axis, norm_size, rms_norm);
 }
 
 template <typename T, loc_t ALoc, loc_t BLoc>
 void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
                tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
-               int32_t axis, int32_t norm_size) {
+               int32_t axis, int32_t norm_size, bool rms_norm = false) {
     kernels::layernorm(input.cdata().data(), sum.data().data(),
                        sum_sqr.data().data(), output.data().data(),
                        static_cast<T *>(nullptr), static_cast<T *>(nullptr),
                        input.dimension(), input.strides(), output.strides(),
                        sum.strides(), dims_t({}), static_cast<T>(1e-5), axis,
-                       norm_size);
+                       norm_size, rms_norm);
 }
 
 template <typename T, loc_t ALoc>
@@ -310,7 +310,8 @@ void tdma_reduce_async(tensor<T, loc_t::local> &src,
             new_dims[0] = CORES;
             auto viewed_gather_tensor =
                 tensor<T>(gather_tensor->data().subspan(
-                              ctx.bid() * CORES * gather_tensor->strides()[0], CORES * gather_tensor->strides()[0]),
+                              ctx.bid() * CORES * gather_tensor->strides()[0],
+                              CORES * gather_tensor->strides()[0]),
                           new_dims, gather_tensor->strides());
 
             reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
@@ -446,6 +447,11 @@ void tdma_wait(thread_context &ctx) {
     __tdma_block_sync_apply([]([[maybe_unused]] int visited) -> void {}, ctx);
 }
 
+void tdma_all_wait(thread_context &ctx) {
+    __tdma_all_sync_apply([]([[maybe_unused]] int visited) -> void {},
+                          []() -> void {}, ctx);
+}
+
 void tdma_cancel() {}
 
 void tdma_status() {}
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index 3dd51f483a..dd6cb530c4 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -168,14 +168,18 @@ void stage1_kernel(
     tensor<float> v17({1, 64, 48, 32});
     auto v16 = V16({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     binary(v16, v4, v17, binary_op_t ::mul);
-    tdma_wait(ctx);
 
-    auto v18 = V16({0, 16 * tid, 0, 64}, {1, 16, 48, 64});
     /*
       [1, 64, 384, 64:] -> [1, 64, 384, 64:]
       [1, 64, 48@b, 64]@shared ->  [1, 16@t, 48@b, 64]@shared
     */
-    unary(v18, v18, unary_op_t::neg);
+    tensor<float> v19({1, 64, 48, 16});
+    auto v18 = V16({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16});
+    unary(v18, v19, unary_op_t::neg);
+    tdma_wait(ctx);
+    __tensor_copy_sync(V16({0, 0, 0, 16 * tid}, {1, 64, 48, 16}),
+                       V16({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16}));
+    __tensor_copy_sync(std::move(v19), V16({0, 0, 0, 16 * tid}, {1, 64, 48, 16}));
 
     /*
       [1,64,384,128] x [1,1,384,128] ->  [1,64,384,128]
@@ -184,6 +188,8 @@ void stage1_kernel(
     tensor<float> v23({1, 64, 48, 32});
     auto v22 = V16({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     binary(v22, v12, v23, binary_op_t::mul);
+    tdma_store_async(
+        v22, ImmOutputs[5]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}), ctx);
 
     tensor<float> v24({1, 64, 48, 32});
     /*
@@ -194,21 +200,20 @@ void stage1_kernel(
 
     tensor<float> v25({1, 64, 32, 48});
     transpose(v24, v25, dims_t({0, 1, 3, 2}));
-    tdma_store_async(v25, V25({0, 0, 32 * tid, 48 * bid}, {1, 64, 32, 48}),
-                     ctx);
-    __tdma_all_sync_apply([]([[maybe_unused]] int v) -> void {},
-                          []() -> void {}, ctx); /* for store */
 
     /*
       [1, 64, 384, 128] @ [1, 64, 128, 384] -> [1, 64, 384, 384]
       [1, 64, 48@b, 32@t] @ [1, 64, 32@t, 384] -> [1, 64, 48@b, 384]@shared
     */
+    tdma_store_async(v25, V25({0, 0, 32 * tid, 48 * bid}, {1, 64, 32, 48}),
+                     ctx);
     tensor<float> v25_1({1, 64, 32, 384});
     tdma_load_async(v25_1, V25({0, 0, 32 * tid, 0}, {1, 64, 32, 384}), ctx);
+    tdma_all_wait(ctx); /* for store */
     tensor_block_mma_sync(v14, v25_1, V26, false, ctx);
     if (tid == 0) {
         tdma_store_async(
-            V26, ImmOutputs[5]({0, 0, 48 * bid, 0}, {1, 64, 48, 384}), ctx);
+            V26, ImmOutputs[6]({0, 0, 48 * bid, 0}, {1, 64, 48, 384}), ctx);
     }
 
     /* [1, 64, 384, 384]           / 11.31370  -> [1, 64, 384, 384]
@@ -242,7 +247,7 @@ void stage1_kernel(
 
     /* need resplit V */
     auto v31 = V31({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
-    tdma_store_async(V31, GV31({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}),
+    tdma_store_async(v31, GV31({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}),
                      ctx);
 
     /*
@@ -255,6 +260,9 @@ void stage1_kernel(
     auto v32 = V32({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
     matmul(v29, V31, v32);
     tdma_wait(ctx);
+    // tdma_store_async(
+    //     v32, ImmOutputs[6]({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}),
+    //     ctx);
 
     /*
       [1, 64, 384, 128] -> [1, 384, 64, 128]
@@ -277,7 +285,7 @@ void stage1_kernel(
      */
     tdma_load_async(var_5, Hidden_in({0, bid * 48, tid * 2048}, {1, 48, 2048}),
                     ctx);
-    auto v35 = V35({0, bid * 48, tid * 2048}, {1, 48, 2048});
+    auto v35 = V35({0, 0, tid * 2048}, {1, 48, 2048});
     tensor<float> v36({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t] */
     binary(var_5, v35, v36, binary_op_t::add);
 
@@ -326,7 +334,7 @@ void stage1_kernel(
       [1, 48@b, 2048@t] + [1, 48@b, 2048@t] @shared -> [1, 48@b, 2048@t]
     */
     tensor<float> v43({1, 48, 2048});
-    auto v42 = V42({0, 0, 2048 * tid}, {0, 0, 2048});
+    auto v42 = V42({0, 0, 2048 * tid}, {1, 48, 2048});
     binary(v36, v42, v43, binary_op_t::add);
     tdma_store_async(v42, Output({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
                      ctx);
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index 208008b970..e941798a16 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -36,13 +36,14 @@ static tensor<float, loc_t::device> Output({1, 384, 8192});
 static tensor<float, loc_t::device> V25({1, 64, 128, 384});
 static tensor<float, loc_t::device> GV31({1, 64, 384, 128});
 
-constexpr int OutNum = 6;
+constexpr int OutNum = 7;
 static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 384, 8192}),    // v0
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v2
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v5
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v14
     tensor<float, loc_t::device>({1, 384, 128}),     // v3
+    tensor<float, loc_t::device>({1, 64, 384, 128}), // v16
     tensor<float, loc_t::device>({1, 64, 384, 384}), // v26
 };
 
@@ -52,6 +53,7 @@ static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 64, 384, 128}),
     tensor<float, loc_t::device>({1, 64, 384, 128}),
     tensor<float, loc_t::device>({1, 384, 128}),
+    tensor<float, loc_t::device>({1, 64, 384, 128}),
     tensor<float, loc_t::device>({1, 64, 384, 384}),
 };
 

From bf10fe5bc4728137501073481a53a92831f815f6 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Tue, 29 Aug 2023 17:50:20 +0800
Subject: [PATCH 140/308] fix v22 v10

---
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 26 ++++++++++++-------
 .../src/runtime/cmodel/tests/demo3/main.cpp   |  2 +-
 2 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index dd6cb530c4..d12dbc10c8 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -108,21 +108,25 @@ void stage1_kernel(
     auto v5_ = V5({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     auto v2_ = V2({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     binary(v2_, v4, v5_, binary_op_t::mul);
-    __tdma_all_sync_apply([]([[maybe_unused]] int v) -> void {},
-                          []() -> void {}, ctx); /* for store */
-    tdma_store_async(
-        v5_, ImmOutputs[2]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}), ctx);
 
-    auto v6 = V2({0, 16 * tid, 0, 64}, {1, 16, 48, 64});
-    auto &v7 = v6;
     /*
       [1, 64, 384, 64:] -> [1, 64, 384, 64:]
-      [1, 64, 48@b, 64] ->  [1, 16@t, 48@b, 64]
+      [1, 64, 48@b, 16@t]@shared ->  [1, 16@t, 48@b, 16@t]
     */
+    auto v6 = V2({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16});
+    tensor<float> v7({1, 64, 48, 16});
+    tdma_wait(ctx);
     unary(v6, v7, unary_op_t::neg);
 
+    __tensor_copy_sync(V2({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16}),
+                       V2({0, 0, 0, 16 * tid}, {1, 64, 48, 16}));
+    __tensor_copy_sync(V2({0, 0, 0, 16 * tid}, {1, 64, 48, 16}), std::move(v7));
+    tdma_wait(ctx);
+
     /* v10 为concat(v7,v8), 实际来源于V2，因此无需实际动作 */
     auto v10 = V2({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    tdma_store_async(
+        v10, ImmOutputs[2]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}), ctx);
 
     /*
       [384, 128][[1, 384]] -> [1, 384, 128]
@@ -175,11 +179,12 @@ void stage1_kernel(
     */
     tensor<float> v19({1, 64, 48, 16});
     auto v18 = V16({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16});
-    unary(v18, v19, unary_op_t::neg);
     tdma_wait(ctx);
+    unary(v18, v19, unary_op_t::neg);
+    __tensor_copy_sync(V16({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16}),
+                       V16({0, 0, 0, 16 * tid}, {1, 64, 48, 16}));
     __tensor_copy_sync(V16({0, 0, 0, 16 * tid}, {1, 64, 48, 16}),
-                       V16({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16}));
-    __tensor_copy_sync(std::move(v19), V16({0, 0, 0, 16 * tid}, {1, 64, 48, 16}));
+                       std::move(v19));
 
     /*
       [1,64,384,128] x [1,1,384,128] ->  [1,64,384,128]
@@ -187,6 +192,7 @@ void stage1_kernel(
     */
     tensor<float> v23({1, 64, 48, 32});
     auto v22 = V16({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    tdma_wait(ctx);
     binary(v22, v12, v23, binary_op_t::mul);
     tdma_store_async(
         v22, ImmOutputs[5]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}), ctx);
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index e941798a16..1e3fb94c04 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -40,7 +40,7 @@ constexpr int OutNum = 7;
 static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 384, 8192}),    // v0
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v2
-    tensor<float, loc_t::device>({1, 64, 384, 128}), // v5
+    tensor<float, loc_t::device>({1, 64, 384, 128}), // v10
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v14
     tensor<float, loc_t::device>({1, 384, 128}),     // v3
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v16

From 6b19bc2e26d954996df8f33704106238c96a6143 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Tue, 29 Aug 2023 18:26:20 +0800
Subject: [PATCH 141/308] pass v28

---
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 20 +++++++++----------
 .../src/runtime/cmodel/tests/demo3/main.cpp   |  2 +-
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index d12dbc10c8..f8a9728d38 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -213,29 +213,29 @@ void stage1_kernel(
     */
     tdma_store_async(v25, V25({0, 0, 32 * tid, 48 * bid}, {1, 64, 32, 48}),
                      ctx);
+    tdma_all_wait(ctx); /* for store */
     tensor<float> v25_1({1, 64, 32, 384});
     tdma_load_async(v25_1, V25({0, 0, 32 * tid, 0}, {1, 64, 32, 384}), ctx);
-    tdma_all_wait(ctx); /* for store */
+    tdma_all_wait(ctx);
     tensor_block_mma_sync(v14, v25_1, V26, false, ctx);
-    if (tid == 0) {
-        tdma_store_async(
-            V26, ImmOutputs[6]({0, 0, 48 * bid, 0}, {1, 64, 48, 384}), ctx);
-    }
 
     /* [1, 64, 384, 384]           / 11.31370  -> [1, 64, 384, 384]
-       [1, 16@t, 48@b, 384]@shared   / 11.31370 -> [1, 16@t, 48@b, 384]@shared
+       [1, 16@t, 48@b, 384]@shared   / 11.31370 -> [1, 16@t, 48@b, 384]
     */
-    auto v27 = V26({0, 16 * tid, 0, 0}, {1, 16, 48, 384});
+    auto v26 = V26({0, 16 * tid, 0, 0}, {1, 16, 48, 384});
+    tensor<float> v27({1, 16, 48, 384});
     auto v26_c = tensor<float>({1, 1, 1, 1});
     tdma_fill_async(v26_c, 11.313708f);
-    binary(v27, v26_c, v27, binary_op_t::div);
+    binary(v26, v26_c, v27, binary_op_t::div);
 
     /* [1, 64, 384, 384] + [1,1,384,384] -> [1, 64, 384, 384]
-       [1, 16@t, 48@b, 384]@shared + [1, 1, 48@b, 384] -> [1, 16@t, 48@b,
-       384]@shared
+       [1, 16@t, 48@b, 384] + [1, 1, 48@b, 384] -> [1, 16@t, 48@b,
+       384]
     */
     auto &v28 = v27;
     binary(v27, attn_mask, v28, binary_op_t::add);
+    tdma_store_async(
+        v28, ImmOutputs[6]({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 384}), ctx);
 
     /*
       [1, 64, 384, 384] -> [1, 64, 384, 384]
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index 1e3fb94c04..a4c7ab0f97 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -44,7 +44,7 @@ static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v14
     tensor<float, loc_t::device>({1, 384, 128}),     // v3
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v16
-    tensor<float, loc_t::device>({1, 64, 384, 384}), // v26
+    tensor<float, loc_t::device>({1, 64, 384, 384}), // v28
 };
 
 static tensor<float, loc_t::device> ImmOutputs[OutNum] = {

From 44f637d0ea5774df312ab2ca2925ccc912602008 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Tue, 29 Aug 2023 19:57:25 +0800
Subject: [PATCH 142/308] pass v43

---
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 28 +++++++++++++------
 .../src/runtime/cmodel/tests/demo3/main.cpp   | 10 ++++++-
 2 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index f8a9728d38..ef34332d9a 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -260,21 +260,20 @@ void stage1_kernel(
       [1,64,384,384] @ [1,64,384,128] ->  [1,64,384,128]
       [1, 16@t, 48@b, 384] @ [1, 16@t, 384, 128] -> [1, 16@t, 48@b, 128]@shared
     */
+    tdma_all_wait(ctx);
     tensor<float> v31_resplit({1, 16, 384, 128});
     tdma_load_async(v31_resplit, GV31({0, 16 * tid, 0, 0}, {1, 16, 384, 128}),
                     ctx);
     auto v32 = V32({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
-    matmul(v29, V31, v32);
+    matmul(v29, v31_resplit, v32);
     tdma_wait(ctx);
-    // tdma_store_async(
-    //     v32, ImmOutputs[6]({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}),
-    //     ctx);
-
+    tdma_store_async(
+        v32, ImmOutputs[7]({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}), ctx);
     /*
       [1, 64, 384, 128] -> [1, 384, 64, 128]
       [1, 64, 48@b, 128]@shared -> [1, 48@b, 64, 128]@shared
      */
-    auto v33 = V33({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
+    auto v33 = V33({0, 0, 16 * tid, 0}, {1, 48, 16, 128});
     transpose(v32, v33, {0, 2, 1, 3});
 
     /*
@@ -283,7 +282,13 @@ void stage1_kernel(
      */
     auto V34 = view(V33, {1, 48, 8192});
     auto v34 = V34({0, 0, 2048 * tid}, {1, 48, 2048});
+    tdma_wait(ctx);
     tensor_block_mma_sync(v34, v35_w, V35, false, ctx);
+    {
+        auto v35 = V35({0, 0, tid * 2048}, {1, 48, 2048});
+        tdma_store_async(
+            v35, ImmOutputs[8]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
+    }
 
     /*
     [1,384,8192] +  [1,384,8192]  -> [1,384,8192]
@@ -309,6 +314,11 @@ void stage1_kernel(
       [1, 48@b, 2048@t] @ [2048@t, 22016] -> [1, 48@b, 22016]@shared
     */
     tensor_block_mma_sync(v37, v38_w, V38, false, ctx);
+    {
+        auto v38 = V38({0, 0, 5504 * tid}, {1, 48, 5504});
+        tdma_store_async(
+            v38, ImmOutputs[9]({0, 48 * bid, 5504 * tid}, {1, 48, 5504}), ctx);
+    }
 
     /*
       [1,384, 22016] -> [1,384, 22016]
@@ -342,8 +352,10 @@ void stage1_kernel(
     tensor<float> v43({1, 48, 2048});
     auto v42 = V42({0, 0, 2048 * tid}, {1, 48, 2048});
     binary(v36, v42, v43, binary_op_t::add);
-    tdma_store_async(v42, Output({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
-                     ctx);
+    {
+        tdma_store_async(
+            v43, ImmOutputs[10]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
+    }
 #if 0
 #endif
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index a4c7ab0f97..cdc4748565 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -36,7 +36,7 @@ static tensor<float, loc_t::device> Output({1, 384, 8192});
 static tensor<float, loc_t::device> V25({1, 64, 128, 384});
 static tensor<float, loc_t::device> GV31({1, 64, 384, 128});
 
-constexpr int OutNum = 7;
+constexpr int OutNum = 11;
 static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 384, 8192}),    // v0
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v2
@@ -45,6 +45,10 @@ static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 384, 128}),     // v3
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v16
     tensor<float, loc_t::device>({1, 64, 384, 384}), // v28
+    tensor<float, loc_t::device>({1, 64, 384, 128}), // v32
+    tensor<float, loc_t::device>({1,384,8192}), // v35
+    tensor<float, loc_t::device>({1,384,22016}), // v38
+    tensor<float, loc_t::device>({1,384,8192}), // v43
 };
 
 static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
@@ -55,6 +59,10 @@ static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 384, 128}),
     tensor<float, loc_t::device>({1, 64, 384, 128}),
     tensor<float, loc_t::device>({1, 64, 384, 384}),
+    tensor<float, loc_t::device>({1, 64, 384, 128}),
+    tensor<float, loc_t::device>({1,384,8192}),
+    tensor<float, loc_t::device>({1,384,22016}),
+    tensor<float, loc_t::device>({1,384,8192}),
 };
 
 DEFINE_BFUNC(0)

From 3c3588879d578586748dd4d419b0f91e4add8d9c Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Wed, 30 Aug 2023 12:02:01 +0800
Subject: [PATCH 143/308] remove dump

---
 .../src/runtime/cmodel/tests/demo3/kernel.h   | 83 ++++++++++++++-----
 .../src/runtime/cmodel/tests/demo3/main.cpp   | 29 ++++---
 2 files changed, 79 insertions(+), 33 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index ef34332d9a..522c42b0a2 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -16,6 +16,7 @@ static tensor<int64_t> position_ids({1, 48});
 static tensor<float> v38_w({2048, 22016});
 static tensor<float> v40_w({2048, 22016});
 static tensor<float> v42_w({5504, 8192});
+#define DUMP 0
 
 void stage1_kernel(
     tensor<float, loc_t::device> &Hidden_in,               /* [1, 384, 8192] */
@@ -72,8 +73,13 @@ void stage1_kernel(
         tdma_reduce_async(v0_sum, v0_sum, reduce_op_t::sum, ctx);
         tdma_reduce_async(v0_sum_sqr, v0_sum_sqr, reduce_op_t::sum, ctx);
         layernorm(v0, v0_sum, v0_sum_sqr, v0, 2, 8192, true);
-        tdma_store_async(
-            v0, ImmOutputs[0]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
+#if DUMP
+        {
+            tdma_store_async(
+                v0, ImmOutputs[0]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
+                ctx);
+        }
+#endif
     } // v0 [1, 384, 8192] [1, 48@b, 8192]
 
     auto v1 = unsqueeze(v0); // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
@@ -82,12 +88,13 @@ void stage1_kernel(
       [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1, 64, 48@b, 128] @ shared
      */
     tensor_block_mma_sync(v1, v2_w, V2, false, ctx);
+#if DUMP
     if (tid == 0) {
         tdma_store_async(
             V2, ImmOutputs[1]({0, 0, 48 * bid, 0}, {1, 64, 48, 128}), ctx);
     }
-    __tdma_all_sync_apply([]([[maybe_unused]] int v) -> void {},
-                          []() -> void {}, ctx); /* for store */
+    tdma_all_wait(ctx);
+#endif
 
     /*
       [384, 128][[1, 384]] -> [1, 384, 128]
@@ -95,9 +102,12 @@ void stage1_kernel(
     */
     tensor<float> v3({1, 48, 32});
     gather(v3_data, position_ids, v3, 0);
-    tdma_store_async(v3, ImmOutputs[4]({0, 48 * bid, 32 * tid}, {1, 48, 32}),
-                     ctx);
-
+#if DUMP
+    {
+        tdma_store_async(
+            v3, ImmOutputs[4]({0, 48 * bid, 32 * tid}, {1, 48, 32}), ctx);
+    }
+#endif
     auto v4 = unsqueeze(v3); /* 1, 1, 48, 32 */
 
     /*
@@ -125,8 +135,13 @@ void stage1_kernel(
 
     /* v10 为concat(v7,v8), 实际来源于V2，因此无需实际动作 */
     auto v10 = V2({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-    tdma_store_async(
-        v10, ImmOutputs[2]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}), ctx);
+#if DUMP
+    {
+        tdma_store_async(
+            v10, ImmOutputs[2]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
+            ctx);
+    }
+#endif
 
     /*
       [384, 128][[1, 384]] -> [1, 384, 128]
@@ -145,8 +160,8 @@ void stage1_kernel(
     // auto v2_ = V2({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     binary(v2_, v12, v13_, binary_op_t::mul);
 
-    __tdma_all_sync_apply([]([[maybe_unused]] int v) -> void {},
-                          []() -> void {}, ctx); /* wait v5,v13 */
+    tdma_all_wait(ctx); /* wait v5,v13 */
+
     /*
     [1, 64, 384, 128] + [1, 64, 384, 128] -> [1, 64, 384, 128]
     [1, 64, 48@b, 32@t] + [1, 64, 48@b, 32@t] -> [1, 64, 48@b, 32@t]
@@ -155,9 +170,13 @@ void stage1_kernel(
     auto v5__ = V5({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     auto v13__ = V13({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     binary(v5__, v13__, v14, binary_op_t::add);
-    tdma_store_async(
-        v14, ImmOutputs[3]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}), ctx);
-
+#if DUMP
+    {
+        tdma_store_async(
+            v14, ImmOutputs[3]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
+            ctx);
+    }
+#endif
     tensor<float> &v15 = v0;
     /*
       [1,1,384,8192] @ [64, 8192, 128] -> [1,64,384,128]
@@ -194,8 +213,13 @@ void stage1_kernel(
     auto v22 = V16({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     tdma_wait(ctx);
     binary(v22, v12, v23, binary_op_t::mul);
-    tdma_store_async(
-        v22, ImmOutputs[5]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}), ctx);
+#if DUMP
+    {
+        tdma_store_async(
+            v22, ImmOutputs[5]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
+            ctx);
+    }
+#endif
 
     tensor<float> v24({1, 64, 48, 32});
     /*
@@ -234,9 +258,13 @@ void stage1_kernel(
     */
     auto &v28 = v27;
     binary(v27, attn_mask, v28, binary_op_t::add);
-    tdma_store_async(
-        v28, ImmOutputs[6]({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 384}), ctx);
-
+#if DUMP
+    {
+        tdma_store_async(
+            v28, ImmOutputs[6]({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 384}),
+            ctx);
+    }
+#endif
     /*
       [1, 64, 384, 384] -> [1, 64, 384, 384]
       [1, 16@t, 48@b, 384]@shared -> [1, 16@t, 48@b, 384]
@@ -267,8 +295,13 @@ void stage1_kernel(
     auto v32 = V32({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
     matmul(v29, v31_resplit, v32);
     tdma_wait(ctx);
-    tdma_store_async(
-        v32, ImmOutputs[7]({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}), ctx);
+#if DUMP
+    {
+        tdma_store_async(
+            v32, ImmOutputs[7]({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}),
+            ctx);
+    }
+#endif
     /*
       [1, 64, 384, 128] -> [1, 384, 64, 128]
       [1, 64, 48@b, 128]@shared -> [1, 48@b, 64, 128]@shared
@@ -284,11 +317,13 @@ void stage1_kernel(
     auto v34 = V34({0, 0, 2048 * tid}, {1, 48, 2048});
     tdma_wait(ctx);
     tensor_block_mma_sync(v34, v35_w, V35, false, ctx);
+#if DUMP
     {
         auto v35 = V35({0, 0, tid * 2048}, {1, 48, 2048});
         tdma_store_async(
             v35, ImmOutputs[8]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
     }
+#endif
 
     /*
     [1,384,8192] +  [1,384,8192]  -> [1,384,8192]
@@ -314,11 +349,13 @@ void stage1_kernel(
       [1, 48@b, 2048@t] @ [2048@t, 22016] -> [1, 48@b, 22016]@shared
     */
     tensor_block_mma_sync(v37, v38_w, V38, false, ctx);
+#if DUMP
     {
         auto v38 = V38({0, 0, 5504 * tid}, {1, 48, 5504});
         tdma_store_async(
             v38, ImmOutputs[9]({0, 48 * bid, 5504 * tid}, {1, 48, 5504}), ctx);
     }
+#endif
 
     /*
       [1,384, 22016] -> [1,384, 22016]
@@ -352,10 +389,12 @@ void stage1_kernel(
     tensor<float> v43({1, 48, 2048});
     auto v42 = V42({0, 0, 2048 * tid}, {1, 48, 2048});
     binary(v36, v42, v43, binary_op_t::add);
+    tdma_store_async(v43, Output({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
+                     ctx);
+#if DUMP
     {
         tdma_store_async(
             v43, ImmOutputs[10]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
     }
-#if 0
 #endif
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index cdc4748565..3edcb7f314 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -8,7 +8,7 @@
         block##b::thread##t::stage1_kernel(                                    \
             Hidden_in, V0_gamma, V0_beta, V2_w, V16_w, V31_w, V35_w, V3_data,  \
             V11_data, Attn_mask, V38_w, V40_w, V42_w, Position_ids, Output,    \
-            V25, GV31,ImmOutputs);                                                  \
+            V25, GV31, ImmOutputs);                                            \
         return arg;                                                            \
     }
 
@@ -46,9 +46,9 @@ static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v16
     tensor<float, loc_t::device>({1, 64, 384, 384}), // v28
     tensor<float, loc_t::device>({1, 64, 384, 128}), // v32
-    tensor<float, loc_t::device>({1,384,8192}), // v35
-    tensor<float, loc_t::device>({1,384,22016}), // v38
-    tensor<float, loc_t::device>({1,384,8192}), // v43
+    tensor<float, loc_t::device>({1, 384, 8192}),    // v35
+    tensor<float, loc_t::device>({1, 384, 22016}),   // v38
+    tensor<float, loc_t::device>({1, 384, 8192}),    // v43
 };
 
 static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
@@ -60,9 +60,9 @@ static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 64, 384, 128}),
     tensor<float, loc_t::device>({1, 64, 384, 384}),
     tensor<float, loc_t::device>({1, 64, 384, 128}),
-    tensor<float, loc_t::device>({1,384,8192}),
-    tensor<float, loc_t::device>({1,384,22016}),
-    tensor<float, loc_t::device>({1,384,8192}),
+    tensor<float, loc_t::device>({1, 384, 8192}),
+    tensor<float, loc_t::device>({1, 384, 22016}),
+    tensor<float, loc_t::device>({1, 384, 8192}),
 };
 
 DEFINE_BFUNC(0)
@@ -106,8 +106,8 @@ int main([[maybe_unused]] int argc, char **argv) {
     LOAD_FILE(V42_w, 13, float);
     LOAD_FILE(Position_ids, 14, int64_t);
 
-    for (auto o = 0; o < OutNum; o++) {
-        auto src_output = read_file(std::string(argv[(15 + o)]));
+    for (auto o = 0; o < argc - 16; o++) {
+        auto src_output = read_file(std::string(argv[(16 + o)]));
         span_copy(goldenImmOutputs[o].data(),
                   gsl::make_span(src_output).as_span<float>());
     }
@@ -183,11 +183,18 @@ int main([[maybe_unused]] int argc, char **argv) {
     pthread_join(t_7_2, NULL);
     pthread_join(t_7_3, NULL);
 
-    for (auto o = 0; o < OutNum; o++) {
+    for (auto o = 0; o < argc - 16; o++) {
         auto cos = cosine(ImmOutputs[o].data().begin(),
                           goldenImmOutputs[o].data().begin(),
                           goldenImmOutputs[o].data().size());
-        printf("%s cosine %f\n", argv[15 + o], cos);
+        printf("%s cosine %f\n", argv[16 + o], cos);
+    }
+    {
+        auto src_output = read_file(std::string(argv[15]));
+        auto src_span = gsl::make_span(src_output).as_span<float>();
+        auto cos =
+            cosine(Output.data().data(), src_span.data(), src_span.size());
+        printf("Output cosine %f\n", cos);
     }
 
     return 0;

From a040a91fc529d782dfb5c7e87813af9a0fc599f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 30 Aug 2023 15:17:19 +0800
Subject: [PATCH 144/308] add other part

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |   3 +
 .../cpu/src/runtime/cmodel/include/tensor.h   |   3 +
 .../runtime/cmodel/tests/embed/cluster_def.h  | 171 ++++++++++++++++++
 .../src/runtime/cmodel/tests/embed/golden.py  |  33 ++++
 .../src/runtime/cmodel/tests/embed/kernel.h   |  28 +++
 .../src/runtime/cmodel/tests/embed/main.cpp   | 131 ++++++++++++++
 .../runtime/cmodel/tests/embed/shared_def.h   |   5 +
 .../runtime/cmodel/tests/head/cluster_def.h   | 171 ++++++++++++++++++
 .../src/runtime/cmodel/tests/head/golden.py   |  34 ++++
 .../src/runtime/cmodel/tests/head/kernel.h    |  26 +++
 .../src/runtime/cmodel/tests/head/main.cpp    | 131 ++++++++++++++
 .../runtime/cmodel/tests/head/shared_def.h    |   5 +
 .../runtime/cmodel/tests/norm/cluster_def.h   | 171 ++++++++++++++++++
 .../src/runtime/cmodel/tests/norm/golden.py   |  31 ++++
 .../src/runtime/cmodel/tests/norm/kernel.h    |  25 +++
 .../src/runtime/cmodel/tests/norm/main.cpp    | 129 +++++++++++++
 .../runtime/cmodel/tests/norm/shared_def.h    |   4 +
 17 files changed, 1101 insertions(+)
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/embed/cluster_def.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/embed/golden.py
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/head/cluster_def.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/head/golden.py
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/head/kernel.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/head/main.cpp
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/head/shared_def.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/norm/cluster_def.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/norm/golden.py
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/norm/kernel.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/norm/shared_def.h

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index be86f9b262..f2d0e73888 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -24,3 +24,6 @@ endfunction(add_test)
 add_test(demo1 tests/demo1)
 add_test(demo2 tests/demo2)
 add_test(demo3 tests/demo3)
+add_test(norm tests/norm)
+add_test(embed tests/embed)
+add_test(head tests/head)
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index 7bc684ee14..419cff1cbe 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -70,6 +70,9 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
         size_ = compute_size(shapes);
         strides_ = parent->strides();
         data_ = parent->data_.subspan(offset(strides_, begins));
+        if (data_.size() < size_) {
+            throw std::errc::invalid_argument;
+        }
     }
 
     gsl::span<T> data_;
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/cluster_def.h b/modules/cpu/src/runtime/cmodel/tests/embed/cluster_def.h
new file mode 100644
index 0000000000..8fd5d84ed7
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/cluster_def.h
@@ -0,0 +1,171 @@
+#pragma once
+#include <hardware_context.h>
+#include <tdma.h>
+
+namespace block0 {
+#include "shared_def.h"
+constexpr size_t bid = 0;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block0
+
+namespace block1 {
+#include "shared_def.h"
+constexpr size_t bid = 1;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block1
+
+namespace block2 {
+#include "shared_def.h"
+constexpr size_t bid = 2;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block2
+
+namespace block3 {
+#include "shared_def.h"
+constexpr size_t bid = 3;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block3
+
+namespace block4 {
+#include "shared_def.h"
+constexpr size_t bid = 4;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block4
+
+namespace block5 {
+#include "shared_def.h"
+constexpr size_t bid = 5;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block5
+
+namespace block6 {
+#include "shared_def.h"
+constexpr size_t bid = 6;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block6
+
+namespace block7 {
+#include "shared_def.h"
+constexpr size_t bid = 7;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block7
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/golden.py b/modules/cpu/src/runtime/cmodel/tests/embed/golden.py
new file mode 100644
index 0000000000..19ba3da927
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/golden.py
@@ -0,0 +1,33 @@
+import numpy as np
+from torch import nn
+import torch
+from scipy.special import softmax
+import os
+
+
+def rmsnorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray, eps=1e-05):
+    x = torch.from_numpy(x)
+    output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
+    output = output * torch.from_numpy(gamma) + torch.from_numpy(beta)
+    return output.detach().numpy()
+
+
+def layernorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray):
+    return nn.functional.layer_norm(torch.from_numpy(x), [x.shape[-1]], torch.from_numpy(gamma), torch.from_numpy(beta)).detach().numpy()
+
+
+def swish(x: np.ndarray):
+    return x / (1 + np.exp(-x))
+
+
+def gather(data: np.ndarray, axis: int, indices: np.ndarray):
+    return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
+
+
+position_ids = np.random.randint(0, 384, (1, 384), np.int64)
+position_ids.tofile('position_ids.bin')
+data = np.random.rand(32000,8192).astype(np.float32)
+data.tofile('data.bin')
+output = data[position_ids]
+# f32[1,384,8192]
+output.tofile("output.bin")
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h b/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
new file mode 100644
index 0000000000..2269adad89
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
@@ -0,0 +1,28 @@
+// llama 65B
+// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
+// 1 chips, 8 blocks per chip, 4 threads per block
+
+#include "thread_context.h"
+using namespace shared;
+
+#define DUMP 0
+
+void stage1_kernel(
+    tensor<int64_t, loc_t::device> &Position_ids, /* [1, 384] */
+    tensor<float, loc_t::device> &GatherData,   /* [32000, 8192] */
+    tensor<float, loc_t::device> &Output          /* [1, 384, 8192] */
+) {
+    thread_context ctx(bid, tid);
+    tensor<int64_t> position_ids({1, 384});
+    tensor<float> gather_data({32000, 256});
+    tensor<float> output({1, 384, 256});
+
+    tdma_load_async(position_ids, std::move(Position_ids), ctx);
+    tdma_load_async(gather_data,
+                    GatherData({0, 256 * (CORES * bid + tid)}, {32000, 256}),
+                    ctx);
+    gather(gather_data, position_ids, output, 0);
+
+    tdma_store_async(
+        output, Output({0, 0, 256 * (CORES * bid + tid)}, {1, 384, 256}), ctx);
+}
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp b/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
new file mode 100644
index 0000000000..bab5899044
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
@@ -0,0 +1,131 @@
+#include "cluster_def.h"
+#include <io_utils.h>
+#include <runtime_utils.h>
+// #include <pthread.h>
+
+#define DEFINE_TFUNC(b, t)                                                     \
+    void *f_##b##_##t(void *arg) {                                             \
+        block##b::thread##t::stage1_kernel(Position_ids, GatherData, Output);     \
+        return arg;                                                            \
+    }
+
+#define DEFINE_BFUNC(b)                                                        \
+    DEFINE_TFUNC(b, 0)                                                         \
+    DEFINE_TFUNC(b, 1)                                                         \
+    DEFINE_TFUNC(b, 2)                                                         \
+    DEFINE_TFUNC(b, 3)
+
+static tensor<int64_t, loc_t::device> Position_ids({1, 384});
+static tensor<float, loc_t::device> GatherData({32000, 8192});
+static tensor<float, loc_t::device> Output({1, 384, 8192});
+
+DEFINE_BFUNC(0)
+DEFINE_BFUNC(1)
+DEFINE_BFUNC(2)
+DEFINE_BFUNC(3)
+DEFINE_BFUNC(4)
+DEFINE_BFUNC(5)
+DEFINE_BFUNC(6)
+DEFINE_BFUNC(7)
+
+#define LOAD_FILE(name, i, type)                                               \
+    {                                                                          \
+        auto src_##name = read_file(std::string(argv[(i)]));                   \
+        span_copy(name.data(), gsl::make_span(src_##name).as_span<type>());    \
+    }
+
+/**
+ * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
+ *
+ * @param argc
+ * @param argv
+ * @return int
+ */
+int main([[maybe_unused]] int argc, char **argv) {
+    // spdlog::set_level(spdlog::level::debug);
+    global_hardware_init();
+
+    LOAD_FILE(Position_ids, 1, int64_t);
+    LOAD_FILE(GatherData, 2, float);
+
+    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
+
+    pthread_create(&t_0_0, NULL, f_0_0, NULL);
+    pthread_create(&t_0_1, NULL, f_0_1, NULL);
+    pthread_create(&t_0_2, NULL, f_0_2, NULL);
+    pthread_create(&t_0_3, NULL, f_0_3, NULL);
+    pthread_create(&t_1_0, NULL, f_1_0, NULL);
+    pthread_create(&t_1_1, NULL, f_1_1, NULL);
+    pthread_create(&t_1_2, NULL, f_1_2, NULL);
+    pthread_create(&t_1_3, NULL, f_1_3, NULL);
+    pthread_create(&t_2_0, NULL, f_2_0, NULL);
+    pthread_create(&t_2_1, NULL, f_2_1, NULL);
+    pthread_create(&t_2_2, NULL, f_2_2, NULL);
+    pthread_create(&t_2_3, NULL, f_2_3, NULL);
+    pthread_create(&t_3_0, NULL, f_3_0, NULL);
+    pthread_create(&t_3_1, NULL, f_3_1, NULL);
+    pthread_create(&t_3_2, NULL, f_3_2, NULL);
+    pthread_create(&t_3_3, NULL, f_3_3, NULL);
+    pthread_create(&t_4_0, NULL, f_4_0, NULL);
+    pthread_create(&t_4_1, NULL, f_4_1, NULL);
+    pthread_create(&t_4_2, NULL, f_4_2, NULL);
+    pthread_create(&t_4_3, NULL, f_4_3, NULL);
+    pthread_create(&t_5_0, NULL, f_5_0, NULL);
+    pthread_create(&t_5_1, NULL, f_5_1, NULL);
+    pthread_create(&t_5_2, NULL, f_5_2, NULL);
+    pthread_create(&t_5_3, NULL, f_5_3, NULL);
+    pthread_create(&t_6_0, NULL, f_6_0, NULL);
+    pthread_create(&t_6_1, NULL, f_6_1, NULL);
+    pthread_create(&t_6_2, NULL, f_6_2, NULL);
+    pthread_create(&t_6_3, NULL, f_6_3, NULL);
+    pthread_create(&t_7_0, NULL, f_7_0, NULL);
+    pthread_create(&t_7_1, NULL, f_7_1, NULL);
+    pthread_create(&t_7_2, NULL, f_7_2, NULL);
+    pthread_create(&t_7_3, NULL, f_7_3, NULL);
+
+    pthread_join(t_0_0, NULL);
+    pthread_join(t_0_1, NULL);
+    pthread_join(t_0_2, NULL);
+    pthread_join(t_0_3, NULL);
+    pthread_join(t_1_0, NULL);
+    pthread_join(t_1_1, NULL);
+    pthread_join(t_1_2, NULL);
+    pthread_join(t_1_3, NULL);
+    pthread_join(t_2_0, NULL);
+    pthread_join(t_2_1, NULL);
+    pthread_join(t_2_2, NULL);
+    pthread_join(t_2_3, NULL);
+    pthread_join(t_3_0, NULL);
+    pthread_join(t_3_1, NULL);
+    pthread_join(t_3_2, NULL);
+    pthread_join(t_3_3, NULL);
+    pthread_join(t_4_0, NULL);
+    pthread_join(t_4_1, NULL);
+    pthread_join(t_4_2, NULL);
+    pthread_join(t_4_3, NULL);
+    pthread_join(t_5_0, NULL);
+    pthread_join(t_5_1, NULL);
+    pthread_join(t_5_2, NULL);
+    pthread_join(t_5_3, NULL);
+    pthread_join(t_6_0, NULL);
+    pthread_join(t_6_1, NULL);
+    pthread_join(t_6_2, NULL);
+    pthread_join(t_6_3, NULL);
+    pthread_join(t_7_0, NULL);
+    pthread_join(t_7_1, NULL);
+    pthread_join(t_7_2, NULL);
+    pthread_join(t_7_3, NULL);
+
+    {
+        auto src_output = read_file(std::string(argv[3]));
+        auto src_span = gsl::make_span(src_output).as_span<float>();
+        auto cos =
+            cosine(Output.data().data(), src_span.data(), src_span.size());
+        printf("Output cosine %f\n", cos);
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h
new file mode 100644
index 0000000000..99872569ef
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h
@@ -0,0 +1,5 @@
+#include <tdma.h>
+
+namespace shared {
+
+} // namespace shared
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/cluster_def.h b/modules/cpu/src/runtime/cmodel/tests/head/cluster_def.h
new file mode 100644
index 0000000000..8fd5d84ed7
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/head/cluster_def.h
@@ -0,0 +1,171 @@
+#pragma once
+#include <hardware_context.h>
+#include <tdma.h>
+
+namespace block0 {
+#include "shared_def.h"
+constexpr size_t bid = 0;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block0
+
+namespace block1 {
+#include "shared_def.h"
+constexpr size_t bid = 1;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block1
+
+namespace block2 {
+#include "shared_def.h"
+constexpr size_t bid = 2;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block2
+
+namespace block3 {
+#include "shared_def.h"
+constexpr size_t bid = 3;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block3
+
+namespace block4 {
+#include "shared_def.h"
+constexpr size_t bid = 4;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block4
+
+namespace block5 {
+#include "shared_def.h"
+constexpr size_t bid = 5;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block5
+
+namespace block6 {
+#include "shared_def.h"
+constexpr size_t bid = 6;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block6
+
+namespace block7 {
+#include "shared_def.h"
+constexpr size_t bid = 7;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block7
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/golden.py b/modules/cpu/src/runtime/cmodel/tests/head/golden.py
new file mode 100644
index 0000000000..7024824698
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/head/golden.py
@@ -0,0 +1,34 @@
+import numpy as np
+from torch import nn
+import torch
+from scipy.special import softmax
+import os
+
+
+def rmsnorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray, eps=1e-05):
+    x = torch.from_numpy(x)
+    output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
+    output = output * torch.from_numpy(gamma) + torch.from_numpy(beta)
+    return output.detach().numpy()
+
+
+def layernorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray):
+    return nn.functional.layer_norm(torch.from_numpy(x), [x.shape[-1]], torch.from_numpy(gamma), torch.from_numpy(beta)).detach().numpy()
+
+
+def swish(x: np.ndarray):
+    return x / (1 + np.exp(-x))
+
+
+def gather(data: np.ndarray, axis: int, indices: np.ndarray):
+    return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
+
+
+# position_ids = np.random.randint(0, 384, (1, 384), np.int64)
+hidden_in = np.random.rand(1, 384, 8192).astype(np.float32)
+hidden_in.tofile('hidden_in.bin')
+W = np.random.rand(8192, 32000).astype(np.float32)
+W.tofile('W.bin')
+output = hidden_in @ W
+# f32[1,384,8192]
+output.tofile("output.bin")
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/kernel.h b/modules/cpu/src/runtime/cmodel/tests/head/kernel.h
new file mode 100644
index 0000000000..7fa0e71e52
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/head/kernel.h
@@ -0,0 +1,26 @@
+// llama 65B
+// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
+// 1 chips, 8 blocks per chip, 4 threads per block
+
+#include "thread_context.h"
+using namespace shared;
+
+#define DUMP 0
+
+void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
+                   tensor<float, loc_t::device> &W,         /* [8192, 32000] */
+                   tensor<float, loc_t::device> &Output /* [1, 384, 32000] */
+) {
+    thread_context ctx(bid, tid);
+    tensor<float> hidden_in({1, 48, 2048});
+    tensor<float> w({2048, 32000});
+
+    tdma_load_async(hidden_in,
+                    Hidden_in({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
+    tdma_load_async(w, W({2048 * tid, 0}, {2048, 32000}), ctx);
+    tensor_block_mma_sync(hidden_in, w, output, false, ctx);
+
+    auto output_1 = output({0, 0, 8000 * tid}, {1, 48, 8000});
+    tdma_store_async(output_1, Output({0, 48 * bid, 8000 * tid}, {1, 48, 8000}),
+                     ctx);
+}
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
new file mode 100644
index 0000000000..3e4b979126
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
@@ -0,0 +1,131 @@
+#include "cluster_def.h"
+#include <io_utils.h>
+#include <runtime_utils.h>
+// #include <pthread.h>
+
+#define DEFINE_TFUNC(b, t)                                                     \
+    void *f_##b##_##t(void *arg) {                                             \
+        block##b::thread##t::stage1_kernel(Hidden_in, W, Output);     \
+        return arg;                                                            \
+    }
+
+#define DEFINE_BFUNC(b)                                                        \
+    DEFINE_TFUNC(b, 0)                                                         \
+    DEFINE_TFUNC(b, 1)                                                         \
+    DEFINE_TFUNC(b, 2)                                                         \
+    DEFINE_TFUNC(b, 3)
+
+static tensor<float, loc_t::device> Hidden_in({1, 384, 8192});
+static tensor<float, loc_t::device> W({8192, 32000});
+static tensor<float, loc_t::device> Output({1, 384, 32000});
+
+DEFINE_BFUNC(0)
+DEFINE_BFUNC(1)
+DEFINE_BFUNC(2)
+DEFINE_BFUNC(3)
+DEFINE_BFUNC(4)
+DEFINE_BFUNC(5)
+DEFINE_BFUNC(6)
+DEFINE_BFUNC(7)
+
+#define LOAD_FILE(name, i, type)                                               \
+    {                                                                          \
+        auto src_##name = read_file(std::string(argv[(i)]));                   \
+        span_copy(name.data(), gsl::make_span(src_##name).as_span<type>());    \
+    }
+
+/**
+ * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
+ *
+ * @param argc
+ * @param argv
+ * @return int
+ */
+int main([[maybe_unused]] int argc, char **argv) {
+    // spdlog::set_level(spdlog::level::debug);
+    global_hardware_init();
+
+    LOAD_FILE(Hidden_in, 1, float);
+    LOAD_FILE(W, 2, float);
+
+    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
+
+    pthread_create(&t_0_0, NULL, f_0_0, NULL);
+    pthread_create(&t_0_1, NULL, f_0_1, NULL);
+    pthread_create(&t_0_2, NULL, f_0_2, NULL);
+    pthread_create(&t_0_3, NULL, f_0_3, NULL);
+    pthread_create(&t_1_0, NULL, f_1_0, NULL);
+    pthread_create(&t_1_1, NULL, f_1_1, NULL);
+    pthread_create(&t_1_2, NULL, f_1_2, NULL);
+    pthread_create(&t_1_3, NULL, f_1_3, NULL);
+    pthread_create(&t_2_0, NULL, f_2_0, NULL);
+    pthread_create(&t_2_1, NULL, f_2_1, NULL);
+    pthread_create(&t_2_2, NULL, f_2_2, NULL);
+    pthread_create(&t_2_3, NULL, f_2_3, NULL);
+    pthread_create(&t_3_0, NULL, f_3_0, NULL);
+    pthread_create(&t_3_1, NULL, f_3_1, NULL);
+    pthread_create(&t_3_2, NULL, f_3_2, NULL);
+    pthread_create(&t_3_3, NULL, f_3_3, NULL);
+    pthread_create(&t_4_0, NULL, f_4_0, NULL);
+    pthread_create(&t_4_1, NULL, f_4_1, NULL);
+    pthread_create(&t_4_2, NULL, f_4_2, NULL);
+    pthread_create(&t_4_3, NULL, f_4_3, NULL);
+    pthread_create(&t_5_0, NULL, f_5_0, NULL);
+    pthread_create(&t_5_1, NULL, f_5_1, NULL);
+    pthread_create(&t_5_2, NULL, f_5_2, NULL);
+    pthread_create(&t_5_3, NULL, f_5_3, NULL);
+    pthread_create(&t_6_0, NULL, f_6_0, NULL);
+    pthread_create(&t_6_1, NULL, f_6_1, NULL);
+    pthread_create(&t_6_2, NULL, f_6_2, NULL);
+    pthread_create(&t_6_3, NULL, f_6_3, NULL);
+    pthread_create(&t_7_0, NULL, f_7_0, NULL);
+    pthread_create(&t_7_1, NULL, f_7_1, NULL);
+    pthread_create(&t_7_2, NULL, f_7_2, NULL);
+    pthread_create(&t_7_3, NULL, f_7_3, NULL);
+
+    pthread_join(t_0_0, NULL);
+    pthread_join(t_0_1, NULL);
+    pthread_join(t_0_2, NULL);
+    pthread_join(t_0_3, NULL);
+    pthread_join(t_1_0, NULL);
+    pthread_join(t_1_1, NULL);
+    pthread_join(t_1_2, NULL);
+    pthread_join(t_1_3, NULL);
+    pthread_join(t_2_0, NULL);
+    pthread_join(t_2_1, NULL);
+    pthread_join(t_2_2, NULL);
+    pthread_join(t_2_3, NULL);
+    pthread_join(t_3_0, NULL);
+    pthread_join(t_3_1, NULL);
+    pthread_join(t_3_2, NULL);
+    pthread_join(t_3_3, NULL);
+    pthread_join(t_4_0, NULL);
+    pthread_join(t_4_1, NULL);
+    pthread_join(t_4_2, NULL);
+    pthread_join(t_4_3, NULL);
+    pthread_join(t_5_0, NULL);
+    pthread_join(t_5_1, NULL);
+    pthread_join(t_5_2, NULL);
+    pthread_join(t_5_3, NULL);
+    pthread_join(t_6_0, NULL);
+    pthread_join(t_6_1, NULL);
+    pthread_join(t_6_2, NULL);
+    pthread_join(t_6_3, NULL);
+    pthread_join(t_7_0, NULL);
+    pthread_join(t_7_1, NULL);
+    pthread_join(t_7_2, NULL);
+    pthread_join(t_7_3, NULL);
+
+    {
+        auto src_output = read_file(std::string(argv[3]));
+        auto src_span = gsl::make_span(src_output).as_span<float>();
+        auto cos =
+            cosine(Output.data().data(), src_span.data(), src_span.size());
+        printf("Output cosine %f\n", cos);
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/head/shared_def.h
new file mode 100644
index 0000000000..d7c69fe1ef
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/head/shared_def.h
@@ -0,0 +1,5 @@
+#include <tdma.h>
+
+namespace shared {
+tensor<float, loc_t::shared> output({1, 48, 32000});
+} // namespace shared
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/cluster_def.h b/modules/cpu/src/runtime/cmodel/tests/norm/cluster_def.h
new file mode 100644
index 0000000000..8fd5d84ed7
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/cluster_def.h
@@ -0,0 +1,171 @@
+#pragma once
+#include <hardware_context.h>
+#include <tdma.h>
+
+namespace block0 {
+#include "shared_def.h"
+constexpr size_t bid = 0;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block0
+
+namespace block1 {
+#include "shared_def.h"
+constexpr size_t bid = 1;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block1
+
+namespace block2 {
+#include "shared_def.h"
+constexpr size_t bid = 2;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block2
+
+namespace block3 {
+#include "shared_def.h"
+constexpr size_t bid = 3;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block3
+
+namespace block4 {
+#include "shared_def.h"
+constexpr size_t bid = 4;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block4
+
+namespace block5 {
+#include "shared_def.h"
+constexpr size_t bid = 5;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block5
+
+namespace block6 {
+#include "shared_def.h"
+constexpr size_t bid = 6;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block6
+
+namespace block7 {
+#include "shared_def.h"
+constexpr size_t bid = 7;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block7
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/golden.py b/modules/cpu/src/runtime/cmodel/tests/norm/golden.py
new file mode 100644
index 0000000000..4ead78241d
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/golden.py
@@ -0,0 +1,31 @@
+import numpy as np
+from torch import nn
+import torch
+from scipy.special import softmax
+import os
+
+
+def rmsnorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray, eps=1e-05):
+    x = torch.from_numpy(x)
+    output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
+    output = output * torch.from_numpy(gamma) + torch.from_numpy(beta)
+    return output.detach().numpy()
+
+
+def layernorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray):
+    return nn.functional.layer_norm(torch.from_numpy(x), [x.shape[-1]], torch.from_numpy(gamma), torch.from_numpy(beta)).detach().numpy()
+
+
+def swish(x: np.ndarray):
+    return x / (1 + np.exp(-x))
+
+
+def gather(data: np.ndarray, axis: int, indices: np.ndarray):
+    return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
+
+
+hidden_in = np.random.rand(1, 384, 8192).astype(np.float32)
+hidden_in.tofile('hidden_in.bin')
+output = rmsnorm(hidden_in, np.ones([8192], np.float32), np.zeros([8192], np.float32))
+# f32[1,384,8192]
+output.tofile("output.bin")
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h b/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h
new file mode 100644
index 0000000000..76e9a2767b
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h
@@ -0,0 +1,25 @@
+// llama 65B
+// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
+// 1 chips, 8 blocks per chip, 4 threads per block
+
+#include "thread_context.h"
+using namespace shared;
+
+#define DUMP 0
+
+void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
+                   tensor<float, loc_t::device> &Output     /* [1, 384, 8192] */
+) {
+    thread_context ctx(bid, tid);
+    tensor<float> hidden_in({1, 12, 8192});
+    tensor<float> output({1, 12, 8192});
+    tdma_load_async(hidden_in,
+                    Hidden_in({0, 12 * (CORES * bid + tid), 0}, {1, 12, 8192}),
+                    ctx);
+    tensor<float> sum({1, 12});
+    tensor<float> sum_sqr({1, 12});
+    reduce_sum_sqr(hidden_in, sum, sum_sqr);
+    layernorm(hidden_in, sum, sum_sqr, output, 2, 8192, true);
+    tdma_store_async(
+        output, Output({0, 12 * (CORES * bid + tid), 0}, {1, 12, 8192}), ctx);
+}
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp b/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
new file mode 100644
index 0000000000..f0f10f305c
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
@@ -0,0 +1,129 @@
+#include "cluster_def.h"
+#include <io_utils.h>
+#include <runtime_utils.h>
+// #include <pthread.h>
+
+#define DEFINE_TFUNC(b, t)                                                     \
+    void *f_##b##_##t(void *arg) {                                             \
+        block##b::thread##t::stage1_kernel(Hidden_in, Output);                 \
+        return arg;                                                            \
+    }
+
+#define DEFINE_BFUNC(b)                                                        \
+    DEFINE_TFUNC(b, 0)                                                         \
+    DEFINE_TFUNC(b, 1)                                                         \
+    DEFINE_TFUNC(b, 2)                                                         \
+    DEFINE_TFUNC(b, 3)
+
+static tensor<float, loc_t::device> Hidden_in({1, 384, 8192});
+static tensor<float, loc_t::device> Output({1, 384, 8192});
+
+DEFINE_BFUNC(0)
+DEFINE_BFUNC(1)
+DEFINE_BFUNC(2)
+DEFINE_BFUNC(3)
+DEFINE_BFUNC(4)
+DEFINE_BFUNC(5)
+DEFINE_BFUNC(6)
+DEFINE_BFUNC(7)
+
+#define LOAD_FILE(name, i, type)                                               \
+    {                                                                          \
+        auto src_##name = read_file(std::string(argv[(i)]));                   \
+        span_copy(name.data(), gsl::make_span(src_##name).as_span<type>());    \
+    }
+
+/**
+ * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
+ *
+ * @param argc
+ * @param argv
+ * @return int
+ */
+int main([[maybe_unused]] int argc, char **argv) {
+    // spdlog::set_level(spdlog::level::debug);
+    global_hardware_init();
+
+    LOAD_FILE(Hidden_in, 1, float);
+
+    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
+
+    pthread_create(&t_0_0, NULL, f_0_0, NULL);
+    pthread_create(&t_0_1, NULL, f_0_1, NULL);
+    pthread_create(&t_0_2, NULL, f_0_2, NULL);
+    pthread_create(&t_0_3, NULL, f_0_3, NULL);
+    pthread_create(&t_1_0, NULL, f_1_0, NULL);
+    pthread_create(&t_1_1, NULL, f_1_1, NULL);
+    pthread_create(&t_1_2, NULL, f_1_2, NULL);
+    pthread_create(&t_1_3, NULL, f_1_3, NULL);
+    pthread_create(&t_2_0, NULL, f_2_0, NULL);
+    pthread_create(&t_2_1, NULL, f_2_1, NULL);
+    pthread_create(&t_2_2, NULL, f_2_2, NULL);
+    pthread_create(&t_2_3, NULL, f_2_3, NULL);
+    pthread_create(&t_3_0, NULL, f_3_0, NULL);
+    pthread_create(&t_3_1, NULL, f_3_1, NULL);
+    pthread_create(&t_3_2, NULL, f_3_2, NULL);
+    pthread_create(&t_3_3, NULL, f_3_3, NULL);
+    pthread_create(&t_4_0, NULL, f_4_0, NULL);
+    pthread_create(&t_4_1, NULL, f_4_1, NULL);
+    pthread_create(&t_4_2, NULL, f_4_2, NULL);
+    pthread_create(&t_4_3, NULL, f_4_3, NULL);
+    pthread_create(&t_5_0, NULL, f_5_0, NULL);
+    pthread_create(&t_5_1, NULL, f_5_1, NULL);
+    pthread_create(&t_5_2, NULL, f_5_2, NULL);
+    pthread_create(&t_5_3, NULL, f_5_3, NULL);
+    pthread_create(&t_6_0, NULL, f_6_0, NULL);
+    pthread_create(&t_6_1, NULL, f_6_1, NULL);
+    pthread_create(&t_6_2, NULL, f_6_2, NULL);
+    pthread_create(&t_6_3, NULL, f_6_3, NULL);
+    pthread_create(&t_7_0, NULL, f_7_0, NULL);
+    pthread_create(&t_7_1, NULL, f_7_1, NULL);
+    pthread_create(&t_7_2, NULL, f_7_2, NULL);
+    pthread_create(&t_7_3, NULL, f_7_3, NULL);
+
+    pthread_join(t_0_0, NULL);
+    pthread_join(t_0_1, NULL);
+    pthread_join(t_0_2, NULL);
+    pthread_join(t_0_3, NULL);
+    pthread_join(t_1_0, NULL);
+    pthread_join(t_1_1, NULL);
+    pthread_join(t_1_2, NULL);
+    pthread_join(t_1_3, NULL);
+    pthread_join(t_2_0, NULL);
+    pthread_join(t_2_1, NULL);
+    pthread_join(t_2_2, NULL);
+    pthread_join(t_2_3, NULL);
+    pthread_join(t_3_0, NULL);
+    pthread_join(t_3_1, NULL);
+    pthread_join(t_3_2, NULL);
+    pthread_join(t_3_3, NULL);
+    pthread_join(t_4_0, NULL);
+    pthread_join(t_4_1, NULL);
+    pthread_join(t_4_2, NULL);
+    pthread_join(t_4_3, NULL);
+    pthread_join(t_5_0, NULL);
+    pthread_join(t_5_1, NULL);
+    pthread_join(t_5_2, NULL);
+    pthread_join(t_5_3, NULL);
+    pthread_join(t_6_0, NULL);
+    pthread_join(t_6_1, NULL);
+    pthread_join(t_6_2, NULL);
+    pthread_join(t_6_3, NULL);
+    pthread_join(t_7_0, NULL);
+    pthread_join(t_7_1, NULL);
+    pthread_join(t_7_2, NULL);
+    pthread_join(t_7_3, NULL);
+
+    {
+        auto src_output = read_file(std::string(argv[2]));
+        auto src_span = gsl::make_span(src_output).as_span<float>();
+        auto cos =
+            cosine(Output.data().data(), src_span.data(), src_span.size());
+        printf("Output cosine %f\n", cos);
+    }
+
+    return 0;
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/norm/shared_def.h
new file mode 100644
index 0000000000..b18a608408
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/shared_def.h
@@ -0,0 +1,4 @@
+#include <tdma.h>
+
+namespace shared {
+} // namespace shared
\ No newline at end of file

From 7f8d96466e425a5385bdc8d45183d780648301cb Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 31 Aug 2023 12:27:33 +0800
Subject: [PATCH 145/308] pass all llama65b decoder layers

---
 modules/cpu/src/runtime/cmodel/include/tdma.h |  14 ++
 .../src/runtime/cmodel/tests/demo3/golden.py  | 110 ++++----
 .../src/runtime/cmodel/tests/demo3/kernel.h   |   2 +-
 .../src/runtime/cmodel/tests/demo3/main.cpp   | 235 ++++++++++--------
 4 files changed, 207 insertions(+), 154 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 94e746d3fd..b4c45f0088 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -14,8 +14,10 @@
 #include <thread_context.h>
 #include <transpose.h>
 #include <unary.h>
+#ifndef __riscv_vector
 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
 #include <spdlog/spdlog.h>
+#endif
 
 template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &src) {
     auto new_dims = dims_t(src.dimension());
@@ -215,8 +217,10 @@ void __tdma_block_sync_apply(std::function<void(int)> func,
                              thread_context &ctx) {
     global_hardware_ctx->lock_block(ctx.bid());
     int visited = global_hardware_ctx->mark_block_visit(ctx.bid(), ctx.tid());
+#ifndef __riscv_vector
     SPDLOG_DEBUG("__tdma_block_sync_apply bid {} tid {} visited {}\n",
                  ctx.bid(), ctx.tid(), visited);
+#endif
     func(visited);
     global_hardware_ctx->unlock_block(ctx.bid());
     global_hardware_ctx->wait_block_sync(ctx.bid(), visited);
@@ -227,8 +231,10 @@ void __tdma_all_sync_apply(std::function<void(int)> apply_func,
                            thread_context &ctx) {
     global_hardware_ctx->lock_all();
     int visited = global_hardware_ctx->mark_all_visit(ctx.bid(), ctx.tid());
+#ifndef __riscv_vector
     SPDLOG_DEBUG("__tdma_all_sync_apply bid {} tid {} visited {}\n", ctx.bid(),
                  ctx.tid(), visited);
+#endif
     apply_func(visited);
     global_hardware_ctx->unlock_all();
     global_hardware_ctx->wait_all_sync(visited, broadcast_func);
@@ -255,6 +261,14 @@ template <class T> void tdma_fill_async(tensor<T, loc_t::local> &src, T value) {
           });
 }
 
+template <class T>
+void tdma_fill_async(tensor<T, loc_t::shared> &src, T value) {
+    apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
+          [&](gsl::span<const size_t> index) -> void {
+              src.data()[offset(src.strides(), index)] = value;
+          });
+}
+
 template <class T>
 void tdma_broadcast_async(tensor<T, loc_t::local> &src,
                           tensor<T, loc_t::shared> &dest, thread_context &ctx) {
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
index 045c09abfa..c1341091d1 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
@@ -43,58 +43,64 @@ def gather(data:np.ndarray, axis:int, indices:np.ndarray):
 mlp_up_weights = np.reshape(np.fromfile(os.path.join(const_dir,"_mlp_up_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (8192, 22016))
 mlp_down_weights = np.reshape(np.fromfile(os.path.join(const_dir,"_mlp_down_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (22016, 8192))
 
-# np.random.rand(8192).astype(np.float32), np.random.rand(8192).astype(np.float32)
-v0 = rmsnorm(hidden_in, input_ln_gamma, input_ln_beta) # f32[1,384,8192]
-v0.tofile("v0.bin")
-v1 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
-v2 = (v1 @ WQ) # f32[1,64,384,128]
-v2.tofile("v2.bin")
-v3 = gather1_data[position_ids] # f32[1,384,128]
-v3.tofile("v3.bin")
-v4 = np.reshape(v3, (1,1,384,128))
-v5 = v2 * v4 # f32[1,64,384,128]
-v5.tofile("v5.bin")
-v6 = v2[:,:,:,64:] # Slice(v3, const(i64[1] : {64L}), const(i64[1] : {9223372036854775807}), 3, 1) # f32[1,64,384,64]
-v7 = -(v6) # f32[1,64,384,64]
-v8 = v2[:,:,:,0:64] # Slice(v3, 0, 64, 3, 1) # f32[1,64,384,64]
-v9 = (v7, v8) # (f32[1,64,384,64], f32[1,64,384,64]
+for index in range(80):
+    # np.random.rand(8192).astype(np.float32), np.random.rand(8192).astype(np.float32)
+    v0 = rmsnorm(hidden_in, input_ln_gamma, input_ln_beta) # f32[1,384,8192]
+    # v0.tofile("v0.bin")
+    v1 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
+    v2 = (v1 @ WQ) # f32[1,64,384,128]
+    # v2.tofile("v2.bin")
+    v3 = gather1_data[position_ids] # f32[1,384,128]
+    # v3.tofile("v3.bin")
+    v4 = np.reshape(v3, (1,1,384,128))
+    v5 = v2 * v4 # f32[1,64,384,128]
+    # v5.tofile("v5.bin")
+    v6 = v2[:,:,:,64:] # Slice(v3, const(i64[1] : {64L}), const(i64[1] : {9223372036854775807}), 3, 1) # f32[1,64,384,64]
+    v7 = -(v6) # f32[1,64,384,64]
+    v8 = v2[:,:,:,0:64] # Slice(v3, 0, 64, 3, 1) # f32[1,64,384,64]
+    v9 = (v7, v8) # (f32[1,64,384,64], f32[1,64,384,64]
 
-v10 = np.concatenate(v9, -1) # f32[1,64,384,128]
-v11 = gather2_data[position_ids] # f32[1,384,128]
-v12 = np.reshape(v11, (1,1,384,128))
-v13 = v10 * v12 # f32[1,64,384,128]
-v14 = v5 + v13 # f32[1,64,384,128]
-v14.tofile("v14.bin")
-v15 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
-v16 = (v15 @ WK) # f32[1,64,384,128]
-v17 = v16 * v4 # f32[1,64,384,128]
-v18 = v16[:,:,:,64:] # Slice(v3, const(i64[1] : {64L}), const(i64[1] : {9223372036854775807}), 3, 1) # f32[1,64,384,64]
-v19 = -(v18) # f32[1,64,384,64]
-v20 = v16[:,:,:,0:64] # Slice(v3, 0, 64, 3, 1) # f32[1,64,384,64]
-v21 = (v19, v20) # (f32[1,64,384,64], f32[1,64,384,64])
+    v10 = np.concatenate(v9, -1) # f32[1,64,384,128]
+    # v10.tofile("v10.bin")
+    v11 = gather2_data[position_ids] # f32[1,384,128]
+    v12 = np.reshape(v11, (1,1,384,128))
+    v13 = v10 * v12 # f32[1,64,384,128]
+    v14 = v5 + v13 # f32[1,64,384,128]
+    v14.tofile("v14.bin")
+    v15 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
+    v16 = (v15 @ WK) # f32[1,64,384,128]
+    v17 = v16 * v4 # f32[1,64,384,128]
+    v18 = v16[:,:,:,64:] # Slice(v3, const(i64[1] : {64L}), const(i64[1] : {9223372036854775807}), 3, 1) # f32[1,64,384,64]
+    v19 = -(v18) # f32[1,64,384,64]
+    v20 = v16[:,:,:,0:64] # Slice(v3, 0, 64, 3, 1) # f32[1,64,384,64]
+    v21 = (v19, v20) # (f32[1,64,384,64], f32[1,64,384,64])
 
-v22 = np.concatenate(v21, -1) # f32[1,64,384,128]
-v23 = v22 * v12 # f32[1,64,384,128]
-v24 = v17 + v23 # f32[1,64,384,128]
-v25 = np.transpose(v24, [0,1,3,2]) # f32[1,64,128,384]
-v26 = v14 @ v25 # f32[1,64,384,384]
-v26.tofile("v26.bin")
-v27 = (v26/ 11.31370) # f32[1,64,384,384]
-v28 = v27 + attn_mask # f32[1,64,384,384]
-v29 = softmax(v28, -1) # f32[1,64,384,384]
-v30 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
-v31 = (v30 @ WV) # f32[1,64,384,128]
-v32 = v29 @ v31 # f32[1,64,384,128]
-v33 = np.transpose(v32, [0,2,1,3]) # f32[1,384,64,128]
-v34 = np.reshape(v33, [1,384,8192]) # f32[1,384,8192]
-v35 = v34 @ WO # f32[1,384,8192]
-v36 = (hidden_in + v35) # f32[1,384,8192]
-v37 = rmsnorm(v36, post_ln_gamma, post_ln_beta) # f32[1,384,8192]
-v38 = v37 @ mlp_gate_weights # f32[1,384,22016]
-v39 = swish(v38) # f32[1,384,22016]
-v40 = v37 @ mlp_up_weights # f32[1,384,22016]
-v41 = v39 * v40 # f32[1,384,22016]
-v42 = v41 @ mlp_down_weights # f32[1,384,8192]
-v43 = v36 + v42 # f32[1,384,8192]
+    v22 = np.concatenate(v21, -1) # f32[1,64,384,128]
+    # v22.tofile("v22.bin")
+    v23 = v22 * v12 # f32[1,64,384,128]
+    v24 = v17 + v23 # f32[1,64,384,128]
+    v25 = np.transpose(v24, [0,1,3,2]) # f32[1,64,128,384]
+    v26 = v14 @ v25 # f32[1,64,384,384]
+    # v26.tofile("v26.bin")
+    v27 = (v26/ 11.31370) # f32[1,64,384,384]
+    v28 = v27 + attn_mask # f32[1,64,384,384]
+    # v28.tofile("v28.bin")
+    v29 = softmax(v28, -1) # f32[1,64,384,384]
+    v30 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
+    v31 = (v30 @ WV) # f32[1,64,384,128]
+    v32 = v29 @ v31 # f32[1,64,384,128]
+    v33 = np.transpose(v32, [0,2,1,3]) # f32[1,384,64,128]
+    v34 = np.reshape(v33, [1,384,8192]) # f32[1,384,8192]
+    v35 = v34 @ WO # f32[1,384,8192]
+    v36 = (hidden_in + v35) # f32[1,384,8192]
+    v37 = rmsnorm(v36, post_ln_gamma, post_ln_beta) # f32[1,384,8192]
+    v38 = v37 @ mlp_gate_weights # f32[1,384,22016]
+    v39 = swish(v38) # f32[1,384,22016]
+    v40 = v37 @ mlp_up_weights # f32[1,384,22016]
+    v41 = v39 * v40 # f32[1,384,22016]
+    v42 = v41 @ mlp_down_weights # f32[1,384,8192]
+    v43 = v36 + v42 # f32[1,384,8192]
 
-v43.tofile("v43.bin")
\ No newline at end of file
+    # v43.tofile("v43.bin")
+    hidden_in = v43
+hidden_in.tofile("hidden_in.bin")
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
index 522c42b0a2..afccdb2ed7 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
@@ -389,7 +389,7 @@ void stage1_kernel(
     tensor<float> v43({1, 48, 2048});
     auto v42 = V42({0, 0, 2048 * tid}, {1, 48, 2048});
     binary(v36, v42, v43, binary_op_t::add);
-    tdma_store_async(v43, Output({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
+    tdma_store_async(v43, Hidden_in({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
                      ctx);
 #if DUMP
     {
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
index 3edcb7f314..2f4bdf72b6 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
@@ -1,4 +1,5 @@
 #include "cluster_def.h"
+#include <chrono>
 #include <io_utils.h>
 #include <runtime_utils.h>
 // #include <pthread.h>
@@ -80,6 +81,21 @@ DEFINE_BFUNC(7)
         span_copy(name.data(), gsl::make_span(src_##name).as_span<type>());    \
     }
 
+#define CLEAR_SHARED(i)                                                        \
+    tdma_fill_async<float>(block##i::shared::V2, 0);                           \
+    tdma_fill_async<float>(block##i::shared::V5, 0);                           \
+    tdma_fill_async<float>(block##i::shared::V13, 0);                          \
+    tdma_fill_async<float>(block##i::shared::V16, 0);                          \
+    tdma_fill_async<float>(block##i::shared::V25, 0);                          \
+    tdma_fill_async<float>(block##i::shared::V26, 0);                          \
+    tdma_fill_async<float>(block##i::shared::V31, 0);                          \
+    tdma_fill_async<float>(block##i::shared::V32, 0);                          \
+    tdma_fill_async<float>(block##i::shared::V33, 0);                          \
+    tdma_fill_async<float>(block##i::shared::V35, 0);                          \
+    tdma_fill_async<float>(block##i::shared::V38, 0);                          \
+    tdma_fill_async<float>(block##i::shared::V40, 0);                          \
+    tdma_fill_async<float>(block##i::shared::V42, 0);
+
 /**
  * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
  *
@@ -88,113 +104,130 @@ DEFINE_BFUNC(7)
  * @return int
  */
 int main([[maybe_unused]] int argc, char **argv) {
-    // spdlog::set_level(spdlog::level::debug);
     global_hardware_init();
-
     LOAD_FILE(Hidden_in, 1, float);
-    LOAD_FILE(V0_gamma, 2, float);
-    LOAD_FILE(V0_beta, 3, float);
-    LOAD_FILE(V2_w, 4, float);
-    LOAD_FILE(V16_w, 5, float);
-    LOAD_FILE(V31_w, 6, float);
-    LOAD_FILE(V35_w, 7, float);
-    LOAD_FILE(V3_data, 8, float);
-    LOAD_FILE(V11_data, 9, float);
     LOAD_FILE(Attn_mask, 10, float);
-    LOAD_FILE(V38_w, 11, float);
-    LOAD_FILE(V40_w, 12, float);
-    LOAD_FILE(V42_w, 13, float);
     LOAD_FILE(Position_ids, 14, int64_t);
+    for (auto index = 0; index < 80; index++) {
+        // spdlog::set_level(spdlog::level::debug);
+        auto start = std::chrono::steady_clock::now();
 
-    for (auto o = 0; o < argc - 16; o++) {
-        auto src_output = read_file(std::string(argv[(16 + o)]));
-        span_copy(goldenImmOutputs[o].data(),
-                  gsl::make_span(src_output).as_span<float>());
-    }
+        LOAD_FILE(V0_gamma, 2, float);
+        LOAD_FILE(V0_beta, 3, float);
+        LOAD_FILE(V2_w, 4, float);
+        LOAD_FILE(V16_w, 5, float);
+        LOAD_FILE(V31_w, 6, float);
+        LOAD_FILE(V35_w, 7, float);
+        LOAD_FILE(V3_data, 8, float);
+        LOAD_FILE(V11_data, 9, float);
+        LOAD_FILE(V38_w, 11, float);
+        LOAD_FILE(V40_w, 12, float);
+        LOAD_FILE(V42_w, 13, float);
 
-    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
-
-    pthread_create(&t_0_0, NULL, f_0_0, NULL);
-    pthread_create(&t_0_1, NULL, f_0_1, NULL);
-    pthread_create(&t_0_2, NULL, f_0_2, NULL);
-    pthread_create(&t_0_3, NULL, f_0_3, NULL);
-    pthread_create(&t_1_0, NULL, f_1_0, NULL);
-    pthread_create(&t_1_1, NULL, f_1_1, NULL);
-    pthread_create(&t_1_2, NULL, f_1_2, NULL);
-    pthread_create(&t_1_3, NULL, f_1_3, NULL);
-    pthread_create(&t_2_0, NULL, f_2_0, NULL);
-    pthread_create(&t_2_1, NULL, f_2_1, NULL);
-    pthread_create(&t_2_2, NULL, f_2_2, NULL);
-    pthread_create(&t_2_3, NULL, f_2_3, NULL);
-    pthread_create(&t_3_0, NULL, f_3_0, NULL);
-    pthread_create(&t_3_1, NULL, f_3_1, NULL);
-    pthread_create(&t_3_2, NULL, f_3_2, NULL);
-    pthread_create(&t_3_3, NULL, f_3_3, NULL);
-    pthread_create(&t_4_0, NULL, f_4_0, NULL);
-    pthread_create(&t_4_1, NULL, f_4_1, NULL);
-    pthread_create(&t_4_2, NULL, f_4_2, NULL);
-    pthread_create(&t_4_3, NULL, f_4_3, NULL);
-    pthread_create(&t_5_0, NULL, f_5_0, NULL);
-    pthread_create(&t_5_1, NULL, f_5_1, NULL);
-    pthread_create(&t_5_2, NULL, f_5_2, NULL);
-    pthread_create(&t_5_3, NULL, f_5_3, NULL);
-    pthread_create(&t_6_0, NULL, f_6_0, NULL);
-    pthread_create(&t_6_1, NULL, f_6_1, NULL);
-    pthread_create(&t_6_2, NULL, f_6_2, NULL);
-    pthread_create(&t_6_3, NULL, f_6_3, NULL);
-    pthread_create(&t_7_0, NULL, f_7_0, NULL);
-    pthread_create(&t_7_1, NULL, f_7_1, NULL);
-    pthread_create(&t_7_2, NULL, f_7_2, NULL);
-    pthread_create(&t_7_3, NULL, f_7_3, NULL);
-
-    pthread_join(t_0_0, NULL);
-    pthread_join(t_0_1, NULL);
-    pthread_join(t_0_2, NULL);
-    pthread_join(t_0_3, NULL);
-    pthread_join(t_1_0, NULL);
-    pthread_join(t_1_1, NULL);
-    pthread_join(t_1_2, NULL);
-    pthread_join(t_1_3, NULL);
-    pthread_join(t_2_0, NULL);
-    pthread_join(t_2_1, NULL);
-    pthread_join(t_2_2, NULL);
-    pthread_join(t_2_3, NULL);
-    pthread_join(t_3_0, NULL);
-    pthread_join(t_3_1, NULL);
-    pthread_join(t_3_2, NULL);
-    pthread_join(t_3_3, NULL);
-    pthread_join(t_4_0, NULL);
-    pthread_join(t_4_1, NULL);
-    pthread_join(t_4_2, NULL);
-    pthread_join(t_4_3, NULL);
-    pthread_join(t_5_0, NULL);
-    pthread_join(t_5_1, NULL);
-    pthread_join(t_5_2, NULL);
-    pthread_join(t_5_3, NULL);
-    pthread_join(t_6_0, NULL);
-    pthread_join(t_6_1, NULL);
-    pthread_join(t_6_2, NULL);
-    pthread_join(t_6_3, NULL);
-    pthread_join(t_7_0, NULL);
-    pthread_join(t_7_1, NULL);
-    pthread_join(t_7_2, NULL);
-    pthread_join(t_7_3, NULL);
-
-    for (auto o = 0; o < argc - 16; o++) {
-        auto cos = cosine(ImmOutputs[o].data().begin(),
-                          goldenImmOutputs[o].data().begin(),
-                          goldenImmOutputs[o].data().size());
-        printf("%s cosine %f\n", argv[16 + o], cos);
-    }
-    {
-        auto src_output = read_file(std::string(argv[15]));
-        auto src_span = gsl::make_span(src_output).as_span<float>();
-        auto cos =
-            cosine(Output.data().data(), src_span.data(), src_span.size());
-        printf("Output cosine %f\n", cos);
+        for (auto o = 0; o < argc - 16; o++) {
+            auto src_output = read_file(std::string(argv[(16 + o)]));
+            span_copy(goldenImmOutputs[o].data(),
+                      gsl::make_span(src_output).as_span<float>());
+        }
+
+        pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+        pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+        pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+        pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
+
+        pthread_create(&t_0_0, NULL, f_0_0, NULL);
+        pthread_create(&t_0_1, NULL, f_0_1, NULL);
+        pthread_create(&t_0_2, NULL, f_0_2, NULL);
+        pthread_create(&t_0_3, NULL, f_0_3, NULL);
+        pthread_create(&t_1_0, NULL, f_1_0, NULL);
+        pthread_create(&t_1_1, NULL, f_1_1, NULL);
+        pthread_create(&t_1_2, NULL, f_1_2, NULL);
+        pthread_create(&t_1_3, NULL, f_1_3, NULL);
+        pthread_create(&t_2_0, NULL, f_2_0, NULL);
+        pthread_create(&t_2_1, NULL, f_2_1, NULL);
+        pthread_create(&t_2_2, NULL, f_2_2, NULL);
+        pthread_create(&t_2_3, NULL, f_2_3, NULL);
+        pthread_create(&t_3_0, NULL, f_3_0, NULL);
+        pthread_create(&t_3_1, NULL, f_3_1, NULL);
+        pthread_create(&t_3_2, NULL, f_3_2, NULL);
+        pthread_create(&t_3_3, NULL, f_3_3, NULL);
+        pthread_create(&t_4_0, NULL, f_4_0, NULL);
+        pthread_create(&t_4_1, NULL, f_4_1, NULL);
+        pthread_create(&t_4_2, NULL, f_4_2, NULL);
+        pthread_create(&t_4_3, NULL, f_4_3, NULL);
+        pthread_create(&t_5_0, NULL, f_5_0, NULL);
+        pthread_create(&t_5_1, NULL, f_5_1, NULL);
+        pthread_create(&t_5_2, NULL, f_5_2, NULL);
+        pthread_create(&t_5_3, NULL, f_5_3, NULL);
+        pthread_create(&t_6_0, NULL, f_6_0, NULL);
+        pthread_create(&t_6_1, NULL, f_6_1, NULL);
+        pthread_create(&t_6_2, NULL, f_6_2, NULL);
+        pthread_create(&t_6_3, NULL, f_6_3, NULL);
+        pthread_create(&t_7_0, NULL, f_7_0, NULL);
+        pthread_create(&t_7_1, NULL, f_7_1, NULL);
+        pthread_create(&t_7_2, NULL, f_7_2, NULL);
+        pthread_create(&t_7_3, NULL, f_7_3, NULL);
+
+        pthread_join(t_0_0, NULL);
+        pthread_join(t_0_1, NULL);
+        pthread_join(t_0_2, NULL);
+        pthread_join(t_0_3, NULL);
+        pthread_join(t_1_0, NULL);
+        pthread_join(t_1_1, NULL);
+        pthread_join(t_1_2, NULL);
+        pthread_join(t_1_3, NULL);
+        pthread_join(t_2_0, NULL);
+        pthread_join(t_2_1, NULL);
+        pthread_join(t_2_2, NULL);
+        pthread_join(t_2_3, NULL);
+        pthread_join(t_3_0, NULL);
+        pthread_join(t_3_1, NULL);
+        pthread_join(t_3_2, NULL);
+        pthread_join(t_3_3, NULL);
+        pthread_join(t_4_0, NULL);
+        pthread_join(t_4_1, NULL);
+        pthread_join(t_4_2, NULL);
+        pthread_join(t_4_3, NULL);
+        pthread_join(t_5_0, NULL);
+        pthread_join(t_5_1, NULL);
+        pthread_join(t_5_2, NULL);
+        pthread_join(t_5_3, NULL);
+        pthread_join(t_6_0, NULL);
+        pthread_join(t_6_1, NULL);
+        pthread_join(t_6_2, NULL);
+        pthread_join(t_6_3, NULL);
+        pthread_join(t_7_0, NULL);
+        pthread_join(t_7_1, NULL);
+        pthread_join(t_7_2, NULL);
+        pthread_join(t_7_3, NULL);
+
+        auto stop = std::chrono::steady_clock::now();
+        double duration =
+            std::chrono::duration<double, std::milli>(stop - start).count();
+        std::cout << "Demo run: " << duration / 1000 << " secs" << std::endl;
+        
+        for (auto o = 0; o < argc - 16; o++) {
+            auto cos = cosine(ImmOutputs[o].data().begin(),
+                              goldenImmOutputs[o].data().begin(),
+                              goldenImmOutputs[o].data().size());
+            printf("%s cosine %f\n", argv[16 + o], cos);
+        }
+        {
+            auto src_output = read_file(std::string(argv[15]));
+            auto src_span = gsl::make_span(src_output).as_span<float>();
+            auto cos = cosine(Hidden_in.data().data(), src_span.data(),
+                              src_span.size());
+            printf("Output cosine %f\n", cos);
+        }
+
+        CLEAR_SHARED(0);
+        CLEAR_SHARED(1);
+        CLEAR_SHARED(2);
+        CLEAR_SHARED(3);
+        CLEAR_SHARED(4);
+        CLEAR_SHARED(5);
+        CLEAR_SHARED(6);
+        CLEAR_SHARED(7);
     }
 
     return 0;

From 4becac1574dabddd3c470b7ed273c15aedb4159b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 5 Sep 2023 11:00:08 +0800
Subject: [PATCH 146/308] pass gather

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |  48 +-
 .../cpu/src/runtime/cmodel/include/gather.h   |  16 +-
 .../runtime/cmodel/include/hardware_context.h |  53 +-
 .../cpu/src/runtime/cmodel/include/io_utils.h |  28 -
 .../runtime/cmodel/include/runtime_utils.h    |  81 ++-
 modules/cpu/src/runtime/cmodel/include/tdma.h | 586 +++++++++---------
 .../cpu/src/runtime/cmodel/include/tensor.h   |  24 +-
 modules/cpu/src/runtime/cmodel/src/dummy.cpp  |   0
 .../runtime/cmodel/src/hardware_context.cpp   | 135 ----
 .../cmodel/tests/demo4/cluster_def copy.h     | 171 +++++
 .../runtime/cmodel/tests/demo4/cluster_def.h  | 171 +++++
 .../src/runtime/cmodel/tests/demo4/golden.py  |  31 +
 .../runtime/cmodel/tests/demo4/kernel copy.h  |  28 +
 .../src/runtime/cmodel/tests/demo4/kernel.h   |  32 +
 .../src/runtime/cmodel/tests/demo4/main.cpp   | 126 ++++
 .../runtime/cmodel/tests/demo4/shared_def.h   |   4 +
 16 files changed, 993 insertions(+), 541 deletions(-)
 delete mode 100644 modules/cpu/src/runtime/cmodel/include/io_utils.h
 create mode 100644 modules/cpu/src/runtime/cmodel/src/dummy.cpp
 delete mode 100644 modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def copy.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/golden.py
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/kernel copy.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/shared_def.h

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index f2d0e73888..615a039f2a 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -1,29 +1,41 @@
+project(cpu)
+cmake_minimum_required(VERSION 3.13)
+
 add_library(cpu_cmodel STATIC
-  src/hardware_context.cpp
+  src/dummy.cpp
 )
 
+set(CMAKE_CXX_STANDARD 20)
+
 target_include_directories(cpu_cmodel PUBLIC include)
-target_link_libraries(cpu_cmodel PUBLIC fmt::fmt spdlog::spdlog)
-if(NOT APPLE AND NOT MSVC)
-  target_link_libraries(cpu_cmodel PRIVATE rt)
-endif()
+target_include_directories(cpu_cmodel PUBLIC /compiler/huochenghai/GNNE/rebuild-ir/nncase/src/Native/include/ /compiler/huochenghai/GNNE/rebuild-ir/nncase/modules/cpu/include/)
+target_include_directories(cpu_cmodel PUBLIC /root/.conan/data/gsl-lite/0.37.0/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/)
+# target_link_libraries(cpu_cmodel PUBLIC gsl::gsl-lite)
+# if(NOT APPLE AND NOT MSVC)
+#   target_link_libraries(cpu_cmodel PRIVATE rt)
+# endif()
 set_target_properties(cpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
-        
-add_executable(cpu_cmodel_cli src/cpu_cmodel.cpp ../shared_memory.cpp)
-target_link_libraries(cpu_cmodel_cli PUBLIC cpu_cmodel)
-set_target_properties(cpu_cmodel_cli PROPERTIES POSITION_INDEPENDENT_CODE ON
-  OUTPUT_NAME "nncase.simulator.cpu.c")
-install(TARGETS cpu_cmodel_cli COMPONENT nncase-runtime)
+
+# add_executable(cpu_cmodel_cli src/cpu_cmodel.cpp ../shared_memory.cpp)
+# target_link_libraries(cpu_cmodel_cli PUBLIC cpu_cmodel)
+# set_target_properties(cpu_cmodel_cli PROPERTIES POSITION_INDEPENDENT_CODE ON
+#   OUTPUT_NAME "nncase.simulator.cpu.c")
+# install(TARGETS cpu_cmodel_cli COMPONENT nncase-runtime)
 
 
 function(add_test name test_path)
+  if (CMAKE_BUILD_TYPE STREQUAL "Release")
+    add_compile_options(-O1)
+  endif()
+  add_link_options(-no-pie -nostartfiles -fPIC -fno-stack-protector -static -Wl,-e,_Z6_startP19hardware_context_mtP15runtime_util_mtPhS3_S3_)
   add_executable(${name} "${test_path}/main.cpp")
-  target_link_libraries(${name} cpu_cmodel spdlog::spdlog)
+  target_link_libraries(${name} cpu_cmodel)
 endfunction(add_test)
 
-add_test(demo1 tests/demo1)
-add_test(demo2 tests/demo2)
-add_test(demo3 tests/demo3)
-add_test(norm tests/norm)
-add_test(embed tests/embed)
-add_test(head tests/head)
+# add_test(demo1 tests/demo1)
+# add_test(demo2 tests/demo2)
+# add_test(demo3 tests/demo3)
+add_test(demo4 tests/demo4)
+# add_test(norm tests/norm)
+# add_test(embed tests/embed)
+# add_test(head tests/head)
diff --git a/modules/cpu/src/runtime/cmodel/include/gather.h b/modules/cpu/src/runtime/cmodel/include/gather.h
index fd5ef81564..604baea0ee 100644
--- a/modules/cpu/src/runtime/cmodel/include/gather.h
+++ b/modules/cpu/src/runtime/cmodel/include/gather.h
@@ -42,21 +42,21 @@ void gather_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
         }
 
         // which index to be used in indices
-        dims_t indices_index(out_index.begin() + axis,
-                             out_index.begin() + axis + indices_shape.size());
-        auto indices_offset =
-            offset(get_default_strides(indices_shape), indices_index);
+        // dims_t indices_index(out_index.begin() + axis,
+        //                      out_index.begin() + axis + indices_shape.size());
+        // auto indices_offset =
+        //     offset((indices_shape), indices_index);
         // select sub block in dim axis
-        in_index[i_index] = indices[indices_offset];
-        ++i_index;
+        // in_index[i_index] = indices[indices_offset];
+        // ++i_index;
 
         // select position in sub block
         for (auto o_index = axis + indices_shape.size();
              o_index < out_index.size(); ++o_index, ++i_index) {
             in_index[i_index] = out_index[o_index];
         }
-        output[offset(out_strides, out_index)] =
-            input[offset(in_strides, in_index)];
+        // output[offset(out_strides, out_index)] =
+        //     input[offset(in_strides, in_index)];
     });
 }
 } // namespace
diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_context.h b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
index 646e9bdf27..c7ef98a1e7 100644
--- a/modules/cpu/src/runtime/cmodel/include/hardware_context.h
+++ b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
@@ -1,30 +1,51 @@
 #pragma once
 
 #include <functional>
-#include <iostream>
-#include <memory>
+// #include <memory>
 
-struct hardware_context_impl;
+struct hardware_context_mt {
+    void (*lock_block)(int bid);
+    int (*mark_block_visit)(int bid, int tid);
+    void (*unlock_block)(int bid);
+    void (*wait_block_sync)(int bid, int visited,
+                            std::function<void()> callable);
+    void (*lock_all)();
+    int (*mark_all_visit)(int bid, int tid);
+    void (*unlock_all)();
+    void (*wait_all_sync)(int visited, std::function<void()> callable);
+    void (*init)();
+};
 
 class hardware_context {
   public:
-    hardware_context();
-    void lock_block(int bid);
-    int mark_block_visit(int bid, int tid);
-    void unlock_block(int bid);
+    // hardware_context(hardware_context_mt *impl) : impl_(impl){};
+    void lock_block(int bid) { impl_->lock_block(bid); }
+    int mark_block_visit(int bid, int tid) {
+        return impl_->mark_block_visit(bid, tid);
+    }
+    void unlock_block(int bid) { impl_->unlock_block(bid); }
     void wait_block_sync(
-        int bid, int visited, std::function<void()> callable = []() -> void {});
-    void lock_all();
-    int mark_all_visit(int bid, int tid);
-    void unlock_all();
+        int bid, int visited,
+        std::function<void()> callable = []() -> void {}) {
+        impl_->wait_block_sync(bid, visited, callable);
+    }
+    void lock_all() { impl_->lock_all(); }
+    int mark_all_visit(int bid, int tid) {
+        return impl_->mark_all_visit(bid, tid);
+    }
+    void unlock_all() { impl_->unlock_all(); }
     void wait_all_sync(
-        int visited, std::function<void()> callable = []() -> void {});
+        int visited, std::function<void()> callable = []() -> void {}) {
+        impl_->wait_all_sync(visited, callable);
+    }
     void *global_var = nullptr;
 
-  private:
-    std::unique_ptr<hardware_context_impl> impl_;
+    hardware_context_mt* impl_;
 };
 
-extern std::unique_ptr<hardware_context> global_hardware_ctx;
+static hardware_context global_hardware_ctx;
 
-void global_hardware_init();
\ No newline at end of file
+void global_hardware_init(hardware_context_mt *impl) {
+    global_hardware_ctx.impl_ = impl;
+    impl->init();
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/io_utils.h b/modules/cpu/src/runtime/cmodel/include/io_utils.h
deleted file mode 100644
index d016bccb6c..0000000000
--- a/modules/cpu/src/runtime/cmodel/include/io_utils.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-#include <filesystem>
-#include <fstream>
-#include <tensor.h>
-#include <vector>
-
-inline std::vector<uint8_t> read_stream(std::istream &stream) {
-    stream.seekg(0, std::ios::end);
-    size_t length = stream.tellg();
-    stream.seekg(0, std::ios::beg);
-    std::vector<uint8_t> data(length);
-    stream.read(reinterpret_cast<char *>(data.data()), length);
-    return data;
-}
-
-inline std::vector<uint8_t> read_file(const std::filesystem::path &filename) {
-    std::ifstream infile(filename.string(), std::ios::binary | std::ios::in);
-    if (!infile.good())
-        throw std::runtime_error("Cannot open file: " + filename.string());
-    return read_stream(infile);
-}
-
-template <class T>
-inline void to_file(gsl::span<T> src, const std::filesystem::path &filename) {
-    std::ofstream ofile(filename.string(), std::ios::binary | std::ios::out);
-    ofile.write(src.template as_span<const char>().data(), src.size_bytes());
-    ofile.close();
-}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 35846c8e3a..6d90d9e776 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -1,24 +1,40 @@
 #pragma once
 
-#include <array>
-#include <cmath>
+// #include <array>
+// #include <cmath>
 #include <cstddef>
 #include <gsl/gsl-lite.hpp>
-#include <iostream>
-#include <numeric>
+// #include <iostream>
+// #include <numeric>
 #include <runtime_types.h>
-#include <vector>
+// #include <vector>
+
+
+
+struct runtime_util_mt {
+    int (*printf)(const char *__restrict __format, ...);
+    void *(*malloc)(size_t size);
+    int (*free)(void *ptr);
+    float (*sqrt)(float x);
+    void (*create_thread)(pthread_t &pt, void *param_, void *(*call)(void *));
+    void (*join_thread)(pthread_t &pt);
+};
+
+static runtime_util_mt runtime_util;            
 
 void print_vec(itlib::small_vector<size_t, 8> vec) {
     for (const size_t v : vec) {
-        std::cout << std::to_string(v) << ", ";
+        runtime_util.printf("%zu, ", v);
     }
-    std::cout << std::endl;
+    runtime_util.printf("\n");
 }
 
 template <class TShape> inline size_t compute_size(const TShape &shape) {
-    return std::accumulate(shape.begin(), shape.end(), 1,
-                           std::multiplies<size_t>());
+    size_t size = 1;
+    for (size_t i = 0; i < shape.size(); ++i) {
+        size *= shape[i];
+    }
+    return size;
 }
 
 template <class TShape>
@@ -35,16 +51,15 @@ inline size_t compute_size(const TShape &shape, const TShape &strides) {
 }
 
 template <class shape_type, class strides_type>
-inline std::size_t compute_strides(const shape_type &shape,
+inline size_t compute_strides(const shape_type &shape,
                                    strides_type &strides) {
-    using strides_value_type = typename std::decay_t<strides_type>::value_type;
-    strides_value_type data_size = 1;
+    size_t data_size = 1;
     for (std::size_t i = shape.size(); i != 0; --i) {
         strides[i - 1] = data_size;
         data_size =
-            strides[i - 1] * static_cast<strides_value_type>(shape[i - 1]);
+            strides[i - 1] * static_cast<size_t>(shape[i - 1]);
     }
-    return static_cast<std::size_t>(data_size);
+    return static_cast<size_t>(data_size);
 }
 
 inline strides_t get_default_strides(dims_t shape) {
@@ -56,11 +71,13 @@ inline strides_t get_default_strides(dims_t shape) {
 template <class offset_type, class S, class It>
 inline offset_type element_offset(const S &strides, It first,
                                   It last) noexcept {
-    using difference_type = typename std::iterator_traits<It>::difference_type;
-    auto size = static_cast<difference_type>((std::min)(
-        static_cast<size_t>(std::distance(first, last)), strides.size()));
-    return std::inner_product(last - size, last, strides.cend() - size,
-                              offset_type(0));
+    // using difference_type = typename
+    // std::iterator_traits<It>::difference_type; auto size =
+    // static_cast<difference_type>((std::min)(
+    //     static_cast<size_t>(std::distance(first, last)), strides.size()));
+    // return std::inner_product(last - size, last, strides.cend() - size,
+    //                           offset_type(0));
+    return 0;
 }
 
 inline size_t offset(gsl::span<const size_t> strides,
@@ -69,8 +86,10 @@ inline size_t offset(gsl::span<const size_t> strides,
     if (strides.size() == 0 || index.size() == 0) {
         return 0;
     }
-    assert(strides.size() == index.size());
+    // elf loader 不支持
+    // assert(strides.size() == index.size());
     return element_offset<size_t>(strides, index.begin(), index.end());
+    // return 0;
 }
 
 inline bool is_shape_equal(const dims_t &a, const dims_t &b) {
@@ -125,15 +144,15 @@ get_last_not_contiguous_index(gsl::span<const size_t> strides,
     return -1;
 }
 
-template <typename T>
-inline void span_copy(gsl::span<T> dest, gsl::span<T> src) {
-    std::copy(src.begin(), src.end(), dest.begin());
-}
+// template <typename T>
+// inline void span_copy(gsl::span<T> dest, gsl::span<T> src) {
+//     std::copy(src.data(), src.data()+src.size(), dest.data());
+// }
 
-template <typename T>
-inline void span_equal(gsl::span<T> dest, gsl::span<T> src) {
-    std::copy(src.begin(), src.end(), dest.begin());
-}
+// template <typename T>
+// inline void span_equal(gsl::span<T> dest, gsl::span<T> src) {
+//     std::copy(src.begin(), src.end(), dest.begin());
+// }
 
 template <typename T> double dot(const T *v1, const T *v2, size_t size) {
     double ret = 0.f;
@@ -146,10 +165,10 @@ template <typename T> double dot(const T *v1, const T *v2, size_t size) {
 
 template <typename T> double cosine(const T *v1, const T *v2, size_t size) {
     for (size_t i = 0; i < 10; i++) {
-        std::cout << v1[i] << " " << v2[i] << std::endl;
+        runtime_util.printf("%f, %f\n", (float)v1[i], (float)v2[i]);;
     }
     return dot(v1, v2, size) /
-           ((sqrt(dot(v1, v1, size)) * sqrt(dot(v2, v2, size))));
+           ((runtime_util.sqrt(dot(v1, v1, size)) * runtime_util.sqrt(dot(v2, v2, size))));
 }
 
 inline dims_t get_reduced_offset(gsl::span<const size_t> in_offset,
@@ -198,4 +217,4 @@ inline dims_t get_reduced_shape(gsl::span<const size_t> in_shape,
         }
     }
     return shape;
-}
\ No newline at end of file
+}
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index b4c45f0088..a9f40173c8 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -1,23 +1,19 @@
 #pragma once
 #include <apply.h>
-#include <binary.h>
+// #include <binary.h>
 #include <cassert>
-#include <concat.h>
+// #include <concat.h>
 #include <functional>
 #include <gather.h>
 #include <hardware_context.h>
-#include <layernorm.h>
-#include <matmul.h>
-#include <reduce.h>
-#include <softmax.h>
+// #include <layernorm.h>
+// #include <matmul.h>
+// #include <reduce.h>
+// #include <softmax.h>
 #include <tensor.h>
 #include <thread_context.h>
-#include <transpose.h>
-#include <unary.h>
-#ifndef __riscv_vector
-#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
-#include <spdlog/spdlog.h>
-#endif
+// #include <transpose.h>
+// #include <unary.h>
 
 template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &src) {
     auto new_dims = dims_t(src.dimension());
@@ -40,7 +36,7 @@ tensor<T, Loc> view_transpose(tensor<T, Loc> &src, dims_t perm) {
 
 template <class T, loc_t Loc>
 tensor<T, Loc> view(tensor<T, Loc> &src, dims_t new_dims) {
-    return tensor<T, Loc>(src.data(), new_dims, get_default_strides(new_dims));
+    return tensor<T, Loc>(src.data(), new_dims, (new_dims));
 }
 
 template <class T, loc_t Loc>
@@ -48,19 +44,19 @@ tensor<T, Loc> view(tensor<T, Loc> &src, dims_t new_dims, dims_t new_strides) {
     return tensor<T, Loc>(src.data(), new_dims, new_strides);
 }
 
-template <class T, loc_t Loc>
-void transpose(tensor<T, Loc> &src, tensor<T, Loc> &dest, dims_t perm) {
-    return kernels::transpose(src.cdata().data(), dest.data().data(),
-                              src.dimension(), perm, src.strides(),
-                              dest.strides());
-}
+// template <class T, loc_t Loc>
+// void transpose(tensor<T, Loc> &src, tensor<T, Loc> &dest, dims_t perm) {
+//     return kernels::transpose(src.cdata().data(), dest.data().data(),
+//                               src.dimension(), perm, src.strides(),
+//                               dest.strides());
+// }
 
-template <loc_t SrcLoc, loc_t DestLoc>
-void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest,
-             int axis) {
-    kernels::softmax(src.cdata().data(), dest.data().data(), src.dimension(),
-                     src.strides(), dest.strides(), axis, 1.0f, false);
-}
+// template <loc_t SrcLoc, loc_t DestLoc>
+// void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest,
+//              int axis) {
+//     kernels::softmax(src.cdata().data(), dest.data().data(), src.dimension(),
+//                      src.strides(), dest.strides(), axis, 1.0f, false);
+// }
 
 template <class T, loc_t DestLoc, loc_t SrcLoc>
 void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
@@ -72,42 +68,42 @@ void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
           });
 }
 
-template <class T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-void binary(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &out,
-            binary_op_t op) {
-    kernels::binary(
-        op, a.cdata().data(), b.cdata().data(), out.data().data(),
-        gsl::make_span(a.dimension()).template as_span<const size_t>(),
-        gsl::make_span(a.strides()).template as_span<const size_t>(),
-        gsl::make_span(b.dimension()).template as_span<const size_t>(),
-        gsl::make_span(b.strides()).template as_span<const size_t>(),
-        gsl::make_span(out.dimension()).template as_span<const size_t>(),
-        gsl::make_span(out.strides()).template as_span<const size_t>());
-}
-
-template <class T, loc_t ALoc, loc_t BLoc>
-void unary(tensor<T, ALoc> &a, tensor<T, BLoc> &out, unary_op_t op) {
-    kernels::unary(
-        op, a.cdata().data(), out.data().data(),
-        gsl::make_span(a.strides()).template as_span<const size_t>(),
-        gsl::make_span(out.dimension()).template as_span<const size_t>(),
-        gsl::make_span(out.strides()).template as_span<const size_t>());
-}
-
-template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &c) {
-    kernels::matmul(a.cdata().data(), b.cdata().data(), c.data().data(),
-                    a.dimension(), a.strides(), b.dimension(), b.strides(),
-                    c.dimension(), c.strides());
-}
-
-template <typename T, loc_t ALoc, loc_t BLoc>
-void reduce(tensor<T, ALoc> &input, tensor<T, BLoc> &output, reduce_op_t op,
-            T init_value, dims_t axis, bool keep_dims) {
-    kernels::reduce(op, &init_value, input.cdata().data(), output.data().data(),
-                    input.dimension(), axis, input.strides(), output.strides(),
-                    keep_dims);
-}
+// template <class T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
+// void binary(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &out,
+//             binary_op_t op) {
+//     kernels::binary(
+//         op, a.cdata().data(), b.cdata().data(), out.data().data(),
+//         gsl::make_span(a.dimension()).template as_span<const size_t>(),
+//         gsl::make_span(a.strides()).template as_span<const size_t>(),
+//         gsl::make_span(b.dimension()).template as_span<const size_t>(),
+//         gsl::make_span(b.strides()).template as_span<const size_t>(),
+//         gsl::make_span(out.dimension()).template as_span<const size_t>(),
+//         gsl::make_span(out.strides()).template as_span<const size_t>());
+// }
+
+// template <class T, loc_t ALoc, loc_t BLoc>
+// void unary(tensor<T, ALoc> &a, tensor<T, BLoc> &out, unary_op_t op) {
+//     kernels::unary(
+//         op, a.cdata().data(), out.data().data(),
+//         gsl::make_span(a.strides()).template as_span<const size_t>(),
+//         gsl::make_span(out.dimension()).template as_span<const size_t>(),
+//         gsl::make_span(out.strides()).template as_span<const size_t>());
+// }
+
+// template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
+// void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &c) {
+//     kernels::matmul(a.cdata().data(), b.cdata().data(), c.data().data(),
+//                     a.dimension(), a.strides(), b.dimension(), b.strides(),
+//                     c.dimension(), c.strides());
+// }
+
+// template <typename T, loc_t ALoc, loc_t BLoc>
+// void reduce(tensor<T, ALoc> &input, tensor<T, BLoc> &output, reduce_op_t op,
+//             T init_value, dims_t axis, bool keep_dims) {
+//     kernels::reduce(op, &init_value, input.cdata().data(), output.data().data(),
+//                     input.dimension(), axis, input.strides(), output.strides(),
+//                     keep_dims);
+// }
 
 template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
 void gather(tensor<T, ALoc> &input, tensor<int64_t, BLoc> &indices,
@@ -118,62 +114,62 @@ void gather(tensor<T, ALoc> &input, tensor<int64_t, BLoc> &indices,
         indices.data().data(), indices.dimension(), axis);
 }
 
-template <typename T, loc_t ALoc, loc_t BLoc>
-void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
-               tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
-               tensor<T, loc_t::local> &gamma, tensor<T, loc_t::local> &beta,
-               T eps, int32_t axis, int32_t norm_size, bool rms_norm = false) {
-    assert(sum.strides() == sum_sqr.strides());
-    assert(is_contiguous(sum.dimension(), sum.strides()));
-    assert(gamma.strides() == beta.strides());
-    assert(is_contiguous(gamma.dimension(), gamma.strides()));
-    kernels::layernorm(
-        input.cdata().data(), sum.data().data(), sum_sqr.data().data(),
-        output.data().data(), gamma.data().data(), beta.data().data(),
-        input.dimension(), input.strides(), output.strides(), sum.strides(),
-        gamma.strides(), eps, axis, norm_size, rms_norm);
-}
-
-template <typename T, loc_t ALoc, loc_t BLoc>
-void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
-               tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
-               int32_t axis, int32_t norm_size, bool rms_norm = false) {
-    kernels::layernorm(input.cdata().data(), sum.data().data(),
-                       sum_sqr.data().data(), output.data().data(),
-                       static_cast<T *>(nullptr), static_cast<T *>(nullptr),
-                       input.dimension(), input.strides(), output.strides(),
-                       sum.strides(), dims_t({}), static_cast<T>(1e-5), axis,
-                       norm_size, rms_norm);
-}
-
-template <typename T, loc_t ALoc>
-void reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
-                    tensor<T, loc_t::local> &sum_sqr) {
-    kernels::reduce_sum_and_sum_sqr(a.cdata().data(), sum.data().data(),
-                                    sum_sqr.data().data(), a.dimension(),
-                                    a.strides(), sum.strides());
-}
-
-template <typename T, loc_t BLoc>
-void concat(std::initializer_list<tensor<T, loc_t::local>> inits,
-            tensor<T, BLoc> &output, size_t axis) {
-    itlib::small_vector<const gsl::byte *const, 8> inputs(inits.size());
-    std::vector<strides_t> in_strides(inits.size());
-    auto concat_dims = dims_t(inits.size(), 1);
-    for (size_t i = 0; i < inits.size(); ++i) {
-        if (inits[i].dimension().size() != 0) {
-            concat_dims[i] = inits[i].dimension()[axis];
-        }
-    }
-
-    for (auto &in : inits) {
-        inputs.push_back((const gsl::byte *const)(in.data().data()));
-        in_strides.push_back(in.strides());
-    }
-
-    kernels::concat(inputs, output.data().data(), output.dimension(),
-                    in_strides, output.strides(), axis, concat_dims);
-}
+// template <typename T, loc_t ALoc, loc_t BLoc>
+// void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
+//                tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
+//                tensor<T, loc_t::local> &gamma, tensor<T, loc_t::local> &beta,
+//                T eps, int32_t axis, int32_t norm_size, bool rms_norm = false) {
+//     assert(sum.strides() == sum_sqr.strides());
+//     assert(is_contiguous(sum.dimension(), sum.strides()));
+//     assert(gamma.strides() == beta.strides());
+//     assert(is_contiguous(gamma.dimension(), gamma.strides()));
+//     kernels::layernorm(
+//         input.cdata().data(), sum.data().data(), sum_sqr.data().data(),
+//         output.data().data(), gamma.data().data(), beta.data().data(),
+//         input.dimension(), input.strides(), output.strides(), sum.strides(),
+//         gamma.strides(), eps, axis, norm_size, rms_norm);
+// }
+
+// template <typename T, loc_t ALoc, loc_t BLoc>
+// void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
+//                tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
+//                int32_t axis, int32_t norm_size, bool rms_norm = false) {
+//     kernels::layernorm(input.cdata().data(), sum.data().data(),
+//                        sum_sqr.data().data(), output.data().data(),
+//                        static_cast<T *>(nullptr), static_cast<T *>(nullptr),
+//                        input.dimension(), input.strides(), output.strides(),
+//                        sum.strides(), dims_t({}), static_cast<T>(1e-5), axis,
+//                        norm_size, rms_norm);
+// }
+
+// template <typename T, loc_t ALoc>
+// void reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
+//                     tensor<T, loc_t::local> &sum_sqr) {
+//     kernels::reduce_sum_and_sum_sqr(a.cdata().data(), sum.data().data(),
+//                                     sum_sqr.data().data(), a.dimension(),
+//                                     a.strides(), sum.strides());
+// }
+
+// template <typename T, loc_t BLoc>
+// void concat(std::initializer_list<tensor<T, loc_t::local>> inits,
+//             tensor<T, BLoc> &output, size_t axis) {
+//     itlib::small_vector<const gsl::byte *const, 8> inputs(inits.size());
+//     std::vector<strides_t> in_strides(inits.size());
+//     auto concat_dims = dims_t(inits.size(), 1);
+//     for (size_t i = 0; i < inits.size(); ++i) {
+//         if (inits[i].dimension().size() != 0) {
+//             concat_dims[i] = inits[i].dimension()[axis];
+//         }
+//     }
+
+//     for (auto &in : inits) {
+//         inputs.push_back((const gsl::byte *const)(in.data().data()));
+//         in_strides.push_back(in.strides());
+//     }
+
+//     kernels::concat(inputs, output.data().data(), output.dimension(),
+//                     in_strides, output.strides(), axis, concat_dims);
+// }
 
 /**
  * @brief Block 级别的 mma，每个 thread 执行自己的 mma，最终 psum 累加写入
@@ -188,56 +184,48 @@ void concat(std::initializer_list<tensor<T, loc_t::local>> inits,
  * @param load_psum
  * @param ctx
  */
-template <typename T, loc_t ALoc, loc_t BLoc>
-void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
-                           tensor<T, loc_t::shared> &c, bool load_psum,
-                           thread_context &ctx) {
-    tensor<T> tmp(c.dimension());
-    matmul(a, b, tmp);
-
-    __tdma_block_sync_apply(
-        [&](int visited) -> void {
-            if (load_psum) {
-                binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
-                    tmp, c, c, binary_op_t::add);
-            } else {
-                if (visited == 1) {
-                    binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
-                        tmp, c, c, binary_op_t::add);
-                } else {
-                    binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
-                        tmp, c, c, binary_op_t::add);
-                }
-            }
-        },
-        ctx);
-}
+// template <typename T, loc_t ALoc, loc_t BLoc>
+// void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
+//                            tensor<T, loc_t::shared> &c, bool load_psum,
+//                            thread_context &ctx) {
+//     tensor<T> tmp(c.dimension());
+//     matmul(a, b, tmp);
+
+//     __tdma_block_sync_apply(
+//         [&](int visited) -> void {
+//             if (load_psum) {
+//                 binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
+//                     tmp, c, c, binary_op_t::add);
+//             } else {
+//                 if (visited == 1) {
+//                     binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
+//                         tmp, c, c, binary_op_t::add);
+//                 } else {
+//                     binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
+//                         tmp, c, c, binary_op_t::add);
+//                 }
+//             }
+//         },
+//         ctx);
+// }
 
 void __tdma_block_sync_apply(std::function<void(int)> func,
                              thread_context &ctx) {
-    global_hardware_ctx->lock_block(ctx.bid());
-    int visited = global_hardware_ctx->mark_block_visit(ctx.bid(), ctx.tid());
-#ifndef __riscv_vector
-    SPDLOG_DEBUG("__tdma_block_sync_apply bid {} tid {} visited {}\n",
-                 ctx.bid(), ctx.tid(), visited);
-#endif
+    global_hardware_ctx.lock_block(ctx.bid());
+    int visited = global_hardware_ctx.mark_block_visit(ctx.bid(), ctx.tid());
     func(visited);
-    global_hardware_ctx->unlock_block(ctx.bid());
-    global_hardware_ctx->wait_block_sync(ctx.bid(), visited);
+    global_hardware_ctx.unlock_block(ctx.bid());
+    global_hardware_ctx.wait_block_sync(ctx.bid(), visited);
 }
 
 void __tdma_all_sync_apply(std::function<void(int)> apply_func,
                            std::function<void()> broadcast_func,
                            thread_context &ctx) {
-    global_hardware_ctx->lock_all();
-    int visited = global_hardware_ctx->mark_all_visit(ctx.bid(), ctx.tid());
-#ifndef __riscv_vector
-    SPDLOG_DEBUG("__tdma_all_sync_apply bid {} tid {} visited {}\n", ctx.bid(),
-                 ctx.tid(), visited);
-#endif
+    global_hardware_ctx.lock_all();
+    int visited = global_hardware_ctx.mark_all_visit(ctx.bid(), ctx.tid());
     apply_func(visited);
-    global_hardware_ctx->unlock_all();
-    global_hardware_ctx->wait_all_sync(visited, broadcast_func);
+    global_hardware_ctx.unlock_all();
+    global_hardware_ctx.wait_all_sync(visited, broadcast_func);
 }
 
 template <class T, loc_t DestLoc>
@@ -273,11 +261,11 @@ template <class T>
 void tdma_broadcast_async(tensor<T, loc_t::local> &src,
                           tensor<T, loc_t::shared> &dest, thread_context &ctx) {
 
-    global_hardware_ctx->lock_block(ctx.bid());
+    global_hardware_ctx.lock_block(ctx.bid());
     __tensor_copy_sync(dest, src);
-    global_hardware_ctx->unlock_block(ctx.bid());
-    // int cnt = global_hardware_ctx->mark_block_visit(ctx.tid());
-    // global_hardware_ctx->wait_block_sync(ctx.bid(), cnt);
+    global_hardware_ctx.unlock_block(ctx.bid());
+    // int cnt = global_hardware_ctx.mark_block_visit(ctx.tid());
+    // global_hardware_ctx.wait_block_sync(ctx.bid(), cnt);
 }
 
 template <class T, loc_t Src, loc_t Dest>
@@ -287,58 +275,58 @@ void tdma_load_broadcast_async([[maybe_unused]] tensor<T, Dest> &dest,
     throw std::system_error(std::make_error_code(std::errc::not_supported));
 }
 
-template <class T>
-void tdma_reduce_async(tensor<T, loc_t::local> &src,
-                       tensor<T, loc_t::local> &dest, reduce_op_t reduce_op,
-                       thread_context &ctx) {
-    __tdma_all_sync_apply(
-        [&src, &ctx](int visited) -> void {
-            tensor<T> *gather_tensor = nullptr;
-            auto new_dims = dims_t(src.dimension());
-            new_dims.insert(new_dims.begin(), BLOCKS * CORES);
-            if (visited == 1) {
-                if (global_hardware_ctx->global_var != nullptr) {
-                    throw std::runtime_error(" the global var has been used!");
-                }
-                gather_tensor = new tensor<T>(new_dims);
-                global_hardware_ctx->global_var = (void *)gather_tensor;
-            } else {
-                gather_tensor =
-                    static_cast<tensor<T> *>(global_hardware_ctx->global_var);
-            }
-            dims_t begin(new_dims.size(), 0);
-            dims_t shape(new_dims);
-            begin[0] = ctx.bid() * CORES + ctx.tid();
-            shape[0] = 1;
-            __tensor_copy_sync<T, loc_t::local, loc_t::local>(
-                std::move((*gather_tensor)(begin, shape)),
-                std::move(unsqueeze(src)));
-        },
-        []() -> void {}, ctx);
-
-    __tdma_all_sync_apply(
-        [&]([[maybe_unused]] int visit) -> void {
-            tensor<T> *gather_tensor =
-                static_cast<tensor<T> *>(global_hardware_ctx->global_var);
-            auto new_dims = dims_t(gather_tensor->dimension());
-            new_dims[0] = CORES;
-            auto viewed_gather_tensor =
-                tensor<T>(gather_tensor->data().subspan(
-                              ctx.bid() * CORES * gather_tensor->strides()[0],
-                              CORES * gather_tensor->strides()[0]),
-                          new_dims, gather_tensor->strides());
-
-            reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
-                   dims_t({0}), false);
-        },
-        []() -> void {
-            auto reduced_tensor =
-                static_cast<tensor<T> *>(global_hardware_ctx->global_var);
-            delete reduced_tensor;
-            global_hardware_ctx->global_var = nullptr;
-        },
-        ctx);
-}
+// template <class T>
+// void tdma_reduce_async(tensor<T, loc_t::local> &src,
+//                        tensor<T, loc_t::local> &dest, reduce_op_t reduce_op,
+//                        thread_context &ctx) {
+//     __tdma_all_sync_apply(
+//         [&src, &ctx](int visited) -> void {
+//             tensor<T> *gather_tensor = nullptr;
+//             auto new_dims = dims_t(src.dimension());
+//             new_dims.insert(new_dims.begin(), BLOCKS * CORES);
+//             if (visited == 1) {
+//                 if (global_hardware_ctx.global_var != nullptr) {
+//                     throw std::runtime_error(" the global var has been used!");
+//                 }
+//                 gather_tensor = new tensor<T>(new_dims);
+//                 global_hardware_ctx.global_var = (void *)gather_tensor;
+//             } else {
+//                 gather_tensor =
+//                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+//             }
+//             dims_t begin(new_dims.size(), 0);
+//             dims_t shape(new_dims);
+//             begin[0] = ctx.bid() * CORES + ctx.tid();
+//             shape[0] = 1;
+//             __tensor_copy_sync<T, loc_t::local, loc_t::local>(
+//                 std::move((*gather_tensor)(begin, shape)),
+//                 std::move(unsqueeze(src)));
+//         },
+//         []() -> void {}, ctx);
+
+//     __tdma_all_sync_apply(
+//         [&]([[maybe_unused]] int visit) -> void {
+//             tensor<T> *gather_tensor =
+//                 static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+//             auto new_dims = dims_t(gather_tensor->dimension());
+//             new_dims[0] = CORES;
+//             auto viewed_gather_tensor =
+//                 tensor<T>(gather_tensor->data().subspan(
+//                               ctx.bid() * CORES * gather_tensor->strides()[0],
+//                               CORES * gather_tensor->strides()[0]),
+//                           new_dims, gather_tensor->strides());
+
+//             reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
+//                    dims_t({0}), false);
+//         },
+//         []() -> void {
+//             auto reduced_tensor =
+//                 static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+//             delete reduced_tensor;
+//             global_hardware_ctx.global_var = nullptr;
+//         },
+//         ctx);
+// }
 
 enum class reduce_strategy_t : uint8_t {
     all,
@@ -359,92 +347,92 @@ enum class reduce_strategy_t : uint8_t {
  * @param axis axis of gather tensor, note gather tensor dims = [32,...]
  * @param ctx
  */
-template <class T, loc_t ALoc, loc_t BLoc>
-void tdma_all_reduce_async(tensor<T, ALoc> &src, tensor<T, BLoc> &dest,
-                           reduce_op_t reduce_op, reduce_strategy_t strategy,
-                           thread_context &ctx) {
-    __tdma_all_sync_apply(
-        [&src, &ctx](int visited) -> void {
-            tensor<T> *gather_tensor = nullptr;
-            auto new_dims = dims_t(src.dimension());
-            new_dims.insert(new_dims.begin(), BLOCKS * CORES);
-            if (visited == 1) {
-                if (global_hardware_ctx->global_var != nullptr) {
-                    throw std::runtime_error(" the global var has been used!");
-                }
-                gather_tensor = new tensor<T>(new_dims);
-                global_hardware_ctx->global_var = (void *)gather_tensor;
-            } else {
-                gather_tensor =
-                    static_cast<tensor<T> *>(global_hardware_ctx->global_var);
-            }
-            dims_t begin(new_dims.size(), 0);
-            dims_t shape(new_dims);
-            begin[0] = ctx.bid() * CORES + ctx.tid();
-            shape[0] = 1;
-            __tensor_copy_sync<T, loc_t::local, ALoc>(
-                std::move((*gather_tensor)(begin, shape)),
-                std::move(unsqueeze(src)));
-        },
-        []() -> void {}, ctx);
-    switch (strategy) {
-    case reduce_strategy_t::all:
-        __tdma_all_sync_apply(
-            [&]([[maybe_unused]] int visit) -> void {
-                tensor<T> *gather_tensor = nullptr;
-                tensor<T> *reduced_tensor = nullptr;
-                if (visit == 1) {
-                    gather_tensor = static_cast<tensor<T> *>(
-                        global_hardware_ctx->global_var);
-                    auto reduced_shape = get_reduced_shape(
-                        gather_tensor->dimension(), dims_t({0}), false);
-                    reduced_tensor = new tensor<T>(reduced_shape);
-                    reduce(*gather_tensor, *reduced_tensor, reduce_op, (T)0,
-                           dims_t({0}), false);
-                    delete gather_tensor;
-                    global_hardware_ctx->global_var = reduced_tensor;
-                } else {
-                    reduced_tensor = static_cast<tensor<T> *>(
-                        global_hardware_ctx->global_var);
-                    __tensor_copy_sync(std::move(dest),
-                                       std::move(*reduced_tensor));
-                }
-            },
-            []() -> void {
-                auto reduced_tensor =
-                    static_cast<tensor<T> *>(global_hardware_ctx->global_var);
-                delete reduced_tensor;
-                global_hardware_ctx->global_var = nullptr;
-            },
-            ctx);
-        break;
-    case reduce_strategy_t::by_block:
-        __tdma_all_sync_apply(
-            [&]([[maybe_unused]] int visit) -> void {
-                tensor<T> *gather_tensor =
-                    static_cast<tensor<T> *>(global_hardware_ctx->global_var);
-                auto new_dims = dims_t(src.dimension());
-                new_dims.insert(new_dims.begin(), BLOCKS);
-                auto new_strides = dims_t(gather_tensor->strides());
-                new_strides[0] *= CORES;
-                auto viewed_gather_tensor =
-                    view(*gather_tensor, new_dims, new_strides);
-
-                reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
-                       dims_t({0}), false);
-            },
-            []() -> void {
-                auto reduced_tensor =
-                    static_cast<tensor<T> *>(global_hardware_ctx->global_var);
-                delete reduced_tensor;
-                global_hardware_ctx->global_var = nullptr;
-            },
-            ctx);
-        break;
-    default:
-        break;
-    }
-}
+// template <class T, loc_t ALoc, loc_t BLoc>
+// void tdma_all_reduce_async(tensor<T, ALoc> &src, tensor<T, BLoc> &dest,
+//                            reduce_op_t reduce_op, reduce_strategy_t strategy,
+//                            thread_context &ctx) {
+//     __tdma_all_sync_apply(
+//         [&src, &ctx](int visited) -> void {
+//             tensor<T> *gather_tensor = nullptr;
+//             auto new_dims = dims_t(src.dimension());
+//             new_dims.insert(new_dims.begin(), BLOCKS * CORES);
+//             if (visited == 1) {
+//                 if (global_hardware_ctx.global_var != nullptr) {
+//                     throw std::runtime_error(" the global var has been used!");
+//                 }
+//                 gather_tensor = new tensor<T>(new_dims);
+//                 global_hardware_ctx.global_var = (void *)gather_tensor;
+//             } else {
+//                 gather_tensor =
+//                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+//             }
+//             dims_t begin(new_dims.size(), 0);
+//             dims_t shape(new_dims);
+//             begin[0] = ctx.bid() * CORES + ctx.tid();
+//             shape[0] = 1;
+//             __tensor_copy_sync<T, loc_t::local, ALoc>(
+//                 std::move((*gather_tensor)(begin, shape)),
+//                 std::move(unsqueeze(src)));
+//         },
+//         []() -> void {}, ctx);
+//     switch (strategy) {
+//     case reduce_strategy_t::all:
+//         __tdma_all_sync_apply(
+//             [&]([[maybe_unused]] int visit) -> void {
+//                 tensor<T> *gather_tensor = nullptr;
+//                 tensor<T> *reduced_tensor = nullptr;
+//                 if (visit == 1) {
+//                     gather_tensor = static_cast<tensor<T> *>(
+//                         global_hardware_ctx.global_var);
+//                     auto reduced_shape = get_reduced_shape(
+//                         gather_tensor->dimension(), dims_t({0}), false);
+//                     reduced_tensor = new tensor<T>(reduced_shape);
+//                     reduce(*gather_tensor, *reduced_tensor, reduce_op, (T)0,
+//                            dims_t({0}), false);
+//                     delete gather_tensor;
+//                     global_hardware_ctx.global_var = reduced_tensor;
+//                 } else {
+//                     reduced_tensor = static_cast<tensor<T> *>(
+//                         global_hardware_ctx.global_var);
+//                     __tensor_copy_sync(std::move(dest),
+//                                        std::move(*reduced_tensor));
+//                 }
+//             },
+//             []() -> void {
+//                 auto reduced_tensor =
+//                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+//                 delete reduced_tensor;
+//                 global_hardware_ctx.global_var = nullptr;
+//             },
+//             ctx);
+//         break;
+//     case reduce_strategy_t::by_block:
+//         __tdma_all_sync_apply(
+//             [&]([[maybe_unused]] int visit) -> void {
+//                 tensor<T> *gather_tensor =
+//                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+//                 auto new_dims = dims_t(src.dimension());
+//                 new_dims.insert(new_dims.begin(), BLOCKS);
+//                 auto new_strides = dims_t(gather_tensor->strides());
+//                 new_strides[0] *= CORES;
+//                 auto viewed_gather_tensor =
+//                     view(*gather_tensor, new_dims, new_strides);
+
+//                 reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
+//                        dims_t({0}), false);
+//             },
+//             []() -> void {
+//                 auto reduced_tensor =
+//                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+//                 delete reduced_tensor;
+//                 global_hardware_ctx.global_var = nullptr;
+//             },
+//             ctx);
+//         break;
+//     default:
+//         break;
+//     }
+// }
 
 void tdma_gather_async() {}
 
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index 419cff1cbe..d8cdfd2826 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <array>
 #include <cstddef>
 #include <gsl/gsl-lite.hpp>
 #include <hardware_def.h>
@@ -24,10 +23,21 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
           strides_(get_default_strides(dims_)),
           size_(compute_size(dims_)) {
         parent_ = nullptr;
-        auto ptr = new T[size_]();
+        auto ptr = (T *)runtime_util.malloc(size_ * sizeof(T));
         data_ = gsl::make_span(ptr, size_);
     }
 
+    tensor(gsl::span<T> data, dims_t dims)
+        : data_(data),
+          parent_(data.data()),
+          dims_(dims),
+          strides_(get_default_strides(dims_)),
+          size_(compute_size(dims_)) {
+        if (size_ != data_.size()) {
+            throw std::errc::invalid_argument;
+        }
+    }
+
     tensor(gsl::span<T> data, dims_t dims, strides_t strides)
         : data_(data),
           parent_(data.data()),
@@ -58,7 +68,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
 
     ~tensor() {
         if (parent_ == nullptr) {
-            delete[] data_.data();
+            runtime_util.free(data_.data());
         }
     }
 
@@ -69,9 +79,11 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
           strides_(parent->strides().begin(), parent->strides().end()) {
         size_ = compute_size(shapes);
         strides_ = parent->strides();
-        data_ = parent->data_.subspan(offset(strides_, begins));
+        auto subspan_offset = offset(strides_, begins);
+        data_ = parent->data_.subspan(subspan_offset);
         if (data_.size() < size_) {
-            throw std::errc::invalid_argument;
+            // std::errc 也不能使用
+            // throw std::errc::invalid_argument;
         }
     }
 
@@ -79,5 +91,5 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
     void *parent_;
     dims_t dims_;
     strides_t strides_;
-    std::size_t size_;
+    size_t size_;
 };
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/src/dummy.cpp b/modules/cpu/src/runtime/cmodel/src/dummy.cpp
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp b/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
deleted file mode 100644
index 1d7a8472b9..0000000000
--- a/modules/cpu/src/runtime/cmodel/src/hardware_context.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#include <hardware_context.h>
-#include <hardware_def.h>
-#include <pthread.h>
-
-class condition_variable {
-  public:
-    condition_variable() {
-        pthread_cond_init(&cond, NULL);
-        pthread_mutex_init(&mutex, NULL);
-    }
-
-    pthread_mutex_t mutex;
-    pthread_cond_t cond;
-
-    ~condition_variable() {
-        pthread_mutex_destroy(&mutex);
-        pthread_cond_destroy(&cond);
-    }
-};
-
-struct hardware_context_impl {
-  public:
-    hardware_context_impl() {
-        global_cond = condition_variable();
-        pthread_mutex_init(&global_mutex, NULL);
-
-        for (size_t i = 0; i < BLOCKS; i++) {
-            pthread_mutex_init(&block_mutexs[i], NULL);
-            block_conds[i] = condition_variable();
-            for (size_t j = 0; j < CORES; j++) {
-                block_visited[i][j] = false;
-                global_visited[i][j] = false;
-            }
-        }
-    }
-
-    void reset_block_visited(int bid) {
-        for (size_t i = 0; i < CORES; i++) {
-            block_visited[bid][i] = false;
-        }
-    }
-
-    void reset_global_visited() {
-        for (size_t i = 0; i < BLOCKS; i++) {
-            for (size_t j = 0; j < CORES; j++) {
-                global_visited[i][j] = false;
-            }
-        }
-    }
-
-    pthread_mutex_t global_mutex;
-    condition_variable global_cond;
-    bool global_visited[BLOCKS][CORES];
-    pthread_mutex_t block_mutexs[BLOCKS];
-    condition_variable block_conds[BLOCKS];
-    bool block_visited[BLOCKS][CORES];
-
-    ~hardware_context_impl() {
-        pthread_mutex_destroy(&global_mutex);
-        for (size_t i = 0; i < BLOCKS; i++) {
-            pthread_mutex_destroy(&block_mutexs[i]);
-        }
-    }
-};
-
-hardware_context::hardware_context() {
-    impl_ = std::make_unique<hardware_context_impl>();
-}
-
-void hardware_context::lock_block(int bid) {
-    pthread_mutex_lock(&impl_->block_mutexs[bid]);
-}
-
-void hardware_context::unlock_block(int bid) {
-    pthread_mutex_unlock(&impl_->block_mutexs[bid]);
-}
-
-int hardware_context::mark_block_visit(int bid, int tid) {
-    impl_->block_visited[bid][tid] = true;
-    int visited = 0;
-    for (size_t i = 0; i < CORES; i++) {
-        visited += impl_->block_visited[bid][i] == true ? 1 : 0;
-    }
-    return visited;
-}
-
-void hardware_context::wait_block_sync(int bid, int visited,
-                                       std::function<void()> callable) {
-    pthread_mutex_lock(&impl_->block_conds[bid].mutex);
-    if (visited == CORES) {
-        callable();
-        impl_->reset_block_visited(bid);
-        pthread_cond_broadcast(&impl_->block_conds[bid].cond);
-    } else {
-        pthread_cond_wait(&impl_->block_conds[bid].cond,
-                          &impl_->block_conds[bid].mutex);
-    }
-    pthread_mutex_unlock(&impl_->block_conds[bid].mutex);
-}
-
-void hardware_context::lock_all() { pthread_mutex_lock(&impl_->global_mutex); }
-
-void hardware_context::unlock_all() {
-    pthread_mutex_unlock(&impl_->global_mutex);
-}
-
-int hardware_context::mark_all_visit(int bid, int tid) {
-    impl_->global_visited[bid][tid] = true;
-    int visited = 0;
-    for (size_t i = 0; i < BLOCKS; i++) {
-        for (size_t j = 0; j < CORES; j++) {
-            visited += impl_->global_visited[i][j] == true ? 1 : 0;
-        }
-    }
-    return visited;
-}
-
-void hardware_context::wait_all_sync(int visited,
-                                     std::function<void()> callable) {
-    pthread_mutex_lock(&impl_->global_cond.mutex);
-    if (visited == BLOCKS * CORES) {
-        callable();
-        impl_->reset_global_visited();
-        pthread_cond_broadcast(&impl_->global_cond.cond);
-    } else {
-        pthread_cond_wait(&impl_->global_cond.cond, &impl_->global_cond.mutex);
-    }
-    pthread_mutex_unlock(&impl_->global_cond.mutex);
-}
-
-std::unique_ptr<hardware_context> global_hardware_ctx = nullptr;
-
-void global_hardware_init() {
-    global_hardware_ctx = std::make_unique<hardware_context>();
-}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def copy.h b/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def copy.h
new file mode 100644
index 0000000000..8fd5d84ed7
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def copy.h	
@@ -0,0 +1,171 @@
+#pragma once
+#include <hardware_context.h>
+#include <tdma.h>
+
+namespace block0 {
+#include "shared_def.h"
+constexpr size_t bid = 0;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block0
+
+namespace block1 {
+#include "shared_def.h"
+constexpr size_t bid = 1;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block1
+
+namespace block2 {
+#include "shared_def.h"
+constexpr size_t bid = 2;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block2
+
+namespace block3 {
+#include "shared_def.h"
+constexpr size_t bid = 3;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block3
+
+namespace block4 {
+#include "shared_def.h"
+constexpr size_t bid = 4;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block4
+
+namespace block5 {
+#include "shared_def.h"
+constexpr size_t bid = 5;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block5
+
+namespace block6 {
+#include "shared_def.h"
+constexpr size_t bid = 6;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block6
+
+namespace block7 {
+#include "shared_def.h"
+constexpr size_t bid = 7;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block7
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def.h b/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def.h
new file mode 100644
index 0000000000..8fd5d84ed7
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def.h
@@ -0,0 +1,171 @@
+#pragma once
+#include <hardware_context.h>
+#include <tdma.h>
+
+namespace block0 {
+#include "shared_def.h"
+constexpr size_t bid = 0;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block0
+
+namespace block1 {
+#include "shared_def.h"
+constexpr size_t bid = 1;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block1
+
+namespace block2 {
+#include "shared_def.h"
+constexpr size_t bid = 2;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block2
+
+namespace block3 {
+#include "shared_def.h"
+constexpr size_t bid = 3;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block3
+
+namespace block4 {
+#include "shared_def.h"
+constexpr size_t bid = 4;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block4
+
+namespace block5 {
+#include "shared_def.h"
+constexpr size_t bid = 5;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block5
+
+namespace block6 {
+#include "shared_def.h"
+constexpr size_t bid = 6;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block6
+
+namespace block7 {
+#include "shared_def.h"
+constexpr size_t bid = 7;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block7
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo4/golden.py
new file mode 100644
index 0000000000..4ead78241d
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo4/golden.py
@@ -0,0 +1,31 @@
+import numpy as np
+from torch import nn
+import torch
+from scipy.special import softmax
+import os
+
+
+def rmsnorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray, eps=1e-05):
+    x = torch.from_numpy(x)
+    output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
+    output = output * torch.from_numpy(gamma) + torch.from_numpy(beta)
+    return output.detach().numpy()
+
+
+def layernorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray):
+    return nn.functional.layer_norm(torch.from_numpy(x), [x.shape[-1]], torch.from_numpy(gamma), torch.from_numpy(beta)).detach().numpy()
+
+
+def swish(x: np.ndarray):
+    return x / (1 + np.exp(-x))
+
+
+def gather(data: np.ndarray, axis: int, indices: np.ndarray):
+    return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
+
+
+hidden_in = np.random.rand(1, 384, 8192).astype(np.float32)
+hidden_in.tofile('hidden_in.bin')
+output = rmsnorm(hidden_in, np.ones([8192], np.float32), np.zeros([8192], np.float32))
+# f32[1,384,8192]
+output.tofile("output.bin")
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/kernel copy.h b/modules/cpu/src/runtime/cmodel/tests/demo4/kernel copy.h
new file mode 100644
index 0000000000..2269adad89
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo4/kernel copy.h	
@@ -0,0 +1,28 @@
+// llama 65B
+// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
+// 1 chips, 8 blocks per chip, 4 threads per block
+
+#include "thread_context.h"
+using namespace shared;
+
+#define DUMP 0
+
+void stage1_kernel(
+    tensor<int64_t, loc_t::device> &Position_ids, /* [1, 384] */
+    tensor<float, loc_t::device> &GatherData,   /* [32000, 8192] */
+    tensor<float, loc_t::device> &Output          /* [1, 384, 8192] */
+) {
+    thread_context ctx(bid, tid);
+    tensor<int64_t> position_ids({1, 384});
+    tensor<float> gather_data({32000, 256});
+    tensor<float> output({1, 384, 256});
+
+    tdma_load_async(position_ids, std::move(Position_ids), ctx);
+    tdma_load_async(gather_data,
+                    GatherData({0, 256 * (CORES * bid + tid)}, {32000, 256}),
+                    ctx);
+    gather(gather_data, position_ids, output, 0);
+
+    tdma_store_async(
+        output, Output({0, 0, 256 * (CORES * bid + tid)}, {1, 384, 256}), ctx);
+}
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h
new file mode 100644
index 0000000000..d8f372b13c
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h
@@ -0,0 +1,32 @@
+// llama 65B
+// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
+// 1 chips, 8 blocks per chip, 4 threads per block
+
+#include "thread_context.h"
+using namespace shared;
+
+#define DUMP 0
+
+void stage1_kernel(
+    [[maybe_unused]] tensor<int64_t, loc_t::device> &Position_ids, /* [1, 384] */
+    [[maybe_unused]] tensor<float, loc_t::device> &GatherData,   /* [32000, 8192] */
+    [[maybe_unused]] tensor<float, loc_t::device> &Output          /* [1, 384, 8192] */
+) {
+    thread_context ctx(bid, tid);
+    tensor<int64_t> position_ids({1, 384});
+    tensor<float> gather_data({32000, 256});
+    tensor<float> output({1, 384, 256});
+
+    tdma_load_async(position_ids, std::move(Position_ids), ctx);
+    dims_t begins{0, 256 * (CORES * bid + tid)};
+    dims_t ends{32000, 256};
+    runtime_util.printf("t+b %d %d\n", bid, tid);
+    GatherData(begins, ends);
+    tdma_load_async(gather_data,
+                    GatherData(begins, ends),
+                    ctx);
+    gather(gather_data, position_ids, output, 0);
+
+    tdma_store_async(
+        output, Output({0, 0, 256 * (CORES * bid + tid)}, {1, 384, 256}), ctx);
+}
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
new file mode 100644
index 0000000000..5e02356215
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
@@ -0,0 +1,126 @@
+#include "cluster_def.h"
+// #include <io_utils.h>
+// #include <cstring>
+#include <runtime_utils.h>
+// #include <pthread.h>
+
+#define DEFINE_TFUNC(b, t)                                                     \
+    void *f_##b##_##t(void *arg) {                                             \
+        block##b::thread##t::stage1_kernel(*Position_ids, *GatherData,         \
+                                           *Output);                           \
+        return arg;                                                            \
+    }
+
+#define DEFINE_BFUNC(b)                                                        \
+    DEFINE_TFUNC(b, 0)                                                         \
+    DEFINE_TFUNC(b, 1)                                                         \
+    DEFINE_TFUNC(b, 2)                                                         \
+    DEFINE_TFUNC(b, 3)
+
+static tensor<int64_t, loc_t::device> *Position_ids;
+static tensor<float, loc_t::device> *GatherData;
+static tensor<float, loc_t::device> *Output;
+
+DEFINE_BFUNC(0)
+DEFINE_BFUNC(1)
+DEFINE_BFUNC(2)
+DEFINE_BFUNC(3)
+DEFINE_BFUNC(4)
+DEFINE_BFUNC(5)
+DEFINE_BFUNC(6)
+DEFINE_BFUNC(7)
+
+void _start(hardware_context_mt *hw_impl, runtime_util_mt *rt_util_mt,
+            uint8_t *position_ids, uint8_t *gather_data, uint8_t *output) {
+    global_hardware_init(hw_impl);
+    runtime_util = *rt_util_mt;
+    runtime_util.printf("%p\t%p\n", gather_data, output);
+
+    auto Position_ids_ = tensor<int64_t, loc_t::device>(
+        gsl::make_span((int64_t *)position_ids, 384), {1, 384});
+    runtime_util.printf("1\n");
+
+    auto GatherData_ = tensor<float, loc_t::device>(
+        gsl::make_span((float *)gather_data, 384*8192), {1, 384, 8192});
+
+    runtime_util.printf("2\n");
+    auto Output_ = tensor<float, loc_t::device>(
+        gsl::make_span((float *)output, 384*8192), {1, 384, 8192});
+
+    runtime_util.printf("3\n");
+    Position_ids = &Position_ids_;
+    GatherData = &GatherData_;
+    Output = &Output_;
+    runtime_util.printf("%d\n", Position_ids->data().size());
+
+    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
+
+    runtime_util.create_thread(t_0_0, NULL, f_0_0);
+    // runtime_util.create_thread(t_0_1, NULL, f_0_1);
+    // runtime_util.create_thread(t_0_2, NULL, f_0_2);
+    // runtime_util.create_thread(t_0_3, NULL, f_0_3);
+    // runtime_util.create_thread(t_1_0, NULL, f_1_0);
+    // runtime_util.create_thread(t_1_1, NULL, f_1_1);
+    // runtime_util.create_thread(t_1_2, NULL, f_1_2);
+    // runtime_util.create_thread(t_1_3, NULL, f_1_3);
+    // runtime_util.create_thread(t_2_0, NULL, f_2_0);
+    // runtime_util.create_thread(t_2_1, NULL, f_2_1);
+    // runtime_util.create_thread(t_2_2, NULL, f_2_2);
+    // runtime_util.create_thread(t_2_3, NULL, f_2_3);
+    // runtime_util.create_thread(t_3_0, NULL, f_3_0);
+    // runtime_util.create_thread(t_3_1, NULL, f_3_1);
+    // runtime_util.create_thread(t_3_2, NULL, f_3_2);
+    // runtime_util.create_thread(t_3_3, NULL, f_3_3);
+    // runtime_util.create_thread(t_4_0, NULL, f_4_0);
+    // runtime_util.create_thread(t_4_1, NULL, f_4_1);
+    // runtime_util.create_thread(t_4_2, NULL, f_4_2);
+    // runtime_util.create_thread(t_4_3, NULL, f_4_3);
+    // runtime_util.create_thread(t_5_0, NULL, f_5_0);
+    // runtime_util.create_thread(t_5_1, NULL, f_5_1);
+    // runtime_util.create_thread(t_5_2, NULL, f_5_2);
+    // runtime_util.create_thread(t_5_3, NULL, f_5_3);
+    // runtime_util.create_thread(t_6_0, NULL, f_6_0);
+    // runtime_util.create_thread(t_6_1, NULL, f_6_1);
+    // runtime_util.create_thread(t_6_2, NULL, f_6_2);
+    // runtime_util.create_thread(t_6_3, NULL, f_6_3);
+    // runtime_util.create_thread(t_7_0, NULL, f_7_0);
+    // runtime_util.create_thread(t_7_1, NULL, f_7_1);
+    // runtime_util.create_thread(t_7_2, NULL, f_7_2);
+    // runtime_util.create_thread(t_7_3, NULL, f_7_3);
+
+    runtime_util.join_thread(t_0_0);
+    // runtime_util.join_thread(t_0_1);
+    // runtime_util.join_thread(t_0_2);
+    // runtime_util.join_thread(t_0_3);
+    // runtime_util.join_thread(t_1_0);
+    // runtime_util.join_thread(t_1_1);
+    // runtime_util.join_thread(t_1_2);
+    // runtime_util.join_thread(t_1_3);
+    // runtime_util.join_thread(t_2_0);
+    // runtime_util.join_thread(t_2_1);
+    // runtime_util.join_thread(t_2_2);
+    // runtime_util.join_thread(t_2_3);
+    // runtime_util.join_thread(t_3_0);
+    // runtime_util.join_thread(t_3_1);
+    // runtime_util.join_thread(t_3_2);
+    // runtime_util.join_thread(t_3_3);
+    // runtime_util.join_thread(t_4_0);
+    // runtime_util.join_thread(t_4_1);
+    // runtime_util.join_thread(t_4_2);
+    // runtime_util.join_thread(t_4_3);
+    // runtime_util.join_thread(t_5_0);
+    // runtime_util.join_thread(t_5_1);
+    // runtime_util.join_thread(t_5_2);
+    // runtime_util.join_thread(t_5_3);
+    // runtime_util.join_thread(t_6_0);
+    // runtime_util.join_thread(t_6_1);
+    // runtime_util.join_thread(t_6_2);
+    // runtime_util.join_thread(t_6_3);
+    // runtime_util.join_thread(t_7_0);
+    // runtime_util.join_thread(t_7_1);
+    // runtime_util.join_thread(t_7_2);
+    // runtime_util.join_thread(t_7_3);
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo4/shared_def.h
new file mode 100644
index 0000000000..b18a608408
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/demo4/shared_def.h
@@ -0,0 +1,4 @@
+#include <tdma.h>
+
+namespace shared {
+} // namespace shared
\ No newline at end of file

From 88b13bf94c013ff60f419d9a6241d265829d85a5 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 5 Sep 2023 11:27:59 +0800
Subject: [PATCH 147/308] open 32 threads for demo4

---
 .../runtime/cmodel/include/runtime_utils.h    |   4 +-
 .../cpu/src/runtime/cmodel/include/tensor.h   |   3 +-
 .../src/runtime/cmodel/tests/demo4/kernel.h   |   8 +-
 .../src/runtime/cmodel/tests/demo4/main.cpp   | 126 +++++++++---------
 4 files changed, 68 insertions(+), 73 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 6d90d9e776..603f0fa23d 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -18,6 +18,7 @@ struct runtime_util_mt {
     float (*sqrt)(float x);
     void (*create_thread)(pthread_t &pt, void *param_, void *(*call)(void *));
     void (*join_thread)(pthread_t &pt);
+    void (*rt_assert)(bool condition, char* message);
 };
 
 static runtime_util_mt runtime_util;            
@@ -86,8 +87,7 @@ inline size_t offset(gsl::span<const size_t> strides,
     if (strides.size() == 0 || index.size() == 0) {
         return 0;
     }
-    // elf loader 不支持
-    // assert(strides.size() == index.size());
+    runtime_util.rt_assert(strides.size() == index.size(), (char*)"strides and index must have the same rank");
     return element_offset<size_t>(strides, index.begin(), index.end());
     // return 0;
 }
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index d8cdfd2826..75e9eabc0e 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -82,8 +82,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
         auto subspan_offset = offset(strides_, begins);
         data_ = parent->data_.subspan(subspan_offset);
         if (data_.size() < size_) {
-            // std::errc 也不能使用
-            // throw std::errc::invalid_argument;
+            runtime_util.rt_assert(false, (char*)"Invalid tensor size");
         }
     }
 
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h
index d8f372b13c..f3bf7d71a1 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h
@@ -14,16 +14,12 @@ void stage1_kernel(
 ) {
     thread_context ctx(bid, tid);
     tensor<int64_t> position_ids({1, 384});
-    tensor<float> gather_data({32000, 256});
+    tensor<float> gather_data({384, 256});
     tensor<float> output({1, 384, 256});
 
     tdma_load_async(position_ids, std::move(Position_ids), ctx);
-    dims_t begins{0, 256 * (CORES * bid + tid)};
-    dims_t ends{32000, 256};
-    runtime_util.printf("t+b %d %d\n", bid, tid);
-    GatherData(begins, ends);
     tdma_load_async(gather_data,
-                    GatherData(begins, ends),
+                    GatherData({0, 256 * (CORES * bid + tid)}, {384, 256}),
                     ctx);
     gather(gather_data, position_ids, output, 0);
 
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
index 5e02356215..647aa94736 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
@@ -41,7 +41,7 @@ void _start(hardware_context_mt *hw_impl, runtime_util_mt *rt_util_mt,
     runtime_util.printf("1\n");
 
     auto GatherData_ = tensor<float, loc_t::device>(
-        gsl::make_span((float *)gather_data, 384*8192), {1, 384, 8192});
+        gsl::make_span((float *)gather_data, 384*8192), {384, 8192});
 
     runtime_util.printf("2\n");
     auto Output_ = tensor<float, loc_t::device>(
@@ -59,68 +59,68 @@ void _start(hardware_context_mt *hw_impl, runtime_util_mt *rt_util_mt,
     pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
     runtime_util.create_thread(t_0_0, NULL, f_0_0);
-    // runtime_util.create_thread(t_0_1, NULL, f_0_1);
-    // runtime_util.create_thread(t_0_2, NULL, f_0_2);
-    // runtime_util.create_thread(t_0_3, NULL, f_0_3);
-    // runtime_util.create_thread(t_1_0, NULL, f_1_0);
-    // runtime_util.create_thread(t_1_1, NULL, f_1_1);
-    // runtime_util.create_thread(t_1_2, NULL, f_1_2);
-    // runtime_util.create_thread(t_1_3, NULL, f_1_3);
-    // runtime_util.create_thread(t_2_0, NULL, f_2_0);
-    // runtime_util.create_thread(t_2_1, NULL, f_2_1);
-    // runtime_util.create_thread(t_2_2, NULL, f_2_2);
-    // runtime_util.create_thread(t_2_3, NULL, f_2_3);
-    // runtime_util.create_thread(t_3_0, NULL, f_3_0);
-    // runtime_util.create_thread(t_3_1, NULL, f_3_1);
-    // runtime_util.create_thread(t_3_2, NULL, f_3_2);
-    // runtime_util.create_thread(t_3_3, NULL, f_3_3);
-    // runtime_util.create_thread(t_4_0, NULL, f_4_0);
-    // runtime_util.create_thread(t_4_1, NULL, f_4_1);
-    // runtime_util.create_thread(t_4_2, NULL, f_4_2);
-    // runtime_util.create_thread(t_4_3, NULL, f_4_3);
-    // runtime_util.create_thread(t_5_0, NULL, f_5_0);
-    // runtime_util.create_thread(t_5_1, NULL, f_5_1);
-    // runtime_util.create_thread(t_5_2, NULL, f_5_2);
-    // runtime_util.create_thread(t_5_3, NULL, f_5_3);
-    // runtime_util.create_thread(t_6_0, NULL, f_6_0);
-    // runtime_util.create_thread(t_6_1, NULL, f_6_1);
-    // runtime_util.create_thread(t_6_2, NULL, f_6_2);
-    // runtime_util.create_thread(t_6_3, NULL, f_6_3);
-    // runtime_util.create_thread(t_7_0, NULL, f_7_0);
-    // runtime_util.create_thread(t_7_1, NULL, f_7_1);
-    // runtime_util.create_thread(t_7_2, NULL, f_7_2);
-    // runtime_util.create_thread(t_7_3, NULL, f_7_3);
+    runtime_util.create_thread(t_0_1, NULL, f_0_1);
+    runtime_util.create_thread(t_0_2, NULL, f_0_2);
+    runtime_util.create_thread(t_0_3, NULL, f_0_3);
+    runtime_util.create_thread(t_1_0, NULL, f_1_0);
+    runtime_util.create_thread(t_1_1, NULL, f_1_1);
+    runtime_util.create_thread(t_1_2, NULL, f_1_2);
+    runtime_util.create_thread(t_1_3, NULL, f_1_3);
+    runtime_util.create_thread(t_2_0, NULL, f_2_0);
+    runtime_util.create_thread(t_2_1, NULL, f_2_1);
+    runtime_util.create_thread(t_2_2, NULL, f_2_2);
+    runtime_util.create_thread(t_2_3, NULL, f_2_3);
+    runtime_util.create_thread(t_3_0, NULL, f_3_0);
+    runtime_util.create_thread(t_3_1, NULL, f_3_1);
+    runtime_util.create_thread(t_3_2, NULL, f_3_2);
+    runtime_util.create_thread(t_3_3, NULL, f_3_3);
+    runtime_util.create_thread(t_4_0, NULL, f_4_0);
+    runtime_util.create_thread(t_4_1, NULL, f_4_1);
+    runtime_util.create_thread(t_4_2, NULL, f_4_2);
+    runtime_util.create_thread(t_4_3, NULL, f_4_3);
+    runtime_util.create_thread(t_5_0, NULL, f_5_0);
+    runtime_util.create_thread(t_5_1, NULL, f_5_1);
+    runtime_util.create_thread(t_5_2, NULL, f_5_2);
+    runtime_util.create_thread(t_5_3, NULL, f_5_3);
+    runtime_util.create_thread(t_6_0, NULL, f_6_0);
+    runtime_util.create_thread(t_6_1, NULL, f_6_1);
+    runtime_util.create_thread(t_6_2, NULL, f_6_2);
+    runtime_util.create_thread(t_6_3, NULL, f_6_3);
+    runtime_util.create_thread(t_7_0, NULL, f_7_0);
+    runtime_util.create_thread(t_7_1, NULL, f_7_1);
+    runtime_util.create_thread(t_7_2, NULL, f_7_2);
+    runtime_util.create_thread(t_7_3, NULL, f_7_3);
 
     runtime_util.join_thread(t_0_0);
-    // runtime_util.join_thread(t_0_1);
-    // runtime_util.join_thread(t_0_2);
-    // runtime_util.join_thread(t_0_3);
-    // runtime_util.join_thread(t_1_0);
-    // runtime_util.join_thread(t_1_1);
-    // runtime_util.join_thread(t_1_2);
-    // runtime_util.join_thread(t_1_3);
-    // runtime_util.join_thread(t_2_0);
-    // runtime_util.join_thread(t_2_1);
-    // runtime_util.join_thread(t_2_2);
-    // runtime_util.join_thread(t_2_3);
-    // runtime_util.join_thread(t_3_0);
-    // runtime_util.join_thread(t_3_1);
-    // runtime_util.join_thread(t_3_2);
-    // runtime_util.join_thread(t_3_3);
-    // runtime_util.join_thread(t_4_0);
-    // runtime_util.join_thread(t_4_1);
-    // runtime_util.join_thread(t_4_2);
-    // runtime_util.join_thread(t_4_3);
-    // runtime_util.join_thread(t_5_0);
-    // runtime_util.join_thread(t_5_1);
-    // runtime_util.join_thread(t_5_2);
-    // runtime_util.join_thread(t_5_3);
-    // runtime_util.join_thread(t_6_0);
-    // runtime_util.join_thread(t_6_1);
-    // runtime_util.join_thread(t_6_2);
-    // runtime_util.join_thread(t_6_3);
-    // runtime_util.join_thread(t_7_0);
-    // runtime_util.join_thread(t_7_1);
-    // runtime_util.join_thread(t_7_2);
-    // runtime_util.join_thread(t_7_3);
+    runtime_util.join_thread(t_0_1);
+    runtime_util.join_thread(t_0_2);
+    runtime_util.join_thread(t_0_3);
+    runtime_util.join_thread(t_1_0);
+    runtime_util.join_thread(t_1_1);
+    runtime_util.join_thread(t_1_2);
+    runtime_util.join_thread(t_1_3);
+    runtime_util.join_thread(t_2_0);
+    runtime_util.join_thread(t_2_1);
+    runtime_util.join_thread(t_2_2);
+    runtime_util.join_thread(t_2_3);
+    runtime_util.join_thread(t_3_0);
+    runtime_util.join_thread(t_3_1);
+    runtime_util.join_thread(t_3_2);
+    runtime_util.join_thread(t_3_3);
+    runtime_util.join_thread(t_4_0);
+    runtime_util.join_thread(t_4_1);
+    runtime_util.join_thread(t_4_2);
+    runtime_util.join_thread(t_4_3);
+    runtime_util.join_thread(t_5_0);
+    runtime_util.join_thread(t_5_1);
+    runtime_util.join_thread(t_5_2);
+    runtime_util.join_thread(t_5_3);
+    runtime_util.join_thread(t_6_0);
+    runtime_util.join_thread(t_6_1);
+    runtime_util.join_thread(t_6_2);
+    runtime_util.join_thread(t_6_3);
+    runtime_util.join_thread(t_7_0);
+    runtime_util.join_thread(t_7_1);
+    runtime_util.join_thread(t_7_2);
+    runtime_util.join_thread(t_7_3);
 }
\ No newline at end of file

From 4e6be0158442072c7fc5e096f9442ef3313d53fc Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 5 Sep 2023 14:57:31 +0800
Subject: [PATCH 148/308] update binary/unary with external op

---
 .../cpu/src/runtime/cmodel/include/binary.h   |  86 ++-
 .../runtime/cmodel/include/runtime_utils.h    |  48 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h | 549 +++++++++---------
 .../cpu/src/runtime/cmodel/include/unary.h    |  59 +-
 4 files changed, 395 insertions(+), 347 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/binary.h b/modules/cpu/src/runtime/cmodel/include/binary.h
index c7184f0762..bbadf375d1 100644
--- a/modules/cpu/src/runtime/cmodel/include/binary.h
+++ b/modules/cpu/src/runtime/cmodel/include/binary.h
@@ -17,6 +17,8 @@
 #include <gsl/gsl-lite.hpp>
 #include <runtime_utils.h>
 
+using namespace nncase::runtime::cpu;
+
 namespace kernels {
 
 namespace {
@@ -55,24 +57,72 @@ void binary_impl(binary_op_t op, const T *lhs, const T *rhs, T *output,
                  gsl::span<const size_t> rhs_strides,
                  gsl::span<const size_t> out_shape,
                  gsl::span<const size_t> out_strides) {
-    switch (op) {
-        BINARY_IMPL_OP(add, std::plus<T>());
-        BINARY_IMPL_OP(sub, std::minus<T>());
-        BINARY_IMPL_OP(mul, std::multiplies<T>());
-        BINARY_IMPL_OP(div, std::divides<T>());
-        BINARY_IMPL_OP(idenity_a, [](T a, [[maybe_unused]] T b) { return a; });
-        BINARY_IMPL_OP(min, [](T a, T b) { return std::min(a, b); });
-        BINARY_IMPL_OP(max, [](T a, T b) { return std::max(a, b); });
-        BINARY_IMPL_OP(pow, [](T a, T b) { return std::pow(a, b); });
-        BINARY_IMPL_OP(mod, [](T a, T b) { return std::fmod(a, b); });
-        // BINARY_IMPL_OP(logical_and,
-        //                [](T a, T b) { return static_cast<T>(a && b); });
-        // BINARY_IMPL_OP(logical_or,
-        //                [](T a, T b) { return static_cast<T>(a || b); });
-        // BINARY_IMPL_OP(logical_xor,
-        //                [](T a, T b) { return static_cast<T>(a ^ b); });
-    default:
-        throw "Unsupported Binary Op!";
+    // TODO: only support float for now
+    if (std::is_same_v<T, float>) {
+        switch (op) {
+            BINARY_IMPL_OP(add, nncase_mt.float_binary_add);
+            BINARY_IMPL_OP(sub, nncase_mt.float_binary_sub);
+            BINARY_IMPL_OP(mul, nncase_mt.float_binary_mul);
+            BINARY_IMPL_OP(div, nncase_mt.float_binary_div);
+            BINARY_IMPL_OP(idenity_a,
+                           [](T a, [[maybe_unused]] T b) { return a; });
+            BINARY_IMPL_OP(min, nncase_mt.float_binary_min);
+            BINARY_IMPL_OP(max, nncase_mt.float_binary_max);
+            BINARY_IMPL_OP(pow, nncase_mt.float_binary_pow);
+            BINARY_IMPL_OP(mod, nncase_mt.float_binary_mod);
+            // BINARY_IMPL_OP(logical_and,
+            //                [](T a, T b) { return static_cast<T>(a && b); });
+            // BINARY_IMPL_OP(logical_or,
+            //                [](T a, T b) { return static_cast<T>(a || b); });
+            // BINARY_IMPL_OP(logical_xor,
+            //                [](T a, T b) { return static_cast<T>(a ^ b); });
+        default:
+            runtime_util.rt_assert(false, (char *)"Unsupported Binary Op!");
+        }
+    } else if (std::is_same_v<T, int32_t>) {
+        switch (op) {
+            BINARY_IMPL_OP(add, nncase_mt.int32_binary_add);
+            BINARY_IMPL_OP(sub, nncase_mt.int32_binary_sub);
+            BINARY_IMPL_OP(mul, nncase_mt.int32_binary_mul);
+            BINARY_IMPL_OP(div, nncase_mt.int32_binary_div);
+            BINARY_IMPL_OP(idenity_a,
+                           [](T a, [[maybe_unused]] T b) { return a; });
+            BINARY_IMPL_OP(min, nncase_mt.int32_binary_min);
+            BINARY_IMPL_OP(max, nncase_mt.int32_binary_max);
+            BINARY_IMPL_OP(pow, nncase_mt.int32_binary_pow);
+            BINARY_IMPL_OP(mod, nncase_mt.int32_binary_mod);
+            // BINARY_IMPL_OP(logical_and,
+            //                [](T a, T b) { return static_cast<T>(a && b); });
+            // BINARY_IMPL_OP(logical_or,
+            //                [](T a, T b) { return static_cast<T>(a || b); });
+            // BINARY_IMPL_OP(logical_xor,
+            //                [](T a, T b) { return static_cast<T>(a ^ b); });
+        default:
+            runtime_util.rt_assert(false, (char *)"Unsupported Binary Op!");
+        }
+    } else if (std::is_same_v<T, int64_t>) {
+        switch (op) {
+            BINARY_IMPL_OP(add, nncase_mt.int64_binary_add);
+            BINARY_IMPL_OP(sub, nncase_mt.int64_binary_sub);
+            BINARY_IMPL_OP(mul, nncase_mt.int64_binary_mul);
+            BINARY_IMPL_OP(div, nncase_mt.int64_binary_div);
+            BINARY_IMPL_OP(idenity_a,
+                           [](T a, [[maybe_unused]] T b) { return a; });
+            BINARY_IMPL_OP(min, nncase_mt.int64_binary_min);
+            BINARY_IMPL_OP(max, nncase_mt.int64_binary_max);
+            BINARY_IMPL_OP(pow, nncase_mt.int64_binary_pow);
+            BINARY_IMPL_OP(mod, nncase_mt.int64_binary_mod);
+            // BINARY_IMPL_OP(logical_and,
+            //                [](T a, T b) { return static_cast<T>(a && b); });
+            // BINARY_IMPL_OP(logical_or,
+            //                [](T a, T b) { return static_cast<T>(a || b); });
+            // BINARY_IMPL_OP(logical_xor,
+            //                [](T a, T b) { return static_cast<T>(a ^ b); });
+        default:
+            runtime_util.rt_assert(false, (char *)"Unsupported Binary Op!");
+        }
+    } else {
+        runtime_util.rt_assert(false, (char *)"Unsupported Binary Type!");
     }
 }
 
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 603f0fa23d..3ca7b63f10 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -1,15 +1,9 @@
 #pragma once
 
-// #include <array>
-// #include <cmath>
 #include <cstddef>
 #include <gsl/gsl-lite.hpp>
-// #include <iostream>
-// #include <numeric>
 #include <runtime_types.h>
-// #include <vector>
-
-
+#include "../../cpu_common.h"
 
 struct runtime_util_mt {
     int (*printf)(const char *__restrict __format, ...);
@@ -18,10 +12,10 @@ struct runtime_util_mt {
     float (*sqrt)(float x);
     void (*create_thread)(pthread_t &pt, void *param_, void *(*call)(void *));
     void (*join_thread)(pthread_t &pt);
-    void (*rt_assert)(bool condition, char* message);
+    void (*rt_assert)(bool condition, char *message);
 };
 
-static runtime_util_mt runtime_util;            
+static runtime_util_mt runtime_util;
 
 void print_vec(itlib::small_vector<size_t, 8> vec) {
     for (const size_t v : vec) {
@@ -52,13 +46,11 @@ inline size_t compute_size(const TShape &shape, const TShape &strides) {
 }
 
 template <class shape_type, class strides_type>
-inline size_t compute_strides(const shape_type &shape,
-                                   strides_type &strides) {
+inline size_t compute_strides(const shape_type &shape, strides_type &strides) {
     size_t data_size = 1;
     for (std::size_t i = shape.size(); i != 0; --i) {
         strides[i - 1] = data_size;
-        data_size =
-            strides[i - 1] * static_cast<size_t>(shape[i - 1]);
+        data_size = strides[i - 1] * static_cast<size_t>(shape[i - 1]);
     }
     return static_cast<size_t>(data_size);
 }
@@ -69,16 +61,13 @@ inline strides_t get_default_strides(dims_t shape) {
     return strides;
 }
 
-template <class offset_type, class S, class It>
-inline offset_type element_offset(const S &strides, It first,
-                                  It last) noexcept {
-    // using difference_type = typename
-    // std::iterator_traits<It>::difference_type; auto size =
-    // static_cast<difference_type>((std::min)(
-    //     static_cast<size_t>(std::distance(first, last)), strides.size()));
-    // return std::inner_product(last - size, last, strides.cend() - size,
-    //                           offset_type(0));
-    return 0;
+template <class offset_type, class S>
+inline offset_type element_offset(const S &strides, const S &index) noexcept {
+    offset_type size = 0;
+    for (auto i = 0; i < strides.size(); i++) {
+        size += strides[i] * index[i];
+    }
+    return size;
 }
 
 inline size_t offset(gsl::span<const size_t> strides,
@@ -87,9 +76,9 @@ inline size_t offset(gsl::span<const size_t> strides,
     if (strides.size() == 0 || index.size() == 0) {
         return 0;
     }
-    runtime_util.rt_assert(strides.size() == index.size(), (char*)"strides and index must have the same rank");
-    return element_offset<size_t>(strides, index.begin(), index.end());
-    // return 0;
+    runtime_util.rt_assert(strides.size() == index.size(),
+                           (char *)"strides and index must have the same rank");
+    return element_offset<size_t>(strides, index);
 }
 
 inline bool is_shape_equal(const dims_t &a, const dims_t &b) {
@@ -165,10 +154,11 @@ template <typename T> double dot(const T *v1, const T *v2, size_t size) {
 
 template <typename T> double cosine(const T *v1, const T *v2, size_t size) {
     for (size_t i = 0; i < 10; i++) {
-        runtime_util.printf("%f, %f\n", (float)v1[i], (float)v2[i]);;
+        runtime_util.printf("%f, %f\n", (float)v1[i], (float)v2[i]);
+        ;
     }
-    return dot(v1, v2, size) /
-           ((runtime_util.sqrt(dot(v1, v1, size)) * runtime_util.sqrt(dot(v2, v2, size))));
+    return dot(v1, v2, size) / ((runtime_util.sqrt(dot(v1, v1, size)) *
+                                 runtime_util.sqrt(dot(v2, v2, size))));
 }
 
 inline dims_t get_reduced_offset(gsl::span<const size_t> in_offset,
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index a9f40173c8..b91b194bc4 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -1,19 +1,20 @@
 #pragma once
 #include <apply.h>
-// #include <binary.h>
+#include <binary.h>
 #include <cassert>
-// #include <concat.h>
+#include <concat.h>
 #include <functional>
 #include <gather.h>
 #include <hardware_context.h>
-// #include <layernorm.h>
-// #include <matmul.h>
-// #include <reduce.h>
-// #include <softmax.h>
+#include <layernorm.h>
+#include <matmul.h>
+#include <reduce.h>
+#include <softmax.h>
 #include <tensor.h>
 #include <thread_context.h>
-// #include <transpose.h>
-// #include <unary.h>
+#include <transpose.h>
+#include <unary.h>
+#include "../../cpu_common.h"
 
 template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &src) {
     auto new_dims = dims_t(src.dimension());
@@ -44,19 +45,19 @@ tensor<T, Loc> view(tensor<T, Loc> &src, dims_t new_dims, dims_t new_strides) {
     return tensor<T, Loc>(src.data(), new_dims, new_strides);
 }
 
-// template <class T, loc_t Loc>
-// void transpose(tensor<T, Loc> &src, tensor<T, Loc> &dest, dims_t perm) {
-//     return kernels::transpose(src.cdata().data(), dest.data().data(),
-//                               src.dimension(), perm, src.strides(),
-//                               dest.strides());
-// }
+template <class T, loc_t Loc>
+void transpose(tensor<T, Loc> &src, tensor<T, Loc> &dest, dims_t perm) {
+    return kernels::transpose(src.cdata().data(), dest.data().data(),
+                              src.dimension(), perm, src.strides(),
+                              dest.strides());
+}
 
-// template <loc_t SrcLoc, loc_t DestLoc>
-// void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest,
-//              int axis) {
-//     kernels::softmax(src.cdata().data(), dest.data().data(), src.dimension(),
-//                      src.strides(), dest.strides(), axis, 1.0f, false);
-// }
+template <loc_t SrcLoc, loc_t DestLoc>
+void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest,
+             int axis) {
+    kernels::softmax(src.cdata().data(), dest.data().data(), src.dimension(),
+                     src.strides(), dest.strides(), axis, 1.0f, false);
+}
 
 template <class T, loc_t DestLoc, loc_t SrcLoc>
 void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
@@ -68,42 +69,42 @@ void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
           });
 }
 
-// template <class T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-// void binary(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &out,
-//             binary_op_t op) {
-//     kernels::binary(
-//         op, a.cdata().data(), b.cdata().data(), out.data().data(),
-//         gsl::make_span(a.dimension()).template as_span<const size_t>(),
-//         gsl::make_span(a.strides()).template as_span<const size_t>(),
-//         gsl::make_span(b.dimension()).template as_span<const size_t>(),
-//         gsl::make_span(b.strides()).template as_span<const size_t>(),
-//         gsl::make_span(out.dimension()).template as_span<const size_t>(),
-//         gsl::make_span(out.strides()).template as_span<const size_t>());
-// }
-
-// template <class T, loc_t ALoc, loc_t BLoc>
-// void unary(tensor<T, ALoc> &a, tensor<T, BLoc> &out, unary_op_t op) {
-//     kernels::unary(
-//         op, a.cdata().data(), out.data().data(),
-//         gsl::make_span(a.strides()).template as_span<const size_t>(),
-//         gsl::make_span(out.dimension()).template as_span<const size_t>(),
-//         gsl::make_span(out.strides()).template as_span<const size_t>());
-// }
-
-// template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-// void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &c) {
-//     kernels::matmul(a.cdata().data(), b.cdata().data(), c.data().data(),
-//                     a.dimension(), a.strides(), b.dimension(), b.strides(),
-//                     c.dimension(), c.strides());
-// }
-
-// template <typename T, loc_t ALoc, loc_t BLoc>
-// void reduce(tensor<T, ALoc> &input, tensor<T, BLoc> &output, reduce_op_t op,
-//             T init_value, dims_t axis, bool keep_dims) {
-//     kernels::reduce(op, &init_value, input.cdata().data(), output.data().data(),
-//                     input.dimension(), axis, input.strides(), output.strides(),
-//                     keep_dims);
-// }
+template <class T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
+void binary(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &out,
+            binary_op_t op) {
+    kernels::binary(
+        op, a.cdata().data(), b.cdata().data(), out.data().data(),
+        gsl::make_span(a.dimension()).template as_span<const size_t>(),
+        gsl::make_span(a.strides()).template as_span<const size_t>(),
+        gsl::make_span(b.dimension()).template as_span<const size_t>(),
+        gsl::make_span(b.strides()).template as_span<const size_t>(),
+        gsl::make_span(out.dimension()).template as_span<const size_t>(),
+        gsl::make_span(out.strides()).template as_span<const size_t>());
+}
+
+template <class T, loc_t ALoc, loc_t BLoc>
+void unary(tensor<T, ALoc> &a, tensor<T, BLoc> &out, unary_op_t op) {
+    kernels::unary(
+        op, a.cdata().data(), out.data().data(),
+        gsl::make_span(a.strides()).template as_span<const size_t>(),
+        gsl::make_span(out.dimension()).template as_span<const size_t>(),
+        gsl::make_span(out.strides()).template as_span<const size_t>());
+}
+
+template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
+void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &c) {
+    kernels::matmul(a.cdata().data(), b.cdata().data(), c.data().data(),
+                    a.dimension(), a.strides(), b.dimension(), b.strides(),
+                    c.dimension(), c.strides());
+}
+
+template <typename T, loc_t ALoc, loc_t BLoc>
+void reduce(tensor<T, ALoc> &input, tensor<T, BLoc> &output, reduce_op_t op,
+            T init_value, dims_t axis, bool keep_dims) {
+    kernels::reduce(op, &init_value, input.cdata().data(), output.data().data(),
+                    input.dimension(), axis, input.strides(), output.strides(),
+                    keep_dims);
+}
 
 template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
 void gather(tensor<T, ALoc> &input, tensor<int64_t, BLoc> &indices,
@@ -114,62 +115,62 @@ void gather(tensor<T, ALoc> &input, tensor<int64_t, BLoc> &indices,
         indices.data().data(), indices.dimension(), axis);
 }
 
-// template <typename T, loc_t ALoc, loc_t BLoc>
-// void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
-//                tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
-//                tensor<T, loc_t::local> &gamma, tensor<T, loc_t::local> &beta,
-//                T eps, int32_t axis, int32_t norm_size, bool rms_norm = false) {
-//     assert(sum.strides() == sum_sqr.strides());
-//     assert(is_contiguous(sum.dimension(), sum.strides()));
-//     assert(gamma.strides() == beta.strides());
-//     assert(is_contiguous(gamma.dimension(), gamma.strides()));
-//     kernels::layernorm(
-//         input.cdata().data(), sum.data().data(), sum_sqr.data().data(),
-//         output.data().data(), gamma.data().data(), beta.data().data(),
-//         input.dimension(), input.strides(), output.strides(), sum.strides(),
-//         gamma.strides(), eps, axis, norm_size, rms_norm);
-// }
-
-// template <typename T, loc_t ALoc, loc_t BLoc>
-// void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
-//                tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
-//                int32_t axis, int32_t norm_size, bool rms_norm = false) {
-//     kernels::layernorm(input.cdata().data(), sum.data().data(),
-//                        sum_sqr.data().data(), output.data().data(),
-//                        static_cast<T *>(nullptr), static_cast<T *>(nullptr),
-//                        input.dimension(), input.strides(), output.strides(),
-//                        sum.strides(), dims_t({}), static_cast<T>(1e-5), axis,
-//                        norm_size, rms_norm);
-// }
-
-// template <typename T, loc_t ALoc>
-// void reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
-//                     tensor<T, loc_t::local> &sum_sqr) {
-//     kernels::reduce_sum_and_sum_sqr(a.cdata().data(), sum.data().data(),
-//                                     sum_sqr.data().data(), a.dimension(),
-//                                     a.strides(), sum.strides());
-// }
-
-// template <typename T, loc_t BLoc>
-// void concat(std::initializer_list<tensor<T, loc_t::local>> inits,
-//             tensor<T, BLoc> &output, size_t axis) {
-//     itlib::small_vector<const gsl::byte *const, 8> inputs(inits.size());
-//     std::vector<strides_t> in_strides(inits.size());
-//     auto concat_dims = dims_t(inits.size(), 1);
-//     for (size_t i = 0; i < inits.size(); ++i) {
-//         if (inits[i].dimension().size() != 0) {
-//             concat_dims[i] = inits[i].dimension()[axis];
-//         }
-//     }
-
-//     for (auto &in : inits) {
-//         inputs.push_back((const gsl::byte *const)(in.data().data()));
-//         in_strides.push_back(in.strides());
-//     }
-
-//     kernels::concat(inputs, output.data().data(), output.dimension(),
-//                     in_strides, output.strides(), axis, concat_dims);
-// }
+template <typename T, loc_t ALoc, loc_t BLoc>
+void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
+               tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
+               tensor<T, loc_t::local> &gamma, tensor<T, loc_t::local> &beta,
+               T eps, int32_t axis, int32_t norm_size, bool rms_norm = false) {
+    assert(sum.strides() == sum_sqr.strides());
+    assert(is_contiguous(sum.dimension(), sum.strides()));
+    assert(gamma.strides() == beta.strides());
+    assert(is_contiguous(gamma.dimension(), gamma.strides()));
+    kernels::layernorm(
+        input.cdata().data(), sum.data().data(), sum_sqr.data().data(),
+        output.data().data(), gamma.data().data(), beta.data().data(),
+        input.dimension(), input.strides(), output.strides(), sum.strides(),
+        gamma.strides(), eps, axis, norm_size, rms_norm);
+}
+
+template <typename T, loc_t ALoc, loc_t BLoc>
+void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
+               tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
+               int32_t axis, int32_t norm_size, bool rms_norm = false) {
+    kernels::layernorm(input.cdata().data(), sum.data().data(),
+                       sum_sqr.data().data(), output.data().data(),
+                       static_cast<T *>(nullptr), static_cast<T *>(nullptr),
+                       input.dimension(), input.strides(), output.strides(),
+                       sum.strides(), dims_t({}), static_cast<T>(1e-5), axis,
+                       norm_size, rms_norm);
+}
+
+template <typename T, loc_t ALoc>
+void reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
+                    tensor<T, loc_t::local> &sum_sqr) {
+    kernels::reduce_sum_and_sum_sqr(a.cdata().data(), sum.data().data(),
+                                    sum_sqr.data().data(), a.dimension(),
+                                    a.strides(), sum.strides());
+}
+
+template <typename T, loc_t BLoc>
+void concat(std::initializer_list<tensor<T, loc_t::local>> inits,
+            tensor<T, BLoc> &output, size_t axis) {
+    itlib::small_vector<const gsl::byte *const, 8> inputs(inits.size());
+    std::vector<strides_t> in_strides(inits.size());
+    auto concat_dims = dims_t(inits.size(), 1);
+    for (size_t i = 0; i < inits.size(); ++i) {
+        if (inits[i].dimension().size() != 0) {
+            concat_dims[i] = inits[i].dimension()[axis];
+        }
+    }
+
+    for (auto &in : inits) {
+        inputs.push_back((const gsl::byte *const)(in.data().data()));
+        in_strides.push_back(in.strides());
+    }
+
+    kernels::concat(inputs, output.data().data(), output.dimension(),
+                    in_strides, output.strides(), axis, concat_dims);
+}
 
 /**
  * @brief Block 级别的 mma，每个 thread 执行自己的 mma，最终 psum 累加写入
@@ -184,30 +185,30 @@ void gather(tensor<T, ALoc> &input, tensor<int64_t, BLoc> &indices,
  * @param load_psum
  * @param ctx
  */
-// template <typename T, loc_t ALoc, loc_t BLoc>
-// void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
-//                            tensor<T, loc_t::shared> &c, bool load_psum,
-//                            thread_context &ctx) {
-//     tensor<T> tmp(c.dimension());
-//     matmul(a, b, tmp);
-
-//     __tdma_block_sync_apply(
-//         [&](int visited) -> void {
-//             if (load_psum) {
-//                 binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
-//                     tmp, c, c, binary_op_t::add);
-//             } else {
-//                 if (visited == 1) {
-//                     binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
-//                         tmp, c, c, binary_op_t::add);
-//                 } else {
-//                     binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
-//                         tmp, c, c, binary_op_t::add);
-//                 }
-//             }
-//         },
-//         ctx);
-// }
+template <typename T, loc_t ALoc, loc_t BLoc>
+void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
+                           tensor<T, loc_t::shared> &c, bool load_psum,
+                           thread_context &ctx) {
+    tensor<T> tmp(c.dimension());
+    matmul(a, b, tmp);
+
+    __tdma_block_sync_apply(
+        [&](int visited) -> void {
+            if (load_psum) {
+                binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
+                    tmp, c, c, binary_op_t::add);
+            } else {
+                if (visited == 1) {
+                    binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
+                        tmp, c, c, binary_op_t::add);
+                } else {
+                    binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
+                        tmp, c, c, binary_op_t::add);
+                }
+            }
+        },
+        ctx);
+}
 
 void __tdma_block_sync_apply(std::function<void(int)> func,
                              thread_context &ctx) {
@@ -275,58 +276,58 @@ void tdma_load_broadcast_async([[maybe_unused]] tensor<T, Dest> &dest,
     throw std::system_error(std::make_error_code(std::errc::not_supported));
 }
 
-// template <class T>
-// void tdma_reduce_async(tensor<T, loc_t::local> &src,
-//                        tensor<T, loc_t::local> &dest, reduce_op_t reduce_op,
-//                        thread_context &ctx) {
-//     __tdma_all_sync_apply(
-//         [&src, &ctx](int visited) -> void {
-//             tensor<T> *gather_tensor = nullptr;
-//             auto new_dims = dims_t(src.dimension());
-//             new_dims.insert(new_dims.begin(), BLOCKS * CORES);
-//             if (visited == 1) {
-//                 if (global_hardware_ctx.global_var != nullptr) {
-//                     throw std::runtime_error(" the global var has been used!");
-//                 }
-//                 gather_tensor = new tensor<T>(new_dims);
-//                 global_hardware_ctx.global_var = (void *)gather_tensor;
-//             } else {
-//                 gather_tensor =
-//                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-//             }
-//             dims_t begin(new_dims.size(), 0);
-//             dims_t shape(new_dims);
-//             begin[0] = ctx.bid() * CORES + ctx.tid();
-//             shape[0] = 1;
-//             __tensor_copy_sync<T, loc_t::local, loc_t::local>(
-//                 std::move((*gather_tensor)(begin, shape)),
-//                 std::move(unsqueeze(src)));
-//         },
-//         []() -> void {}, ctx);
-
-//     __tdma_all_sync_apply(
-//         [&]([[maybe_unused]] int visit) -> void {
-//             tensor<T> *gather_tensor =
-//                 static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-//             auto new_dims = dims_t(gather_tensor->dimension());
-//             new_dims[0] = CORES;
-//             auto viewed_gather_tensor =
-//                 tensor<T>(gather_tensor->data().subspan(
-//                               ctx.bid() * CORES * gather_tensor->strides()[0],
-//                               CORES * gather_tensor->strides()[0]),
-//                           new_dims, gather_tensor->strides());
-
-//             reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
-//                    dims_t({0}), false);
-//         },
-//         []() -> void {
-//             auto reduced_tensor =
-//                 static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-//             delete reduced_tensor;
-//             global_hardware_ctx.global_var = nullptr;
-//         },
-//         ctx);
-// }
+template <class T>
+void tdma_reduce_async(tensor<T, loc_t::local> &src,
+                       tensor<T, loc_t::local> &dest, reduce_op_t reduce_op,
+                       thread_context &ctx) {
+    __tdma_all_sync_apply(
+        [&src, &ctx](int visited) -> void {
+            tensor<T> *gather_tensor = nullptr;
+            auto new_dims = dims_t(src.dimension());
+            new_dims.insert(new_dims.begin(), BLOCKS * CORES);
+            if (visited == 1) {
+                if (global_hardware_ctx.global_var != nullptr) {
+                    throw std::runtime_error(" the global var has been used!");
+                }
+                gather_tensor = new tensor<T>(new_dims);
+                global_hardware_ctx.global_var = (void *)gather_tensor;
+            } else {
+                gather_tensor =
+                    static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+            }
+            dims_t begin(new_dims.size(), 0);
+            dims_t shape(new_dims);
+            begin[0] = ctx.bid() * CORES + ctx.tid();
+            shape[0] = 1;
+            __tensor_copy_sync<T, loc_t::local, loc_t::local>(
+                std::move((*gather_tensor)(begin, shape)),
+                std::move(unsqueeze(src)));
+        },
+        []() -> void {}, ctx);
+
+    __tdma_all_sync_apply(
+        [&]([[maybe_unused]] int visit) -> void {
+            tensor<T> *gather_tensor =
+                static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+            auto new_dims = dims_t(gather_tensor->dimension());
+            new_dims[0] = CORES;
+            auto viewed_gather_tensor =
+                tensor<T>(gather_tensor->data().subspan(
+                              ctx.bid() * CORES * gather_tensor->strides()[0],
+                              CORES * gather_tensor->strides()[0]),
+                          new_dims, gather_tensor->strides());
+
+            reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
+                   dims_t({0}), false);
+        },
+        []() -> void {
+            auto reduced_tensor =
+                static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+            delete reduced_tensor;
+            global_hardware_ctx.global_var = nullptr;
+        },
+        ctx);
+}
 
 enum class reduce_strategy_t : uint8_t {
     all,
@@ -347,92 +348,92 @@ enum class reduce_strategy_t : uint8_t {
  * @param axis axis of gather tensor, note gather tensor dims = [32,...]
  * @param ctx
  */
-// template <class T, loc_t ALoc, loc_t BLoc>
-// void tdma_all_reduce_async(tensor<T, ALoc> &src, tensor<T, BLoc> &dest,
-//                            reduce_op_t reduce_op, reduce_strategy_t strategy,
-//                            thread_context &ctx) {
-//     __tdma_all_sync_apply(
-//         [&src, &ctx](int visited) -> void {
-//             tensor<T> *gather_tensor = nullptr;
-//             auto new_dims = dims_t(src.dimension());
-//             new_dims.insert(new_dims.begin(), BLOCKS * CORES);
-//             if (visited == 1) {
-//                 if (global_hardware_ctx.global_var != nullptr) {
-//                     throw std::runtime_error(" the global var has been used!");
-//                 }
-//                 gather_tensor = new tensor<T>(new_dims);
-//                 global_hardware_ctx.global_var = (void *)gather_tensor;
-//             } else {
-//                 gather_tensor =
-//                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-//             }
-//             dims_t begin(new_dims.size(), 0);
-//             dims_t shape(new_dims);
-//             begin[0] = ctx.bid() * CORES + ctx.tid();
-//             shape[0] = 1;
-//             __tensor_copy_sync<T, loc_t::local, ALoc>(
-//                 std::move((*gather_tensor)(begin, shape)),
-//                 std::move(unsqueeze(src)));
-//         },
-//         []() -> void {}, ctx);
-//     switch (strategy) {
-//     case reduce_strategy_t::all:
-//         __tdma_all_sync_apply(
-//             [&]([[maybe_unused]] int visit) -> void {
-//                 tensor<T> *gather_tensor = nullptr;
-//                 tensor<T> *reduced_tensor = nullptr;
-//                 if (visit == 1) {
-//                     gather_tensor = static_cast<tensor<T> *>(
-//                         global_hardware_ctx.global_var);
-//                     auto reduced_shape = get_reduced_shape(
-//                         gather_tensor->dimension(), dims_t({0}), false);
-//                     reduced_tensor = new tensor<T>(reduced_shape);
-//                     reduce(*gather_tensor, *reduced_tensor, reduce_op, (T)0,
-//                            dims_t({0}), false);
-//                     delete gather_tensor;
-//                     global_hardware_ctx.global_var = reduced_tensor;
-//                 } else {
-//                     reduced_tensor = static_cast<tensor<T> *>(
-//                         global_hardware_ctx.global_var);
-//                     __tensor_copy_sync(std::move(dest),
-//                                        std::move(*reduced_tensor));
-//                 }
-//             },
-//             []() -> void {
-//                 auto reduced_tensor =
-//                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-//                 delete reduced_tensor;
-//                 global_hardware_ctx.global_var = nullptr;
-//             },
-//             ctx);
-//         break;
-//     case reduce_strategy_t::by_block:
-//         __tdma_all_sync_apply(
-//             [&]([[maybe_unused]] int visit) -> void {
-//                 tensor<T> *gather_tensor =
-//                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-//                 auto new_dims = dims_t(src.dimension());
-//                 new_dims.insert(new_dims.begin(), BLOCKS);
-//                 auto new_strides = dims_t(gather_tensor->strides());
-//                 new_strides[0] *= CORES;
-//                 auto viewed_gather_tensor =
-//                     view(*gather_tensor, new_dims, new_strides);
-
-//                 reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
-//                        dims_t({0}), false);
-//             },
-//             []() -> void {
-//                 auto reduced_tensor =
-//                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-//                 delete reduced_tensor;
-//                 global_hardware_ctx.global_var = nullptr;
-//             },
-//             ctx);
-//         break;
-//     default:
-//         break;
-//     }
-// }
+template <class T, loc_t ALoc, loc_t BLoc>
+void tdma_all_reduce_async(tensor<T, ALoc> &src, tensor<T, BLoc> &dest,
+                           reduce_op_t reduce_op, reduce_strategy_t strategy,
+                           thread_context &ctx) {
+    __tdma_all_sync_apply(
+        [&src, &ctx](int visited) -> void {
+            tensor<T> *gather_tensor = nullptr;
+            auto new_dims = dims_t(src.dimension());
+            new_dims.insert(new_dims.begin(), BLOCKS * CORES);
+            if (visited == 1) {
+                if (global_hardware_ctx.global_var != nullptr) {
+                    throw std::runtime_error(" the global var has been used!");
+                }
+                gather_tensor = new tensor<T>(new_dims);
+                global_hardware_ctx.global_var = (void *)gather_tensor;
+            } else {
+                gather_tensor =
+                    static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+            }
+            dims_t begin(new_dims.size(), 0);
+            dims_t shape(new_dims);
+            begin[0] = ctx.bid() * CORES + ctx.tid();
+            shape[0] = 1;
+            __tensor_copy_sync<T, loc_t::local, ALoc>(
+                std::move((*gather_tensor)(begin, shape)),
+                std::move(unsqueeze(src)));
+        },
+        []() -> void {}, ctx);
+    switch (strategy) {
+    case reduce_strategy_t::all:
+        __tdma_all_sync_apply(
+            [&]([[maybe_unused]] int visit) -> void {
+                tensor<T> *gather_tensor = nullptr;
+                tensor<T> *reduced_tensor = nullptr;
+                if (visit == 1) {
+                    gather_tensor = static_cast<tensor<T> *>(
+                        global_hardware_ctx.global_var);
+                    auto reduced_shape = get_reduced_shape(
+                        gather_tensor->dimension(), dims_t({0}), false);
+                    reduced_tensor = new tensor<T>(reduced_shape);
+                    reduce(*gather_tensor, *reduced_tensor, reduce_op, (T)0,
+                           dims_t({0}), false);
+                    delete gather_tensor;
+                    global_hardware_ctx.global_var = reduced_tensor;
+                } else {
+                    reduced_tensor = static_cast<tensor<T> *>(
+                        global_hardware_ctx.global_var);
+                    __tensor_copy_sync(std::move(dest),
+                                       std::move(*reduced_tensor));
+                }
+            },
+            []() -> void {
+                auto reduced_tensor =
+                    static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+                delete reduced_tensor;
+                global_hardware_ctx.global_var = nullptr;
+            },
+            ctx);
+        break;
+    case reduce_strategy_t::by_block:
+        __tdma_all_sync_apply(
+            [&]([[maybe_unused]] int visit) -> void {
+                tensor<T> *gather_tensor =
+                    static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+                auto new_dims = dims_t(src.dimension());
+                new_dims.insert(new_dims.begin(), BLOCKS);
+                auto new_strides = dims_t(gather_tensor->strides());
+                new_strides[0] *= CORES;
+                auto viewed_gather_tensor =
+                    view(*gather_tensor, new_dims, new_strides);
+
+                reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
+                       dims_t({0}), false);
+            },
+            []() -> void {
+                auto reduced_tensor =
+                    static_cast<tensor<T> *>(global_hardware_ctx.global_var);
+                delete reduced_tensor;
+                global_hardware_ctx.global_var = nullptr;
+            },
+            ctx);
+        break;
+    default:
+        break;
+    }
+}
 
 void tdma_gather_async() {}
 
diff --git a/modules/cpu/src/runtime/cmodel/include/unary.h b/modules/cpu/src/runtime/cmodel/include/unary.h
index bf1f825999..ede62b8019 100644
--- a/modules/cpu/src/runtime/cmodel/include/unary.h
+++ b/modules/cpu/src/runtime/cmodel/include/unary.h
@@ -17,6 +17,7 @@
 #include <gsl/gsl-lite.hpp>
 #include <runtime_utils.h>
 
+using namespace nncase::runtime::cpu;
 namespace kernels {
 
 namespace {
@@ -41,33 +42,39 @@ void unary_impl(unary_op_t op, const T *input, T *output,
                 gsl::span<const size_t> input_strides,
                 gsl::span<const size_t> out_shape,
                 gsl::span<const size_t> out_strides) noexcept {
-    switch (op) {
-        UNARY_IMPL_OP(abs, fabsf);
-        UNARY_IMPL_OP(acos, acosf);
-        UNARY_IMPL_OP(acosh, acoshf);
-        UNARY_IMPL_OP(asin, asinf);
-        UNARY_IMPL_OP(asinh, asinhf);
-        UNARY_IMPL_OP(ceil, ceilf);
-        UNARY_IMPL_OP(cos, cosf);
-        UNARY_IMPL_OP(cosh, coshf);
-        UNARY_IMPL_OP(exp, expf);
-        UNARY_IMPL_OP(floor, floorf);
-        UNARY_IMPL_OP(log, logf);
-        UNARY_IMPL_OP(logical_not, [](float v) { return !v; });
-        UNARY_IMPL_OP(neg, std::negate<float>());
-        UNARY_IMPL_OP(round, [](float v) { return round(v); });
-        UNARY_IMPL_OP(rsqrt, [](float v) { return 1.f / sqrtf(v); });
-        UNARY_IMPL_OP(sign, [](float v) { return (0.f < v) - (v < 0.f); });
-        UNARY_IMPL_OP(sin, sinf);
-        UNARY_IMPL_OP(sinh, sinhf);
-        UNARY_IMPL_OP(sqrt, sqrtf);
-        UNARY_IMPL_OP(square, [](float v) { return v * v; });
-        UNARY_IMPL_OP(tanh, tanhf);
-        UNARY_IMPL_OP(swish, [](float x) { return x / (1 + exp(-x)); });
-    default:
-        return;
+    if (std::is_same_v<T, float>) {
+        switch (op) {
+            UNARY_IMPL_OP(abs, nncase_mt.float_unary_abs);
+            UNARY_IMPL_OP(acos, nncase_mt.float_unary_cos);
+            UNARY_IMPL_OP(acosh, nncase_mt.float_unary_cosh);
+            UNARY_IMPL_OP(asin, nncase_mt.float_unary_asin);
+            UNARY_IMPL_OP(asinh, nncase_mt.float_unary_asinh);
+            UNARY_IMPL_OP(ceil, nncase_mt.float_unary_ceil);
+            UNARY_IMPL_OP(cos, nncase_mt.float_unary_cos);
+            UNARY_IMPL_OP(cosh, nncase_mt.float_unary_cosh);
+            UNARY_IMPL_OP(exp, nncase_mt.float_unary_exp);
+            UNARY_IMPL_OP(floor, nncase_mt.float_unary_floor);
+            UNARY_IMPL_OP(log, nncase_mt.float_unary_log);
+            UNARY_IMPL_OP(logical_not, nncase_mt.float_unary_logical_not);
+            UNARY_IMPL_OP(neg, nncase_mt.float_unary_neg);
+            UNARY_IMPL_OP(round, nncase_mt.float_unary_round);
+            UNARY_IMPL_OP(rsqrt, nncase_mt.float_unary_rsqrt);
+            UNARY_IMPL_OP(sign, nncase_mt.float_unary_sign);
+            UNARY_IMPL_OP(sin, nncase_mt.float_unary_sin);
+            UNARY_IMPL_OP(sinh, nncase_mt.float_unary_sinh);
+            UNARY_IMPL_OP(sqrt, nncase_mt.float_unary_sqrt);
+            UNARY_IMPL_OP(square, nncase_mt.float_unary_square);
+            UNARY_IMPL_OP(tanh, nncase_mt.float_unary_tanh);
+            UNARY_IMPL_OP(swish, [](float x) {
+                return x / (1 + nncase_mt.float_unary_exp(-x));
+            });
+        default:
+            runtime_util.rt_assert(false, (char *)"Unsupported Unary Op!");
+        }
+    } else {
+        runtime_util.rt_assert(false, (char *)"Unsupported Unary Type!");
     }
-}
+} // namespace
 
 } // namespace
 

From 7d121bd615212c04bc212a446012f29dc08a97b5 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 5 Sep 2023 15:38:32 +0800
Subject: [PATCH 149/308] fix codes using stdlib

---
 .../src/runtime/cmodel/include/layernorm.h    |  9 +++++----
 .../cpu/src/runtime/cmodel/include/matmul.h   |  6 +++---
 .../cpu/src/runtime/cmodel/include/reduce.h   | 15 ++++++++------
 .../runtime/cmodel/include/runtime_utils.h    | 18 +++++++++++++++--
 .../cpu/src/runtime/cmodel/include/softmax.h  | 20 +++++++++++++++----
 modules/cpu/src/runtime/cmodel/include/tdma.h |  9 +++++----
 .../cpu/src/runtime/cmodel/include/tensor.h   |  4 ++--
 7 files changed, 56 insertions(+), 25 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index b646a2b7b8..80ac9522fe 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -5,6 +5,7 @@
 #include <riscv_vector.h>
 #endif
 
+using namespace nncase::runtime::cpu;
 namespace kernels {
 
 namespace {
@@ -26,8 +27,8 @@ void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *output,
         if (rms_norm) {
             mean = 0;
         }
-        auto sigma =
-            std::sqrt(sum_sqr[o_offset] / norm_size - mean * mean + eps);
+        auto sigma = nncase_mt.float_unary_sqrt(sum_sqr[o_offset] / norm_size -
+                                                mean * mean + eps);
 
         auto input_offset = offset(input_stride, input_index);
         auto in_offset = offset(gamma_strides, input_index.subspan(axis));
@@ -142,8 +143,8 @@ template <class T>
 void layernorm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
                dims_t input_dims, strides_t input_strides,
                strides_t output_strides, strides_t sum_strides,
-               strides_t gamma_strides, T eps, int32_t axis,
-               int32_t norm_size, bool rms_norm = false) {
+               strides_t gamma_strides, T eps, int32_t axis, int32_t norm_size,
+               bool rms_norm = false) {
 #ifdef __riscv_vector
     return layernorm_rvv_impl(
         input, sum, sum_sqr, gamma, beta,
diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
index 9aeb902448..5c8aa42cd4 100644
--- a/modules/cpu/src/runtime/cmodel/include/matmul.h
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -35,9 +35,9 @@ void contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
     auto b_unit_size = new_b_shape[3] * new_b_shape[4];
     auto out_unit_size = new_a_shape[3] * new_b_shape[4];
 
-    auto dim0 = std::max(new_a_shape[0], new_b_shape[0]);
-    auto dim1 = std::max(new_a_shape[1], new_b_shape[1]);
-    auto dim2 = std::max(new_a_shape[2], new_b_shape[2]);
+    auto dim0 = new_a_shape[0]> new_b_shape[0]? new_a_shape[0] : new_b_shape[0];
+    auto dim1 = new_a_shape[1]> new_b_shape[1]? new_a_shape[1] : new_b_shape[1];
+    auto dim2 = new_a_shape[2]> new_b_shape[2]? new_a_shape[2] : new_b_shape[2];
     auto ah_size = a_unit_size * new_a_shape[2];
     auto bh_size = b_unit_size * new_b_shape[2];
     auto oh_size = out_unit_size * dim2;
diff --git a/modules/cpu/src/runtime/cmodel/include/reduce.h b/modules/cpu/src/runtime/cmodel/include/reduce.h
index 1ca7592bbf..79ec08d853 100644
--- a/modules/cpu/src/runtime/cmodel/include/reduce.h
+++ b/modules/cpu/src/runtime/cmodel/include/reduce.h
@@ -37,8 +37,11 @@ template <class TShape>
 size_t get_reduce_block_size(const TShape &in_shape, const TShape &axis) {
     size_t size = 1;
     for (size_t i = 0; i < in_shape.size(); i++) {
-        if (std::find(axis.begin(), axis.end(), i) != axis.end()) {
-            size *= in_shape[i];
+        for (size_t j = 0; j < axis.size(); j++) {
+            if (i == axis[j]) {
+                size *= in_shape[i];
+                break;
+            }
         }
     }
 
@@ -143,14 +146,14 @@ void reduce(reduce_op_t op, const T *init_value, const T *input, T *output,
             gsl::span<const size_t> out_strides, bool keep_dims) noexcept {
     auto out_shape = get_reduced_shape(in_shape, axis, keep_dims);
     switch (op) {
-        REDUCE_IMPL(reduce_op_t::mean, std::plus<T>(),
+        REDUCE_IMPL(reduce_op_t::mean, [](T a, T b) { return a + b; },
                     [block_size = (T)get_reduce_block_size(in_shape, axis)](
                         T v) { return v / block_size; });
         REDUCE_IMPL_NO_POST(reduce_op_t::min,
-                            [](T a, T b) { return std::min(a, b); });
+                            [](T a, T b) { return a > b ? b : a; });
         REDUCE_IMPL_NO_POST(reduce_op_t::max,
-                            [](T a, T b) { return std::max(a, b); });
-        REDUCE_IMPL_NO_POST(reduce_op_t::sum, std::plus<T>());
+                            [](T a, T b) { return a > b ? a : b; });
+        REDUCE_IMPL_NO_POST(reduce_op_t::sum, [](T a, T b) { return a + b; });
         REDUCE_IMPL_NO_POST(reduce_op_t::sum_sqr,
                             [](T a, T b) { return a + (b * b); });
     case reduce_op_t::prod:
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 3ca7b63f10..e6216187b4 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -169,7 +169,14 @@ inline dims_t get_reduced_offset(gsl::span<const size_t> in_offset,
     dims_t off;
     off.reserve(in_offset.size() - (keep_dims ? 0 : axis.size()));
     for (size_t i = 0; i < in_offset.size(); i++) {
-        if (std::find(axis.begin(), axis.end(), i) == axis.end()) {
+        bool found = false;
+        for (size_t j = 0; j < axis.size(); j++) {
+            if (i == axis[j]) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
             off.push_back(in_offset[i]);
         } else {
             if (keep_dims)
@@ -199,7 +206,14 @@ inline dims_t get_reduced_shape(gsl::span<const size_t> in_shape,
     dims_t shape;
     shape.reserve(in_shape.size() - (keep_dims ? 0 : axis.size()));
     for (size_t i = 0; i < in_shape.size(); i++) {
-        if (std::find(axis.begin(), axis.end(), i) == axis.end()) {
+        bool found = false;
+        for (size_t j = 0; j < axis.size(); j++) {
+            if (i == axis[j]) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
             shape.push_back(in_shape[i]);
         } else {
             if (keep_dims)
diff --git a/modules/cpu/src/runtime/cmodel/include/softmax.h b/modules/cpu/src/runtime/cmodel/include/softmax.h
index 6967b30ac1..89ca7fc448 100644
--- a/modules/cpu/src/runtime/cmodel/include/softmax.h
+++ b/modules/cpu/src/runtime/cmodel/include/softmax.h
@@ -15,6 +15,8 @@
 #include <cmath>
 #include <runtime_utils.h>
 
+using namespace nncase::runtime::cpu;
+
 namespace kernels {
 
 namespace {
@@ -30,7 +32,10 @@ void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
     auto reduced_shape = get_reduced_shape(in_shape, axes, true);
     auto reduced_strides = get_default_strides(reduced_shape);
     auto reduced_size = compute_size(reduced_shape);
-    std::vector<T> tmp(reduced_size, std::numeric_limits<T>::lowest());
+    auto tmp = (T *)runtime_util.malloc(reduced_size * sizeof(T));
+    for (size_t i = 0; i < reduced_size; i++) {
+        tmp[i] = std::numeric_limits<T>().lowest();
+    }
 
     // reduce_max
     (apply(in_shape, [&](gsl::span<const size_t> index) -> void {
@@ -41,7 +46,7 @@ void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
         auto out_idx = offset(reduced_strides, out_index);
         auto &out = tmp[out_idx];
 
-        out = std::max(in, out);
+        out = in > out ? in : out;
     }));
 
     // x - reduce_max
@@ -57,7 +62,9 @@ void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
     }));
 
     // exp(x - reduce_max) and sum
-    tmp.assign(tmp.size(), static_cast<T>(0));
+    for (size_t i = 0; i < reduced_size; i++) {
+        tmp[i] = static_cast<T>(0);
+    }
     (apply(in_shape, [&](gsl::span<const size_t> index) -> void {
         auto in_idx = offset(out_strides, index);
         const auto in = output[in_idx];
@@ -78,7 +85,12 @@ void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
         auto &out = output[out_idx];
         out /= in;
         if (needLog) {
-            out = std::log(out);
+            if (std::is_same_v<T, float>) {
+                out = nncase_mt.float_unary_log(out);
+            } else {
+                runtime_util.rt_assert(
+                    false, (char *)"Not supported Type in softmax!");
+            }
         }
     }));
 }
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index b91b194bc4..9faced3135 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -155,7 +155,7 @@ template <typename T, loc_t BLoc>
 void concat(std::initializer_list<tensor<T, loc_t::local>> inits,
             tensor<T, BLoc> &output, size_t axis) {
     itlib::small_vector<const gsl::byte *const, 8> inputs(inits.size());
-    std::vector<strides_t> in_strides(inits.size());
+    itlib::small_vector<strides_t> in_strides(inits.size());
     auto concat_dims = dims_t(inits.size(), 1);
     for (size_t i = 0; i < inits.size(); ++i) {
         if (inits[i].dimension().size() != 0) {
@@ -273,7 +273,8 @@ template <class T, loc_t Src, loc_t Dest>
 void tdma_load_broadcast_async([[maybe_unused]] tensor<T, Dest> &dest,
                                [[maybe_unused]] tensor<T, Src> &src,
                                [[maybe_unused]] thread_context &ctx) {
-    throw std::system_error(std::make_error_code(std::errc::not_supported));
+    // throw std::system_error(std::make_error_code(std::errc::not_supported));
+    runtime_util.rt_assert(false, (char*)"not_supported");
 }
 
 template <class T>
@@ -287,7 +288,7 @@ void tdma_reduce_async(tensor<T, loc_t::local> &src,
             new_dims.insert(new_dims.begin(), BLOCKS * CORES);
             if (visited == 1) {
                 if (global_hardware_ctx.global_var != nullptr) {
-                    throw std::runtime_error(" the global var has been used!");
+                    runtime_util.rt_assert(false, (char*)"the global var has been used!");
                 }
                 gather_tensor = new tensor<T>(new_dims);
                 global_hardware_ctx.global_var = (void *)gather_tensor;
@@ -359,7 +360,7 @@ void tdma_all_reduce_async(tensor<T, ALoc> &src, tensor<T, BLoc> &dest,
             new_dims.insert(new_dims.begin(), BLOCKS * CORES);
             if (visited == 1) {
                 if (global_hardware_ctx.global_var != nullptr) {
-                    throw std::runtime_error(" the global var has been used!");
+                    runtime_util.rt_assert(false, (char*)"the global var has been used!");
                 }
                 gather_tensor = new tensor<T>(new_dims);
                 global_hardware_ctx.global_var = (void *)gather_tensor;
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index 75e9eabc0e..ed064dd87a 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -34,7 +34,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
           strides_(get_default_strides(dims_)),
           size_(compute_size(dims_)) {
         if (size_ != data_.size()) {
-            throw std::errc::invalid_argument;
+            runtime_util.rt_assert(false, (char*)"Invalid tensor size");
         }
     }
 
@@ -45,7 +45,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
           strides_(strides),
           size_(compute_size(dims_, strides_)) {
         if (size_ != data_.size()) {
-            throw std::errc::invalid_argument;
+            runtime_util.rt_assert(false, (char*)"Invalid tensor size");
         }
     }
 

From 4c9aaadfb3a3d0ab85ccadfaaa0ccf8142cf5efb Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 5 Sep 2023 16:01:51 +0800
Subject: [PATCH 150/308] update kernel inputs

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt       | 2 +-
 modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp | 9 ++++-----
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index 615a039f2a..d26efa7fca 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -27,7 +27,7 @@ function(add_test name test_path)
   if (CMAKE_BUILD_TYPE STREQUAL "Release")
     add_compile_options(-O1)
   endif()
-  add_link_options(-no-pie -nostartfiles -fPIC -fno-stack-protector -static -Wl,-e,_Z6_startP19hardware_context_mtP15runtime_util_mtPhS3_S3_)
+  add_link_options(-no-pie -nostartfiles -fPIC -fno-stack-protector -static -Wl,-e,_Z6_startP19hardware_context_mtP15runtime_util_mtPPh)
   add_executable(${name} "${test_path}/main.cpp")
   target_link_libraries(${name} cpu_cmodel)
 endfunction(add_test)
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
index 647aa94736..682691ea4a 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
@@ -31,21 +31,20 @@ DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
 void _start(hardware_context_mt *hw_impl, runtime_util_mt *rt_util_mt,
-            uint8_t *position_ids, uint8_t *gather_data, uint8_t *output) {
+            uint8_t **inputs) {
     global_hardware_init(hw_impl);
     runtime_util = *rt_util_mt;
-    runtime_util.printf("%p\t%p\n", gather_data, output);
 
     auto Position_ids_ = tensor<int64_t, loc_t::device>(
-        gsl::make_span((int64_t *)position_ids, 384), {1, 384});
+        gsl::make_span((int64_t *)inputs[0], 384), {1, 384});
     runtime_util.printf("1\n");
 
     auto GatherData_ = tensor<float, loc_t::device>(
-        gsl::make_span((float *)gather_data, 384*8192), {384, 8192});
+        gsl::make_span((float *)inputs[1], 384 * 8192), {384, 8192});
 
     runtime_util.printf("2\n");
     auto Output_ = tensor<float, loc_t::device>(
-        gsl::make_span((float *)output, 384*8192), {1, 384, 8192});
+        gsl::make_span((float *)inputs[2], 384 * 8192), {1, 384, 8192});
 
     runtime_util.printf("3\n");
     Position_ids = &Position_ids_;

From 40604a4bd4ad6a20dfd414c17139c5ce5881f264 Mon Sep 17 00:00:00 2001
From: lerenhua <2532375005@qq.com>
Date: Wed, 6 Sep 2023 11:34:07 +0800
Subject: [PATCH 151/308] Fix gather

---
 modules/cpu/src/runtime/cmodel/include/gather.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/gather.h b/modules/cpu/src/runtime/cmodel/include/gather.h
index 604baea0ee..fd5ef81564 100644
--- a/modules/cpu/src/runtime/cmodel/include/gather.h
+++ b/modules/cpu/src/runtime/cmodel/include/gather.h
@@ -42,21 +42,21 @@ void gather_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
         }
 
         // which index to be used in indices
-        // dims_t indices_index(out_index.begin() + axis,
-        //                      out_index.begin() + axis + indices_shape.size());
-        // auto indices_offset =
-        //     offset((indices_shape), indices_index);
+        dims_t indices_index(out_index.begin() + axis,
+                             out_index.begin() + axis + indices_shape.size());
+        auto indices_offset =
+            offset(get_default_strides(indices_shape), indices_index);
         // select sub block in dim axis
-        // in_index[i_index] = indices[indices_offset];
-        // ++i_index;
+        in_index[i_index] = indices[indices_offset];
+        ++i_index;
 
         // select position in sub block
         for (auto o_index = axis + indices_shape.size();
              o_index < out_index.size(); ++o_index, ++i_index) {
             in_index[i_index] = out_index[o_index];
         }
-        // output[offset(out_strides, out_index)] =
-        //     input[offset(in_strides, in_index)];
+        output[offset(out_strides, out_index)] =
+            input[offset(in_strides, in_index)];
     });
 }
 } // namespace

From 353ca079ba5c82c246fa873eba1dd1ce96bb6d5d Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 6 Sep 2023 13:56:57 +0800
Subject: [PATCH 152/308] refactor cpu cmodel

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |   9 +-
 .../runtime/cmodel/include/hardware_context.h |  18 +-
 .../runtime/cmodel/include/runtime_utils.h    |  19 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h |   2 +-
 .../cpu/src/runtime/cmodel/include/tensor.h   |   1 +
 .../src/runtime/cmodel/tests/demo4/main.cpp   |   8 +-
 .../src/runtime/cmodel/tests/norm/main.cpp    | 171 +++++++---------
 modules/cpu/src/runtime/cpu_common.h          | 188 ------------------
 modules/cpu/src/runtime/hardware_context.cpp  | 169 ++++++++++++++++
 modules/cpu/src/runtime/hardware_context.h    |  27 +++
 modules/cpu/src/runtime/hardware_def.h        |   5 +
 modules/cpu/src/runtime/io_utils.h            |  28 +++
 modules/cpu/src/runtime/method_table_def.h    | 105 ++++++++++
 modules/cpu/src/runtime/method_table_impl.h   | 139 +++++++++++++
 modules/cpu/src/runtime/runtime_types.h       |  52 +++++
 modules/cpu/src/runtime/runtime_utils.h       |  35 ++++
 16 files changed, 655 insertions(+), 321 deletions(-)
 delete mode 100644 modules/cpu/src/runtime/cpu_common.h
 create mode 100644 modules/cpu/src/runtime/hardware_context.cpp
 create mode 100644 modules/cpu/src/runtime/hardware_context.h
 create mode 100644 modules/cpu/src/runtime/hardware_def.h
 create mode 100644 modules/cpu/src/runtime/io_utils.h
 create mode 100644 modules/cpu/src/runtime/method_table_def.h
 create mode 100644 modules/cpu/src/runtime/method_table_impl.h
 create mode 100644 modules/cpu/src/runtime/runtime_types.h
 create mode 100644 modules/cpu/src/runtime/runtime_utils.h

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index d26efa7fca..55f9a4460e 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -3,12 +3,15 @@ cmake_minimum_required(VERSION 3.13)
 
 add_library(cpu_cmodel STATIC
   src/dummy.cpp
+  ../hardware_context.cpp
 )
 
 set(CMAKE_CXX_STANDARD 20)
 
 target_include_directories(cpu_cmodel PUBLIC include)
-target_include_directories(cpu_cmodel PUBLIC /compiler/huochenghai/GNNE/rebuild-ir/nncase/src/Native/include/ /compiler/huochenghai/GNNE/rebuild-ir/nncase/modules/cpu/include/)
+target_include_directories(cpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../src/Native/include)
+target_include_directories(cpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../include)
+target_include_directories(cpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../runtime)
 target_include_directories(cpu_cmodel PUBLIC /root/.conan/data/gsl-lite/0.37.0/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/)
 # target_link_libraries(cpu_cmodel PUBLIC gsl::gsl-lite)
 # if(NOT APPLE AND NOT MSVC)
@@ -27,7 +30,7 @@ function(add_test name test_path)
   if (CMAKE_BUILD_TYPE STREQUAL "Release")
     add_compile_options(-O1)
   endif()
-  add_link_options(-no-pie -nostartfiles -fPIC -fno-stack-protector -static -Wl,-e,_Z6_startP19hardware_context_mtP15runtime_util_mtPPh)
+  add_link_options(-no-pie -nostartfiles -fPIC -fno-stack-protector -static -Wl,-e,_Z6_startPN6nncase7runtime3cpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPh)
   add_executable(${name} "${test_path}/main.cpp")
   target_link_libraries(${name} cpu_cmodel)
 endfunction(add_test)
@@ -36,6 +39,6 @@ endfunction(add_test)
 # add_test(demo2 tests/demo2)
 # add_test(demo3 tests/demo3)
 add_test(demo4 tests/demo4)
-# add_test(norm tests/norm)
+add_test(norm tests/norm)
 # add_test(embed tests/embed)
 # add_test(head tests/head)
diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_context.h b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
index c7ef98a1e7..291f15941d 100644
--- a/modules/cpu/src/runtime/cmodel/include/hardware_context.h
+++ b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
@@ -1,21 +1,9 @@
 #pragma once
 
+#include "../../method_table_def.h"
 #include <functional>
-// #include <memory>
-
-struct hardware_context_mt {
-    void (*lock_block)(int bid);
-    int (*mark_block_visit)(int bid, int tid);
-    void (*unlock_block)(int bid);
-    void (*wait_block_sync)(int bid, int visited,
-                            std::function<void()> callable);
-    void (*lock_all)();
-    int (*mark_all_visit)(int bid, int tid);
-    void (*unlock_all)();
-    void (*wait_all_sync)(int visited, std::function<void()> callable);
-    void (*init)();
-};
 
+using namespace nncase::runtime::cpu;
 class hardware_context {
   public:
     // hardware_context(hardware_context_mt *impl) : impl_(impl){};
@@ -45,7 +33,7 @@ class hardware_context {
 
 static hardware_context global_hardware_ctx;
 
-void global_hardware_init(hardware_context_mt *impl) {
+inline void global_hardware_init(hardware_context_mt *impl) {
     global_hardware_ctx.impl_ = impl;
     impl->init();
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index e6216187b4..f01bf1568a 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -3,18 +3,11 @@
 #include <cstddef>
 #include <gsl/gsl-lite.hpp>
 #include <runtime_types.h>
-#include "../../cpu_common.h"
-
-struct runtime_util_mt {
-    int (*printf)(const char *__restrict __format, ...);
-    void *(*malloc)(size_t size);
-    int (*free)(void *ptr);
-    float (*sqrt)(float x);
-    void (*create_thread)(pthread_t &pt, void *param_, void *(*call)(void *));
-    void (*join_thread)(pthread_t &pt);
-    void (*rt_assert)(bool condition, char *message);
-};
+#include "../../method_table_def.h"
 
+using namespace nncase::runtime::cpu;
+
+static nncase_mt_t nncase_mt;
 static runtime_util_mt runtime_util;
 
 void print_vec(itlib::small_vector<size_t, 8> vec) {
@@ -157,8 +150,8 @@ template <typename T> double cosine(const T *v1, const T *v2, size_t size) {
         runtime_util.printf("%f, %f\n", (float)v1[i], (float)v2[i]);
         ;
     }
-    return dot(v1, v2, size) / ((runtime_util.sqrt(dot(v1, v1, size)) *
-                                 runtime_util.sqrt(dot(v2, v2, size))));
+    return dot(v1, v2, size) / ((nncase_mt.float_unary_sqrt(dot(v1, v1, size)) *
+                                 nncase_mt.float_unary_sqrt(dot(v2, v2, size))));
 }
 
 inline dims_t get_reduced_offset(gsl::span<const size_t> in_offset,
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 9faced3135..5077800cd2 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -14,7 +14,7 @@
 #include <thread_context.h>
 #include <transpose.h>
 #include <unary.h>
-#include "../../cpu_common.h"
+#include "runtime_utils.h"
 
 template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &src) {
     auto new_dims = dims_t(src.dimension());
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index ed064dd87a..da9393cbf8 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -4,6 +4,7 @@
 #include <gsl/gsl-lite.hpp>
 #include <hardware_def.h>
 #include <runtime_utils.h>
+#include "../../method_table_def.h"
 
 enum class loc_t : uint8_t {
     shared,
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
index 682691ea4a..98a85bec6c 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
@@ -1,8 +1,5 @@
 #include "cluster_def.h"
-// #include <io_utils.h>
-// #include <cstring>
 #include <runtime_utils.h>
-// #include <pthread.h>
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
@@ -30,10 +27,11 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
-void _start(hardware_context_mt *hw_impl, runtime_util_mt *rt_util_mt,
+void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt, nncase_mt_t *nncase_mt_impl,
             uint8_t **inputs) {
-    global_hardware_init(hw_impl);
+    global_hardware_init(hw_ctx_impl);
     runtime_util = *rt_util_mt;
+    nncase_mt = *nncase_mt_impl;
 
     auto Position_ids_ = tensor<int64_t, loc_t::device>(
         gsl::make_span((int64_t *)inputs[0], 384), {1, 384});
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp b/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
index f0f10f305c..2978d7b03b 100644
--- a/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
@@ -1,11 +1,9 @@
 #include "cluster_def.h"
-#include <io_utils.h>
 #include <runtime_utils.h>
-// #include <pthread.h>
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(Hidden_in, Output);                 \
+        block##b::thread##t::stage1_kernel(*Hidden_in, *Output);               \
         return arg;                                                            \
     }
 
@@ -15,8 +13,8 @@
     DEFINE_TFUNC(b, 2)                                                         \
     DEFINE_TFUNC(b, 3)
 
-static tensor<float, loc_t::device> Hidden_in({1, 384, 8192});
-static tensor<float, loc_t::device> Output({1, 384, 8192});
+static tensor<float, loc_t::device> *Hidden_in; // {1, 384, 8192}
+static tensor<float, loc_t::device> *Output;    // {1, 384, 8192}
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
@@ -27,103 +25,84 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
-#define LOAD_FILE(name, i, type)                                               \
-    {                                                                          \
-        auto src_##name = read_file(std::string(argv[(i)]));                   \
-        span_copy(name.data(), gsl::make_span(src_##name).as_span<type>());    \
-    }
-
-/**
- * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
- *
- * @param argc
- * @param argv
- * @return int
- */
-int main([[maybe_unused]] int argc, char **argv) {
-    // spdlog::set_level(spdlog::level::debug);
-    global_hardware_init();
+void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt, nncase_mt_t *nncase_mt_impl,
+            uint8_t **inputs) {
+    global_hardware_init(hw_ctx_impl);
+    runtime_util = *rt_util_mt;
+    nncase_mt = *nncase_mt_impl;
 
-    LOAD_FILE(Hidden_in, 1, float);
+    auto input0 = tensor<float, loc_t::device>(
+        gsl::make_span((float *)inputs[0], 384 * 8192), {1, 384, 8192});
+    Hidden_in = &input0;
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
     pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
     pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
-    pthread_create(&t_0_0, NULL, f_0_0, NULL);
-    pthread_create(&t_0_1, NULL, f_0_1, NULL);
-    pthread_create(&t_0_2, NULL, f_0_2, NULL);
-    pthread_create(&t_0_3, NULL, f_0_3, NULL);
-    pthread_create(&t_1_0, NULL, f_1_0, NULL);
-    pthread_create(&t_1_1, NULL, f_1_1, NULL);
-    pthread_create(&t_1_2, NULL, f_1_2, NULL);
-    pthread_create(&t_1_3, NULL, f_1_3, NULL);
-    pthread_create(&t_2_0, NULL, f_2_0, NULL);
-    pthread_create(&t_2_1, NULL, f_2_1, NULL);
-    pthread_create(&t_2_2, NULL, f_2_2, NULL);
-    pthread_create(&t_2_3, NULL, f_2_3, NULL);
-    pthread_create(&t_3_0, NULL, f_3_0, NULL);
-    pthread_create(&t_3_1, NULL, f_3_1, NULL);
-    pthread_create(&t_3_2, NULL, f_3_2, NULL);
-    pthread_create(&t_3_3, NULL, f_3_3, NULL);
-    pthread_create(&t_4_0, NULL, f_4_0, NULL);
-    pthread_create(&t_4_1, NULL, f_4_1, NULL);
-    pthread_create(&t_4_2, NULL, f_4_2, NULL);
-    pthread_create(&t_4_3, NULL, f_4_3, NULL);
-    pthread_create(&t_5_0, NULL, f_5_0, NULL);
-    pthread_create(&t_5_1, NULL, f_5_1, NULL);
-    pthread_create(&t_5_2, NULL, f_5_2, NULL);
-    pthread_create(&t_5_3, NULL, f_5_3, NULL);
-    pthread_create(&t_6_0, NULL, f_6_0, NULL);
-    pthread_create(&t_6_1, NULL, f_6_1, NULL);
-    pthread_create(&t_6_2, NULL, f_6_2, NULL);
-    pthread_create(&t_6_3, NULL, f_6_3, NULL);
-    pthread_create(&t_7_0, NULL, f_7_0, NULL);
-    pthread_create(&t_7_1, NULL, f_7_1, NULL);
-    pthread_create(&t_7_2, NULL, f_7_2, NULL);
-    pthread_create(&t_7_3, NULL, f_7_3, NULL);
-
-    pthread_join(t_0_0, NULL);
-    pthread_join(t_0_1, NULL);
-    pthread_join(t_0_2, NULL);
-    pthread_join(t_0_3, NULL);
-    pthread_join(t_1_0, NULL);
-    pthread_join(t_1_1, NULL);
-    pthread_join(t_1_2, NULL);
-    pthread_join(t_1_3, NULL);
-    pthread_join(t_2_0, NULL);
-    pthread_join(t_2_1, NULL);
-    pthread_join(t_2_2, NULL);
-    pthread_join(t_2_3, NULL);
-    pthread_join(t_3_0, NULL);
-    pthread_join(t_3_1, NULL);
-    pthread_join(t_3_2, NULL);
-    pthread_join(t_3_3, NULL);
-    pthread_join(t_4_0, NULL);
-    pthread_join(t_4_1, NULL);
-    pthread_join(t_4_2, NULL);
-    pthread_join(t_4_3, NULL);
-    pthread_join(t_5_0, NULL);
-    pthread_join(t_5_1, NULL);
-    pthread_join(t_5_2, NULL);
-    pthread_join(t_5_3, NULL);
-    pthread_join(t_6_0, NULL);
-    pthread_join(t_6_1, NULL);
-    pthread_join(t_6_2, NULL);
-    pthread_join(t_6_3, NULL);
-    pthread_join(t_7_0, NULL);
-    pthread_join(t_7_1, NULL);
-    pthread_join(t_7_2, NULL);
-    pthread_join(t_7_3, NULL);
-
-    {
-        auto src_output = read_file(std::string(argv[2]));
-        auto src_span = gsl::make_span(src_output).as_span<float>();
-        auto cos =
-            cosine(Output.data().data(), src_span.data(), src_span.size());
-        printf("Output cosine %f\n", cos);
-    }
+    runtime_util.create_thread(t_0_0, NULL, f_0_0);
+    runtime_util.create_thread(t_0_1, NULL, f_0_1);
+    runtime_util.create_thread(t_0_2, NULL, f_0_2);
+    runtime_util.create_thread(t_0_3, NULL, f_0_3);
+    runtime_util.create_thread(t_1_0, NULL, f_1_0);
+    runtime_util.create_thread(t_1_1, NULL, f_1_1);
+    runtime_util.create_thread(t_1_2, NULL, f_1_2);
+    runtime_util.create_thread(t_1_3, NULL, f_1_3);
+    runtime_util.create_thread(t_2_0, NULL, f_2_0);
+    runtime_util.create_thread(t_2_1, NULL, f_2_1);
+    runtime_util.create_thread(t_2_2, NULL, f_2_2);
+    runtime_util.create_thread(t_2_3, NULL, f_2_3);
+    runtime_util.create_thread(t_3_0, NULL, f_3_0);
+    runtime_util.create_thread(t_3_1, NULL, f_3_1);
+    runtime_util.create_thread(t_3_2, NULL, f_3_2);
+    runtime_util.create_thread(t_3_3, NULL, f_3_3);
+    runtime_util.create_thread(t_4_0, NULL, f_4_0);
+    runtime_util.create_thread(t_4_1, NULL, f_4_1);
+    runtime_util.create_thread(t_4_2, NULL, f_4_2);
+    runtime_util.create_thread(t_4_3, NULL, f_4_3);
+    runtime_util.create_thread(t_5_0, NULL, f_5_0);
+    runtime_util.create_thread(t_5_1, NULL, f_5_1);
+    runtime_util.create_thread(t_5_2, NULL, f_5_2);
+    runtime_util.create_thread(t_5_3, NULL, f_5_3);
+    runtime_util.create_thread(t_6_0, NULL, f_6_0);
+    runtime_util.create_thread(t_6_1, NULL, f_6_1);
+    runtime_util.create_thread(t_6_2, NULL, f_6_2);
+    runtime_util.create_thread(t_6_3, NULL, f_6_3);
+    runtime_util.create_thread(t_7_0, NULL, f_7_0);
+    runtime_util.create_thread(t_7_1, NULL, f_7_1);
+    runtime_util.create_thread(t_7_2, NULL, f_7_2);
+    runtime_util.create_thread(t_7_3, NULL, f_7_3);
 
-    return 0;
+    runtime_util.join_thread(t_0_0);
+    runtime_util.join_thread(t_0_1);
+    runtime_util.join_thread(t_0_2);
+    runtime_util.join_thread(t_0_3);
+    runtime_util.join_thread(t_1_0);
+    runtime_util.join_thread(t_1_1);
+    runtime_util.join_thread(t_1_2);
+    runtime_util.join_thread(t_1_3);
+    runtime_util.join_thread(t_2_0);
+    runtime_util.join_thread(t_2_1);
+    runtime_util.join_thread(t_2_2);
+    runtime_util.join_thread(t_2_3);
+    runtime_util.join_thread(t_3_0);
+    runtime_util.join_thread(t_3_1);
+    runtime_util.join_thread(t_3_2);
+    runtime_util.join_thread(t_3_3);
+    runtime_util.join_thread(t_4_0);
+    runtime_util.join_thread(t_4_1);
+    runtime_util.join_thread(t_4_2);
+    runtime_util.join_thread(t_4_3);
+    runtime_util.join_thread(t_5_0);
+    runtime_util.join_thread(t_5_1);
+    runtime_util.join_thread(t_5_2);
+    runtime_util.join_thread(t_5_3);
+    runtime_util.join_thread(t_6_0);
+    runtime_util.join_thread(t_6_1);
+    runtime_util.join_thread(t_6_2);
+    runtime_util.join_thread(t_6_3);
+    runtime_util.join_thread(t_7_0);
+    runtime_util.join_thread(t_7_1);
+    runtime_util.join_thread(t_7_2);
+    runtime_util.join_thread(t_7_3);
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cpu_common.h b/modules/cpu/src/runtime/cpu_common.h
deleted file mode 100644
index 60b87e5ccc..0000000000
--- a/modules/cpu/src/runtime/cpu_common.h
+++ /dev/null
@@ -1,188 +0,0 @@
-#pragma once
-#include "thread_pool.h"
-#include <functional>
-#include <math.h>
-#include <nncase/runtime/cpu/compiler_defs.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-BEGIN_NS_NNCASE_RT_MODULE(cpu)
-
-typedef struct nncase_method_table {
-    // float unary
-    float (*float_unary_abs)(float);
-    float (*float_unary_acos)(float);
-    float (*float_unary_acosh)(float);
-    float (*float_unary_asin)(float);
-    float (*float_unary_asinh)(float);
-    float (*float_unary_ceil)(float);
-    float (*float_unary_cos)(float);
-    float (*float_unary_cosh)(float);
-    float (*float_unary_exp)(float);
-    float (*float_unary_floor)(float);
-    float (*float_unary_log)(float);
-    float (*float_unary_logical_not)(float);
-    float (*float_unary_neg)(float);
-    float (*float_unary_round)(float);
-    float (*float_unary_rsqrt)(float);
-    float (*float_unary_sign)(float);
-    float (*float_unary_sin)(float);
-    float (*float_unary_sinh)(float);
-    float (*float_unary_sqrt)(float);
-    float (*float_unary_square)(float);
-    float (*float_unary_tanh)(float);
-    // float bianry
-    float (*float_binary_add)(float, float);
-    float (*float_binary_sub)(float, float);
-    float (*float_binary_mul)(float, float);
-    float (*float_binary_div)(float, float);
-    float (*float_binary_min)(float, float);
-    float (*float_binary_max)(float, float);
-    float (*float_binary_pow)(float, float);
-    float (*float_binary_logical_and)(float, float);
-    float (*float_binary_mod)(float, float);
-    // int32 bianry
-    int32_t (*int32_binary_add)(int32_t, int32_t);
-    int32_t (*int32_binary_sub)(int32_t, int32_t);
-    int32_t (*int32_binary_mul)(int32_t, int32_t);
-    int32_t (*int32_binary_div)(int32_t, int32_t);
-    int32_t (*int32_binary_min)(int32_t, int32_t);
-    int32_t (*int32_binary_max)(int32_t, int32_t);
-    int32_t (*int32_binary_pow)(int32_t, int32_t);
-    int32_t (*int32_binary_logical_and)(int32_t, int32_t);
-    int32_t (*int32_binary_mod)(int32_t, int32_t);
-    // int64 bianry
-    int64_t (*int64_binary_add)(int64_t, int64_t);
-    int64_t (*int64_binary_sub)(int64_t, int64_t);
-    int64_t (*int64_binary_mul)(int64_t, int64_t);
-    int64_t (*int64_binary_div)(int64_t, int64_t);
-    int64_t (*int64_binary_min)(int64_t, int64_t);
-    int64_t (*int64_binary_max)(int64_t, int64_t);
-    int64_t (*int64_binary_pow)(int64_t, int64_t);
-    int64_t (*int64_binary_logical_and)(int64_t, int64_t);
-    int64_t (*int64_binary_mod)(int64_t, int64_t);
-    // bool binary
-    bool (*bool_binary_and)(bool, bool);
-    bool (*bool_binary_or)(bool, bool);
-    bool (*bool_binary_xor)(bool, bool);
-
-    // multi-thread
-    void *(*thread_start)(void *(*callable)(void *), void *user,
-                          size_t user_size);
-    void *(*thread_end)();
-} nncase_mt_t;
-
-typedef struct buffer {
-    void *vaddr;
-    size_t paddr;
-    uint32_t *shape;
-    uint32_t *stride;
-    uint32_t rank;
-} buffer_t;
-
-inline float float_unary_logical_not(float x) { return !x; }
-inline float float_unary_neg(float x) { return std::negate<float>()(x); }
-inline float float_unary_rsqrt(float x) { return 1.f / sqrtf(x); }
-inline float float_unary_sign(float x) { return (0.f < x) - (x < 0.f); }
-inline float float_unary_square(float x) { return x * x; }
-
-inline float float_binary_add(float x, float y) { return x + y; }
-inline float float_binary_sub(float x, float y) { return x - y; }
-inline float float_binary_mul(float x, float y) { return x * y; }
-inline float float_binary_div(float x, float y) { return x / y; }
-inline float float_binary_min(float x, float y) { return std::min(x, y); }
-inline float float_binary_max(float x, float y) { return std::max(x, y); }
-inline float float_binary_pow(float x, float y) { return powf(x, y); }
-inline float float_binary_logical_and(float x, float y) { return x && y; }
-inline float float_binary_mod(float x, float y) { return fmod(x, y); }
-
-inline int32_t int32_binary_add(int32_t x, int32_t y) { return x + y; }
-inline int32_t int32_binary_sub(int32_t x, int32_t y) { return x - y; }
-inline int32_t int32_binary_mul(int32_t x, int32_t y) { return x * y; }
-inline int32_t int32_binary_div(int32_t x, int32_t y) { return x / y; }
-inline int32_t int32_binary_min(int32_t x, int32_t y) { return std::min(x, y); }
-inline int32_t int32_binary_max(int32_t x, int32_t y) { return std::max(x, y); }
-#if defined(__APPLE__)
-inline int32_t int32_binary_pow(int32_t x, int32_t y) {
-    return (int32_t)pow(x, y);
-}
-#else
-inline int32_t int32_binary_pow(int32_t x, int32_t y) { return std::pow(x, y); }
-#endif
-inline int32_t int32_binary_logical_and(int32_t x, int32_t y) { return x && y; }
-inline int32_t int32_binary_mod(int32_t x, int32_t y) { return x % y; }
-
-inline int64_t int64_binary_add(int64_t x, int64_t y) { return x + y; }
-inline int64_t int64_binary_sub(int64_t x, int64_t y) { return x - y; }
-inline int64_t int64_binary_mul(int64_t x, int64_t y) { return x * y; }
-inline int64_t int64_binary_div(int64_t x, int64_t y) { return x / y; }
-inline int64_t int64_binary_min(int64_t x, int64_t y) { return std::min(x, y); }
-inline int64_t int64_binary_max(int64_t x, int64_t y) { return std::max(x, y); }
-#if defined(__APPLE__)
-inline int64_t int64_binary_pow(int64_t x, int64_t y) {
-    return (int64_t)pow(x, y);
-}
-#else
-inline int64_t int64_binary_pow(int64_t x, int64_t y) { return std::pow(x, y); }
-#endif
-inline int64_t int64_binary_logical_and(int64_t x, int64_t y) { return x && y; }
-inline int64_t int64_binary_mod(int64_t x, int64_t y) { return x % y; }
-
-inline bool bool_binary_logical_and(bool x, bool y) { return x && y; }
-inline bool bool_binary_logical_or(bool x, bool y) { return x || y; }
-inline bool bool_binary_logical_xor(bool x, bool y) { return x ^ y; }
-
-[[maybe_unused]] static nncase_mt_t nncase_mt{fabsf,
-                                              acosf,
-                                              acoshf,
-                                              asinf,
-                                              asinhf,
-                                              ceilf,
-                                              cosf,
-                                              coshf,
-                                              expf,
-                                              floorf,
-                                              logf,
-                                              float_unary_logical_not,
-                                              float_unary_neg,
-                                              roundf,
-                                              float_unary_rsqrt,
-                                              float_unary_sign,
-                                              sinf,
-                                              sinhf,
-                                              sqrtf,
-                                              float_unary_square,
-                                              tanhf,
-                                              float_binary_add,
-                                              float_binary_sub,
-                                              float_binary_mul,
-                                              float_binary_div,
-                                              float_binary_min,
-                                              float_binary_max,
-                                              float_binary_pow,
-                                              float_binary_logical_and,
-                                              float_binary_mod,
-                                              int32_binary_add,
-                                              int32_binary_sub,
-                                              int32_binary_mul,
-                                              int32_binary_div,
-                                              int32_binary_min,
-                                              int32_binary_max,
-                                              int32_binary_pow,
-                                              int32_binary_logical_and,
-                                              int32_binary_mod,
-                                              int64_binary_add,
-                                              int64_binary_sub,
-                                              int64_binary_mul,
-                                              int64_binary_div,
-                                              int64_binary_min,
-                                              int64_binary_max,
-                                              int64_binary_pow,
-                                              int64_binary_logical_and,
-                                              int64_binary_mod,
-                                              bool_binary_logical_and,
-                                              bool_binary_logical_or,
-                                              bool_binary_logical_xor};
-
-END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/hardware_context.cpp b/modules/cpu/src/runtime/hardware_context.cpp
new file mode 100644
index 0000000000..d128bb67e5
--- /dev/null
+++ b/modules/cpu/src/runtime/hardware_context.cpp
@@ -0,0 +1,169 @@
+#include "hardware_context.h"
+#include "hardware_def.h"
+#include <pthread.h>
+
+using namespace nncase::runtime::cpu;
+std::unique_ptr<hardware_context_impl> hardware_context::impl_;
+
+class condition_variable
+{
+public:
+    condition_variable()
+    {
+        pthread_cond_init(&cond, NULL);
+        pthread_mutex_init(&mutex, NULL);
+    }
+
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+
+    ~condition_variable()
+    {
+        pthread_mutex_destroy(&mutex);
+        pthread_cond_destroy(&cond);
+    }
+};
+
+struct hardware_context_impl
+{
+public:
+    hardware_context_impl()
+    {
+        global_cond = condition_variable();
+        pthread_mutex_init(&global_mutex, NULL);
+
+        for (size_t i = 0; i < BLOCKS; i++)
+        {
+            pthread_mutex_init(&block_mutexs[i], NULL);
+            block_conds[i] = condition_variable();
+            for (size_t j = 0; j < CORES; j++)
+            {
+                block_visited[i][j] = false;
+                global_visited[i][j] = false;
+            }
+        }
+    }
+
+    void reset_block_visited(int bid)
+    {
+        for (size_t i = 0; i < CORES; i++)
+        {
+            block_visited[bid][i] = false;
+        }
+    }
+
+    void reset_global_visited()
+    {
+        for (size_t i = 0; i < BLOCKS; i++)
+        {
+            for (size_t j = 0; j < CORES; j++)
+            {
+                global_visited[i][j] = false;
+            }
+        }
+    }
+
+    pthread_mutex_t global_mutex;
+    condition_variable global_cond;
+    bool global_visited[BLOCKS][CORES];
+    pthread_mutex_t block_mutexs[BLOCKS];
+    condition_variable block_conds[BLOCKS];
+    bool block_visited[BLOCKS][CORES];
+
+    ~hardware_context_impl()
+    {
+        pthread_mutex_destroy(&global_mutex);
+        for (size_t i = 0; i < BLOCKS; i++)
+        {
+            pthread_mutex_destroy(&block_mutexs[i]);
+        }
+    }
+};
+
+void hardware_context::init()
+{
+    impl_ = std::make_unique<hardware_context_impl>();
+}
+
+void hardware_context::lock_block(int bid)
+{
+    pthread_mutex_lock(&impl_->block_mutexs[bid]);
+}
+
+void hardware_context::unlock_block(int bid)
+{
+    pthread_mutex_unlock(&impl_->block_mutexs[bid]);
+}
+
+int hardware_context::mark_block_visit(int bid, int tid)
+{
+    impl_->block_visited[bid][tid] = true;
+    int visited = 0;
+    for (size_t i = 0; i < CORES; i++)
+    {
+        visited += impl_->block_visited[bid][i] == true ? 1 : 0;
+    }
+    return visited;
+}
+
+void hardware_context::wait_block_sync(int bid, int visited,
+    std::function<void()> callable)
+{
+    pthread_mutex_lock(&impl_->block_conds[bid].mutex);
+    if (visited == CORES)
+    {
+        callable();
+        impl_->reset_block_visited(bid);
+        pthread_cond_broadcast(&impl_->block_conds[bid].cond);
+    }
+    else
+    {
+        pthread_cond_wait(&impl_->block_conds[bid].cond,
+            &impl_->block_conds[bid].mutex);
+    }
+    pthread_mutex_unlock(&impl_->block_conds[bid].mutex);
+}
+
+void hardware_context::lock_all() { pthread_mutex_lock(&impl_->global_mutex); }
+
+void hardware_context::unlock_all()
+{
+    pthread_mutex_unlock(&impl_->global_mutex);
+}
+
+int hardware_context::mark_all_visit(int bid, int tid)
+{
+    impl_->global_visited[bid][tid] = true;
+    int visited = 0;
+    for (size_t i = 0; i < BLOCKS; i++)
+    {
+        for (size_t j = 0; j < CORES; j++)
+        {
+            visited += impl_->global_visited[i][j] == true ? 1 : 0;
+        }
+    }
+    return visited;
+}
+
+void hardware_context::wait_all_sync(int visited,
+    std::function<void()> callable)
+{
+    pthread_mutex_lock(&impl_->global_cond.mutex);
+    if (visited == BLOCKS * CORES)
+    {
+        callable();
+        impl_->reset_global_visited();
+        pthread_cond_broadcast(&impl_->global_cond.cond);
+    }
+    else
+    {
+        pthread_cond_wait(&impl_->global_cond.cond, &impl_->global_cond.mutex);
+    }
+    pthread_mutex_unlock(&impl_->global_cond.mutex);
+}
+
+// std::unique_ptr<hardware_context> global_hardware_ctx = nullptr;
+
+// void global_hardware_init() {
+//     global_hardware_ctx = std::make_unique<hardware_context>();
+// }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/hardware_context.h b/modules/cpu/src/runtime/hardware_context.h
new file mode 100644
index 0000000000..d217430c57
--- /dev/null
+++ b/modules/cpu/src/runtime/hardware_context.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <nncase/runtime/cpu/compiler_defs.h>
+
+struct hardware_context_impl;
+
+BEGIN_NS_NNCASE_RT_MODULE(cpu)
+namespace hardware_context
+{
+void init();
+
+void lock_block(int bid);
+int mark_block_visit(int bid, int tid);
+void unlock_block(int bid);
+void wait_block_sync(
+    int bid, int visited, std::function<void()> callable = []() -> void {});
+void lock_all();
+int mark_all_visit(int bid, int tid);
+void unlock_all();
+void wait_all_sync(
+    int visited, std::function<void()> callable = []() -> void {});
+
+extern std::unique_ptr<hardware_context_impl> impl_;
+}
+END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/hardware_def.h b/modules/cpu/src/runtime/hardware_def.h
new file mode 100644
index 0000000000..9dfdcd946a
--- /dev/null
+++ b/modules/cpu/src/runtime/hardware_def.h
@@ -0,0 +1,5 @@
+#pragma once
+#include <stddef.h>
+
+constexpr size_t BLOCKS = 8;
+constexpr size_t CORES = 4;
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/io_utils.h b/modules/cpu/src/runtime/io_utils.h
new file mode 100644
index 0000000000..3918c1a3fe
--- /dev/null
+++ b/modules/cpu/src/runtime/io_utils.h
@@ -0,0 +1,28 @@
+#pragma once
+#include <filesystem>
+#include <fstream>
+#include <gsl/gsl-lite.hpp>
+#include <vector>
+
+inline std::vector<uint8_t> read_stream(std::istream &stream) {
+    stream.seekg(0, std::ios::end);
+    size_t length = stream.tellg();
+    stream.seekg(0, std::ios::beg);
+    std::vector<uint8_t> data(length);
+    stream.read(reinterpret_cast<char *>(data.data()), length);
+    return data;
+}
+
+inline std::vector<uint8_t> read_file(const std::filesystem::path &filename) {
+    std::ifstream infile(filename.string(), std::ios::binary | std::ios::in);
+    if (!infile.good())
+        throw std::runtime_error("Cannot open file: " + filename.string());
+    return read_stream(infile);
+}
+
+template <class T>
+inline void to_file(gsl::span<T> src, const std::filesystem::path &filename) {
+    std::ofstream ofile(filename.string(), std::ios::binary | std::ios::out);
+    ofile.write(src.template as_span<const char>().data(), src.size_bytes());
+    ofile.close();
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/method_table_def.h b/modules/cpu/src/runtime/method_table_def.h
new file mode 100644
index 0000000000..87563ff3e2
--- /dev/null
+++ b/modules/cpu/src/runtime/method_table_def.h
@@ -0,0 +1,105 @@
+#pragma once
+
+#include <functional>
+#include <nncase/runtime/cpu/compiler_defs.h>
+
+
+BEGIN_NS_NNCASE_RT_MODULE(cpu)
+
+typedef struct nncase_method_table {
+    // float unary
+    float (*float_unary_abs)(float);
+    float (*float_unary_acos)(float);
+    float (*float_unary_acosh)(float);
+    float (*float_unary_asin)(float);
+    float (*float_unary_asinh)(float);
+    float (*float_unary_ceil)(float);
+    float (*float_unary_cos)(float);
+    float (*float_unary_cosh)(float);
+    float (*float_unary_exp)(float);
+    float (*float_unary_floor)(float);
+    float (*float_unary_log)(float);
+    float (*float_unary_logical_not)(float);
+    float (*float_unary_neg)(float);
+    float (*float_unary_round)(float);
+    float (*float_unary_rsqrt)(float);
+    float (*float_unary_sign)(float);
+    float (*float_unary_sin)(float);
+    float (*float_unary_sinh)(float);
+    float (*float_unary_sqrt)(float);
+    float (*float_unary_square)(float);
+    float (*float_unary_tanh)(float);
+    // float bianry
+    float (*float_binary_add)(float, float);
+    float (*float_binary_sub)(float, float);
+    float (*float_binary_mul)(float, float);
+    float (*float_binary_div)(float, float);
+    float (*float_binary_min)(float, float);
+    float (*float_binary_max)(float, float);
+    float (*float_binary_pow)(float, float);
+    float (*float_binary_logical_and)(float, float);
+    float (*float_binary_mod)(float, float);
+    // int32 bianry
+    int32_t (*int32_binary_add)(int32_t, int32_t);
+    int32_t (*int32_binary_sub)(int32_t, int32_t);
+    int32_t (*int32_binary_mul)(int32_t, int32_t);
+    int32_t (*int32_binary_div)(int32_t, int32_t);
+    int32_t (*int32_binary_min)(int32_t, int32_t);
+    int32_t (*int32_binary_max)(int32_t, int32_t);
+    int32_t (*int32_binary_pow)(int32_t, int32_t);
+    int32_t (*int32_binary_logical_and)(int32_t, int32_t);
+    int32_t (*int32_binary_mod)(int32_t, int32_t);
+    // int64 bianry
+    int64_t (*int64_binary_add)(int64_t, int64_t);
+    int64_t (*int64_binary_sub)(int64_t, int64_t);
+    int64_t (*int64_binary_mul)(int64_t, int64_t);
+    int64_t (*int64_binary_div)(int64_t, int64_t);
+    int64_t (*int64_binary_min)(int64_t, int64_t);
+    int64_t (*int64_binary_max)(int64_t, int64_t);
+    int64_t (*int64_binary_pow)(int64_t, int64_t);
+    int64_t (*int64_binary_logical_and)(int64_t, int64_t);
+    int64_t (*int64_binary_mod)(int64_t, int64_t);
+    // bool binary
+    bool (*bool_binary_and)(bool, bool);
+    bool (*bool_binary_or)(bool, bool);
+    bool (*bool_binary_xor)(bool, bool);
+
+    // multi-thread
+    void *(*thread_start)(void *(*callable)(void *), void *user,
+                          size_t user_size);
+    void *(*thread_end)();
+} nncase_mt_t;
+
+typedef struct buffer {
+    void *vaddr;
+    size_t paddr;
+    uint32_t *shape;
+    uint32_t *stride;
+    uint32_t rank;
+} buffer_t;
+
+struct runtime_util_mt
+{
+    int (*printf)(const char *__restrict __format, ...);
+    void *(*malloc)(size_t size);
+    void (*free)(void *ptr);
+    void (*create_thread)(pthread_t &pt, void *param_, void *(*call)(void *));
+    void (*join_thread)(pthread_t &pt);
+    void (*rt_assert)(bool condition, char *message);
+};
+
+struct hardware_context_mt
+{
+    void (*lock_block)(int bid);
+    int (*mark_block_visit)(int bid, int tid);
+    void (*unlock_block)(int bid);
+    void (*wait_block_sync)(
+        int bid, int visited, std::function<void()> callable);
+    void (*lock_all)();
+    int (*mark_all_visit)(int bid, int tid);
+    void (*unlock_all)();
+    void (*wait_all_sync)(int visited, std::function<void()> callable);
+    void (*init)();
+};
+
+END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/method_table_impl.h b/modules/cpu/src/runtime/method_table_impl.h
new file mode 100644
index 0000000000..4ea5e7bccf
--- /dev/null
+++ b/modules/cpu/src/runtime/method_table_impl.h
@@ -0,0 +1,139 @@
+#pragma once
+#include "runtime_utils.h"
+#include "thread_pool.h"
+#include <functional>
+#include <math.h>
+#include <nncase/runtime/cpu/compiler_defs.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include "method_table_def.h"
+#include "hardware_context.h"
+
+BEGIN_NS_NNCASE_RT_MODULE(cpu)
+
+inline float float_unary_logical_not(float x) { return !x; }
+inline float float_unary_neg(float x) { return std::negate<float>()(x); }
+inline float float_unary_rsqrt(float x) { return 1.f / sqrtf(x); }
+inline float float_unary_sign(float x) { return (0.f < x) - (x < 0.f); }
+inline float float_unary_square(float x) { return x * x; }
+
+inline float float_binary_add(float x, float y) { return x + y; }
+inline float float_binary_sub(float x, float y) { return x - y; }
+inline float float_binary_mul(float x, float y) { return x * y; }
+inline float float_binary_div(float x, float y) { return x / y; }
+inline float float_binary_min(float x, float y) { return std::min(x, y); }
+inline float float_binary_max(float x, float y) { return std::max(x, y); }
+inline float float_binary_pow(float x, float y) { return powf(x, y); }
+inline float float_binary_logical_and(float x, float y) { return x && y; }
+inline float float_binary_mod(float x, float y) { return fmod(x, y); }
+
+inline int32_t int32_binary_add(int32_t x, int32_t y) { return x + y; }
+inline int32_t int32_binary_sub(int32_t x, int32_t y) { return x - y; }
+inline int32_t int32_binary_mul(int32_t x, int32_t y) { return x * y; }
+inline int32_t int32_binary_div(int32_t x, int32_t y) { return x / y; }
+inline int32_t int32_binary_min(int32_t x, int32_t y) { return std::min(x, y); }
+inline int32_t int32_binary_max(int32_t x, int32_t y) { return std::max(x, y); }
+#if defined(__APPLE__)
+inline int32_t int32_binary_pow(int32_t x, int32_t y) {
+    return (int32_t)pow(x, y);
+}
+#else
+inline int32_t int32_binary_pow(int32_t x, int32_t y) { return std::pow(x, y); }
+#endif
+inline int32_t int32_binary_logical_and(int32_t x, int32_t y) { return x && y; }
+inline int32_t int32_binary_mod(int32_t x, int32_t y) { return x % y; }
+
+inline int64_t int64_binary_add(int64_t x, int64_t y) { return x + y; }
+inline int64_t int64_binary_sub(int64_t x, int64_t y) { return x - y; }
+inline int64_t int64_binary_mul(int64_t x, int64_t y) { return x * y; }
+inline int64_t int64_binary_div(int64_t x, int64_t y) { return x / y; }
+inline int64_t int64_binary_min(int64_t x, int64_t y) { return std::min(x, y); }
+inline int64_t int64_binary_max(int64_t x, int64_t y) { return std::max(x, y); }
+#if defined(__APPLE__)
+inline int64_t int64_binary_pow(int64_t x, int64_t y) {
+    return (int64_t)pow(x, y);
+}
+#else
+inline int64_t int64_binary_pow(int64_t x, int64_t y) { return std::pow(x, y); }
+#endif
+inline int64_t int64_binary_logical_and(int64_t x, int64_t y) { return x && y; }
+inline int64_t int64_binary_mod(int64_t x, int64_t y) { return x % y; }
+
+inline bool bool_binary_logical_and(bool x, bool y) { return x && y; }
+inline bool bool_binary_logical_or(bool x, bool y) { return x || y; }
+inline bool bool_binary_logical_xor(bool x, bool y) { return x ^ y; }
+
+static nncase_mt_t nncase_mt = {fabsf,
+                                acosf,
+                                acoshf,
+                                asinf,
+                                asinhf,
+                                ceilf,
+                                cosf,
+                                coshf,
+                                expf,
+                                floorf,
+                                logf,
+                                float_unary_logical_not,
+                                float_unary_neg,
+                                roundf,
+                                float_unary_rsqrt,
+                                float_unary_sign,
+                                sinf,
+                                sinhf,
+                                sqrtf,
+                                float_unary_square,
+                                tanhf,
+                                float_binary_add,
+                                float_binary_sub,
+                                float_binary_mul,
+                                float_binary_div,
+                                float_binary_min,
+                                float_binary_max,
+                                float_binary_pow,
+                                float_binary_logical_and,
+                                float_binary_mod,
+                                int32_binary_add,
+                                int32_binary_sub,
+                                int32_binary_mul,
+                                int32_binary_div,
+                                int32_binary_min,
+                                int32_binary_max,
+                                int32_binary_pow,
+                                int32_binary_logical_and,
+                                int32_binary_mod,
+                                int64_binary_add,
+                                int64_binary_sub,
+                                int64_binary_mul,
+                                int64_binary_div,
+                                int64_binary_min,
+                                int64_binary_max,
+                                int64_binary_pow,
+                                int64_binary_logical_and,
+                                int64_binary_mod,
+                                bool_binary_logical_and,
+                                bool_binary_logical_or,
+                                bool_binary_logical_xor};
+
+static runtime_util_mt runtime_util = {
+    printf, malloc,
+    free,
+    create_thread,
+    join_thread,
+    rt_assert
+};
+
+static hardware_context_mt hw_ctx_mt = {
+    hardware_context::lock_block,
+    hardware_context::mark_block_visit,
+    hardware_context::unlock_block,
+    hardware_context::wait_block_sync,
+    hardware_context::lock_all,
+    hardware_context::mark_all_visit,
+    hardware_context::unlock_all,
+    hardware_context::wait_all_sync,
+    hardware_context::init
+};
+
+END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/runtime_types.h b/modules/cpu/src/runtime/runtime_types.h
new file mode 100644
index 0000000000..0fa69d7913
--- /dev/null
+++ b/modules/cpu/src/runtime/runtime_types.h
@@ -0,0 +1,52 @@
+#pragma once
+#include <nncase/runtime/small_vector.hpp>
+
+using dims_t = itlib::small_vector<size_t, 8>;
+using strides_t = itlib::small_vector<size_t, 8>;
+using axes_t = itlib::small_vector<int64_t, 8>;
+
+enum class unary_op_t : uint8_t {
+    abs = 0,
+    acos = 1,
+    acosh = 2,
+    asin = 3,
+    asinh = 4,
+    ceil = 5,
+    cos = 6,
+    cosh = 7,
+    exp = 8,
+    floor = 9,
+    log = 10,
+    neg = 11,
+    round = 12,
+    rsqrt = 13,
+    sin = 14,
+    sinh = 15,
+    sign = 16,
+    sqrt = 17,
+    square = 18,
+    tanh = 19,
+    bitwise_not = 20,
+    logical_not = 21,
+    swish = 22
+};
+
+enum class binary_op_t : uint8_t {
+    add = 0,
+    sub = 1,
+    mul = 2,
+    div = 3,
+    mod = 4,
+    min = 5,
+    max = 6,
+    pow = 7,
+    bitwise_and = 8,
+    bitwise_or = 9,
+    bitwise_xor = 10,
+    logical_and = 11,
+    logical_or = 12,
+    logical_xor = 13,
+    left_shift = 14,
+    right_shift = 15,
+    idenity_a = 16,
+};
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/runtime_utils.h b/modules/cpu/src/runtime/runtime_utils.h
new file mode 100644
index 0000000000..73d4698e73
--- /dev/null
+++ b/modules/cpu/src/runtime/runtime_utils.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "runtime_types.h"
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <gsl/gsl-lite.hpp>
+#include <iostream>
+#include <linux/limits.h>
+#include <numeric>
+#include <vector>
+#include <nncase/runtime/cpu/compiler_defs.h>
+
+
+BEGIN_NS_NNCASE_RT_MODULE(cpu)
+inline void create_thread(pthread_t &pt, void *param_, void *(*call)(void *))
+{
+    void *(*new_call)(void *) = call; // + (intptr_t)buf;
+    int ret = pthread_create(&pt, NULL, new_call, param_);
+    if (ret != 0)
+    {
+        printf("thread create failed\n");
+    }
+}
+
+inline void join_thread(pthread_t &pt)
+{
+    pthread_join(pt, NULL);
+}
+
+inline void rt_assert(bool condition, char *message)
+{
+    assert(condition && message);
+}
+END_NS_NNCASE_RT_MODULE
\ No newline at end of file

From f04a62e6a5708477d718065446964a1c17c5bc6b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 6 Sep 2023 14:04:10 +0800
Subject: [PATCH 153/308] update demo head

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |   2 +-
 .../src/runtime/cmodel/tests/head/main.cpp    | 180 ++++++++----------
 2 files changed, 84 insertions(+), 98 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index 55f9a4460e..053c023899 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -41,4 +41,4 @@ endfunction(add_test)
 add_test(demo4 tests/demo4)
 add_test(norm tests/norm)
 # add_test(embed tests/embed)
-# add_test(head tests/head)
+add_test(head tests/head)
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
index 3e4b979126..112e5d4955 100644
--- a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
@@ -1,11 +1,9 @@
 #include "cluster_def.h"
-#include <io_utils.h>
 #include <runtime_utils.h>
-// #include <pthread.h>
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(Hidden_in, W, Output);     \
+        block##b::thread##t::stage1_kernel(*Hidden_in, *W, *Output);           \
         return arg;                                                            \
     }
 
@@ -15,9 +13,9 @@
     DEFINE_TFUNC(b, 2)                                                         \
     DEFINE_TFUNC(b, 3)
 
-static tensor<float, loc_t::device> Hidden_in({1, 384, 8192});
-static tensor<float, loc_t::device> W({8192, 32000});
-static tensor<float, loc_t::device> Output({1, 384, 32000});
+static tensor<float, loc_t::device> *Hidden_in; // {1, 384, 8192}
+static tensor<float, loc_t::device> *W;         // {8192, 32000}
+static tensor<float, loc_t::device> *Output;    // {1, 384, 32000}
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
@@ -28,104 +26,92 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
-#define LOAD_FILE(name, i, type)                                               \
-    {                                                                          \
-        auto src_##name = read_file(std::string(argv[(i)]));                   \
-        span_copy(name.data(), gsl::make_span(src_##name).as_span<type>());    \
-    }
+void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
+    global_hardware_init(hw_ctx_impl);
+    runtime_util = *rt_util_mt;
+    nncase_mt = *nncase_mt_impl;
+
+    auto input0 = tensor<float, loc_t::device>(
+        gsl::make_span((float *)inputs[0], 384 * 8192), {1, 384, 8192});
+    Hidden_in = &input0;
 
-/**
- * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
- *
- * @param argc
- * @param argv
- * @return int
- */
-int main([[maybe_unused]] int argc, char **argv) {
-    // spdlog::set_level(spdlog::level::debug);
-    global_hardware_init();
+    auto input1 = tensor<float, loc_t::device>(
+        gsl::make_span((float *)inputs[0], 8192 * 32000), {8192, 32000});
+    W = &input0;
 
-    LOAD_FILE(Hidden_in, 1, float);
-    LOAD_FILE(W, 2, float);
+    auto input2 = tensor<float, loc_t::device>(
+        gsl::make_span((float *)inputs[0], 384 * 32000), {1, 384, 32000});
+    Output = &input0;
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
     pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
     pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
-    pthread_create(&t_0_0, NULL, f_0_0, NULL);
-    pthread_create(&t_0_1, NULL, f_0_1, NULL);
-    pthread_create(&t_0_2, NULL, f_0_2, NULL);
-    pthread_create(&t_0_3, NULL, f_0_3, NULL);
-    pthread_create(&t_1_0, NULL, f_1_0, NULL);
-    pthread_create(&t_1_1, NULL, f_1_1, NULL);
-    pthread_create(&t_1_2, NULL, f_1_2, NULL);
-    pthread_create(&t_1_3, NULL, f_1_3, NULL);
-    pthread_create(&t_2_0, NULL, f_2_0, NULL);
-    pthread_create(&t_2_1, NULL, f_2_1, NULL);
-    pthread_create(&t_2_2, NULL, f_2_2, NULL);
-    pthread_create(&t_2_3, NULL, f_2_3, NULL);
-    pthread_create(&t_3_0, NULL, f_3_0, NULL);
-    pthread_create(&t_3_1, NULL, f_3_1, NULL);
-    pthread_create(&t_3_2, NULL, f_3_2, NULL);
-    pthread_create(&t_3_3, NULL, f_3_3, NULL);
-    pthread_create(&t_4_0, NULL, f_4_0, NULL);
-    pthread_create(&t_4_1, NULL, f_4_1, NULL);
-    pthread_create(&t_4_2, NULL, f_4_2, NULL);
-    pthread_create(&t_4_3, NULL, f_4_3, NULL);
-    pthread_create(&t_5_0, NULL, f_5_0, NULL);
-    pthread_create(&t_5_1, NULL, f_5_1, NULL);
-    pthread_create(&t_5_2, NULL, f_5_2, NULL);
-    pthread_create(&t_5_3, NULL, f_5_3, NULL);
-    pthread_create(&t_6_0, NULL, f_6_0, NULL);
-    pthread_create(&t_6_1, NULL, f_6_1, NULL);
-    pthread_create(&t_6_2, NULL, f_6_2, NULL);
-    pthread_create(&t_6_3, NULL, f_6_3, NULL);
-    pthread_create(&t_7_0, NULL, f_7_0, NULL);
-    pthread_create(&t_7_1, NULL, f_7_1, NULL);
-    pthread_create(&t_7_2, NULL, f_7_2, NULL);
-    pthread_create(&t_7_3, NULL, f_7_3, NULL);
-
-    pthread_join(t_0_0, NULL);
-    pthread_join(t_0_1, NULL);
-    pthread_join(t_0_2, NULL);
-    pthread_join(t_0_3, NULL);
-    pthread_join(t_1_0, NULL);
-    pthread_join(t_1_1, NULL);
-    pthread_join(t_1_2, NULL);
-    pthread_join(t_1_3, NULL);
-    pthread_join(t_2_0, NULL);
-    pthread_join(t_2_1, NULL);
-    pthread_join(t_2_2, NULL);
-    pthread_join(t_2_3, NULL);
-    pthread_join(t_3_0, NULL);
-    pthread_join(t_3_1, NULL);
-    pthread_join(t_3_2, NULL);
-    pthread_join(t_3_3, NULL);
-    pthread_join(t_4_0, NULL);
-    pthread_join(t_4_1, NULL);
-    pthread_join(t_4_2, NULL);
-    pthread_join(t_4_3, NULL);
-    pthread_join(t_5_0, NULL);
-    pthread_join(t_5_1, NULL);
-    pthread_join(t_5_2, NULL);
-    pthread_join(t_5_3, NULL);
-    pthread_join(t_6_0, NULL);
-    pthread_join(t_6_1, NULL);
-    pthread_join(t_6_2, NULL);
-    pthread_join(t_6_3, NULL);
-    pthread_join(t_7_0, NULL);
-    pthread_join(t_7_1, NULL);
-    pthread_join(t_7_2, NULL);
-    pthread_join(t_7_3, NULL);
-
-    {
-        auto src_output = read_file(std::string(argv[3]));
-        auto src_span = gsl::make_span(src_output).as_span<float>();
-        auto cos =
-            cosine(Output.data().data(), src_span.data(), src_span.size());
-        printf("Output cosine %f\n", cos);
-    }
+    runtime_util.create_thread(t_0_0, NULL, f_0_0);
+    runtime_util.create_thread(t_0_1, NULL, f_0_1);
+    runtime_util.create_thread(t_0_2, NULL, f_0_2);
+    runtime_util.create_thread(t_0_3, NULL, f_0_3);
+    runtime_util.create_thread(t_1_0, NULL, f_1_0);
+    runtime_util.create_thread(t_1_1, NULL, f_1_1);
+    runtime_util.create_thread(t_1_2, NULL, f_1_2);
+    runtime_util.create_thread(t_1_3, NULL, f_1_3);
+    runtime_util.create_thread(t_2_0, NULL, f_2_0);
+    runtime_util.create_thread(t_2_1, NULL, f_2_1);
+    runtime_util.create_thread(t_2_2, NULL, f_2_2);
+    runtime_util.create_thread(t_2_3, NULL, f_2_3);
+    runtime_util.create_thread(t_3_0, NULL, f_3_0);
+    runtime_util.create_thread(t_3_1, NULL, f_3_1);
+    runtime_util.create_thread(t_3_2, NULL, f_3_2);
+    runtime_util.create_thread(t_3_3, NULL, f_3_3);
+    runtime_util.create_thread(t_4_0, NULL, f_4_0);
+    runtime_util.create_thread(t_4_1, NULL, f_4_1);
+    runtime_util.create_thread(t_4_2, NULL, f_4_2);
+    runtime_util.create_thread(t_4_3, NULL, f_4_3);
+    runtime_util.create_thread(t_5_0, NULL, f_5_0);
+    runtime_util.create_thread(t_5_1, NULL, f_5_1);
+    runtime_util.create_thread(t_5_2, NULL, f_5_2);
+    runtime_util.create_thread(t_5_3, NULL, f_5_3);
+    runtime_util.create_thread(t_6_0, NULL, f_6_0);
+    runtime_util.create_thread(t_6_1, NULL, f_6_1);
+    runtime_util.create_thread(t_6_2, NULL, f_6_2);
+    runtime_util.create_thread(t_6_3, NULL, f_6_3);
+    runtime_util.create_thread(t_7_0, NULL, f_7_0);
+    runtime_util.create_thread(t_7_1, NULL, f_7_1);
+    runtime_util.create_thread(t_7_2, NULL, f_7_2);
+    runtime_util.create_thread(t_7_3, NULL, f_7_3);
 
-    return 0;
+    runtime_util.join_thread(t_0_0);
+    runtime_util.join_thread(t_0_1);
+    runtime_util.join_thread(t_0_2);
+    runtime_util.join_thread(t_0_3);
+    runtime_util.join_thread(t_1_0);
+    runtime_util.join_thread(t_1_1);
+    runtime_util.join_thread(t_1_2);
+    runtime_util.join_thread(t_1_3);
+    runtime_util.join_thread(t_2_0);
+    runtime_util.join_thread(t_2_1);
+    runtime_util.join_thread(t_2_2);
+    runtime_util.join_thread(t_2_3);
+    runtime_util.join_thread(t_3_0);
+    runtime_util.join_thread(t_3_1);
+    runtime_util.join_thread(t_3_2);
+    runtime_util.join_thread(t_3_3);
+    runtime_util.join_thread(t_4_0);
+    runtime_util.join_thread(t_4_1);
+    runtime_util.join_thread(t_4_2);
+    runtime_util.join_thread(t_4_3);
+    runtime_util.join_thread(t_5_0);
+    runtime_util.join_thread(t_5_1);
+    runtime_util.join_thread(t_5_2);
+    runtime_util.join_thread(t_5_3);
+    runtime_util.join_thread(t_6_0);
+    runtime_util.join_thread(t_6_1);
+    runtime_util.join_thread(t_6_2);
+    runtime_util.join_thread(t_6_3);
+    runtime_util.join_thread(t_7_0);
+    runtime_util.join_thread(t_7_1);
+    runtime_util.join_thread(t_7_2);
+    runtime_util.join_thread(t_7_3);
 }
\ No newline at end of file

From bf724aac5032ddc5a549718dcae7a15714136458 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 6 Sep 2023 14:16:38 +0800
Subject: [PATCH 154/308] pass graph to tir

---
 .../Evaluator/CPU/CPUModule.cs                |   3 +
 .../Evaluator/CPU/TDMALoadEvaluator.cs        |  17 ++
 .../Evaluator/CPU/TDMAStoreEvaluator.cs       |  17 ++
 .../Evaluator/CPU/UnaryEvaluator.cs           |  18 ++
 .../Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs  |   3 +
 .../Nncase.Modules.CPU/IR/CPU/Functional.cs   |  16 +-
 modules/Nncase.Modules.CPU/IR/CPU/TDMALoad.cs |  11 +
 .../Nncase.Modules.CPU/IR/CPU/TDMAStore.cs    |  13 ++
 modules/Nncase.Modules.CPU/IR/CPU/Unary.cs    |  19 ++
 .../Passes/Rules/DumpConst.cs                 | 149 ++++++-------
 .../Passes/Rules/MHACombine.cs                |  70 +++---
 .../Passes/Rules/MHAFusion.cs                 |   4 +-
 .../Passes/Tile/CPUFusionGroupMutator.cs      |   4 +-
 .../Passes/Tile/SingleCPUFusionConverter.cs   | 210 +++++++++++++++---
 .../Passes/Tile/TileOptions.cs                |   7 +-
 nncase.sln                                    |   2 -
 src/Nncase.Compiler/Compiler.cs               |   1 +
 src/Nncase.Core/DistTensorType.cs             | 101 +++++++++
 src/Nncase.Core/DistributeUtilities.cs        |  71 ++++++
 src/Nncase.Core/IR/ExprFunctor.cs             |  10 +
 src/Nncase.Core/IR/IRType.cs                  |   9 +
 src/Nncase.Core/IR/Op.cs                      |   2 +-
 src/Nncase.Core/IR/Tensors/Boxing.cs          |  29 +++
 src/Nncase.Core/IR/Tensors/Functional.cs      |   3 +
 src/Nncase.Core/IR/TypeFunctor.cs             |   9 +
 src/Nncase.Core/LinqExtensions.cs             |  15 ++
 .../Diagnostics/ILPrintVisitor.cs             |  27 +++
 src/Nncase.Evaluator/Math/Unary.cs            |  50 ++++-
 .../Tensors/BoxingEvaluator.cs                |  52 +++++
 src/Nncase.Evaluator/Tensors/TensorsModule.cs |   1 +
 src/Nncase.Evaluator/TypeInference.cs         |  19 ++
 src/Nncase.Evaluator/TypeInferenceVisitor.cs  |   2 +-
 src/Nncase.Tests/Core/UnitTestExpression.cs   |  16 ++
 .../Distributed/UnitTestDistTensor.cs         |  96 ++++++++
 .../Targets/UnitTestCPUTargetTiling.cs        |   9 +-
 35 files changed, 913 insertions(+), 172 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/CPU/TDMALoadEvaluator.cs
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/CPU/TDMAStoreEvaluator.cs
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/CPU/UnaryEvaluator.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/CPU/TDMALoad.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/CPU/TDMAStore.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/CPU/Unary.cs
 create mode 100644 src/Nncase.Core/DistTensorType.cs
 create mode 100644 src/Nncase.Core/DistributeUtilities.cs
 create mode 100644 src/Nncase.Core/IR/Tensors/Boxing.cs
 create mode 100644 src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
 create mode 100644 src/Nncase.Tests/Distributed/UnitTestDistTensor.cs

diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
index aa01122091..41f7df8b4e 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
@@ -14,5 +14,8 @@ internal class CPUModule : IApplicationPart
     public void ConfigureServices(IRegistrator registrator)
     {
         registrator.RegisterManyInterface<CPUKernelOpEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<TDMALoadEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<TDMAStoreEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<UnaryEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/TDMALoadEvaluator.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/TDMALoadEvaluator.cs
new file mode 100644
index 0000000000..bd92d7e349
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/TDMALoadEvaluator.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.CPU;
+
+namespace Nncase.Evaluator.CPU;
+
+public class TDMALoadEvaluator : ITypeInferencer<TDMALoad>
+{
+    public IRType Visit(ITypeInferenceContext context, TDMALoad target)
+    {
+        var inType = context.CheckArgumentType<TensorType>(target, TDMALoad.Input);
+        var outType = context.CheckArgumentType<TensorType>(target, TDMALoad.Output);
+        return TupleType.Void;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/TDMAStoreEvaluator.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/TDMAStoreEvaluator.cs
new file mode 100644
index 0000000000..b30e06a3bb
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/TDMAStoreEvaluator.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+
+using Nncase.IR;
+
+namespace Nncase.Evaluator.CPU;
+
+public sealed class TDMAStoreEvaluator : ITypeInferencer<TDMAStore>
+{
+    public IRType Visit(ITypeInferenceContext context, TDMAStore target)
+    {
+        var inType = context.CheckArgumentType<TensorType>(target, TDMAStore.Input);
+        var outType = context.CheckArgumentType<TensorType>(target, TDMAStore.Output);
+        return TupleType.Void;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/UnaryEvaluator.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/UnaryEvaluator.cs
new file mode 100644
index 0000000000..15d584e81a
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/UnaryEvaluator.cs
@@ -0,0 +1,18 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.Evaluator;
+using Nncase.IR;
+using Nncase.IR.CPU;
+
+namespace Nncase;
+
+public sealed class UnaryEvaluator : ITypeInferencer<Unary>
+{
+    public IRType Visit(ITypeInferenceContext context, Unary target)
+    {
+        context.CheckArgumentType<TensorType>(target, Unary.Input);
+        context.CheckArgumentType<TensorType>(target, Unary.Output);
+        return TupleType.Void;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs b/modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs
index 1113d70e55..173b6ffeef 100644
--- a/modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs
+++ b/modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs
@@ -19,5 +19,8 @@ public sealed partial class CPUKernelOp : Op
     /// </summary>
     public Op Target { get; }
 
+    /// <inheritdoc/>
+    public override IEnumerable<ParameterInfo> Parameters => Target.Parameters;
+
     public override string DisplayProperty() => Target.GetType().Name;
 }
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
index 52869d0153..a69c97de6a 100644
--- a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
@@ -7,7 +7,6 @@
 using System.Text;
 using System.Threading.Tasks;
 using Nncase.IR.CPU;
-using Nncase.IR.Math;
 
 namespace Nncase.IR.F;
 
@@ -23,4 +22,19 @@ public static Call CPUKernel(Op target, params Expr[] inputs)
     {
         return new Call(new CPUKernelOp(target), inputs);
     }
+
+    public static Call TDMALoad(Expr input, Expr output)
+    {
+        return new Call(new TDMALoad(), input, output);
+    }
+
+    public static Call TDMAStore(Expr input, Expr output)
+    {
+        return new Call(new TDMAStore(), input, output);
+    }
+
+    public static Call Unary(UnaryOp unaryOp, Expr input, Expr output)
+    {
+        return new Call(new Unary(unaryOp), input, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/TDMALoad.cs b/modules/Nncase.Modules.CPU/IR/CPU/TDMALoad.cs
new file mode 100644
index 0000000000..f4b80f5866
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/CPU/TDMALoad.cs
@@ -0,0 +1,11 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.CPU;
+
+public sealed class TDMALoad : Op
+{
+    public static readonly ParameterInfo Input = new(typeof(TDMALoad), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(TDMALoad), 1, "output");
+}
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/TDMAStore.cs b/modules/Nncase.Modules.CPU/IR/CPU/TDMAStore.cs
new file mode 100644
index 0000000000..a56ac8830c
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/CPU/TDMAStore.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+
+namespace Nncase;
+
+public sealed class TDMAStore : Op
+{
+    public static readonly ParameterInfo Input = new(typeof(TDMAStore), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(TDMAStore), 1, "output");
+}
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/Unary.cs b/modules/Nncase.Modules.CPU/IR/CPU/Unary.cs
new file mode 100644
index 0000000000..a76756e011
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/CPU/Unary.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.CPU;
+
+public sealed partial class Unary : Op
+{
+    public static readonly ParameterInfo Input = new(typeof(Unary), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(Unary), 1, "output");
+
+    public UnaryOp UnaryOp { get; }
+
+    /// <inheritdoc/>
+    public override string DisplayProperty()
+    {
+        return $"UnaryOp.{UnaryOp}";
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/DumpConst.cs b/modules/Nncase.Modules.CPU/Passes/Rules/DumpConst.cs
index ff18ef592a..50c0b3fc82 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/DumpConst.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/DumpConst.cs
@@ -3,12 +3,15 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.SymbolStore;
 using System.Linq;
 using System.Reactive;
 using System.Text;
 using System.Threading.Tasks;
+using Nncase.Diagnostics;
 using Nncase.IR;
 using Nncase.IR.CPU;
+using Nncase.IR.F;
 using Nncase.IR.Math;
 using Nncase.IR.NN;
 using Nncase.IR.Tensors;
@@ -22,40 +25,34 @@
 using static Nncase.PatternMatch.Utility;
 using static Nncase.Utilities.ReplaceUtility;
 
-using Nncase.IR.F;
-using Nncase.Diagnostics;
-using System.Diagnostics.SymbolStore;
-
 namespace Nncase.Passes.Rules;
 
-
 /// <summary>
 /// Dump Weights of MM.
 /// </summary>
 [RuleGenerator]
 public sealed partial class DumpMM : IRewriteRule
 {
-	public IPattern Pattern { get; } =
-			IsMatMul(
-				"mm",
-				"mmCall",
-				_ => true,
-				IsWildcard("x"),
-			IsTensorConst("w"));
-
-
-	private Expr? GetReplace(Expr x, Call mmCall, TensorConst w)
-	{
-		var name = mmCall.Metadata.OutputNames?[0].Replace('/', '_') + "_weights.bin";
-		var dir = DumpScope.Current.Directory;
-		Directory.CreateDirectory(dir);
-		using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name), FileMode.Create)))
-		{
-			bw.Write(w.Value.BytesBuffer);
-		}
-
-		return null;
-	}
+    public IPattern Pattern { get; } =
+            IsMatMul(
+                "mm",
+                "mmCall",
+                _ => true,
+                IsWildcard("x"),
+                IsTensorConst("w"));
+
+    private Expr? GetReplace(Expr x, Call mmCall, TensorConst w)
+    {
+        var name = mmCall.Metadata.OutputNames?[0].Replace('/', '_') + "_weights.bin";
+        var dir = DumpScope.Current.Directory;
+        Directory.CreateDirectory(dir);
+        using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name), FileMode.Create)))
+        {
+            bw.Write(w.Value.BytesBuffer);
+        }
+
+        return null;
+    }
 }
 
 /// <summary>
@@ -64,34 +61,33 @@ public sealed partial class DumpMM : IRewriteRule
 [RuleGenerator]
 public sealed partial class DumpLayerNorm : IRewriteRule
 {
-	public IPattern Pattern { get; } =
-			IsLayerNorm(
-				"ln",
-				"lnCall",
-				_ => true,
-				IsWildcard("x"),
-			IsTensorConst("scale"),
-			IsTensorConst("bias"));
-
-
-	private Expr? GetReplace(Call lnCall, TensorConst scale, TensorConst bias)
-	{
-		var name = lnCall.Metadata.OutputNames?[0].Replace('/', '_');
-		var dir = DumpScope.Current.Directory;
-		Directory.CreateDirectory(dir);
-
-		using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name + "_scale.bin"), FileMode.Create)))
-		{
-			bw.Write(scale.Value.BytesBuffer);
-		}
-
-		using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name + "_bias.bin"), FileMode.Create)))
-		{
-			bw.Write(bias.Value.BytesBuffer);
-		}
-
-		return null;
-	}
+    public IPattern Pattern { get; } =
+            IsLayerNorm(
+                "ln",
+                "lnCall",
+                _ => true,
+                IsWildcard("x"),
+                IsTensorConst("scale"),
+                IsTensorConst("bias"));
+
+    private Expr? GetReplace(Call lnCall, TensorConst scale, TensorConst bias)
+    {
+        var name = lnCall.Metadata.OutputNames?[0].Replace('/', '_');
+        var dir = DumpScope.Current.Directory;
+        Directory.CreateDirectory(dir);
+
+        using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name + "_scale.bin"), FileMode.Create)))
+        {
+            bw.Write(scale.Value.BytesBuffer);
+        }
+
+        using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name + "_bias.bin"), FileMode.Create)))
+        {
+            bw.Write(bias.Value.BytesBuffer);
+        }
+
+        return null;
+    }
 }
 
 /// <summary>
@@ -100,26 +96,25 @@ public sealed partial class DumpLayerNorm : IRewriteRule
 [RuleGenerator]
 public sealed partial class DumpGather : IRewriteRule
 {
-	public IPattern Pattern { get; } =
-			IsGather(
-				"gather",
-				"gatherCall",
-				_ => true,
-			IsTensorConst("data"),
-				IsWildcard("index"));
-
-
-	private Expr? GetReplace(Call gatherCall, TensorConst data)
-	{
-		var name = gatherCall.Metadata.OutputNames?[0].Replace('/', '_') + "_data.bin";
-		var dir = DumpScope.Current.Directory;
-		Directory.CreateDirectory(dir);
-
-		using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name), FileMode.Create)))
-		{
-			bw.Write(data.Value.BytesBuffer);
-		}
-
-		return null;
-	}
-}
\ No newline at end of file
+    public IPattern Pattern { get; } =
+            IsGather(
+                "gather",
+                "gatherCall",
+                _ => true,
+                IsTensorConst("data"),
+                IsWildcard("index"));
+
+    private Expr? GetReplace(Call gatherCall, TensorConst data)
+    {
+        var name = gatherCall.Metadata.OutputNames?[0].Replace('/', '_') + "_data.bin";
+        var dir = DumpScope.Current.Directory;
+        Directory.CreateDirectory(dir);
+
+        using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name), FileMode.Create)))
+        {
+            bw.Write(data.Value.BytesBuffer);
+        }
+
+        return null;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs
index 017b1ffd61..3d883c66f5 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs
@@ -9,6 +9,7 @@
 using System.Threading.Tasks;
 using Nncase.IR;
 using Nncase.IR.CPU;
+using Nncase.IR.F;
 using Nncase.IR.Math;
 using Nncase.IR.NN;
 using Nncase.IR.Tensors;
@@ -21,50 +22,49 @@
 using static Nncase.PatternMatch.Utility;
 using static Nncase.Utilities.ReplaceUtility;
 
-using Nncase.IR.F;
-
 namespace Nncase.Passes.Rules;
 
-
 /// <summary>
 /// Convert QKV computation to MHA style.
 /// </summary>
 [RuleGenerator]
 public sealed partial class MHACombine : IRewriteRule
 {
-	public IPattern Pattern { get; } =
+    public IPattern Pattern { get; } =
         IsTranspose(
-		"tp",
-		"tpCall",
-		_ => true,
-		IsReshape(
-			"rshape",
-			"rshapeCall",
-			_ => true,
-			IsMatMul(
-				"mm",
-				"mmCall",
-				_ => true,
-				IsWildcard("x"),
-			IsTensorConst("w")),
-			IsTensorConst("newShape")),
-		IsTensorConst("perm")) with {TypePattern = HasFixedShape()};
+        "tp",
+        "tpCall",
+        _ => true,
+        IsReshape(
+            "rshape",
+            "rshapeCall",
+            _ => true,
+            IsMatMul(
+                "mm",
+                "mmCall",
+                _ => true,
+                IsWildcard("x"),
+                IsTensorConst("w")),
+            IsTensorConst("newShape")),
+        IsTensorConst("perm")) with
+        { TypePattern = HasFixedShape() };
+
+    private Expr? GetReplace(Expr x, Call mmCall, Call rshapeCall, Call tpCall, TensorConst w, TensorConst newShape, TensorConst perm)
+    {
+        var mmOutShape = mmCall.CheckedShape.ToValueArray();
+        var wReshape = newShape.Value.ToArray<int>().TakeLast(2).ToArray();
 
-	private Expr? GetReplace(Expr x, Call mmCall, Call rshapeCall, Call tpCall, TensorConst w, TensorConst newShape, TensorConst perm)
-	{
-		var mmOutShape = mmCall.CheckedShape.ToValueArray();
-		var wReshape = newShape.Value.ToArray<int>().TakeLast(2).ToArray();
+        // TODO: add more patterns, only llama65b for now
+        if (perm.CheckedShape.Size == 4
+            && perm.Value.ToArray<int>().SequenceEqual(new[] { 0, 2, 1, 3 })
+             && wReshape.Aggregate(1, (x, y) => x * y) == mmOutShape[^1]
+             && (mmOutShape.Length == 2 || (mmOutShape.Length == 3 && mmOutShape[0] == 1)))
+        {
+            var newW = Tensors.Transpose(Tensors.Reshape(w, new[] { -1, wReshape[0], wReshape[1] }), new[] { 1, 0, 2 });
+            var newMm = Tensors.MatMul(Tensors.Unsqueeze(x, new[] { 1 }), newW);
+            return newMm;
+        }
 
-		// TODO: add more patterns, only llama65b for now
-		if (perm.CheckedShape.Size == 4
-			&& perm.Value.ToArray<int>().SequenceEqual(new[] { 0, 2, 1, 3 })
-		 	&& wReshape.Aggregate(1, (x, y) => x * y) == mmOutShape[^1]
-		 	&& (mmOutShape.Length == 2 || (mmOutShape.Length == 3 && mmOutShape[0] == 1)))
-		{
-			var newW = Tensors.Transpose(Tensors.Reshape(w, new[] { -1, wReshape[0], wReshape[1] }), new[] { 1, 0, 2 });
-			var newMm = Tensors.MatMul(Tensors.Unsqueeze(x, new[] { 1 }), newW);
-			return newMm;
-		}
-		return null;
-	}
+        return null;
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index b5fb4d042b..68d073b8c0 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -149,7 +149,7 @@ private static Pattern CreatePattern()
         var v17 = IsTensorConst("v17");
         var v18 = IsTensorConst("v18");
         var v19 = IsCall("v19", IsOp<Slice>(), IsVArgs(v7, v15, v16, v17, v18));
-        var v20 = IsCall("v20", IsOp<Unary>(), IsVArgs(v19));
+        var v20 = IsCall("v20", IsOp<IR.Math.Unary>(), IsVArgs(v19));
         var v21 = IsTensorConst("v21");
         var v22 = IsCall("v22", IsOp<Slice>(), IsVArgs(v7, v21, v15, v17, v18));
         var v23 = IsTuple("v23", IsVArgs(v20, v22));
@@ -167,7 +167,7 @@ private static Pattern CreatePattern()
         var v34 = IsCall("v34", IsOp<MatMul>(), IsVArgs(v32, v33));
         var v35 = IsCall("v35", IsOp<Binary>(), IsVArgs(v34, v13));
         var v36 = IsCall("v36", IsOp<Slice>(), IsVArgs(v34, v15, v16, v17, v18));
-        var v37 = IsCall("v37", IsOp<Unary>(), IsVArgs(v36));
+        var v37 = IsCall("v37", IsOp<IR.Math.Unary>(), IsVArgs(v36));
         var v38 = IsCall("v38", IsOp<Slice>(), IsVArgs(v34, v21, v15, v17, v18));
         var v39 = IsTuple("v39", IsVArgs(v37, v38));
 
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
index e0d361a6da..9bbe5c0ff3 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
@@ -105,8 +105,8 @@ protected override Expr RewriteLeafFusion(Fusion expr)
                 }
                 else
                 {
-                    var converter = new SingleCPUFusionConverter();
-                    prim_func = converter.Visit(fusion);
+                    var converter = new SingleCPUFusionConverter(_tileOptions);
+                    prim_func = converter.Convert(fusion);
                 }
 
                 BaseFunction? convert_func = prim_func;
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 99ba7688ab..b64cf46820 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -3,6 +3,7 @@
 
 using System.Reactive;
 using System.Runtime.CompilerServices;
+using DryIoc.FastExpressionCompiler.LightExpression;
 using NetFabric.Hyperlinq;
 using Nncase.Diagnostics;
 using Nncase.IR;
@@ -10,6 +11,7 @@
 using Nncase.IR.CPU;
 using Nncase.IR.F;
 using Nncase.IR.Math;
+using Nncase.IR.Tensors;
 using Nncase.Passes.Mutators;
 using Nncase.PatternMatch;
 using Nncase.Schedule;
@@ -28,12 +30,83 @@ namespace Nncase.Passes.Tile;
 /// </summary>
 internal sealed class SingleCPUFusionConverter
 {
-    public TIR.PrimFunction Visit(Fusion fusion)
+    public SingleCPUFusionConverter(TileOptions tileOptions)
     {
-        var body = new List<Expr>();
-        var visitor = new ConvertVisitor(body);
-        visitor.Visit(fusion);
-        return T.PrimFunc(fusion.Name, fusion.ModuleKind, visitor.InputBuffers.Concat(visitor.OutputBuffers).ToArray()).Body(body.ToArray()).Build();
+        TileOptions = tileOptions;
+    }
+
+    public TileOptions TileOptions { get; }
+
+    public TIR.PrimFunction Convert(Fusion fusion)
+    {
+        // 1. convert to distribute graph
+        var distConverter = new DistributeConvertVisitor(TileOptions);
+        var candidatebodys = distConverter.Convert(fusion.Body);
+        var graph = new EGraph();
+        var bodyEclasses = candidatebodys.Select(graph.Add).ToArray();
+        _ = bodyEclasses.Skip(1).Select(cls => graph.Union(bodyEclasses[0], cls)).ToArray(); // must keep this.
+        graph.Rebuild();
+        var body = graph.Extract(bodyEclasses[0], null);
+        var newFusion = fusion.With(body: body);
+        if (DumpScope.Current.IsEnabled(DumpFlags.Tiling))
+        {
+            DumpScope.Current.DumpDotIR(newFusion, newFusion.Name, "Distribute");
+        }
+
+        // 2. convert new fusion to prim func
+        var primBody = new List<Expr>();
+        var visitor = new ConvertVisitor(primBody);
+        visitor.Visit(newFusion);
+        return T.PrimFunc(newFusion.Name, newFusion.ModuleKind, visitor.InputBuffers.Concat(visitor.OutputBuffers).ToArray()).Body(primBody.ToArray()).Build();
+    }
+
+    private sealed class DistributeConvertVisitor : ExprVisitor<IReadOnlyList<Expr>, Unit>
+    {
+        public DistributeConvertVisitor(TileOptions tileOptions)
+        {
+            TileOptions = tileOptions;
+            Placement = new Placement(Placement.DeviceKind.CPU, tileOptions.Hierarchy, "bt");
+        }
+
+        public TileOptions TileOptions { get; }
+
+        public Placement Placement { get; }
+
+        public IReadOnlyList<Expr> Convert(Expr body)
+        {
+            return Visit(body).Select(newbody => IR.F.Tensors.Boxing(newbody, body.CheckedType)).ToArray();
+        }
+
+        protected override IReadOnlyList<Expr> DefaultVisitLeaf(Expr expr)
+        {
+            return new[] { expr };
+        }
+
+        protected override IReadOnlyList<Expr> VisitLeafVar(Var expr)
+        {
+            var type = (TensorType)expr.TypeAnnotation;
+            return DistributeUtilities.GetLeafCandidateNDSBPs(type, Placement).
+                Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistTensorType(type, ndsbp, Placement))).
+                ToArray();
+        }
+
+        protected override IReadOnlyList<Expr> VisitLeafConst(Const expr)
+        {
+            return DistributeUtilities.GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, Placement)
+                .Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistTensorType((TensorType)expr.CheckedType, ndsbp, Placement))).
+                ToArray();
+        }
+
+        protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
+        {
+            return expr.Arguments.ToArray().
+                Select(arg => ExprMemo[arg]).
+                CartesianProduct<Expr>().
+                Select(args => args.ToArray()).
+                Select(args => new Call(expr.Target, args)).
+                Where(c => c.InferenceType()).
+                ToArray();
+        }
     }
 
     private sealed class ConvertVisitor : ExprVisitor<Unit, Unit>
@@ -61,18 +134,28 @@ protected override Unit VisitLeafCall(Call expr)
         {
             var arguments = expr.Arguments.AsValueEnumerable().Select(TryAllocateBuffer).ToArray();
             var ret = TryAllocateBuffer(expr);
-            var op = ((CPUKernelOp)expr.Target).Target;
-
-            switch (op)
+            switch (expr.Target)
             {
-                case Unary unary:
-                    GenerateUnary(unary, arguments, ret);
-                    break;
-                case Binary binary:
-                    GenerateBinary(binary, arguments, ret, expr);
+                case CPUKernelOp kernelOp:
+                    switch (kernelOp.Target)
+                    {
+                        case IR.Math.Unary unary:
+                            GenerateUnary(unary, arguments, ret);
+                            break;
+
+                        // case Binary binary:
+                        //     GenerateBinary(binary, arguments, ret, expr);
+                        //     break;
+                        // case MatMul matmul:
+                        //     GenerateMatMul(arguments, ret, expr);
+                        //     break;
+                        default:
+                            throw new NotSupportedException();
+                    }
+
                     break;
-                case MatMul matmul:
-                    GenerateMatMul(arguments, ret, expr);
+                case Boxing boxing:
+                    GenerateBoxing(boxing, arguments, ret, expr);
                     break;
                 default:
                     throw new NotSupportedException();
@@ -81,11 +164,50 @@ protected override Unit VisitLeafCall(Call expr)
             return default;
         }
 
+        private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call expr)
+        {
+            switch (expr.Arguments[0].CheckedType, boxing.NewType)
+            {
+                case (TensorType tensorType, DistTensorType distTensorType):
+                    {
+                        _mainBody.Add(T.Block(nameof(Boxing)).Body(IR.F.CPU.TDMALoad(arguments[0], ret)).Build());
+                    }
+
+                    break;
+                case (DistTensorType distTensorType, TensorType tensorType):
+                    {
+                        _mainBody.Add(T.Block(nameof(Boxing)).Body(IR.F.CPU.TDMAStore(arguments[0], ret)).Build());
+                    }
+
+                    break;
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
+        {
+            var input = arguments[IR.Math.Unary.Input.Index];
+            _mainBody.Add(T.Block(nameof(IR.Math.Unary)).Body(IR.F.CPU.Unary(unary.UnaryOp, input, ret)).Build());
+        }
+
+#if false
+        private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
+        {
+            var loops = Enumerable.Range(0, input.Rank).Select(i => (T.ForLoop(out var loopVar, (0, input.Dimensions[i]), i == 0 ? LoopMode.Parallel : LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
+            var loopVars = loops.Select(f => f.loopVar).ToArray();
+            Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Unary(unary.UnaryOp, T.BufferLoad(input, loopVars)));
+            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
+            _mainBody.Add(T.Block(nameof(Unary)).Body(
+                T.MatchBuffer(arguments[0]),
+                T.MatchBuffer(ret),
+                final).Build());
+        }
+
         private void GenerateMatMul(ReadOnlySpan<Buffer> arguments, Buffer ret, Call expr)
         {
             var lhs = arguments[0];
             var rhs = arguments[1];
-
             var loops = Enumerable.Range(0, lhs.Rank - 2).Select(i => (T.ForLoop(out var loopVar, (0, lhs.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
             var loopVars = loops.Select(f => f.loopVar).ToArray();
             var stmt = T.ForLoop(out var m, (0, lhs.Dimensions[^2]), LoopMode.Parallel).Body(
@@ -95,7 +217,6 @@ private void GenerateMatMul(ReadOnlySpan<Buffer> arguments, Buffer ret, Call exp
                         T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), T.BufferLoad(ret, loopVars.Concat(new[] { m, n }).ToArray()) + (T.BufferLoad(lhs, loopVars.Concat(new[] { m, k }).ToArray()) * T.BufferLoad(rhs, loopVars.Concat(new[] { k, n }).ToArray())))))).
                 Build();
             var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-
             // [m,k] @ [k, n]
             var body = T.Block(nameof(MatMul)).Body(
                 T.MatchBuffer(arguments[0]),
@@ -105,19 +226,6 @@ private void GenerateMatMul(ReadOnlySpan<Buffer> arguments, Buffer ret, Call exp
             _mainBody.Add(body.Build());
         }
 
-        private void GenerateUnary(Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
-        {
-            var input = arguments[Unary.Input.Index];
-            var loops = Enumerable.Range(0, input.Rank).Select(i => (T.ForLoop(out var loopVar, (0, input.Dimensions[i]), i == 0 ? LoopMode.Parallel : LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
-            var loopVars = loops.Select(f => f.loopVar).ToArray();
-            Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Unary(unary.UnaryOp, T.BufferLoad(input, loopVars)));
-            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-            _mainBody.Add(T.Block(nameof(Unary)).Body(
-                T.MatchBuffer(arguments[0]),
-                T.MatchBuffer(ret),
-                final).Build());
-        }
-
         private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffer ret, Call call)
         {
             var lhs = call.Arguments[Binary.Lhs.Index];
@@ -147,6 +255,7 @@ private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffe
                 final);
             _mainBody.Add(body.Build());
         }
+#endif 
 
         private TIR.Buffer TryAllocateBuffer(Expr expr)
         {
@@ -156,15 +265,13 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
                 switch (expr)
                 {
                     case Call c:
+                        var (type, loc) = GetTypeAndLocation(c.CheckedType);
                         if (ReferenceEquals(c, VisitRootFusion.Body))
                         {
-                            buffer = T.AttachBuffer((TensorType)c.CheckedType, MemoryLocation.Output, out _, out _, name);
-                        }
-                        else
-                        {
-                            buffer = T.CreateBuffer((TensorType)c.CheckedDataType, MemoryLocation.Data, out _, name);
+                            loc = MemoryLocation.Output;
                         }
 
+                        buffer = T.AttachBuffer(type, loc, out _, out _, name);
                         break;
                     case Var v:
                         buffer = T.AttachBuffer((TensorType)v.CheckedType, MemoryLocation.Input, out _, out _, name);
@@ -181,5 +288,38 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
 
             return buffer;
         }
+
+        private (TensorType, MemoryLocation) GetTypeAndLocation(IRType type)
+        {
+            MemoryLocation location;
+            if (type is DistTensorType distTensorType)
+            {
+                if (distTensorType.Placement.Rank == 2)
+                {
+                    location = MemoryLocation.L1Data;
+                }
+                else if (distTensorType.Placement.Rank == 1)
+                {
+                    location = MemoryLocation.L2Data;
+                }
+            }
+
+            location = MemoryLocation.Data;
+            TensorType tensorType;
+            if (type is DistTensorType distTensor)
+            {
+                DistributeUtilities.IsDistributable(distTensor.TensorType, distTensor.NdSbp.ToArray(), distTensor.Placement, out tensorType);
+            }
+            else if (type is TensorType ttype)
+            {
+                tensorType = ttype;
+            }
+            else
+            {
+                throw new NotSupportedException();
+            }
+
+            return (tensorType, location);
+        }
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
index 749355b5da..ab5091d606 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
@@ -13,8 +13,9 @@ namespace Nncase.Passes.Tile;
 /// TileOptions.
 /// </summary>
 /// <param name="TargetTileSize">TargetTileSize.</param>
-/// <param name="CacheSize">the cache size.</param>
-public sealed record TileOptions(int[] TargetTileSize, int CacheSize)
+/// <param name="Hierarchy">the hierarchy shapes.</param>
+/// <param name="HierarchySizes">each hierarchy ram size.</param>
+public sealed record TileOptions(int[] TargetTileSize, int[] Hierarchy, int[] HierarchySizes)
 {
-    public static TileOptions Default { get; } = new(Array.Empty<int>(), 4 * 1024 * 1024 * 8);
+    public static TileOptions Default { get; } = new(Array.Empty<int>(), new[] { 8, 4 }, new[] { 30 * (int)MathF.Pow(2, 30), 10 * (int)MathF.Pow(2, 30) });
 }
diff --git a/nncase.sln b/nncase.sln
index e77c50726c..4c4b9496e2 100644
--- a/nncase.sln
+++ b/nncase.sln
@@ -44,8 +44,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nncase.IO", "src\Nncase.IO\
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nncase.Schedule", "src\Nncase.Schedule\Nncase.Schedule.csproj", "{8E0E0672-0F96-4EF1-BDCD-D31F96A3DF73}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "targets", "targets", "{A2590531-71C5-4326-88DD-6A9DB2EF0A2B}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nncase.Targets", "src\Nncase.Targets\Nncase.Targets.csproj", "{56283378-06E3-4C6E-A8BF-7BD85C92D42C}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nncase.Simulator", "src\Nncase.Simulator\Nncase.Simulator.csproj", "{901AC17C-7B53-4B10-A2AC-EA7AEA6DC614}"
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 3a29679c27..70a175f94c 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -161,6 +161,7 @@ public void TargetIndependentPass(IPassManager passManager)
         {
             p.Add<Passes.Rules.MHACombine>();
             p.Add<Passes.Rules.Neutral.FoldConstCall>();
+
             // p.Add<Passes.Rules.DumpMM>();
             // p.Add<Passes.Rules.DumpLayerNorm>();
             // p.Add<Passes.Rules.DumpGather>();
diff --git a/src/Nncase.Core/DistTensorType.cs b/src/Nncase.Core/DistTensorType.cs
new file mode 100644
index 0000000000..71e1a26715
--- /dev/null
+++ b/src/Nncase.Core/DistTensorType.cs
@@ -0,0 +1,101 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DryIoc.ImTools;
+
+namespace Nncase.IR;
+
+public abstract record SBP
+{
+    public static SBPSumParallel P => SBPSumParallel.Instance;
+
+    public static SBPSplit S(int axis) => new SBPSplit(axis);
+
+    public static SBPBroadCast B => SBPBroadCast.Instance;
+}
+
+public sealed record SBPSplit(int Axis) : SBP
+{
+    public override string ToString() => $"S({Axis})";
+}
+
+public sealed record SBPSumParallel : SBP
+{
+    public static readonly SBPSumParallel Instance = new SBPSumParallel();
+
+    private SBPSumParallel()
+    {
+    }
+
+    public override string ToString() => "P";
+}
+
+public sealed record SBPBroadCast : SBP
+{
+    public static readonly SBPBroadCast Instance = new SBPBroadCast();
+
+    private SBPBroadCast()
+    {
+    }
+
+    public override string ToString() => "B";
+}
+
+public sealed record Placement
+{
+    public Placement(DeviceKind kind, IRArray<int> hierarchy, string name)
+    {
+        Kind = kind;
+        Hierarchy = hierarchy;
+        Name = name;
+    }
+
+    /// <summary>
+    /// The device kind type.
+    /// </summary>
+    public enum DeviceKind : uint
+    {
+        CPU = 0,
+    }
+
+    public DeviceKind Kind { get; }
+
+    public IRArray<int> Hierarchy { get; }
+
+    public string Name { get; }
+
+    public int Rank => Hierarchy.Count;
+
+    public override string ToString() => $"@{Kind} [{string.Join(',', Hierarchy.Zip(Name).Select(t => t.First.ToString() + '@' + t.Second.ToString()))}]";
+}
+
+public sealed record DistTensorType : IRType
+{
+    public DistTensorType(TensorType tensorType, IRArray<SBP> ndsbp, Placement placement)
+    {
+        if (placement.Hierarchy.Count != ndsbp.Count)
+        {
+            throw new ArgumentException("spb dimension != placement rank!");
+        }
+
+        TensorType = tensorType;
+        NdSbp = ndsbp;
+        Placement = placement;
+    }
+
+    public TensorType TensorType { get; }
+
+    public IRArray<SBP> NdSbp { get; }
+
+    public Placement Placement { get; }
+
+    public override string ToString() => $"{TensorType} ({string.Join(',', NdSbp)}) {Placement}";
+}
diff --git a/src/Nncase.Core/DistributeUtilities.cs b/src/Nncase.Core/DistributeUtilities.cs
new file mode 100644
index 0000000000..a7c56ad9c3
--- /dev/null
+++ b/src/Nncase.Core/DistributeUtilities.cs
@@ -0,0 +1,71 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Diagnostics.CodeAnalysis;
+using Nncase.IR;
+
+namespace Nncase;
+
+public static class DistributeUtilities
+{
+    public static IReadOnlyList<IRArray<SBP>> GetLeafCandidateNDSBPs(TensorType tensorType, Placement placement)
+    {
+        var ndsbps = new List<List<SBP>>();
+        for (int i = 0; i < placement.Rank; i++)
+        {
+            var ndsbp = new List<SBP>();
+            for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
+            {
+                if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && IsDivisible(s, placement.Hierarchy[i]))
+                {
+                    ndsbp.Add(SBP.S(axis));
+                }
+            }
+
+            ndsbp.Add(SBP.B);
+            ndsbps.Add(ndsbp);
+        }
+
+        return ndsbps.CartesianProduct().
+           Select(ndsbp => ndsbp.ToArray()).
+           Where(ndsbp => IsDistributable(tensorType, ndsbp, placement, out _)).
+           Select(ndsbp => new IRArray<SBP>(ndsbp)).
+           ToArray();
+    }
+
+    public static bool IsDistributable(TensorType tensorType, ReadOnlySpan<SBP> ndsbp, Placement placement, [MaybeNullWhen(false)] out TensorType distType)
+    {
+        distType = null;
+        if (!tensorType.Shape.IsFixed)
+        {
+            return false;
+        }
+
+        var shape = tensorType.Shape.ToValueArray();
+        for (int i = 0; i < ndsbp.Length; i++)
+        {
+            if (ndsbp[i] is SBPSplit { Axis: int axis })
+            {
+                if (!IsDivisible(shape[axis], placement.Hierarchy[i]))
+                {
+                    return false;
+                }
+
+                shape[axis] /= placement.Hierarchy[i];
+            }
+        }
+
+        distType = tensorType with { Shape = shape };
+        return true;
+    }
+
+    public static bool IsDivisible(int input, int divisor)
+    {
+        if (input >= divisor && input % divisor == 0)
+        {
+            return true;
+        }
+
+        return false;
+    }
+}
diff --git a/src/Nncase.Core/IR/ExprFunctor.cs b/src/Nncase.Core/IR/ExprFunctor.cs
index 0fd8bc9ed9..5664b5a77b 100644
--- a/src/Nncase.Core/IR/ExprFunctor.cs
+++ b/src/Nncase.Core/IR/ExprFunctor.cs
@@ -123,6 +123,13 @@ public partial class ExprFunctor<TExprResult, TTypeResult> : ExprFunctor<TExprRe
     /// <returns>Result.</returns>
     public virtual TTypeResult VisitType(CallableType type) => base.VisitType(type, default);
 
+    /// <summary>
+    /// Visit callable type.
+    /// </summary>
+    /// <param name="type">Callable type.</param>
+    /// <returns>Result.</returns>
+    public virtual TTypeResult VisitType(DistTensorType type) => base.VisitType(type, default);
+
     /// <summary>
     /// Default visit routine.
     /// </summary>
@@ -151,6 +158,9 @@ public partial class ExprFunctor<TExprResult, TTypeResult> : ExprFunctor<TExprRe
     /// <inheritdoc/>
     public sealed override TTypeResult VisitType(CallableType type, Unit context) => VisitType(type);
 
+    /// <inheritdoc/>
+    public sealed override TTypeResult VisitType(DistTensorType type, Unit context) => VisitType(type);
+
     /// <inheritdoc/>
     public sealed override TTypeResult DefaultVisitType(IRType type, Unit context) => DefaultVisitType(type);
 
diff --git a/src/Nncase.Core/IR/IRType.cs b/src/Nncase.Core/IR/IRType.cs
index ceb76319ad..80cb2fddb0 100644
--- a/src/Nncase.Core/IR/IRType.cs
+++ b/src/Nncase.Core/IR/IRType.cs
@@ -139,6 +139,15 @@ public sealed record TensorType(DataType DType, Shape Shape) : IRType
     /// <param name="elemType"> the Pointed Element Type.</param>
     /// <returns>the pointer tensor type.</returns>
     public static TensorType Pointer(DataType elemType) => new(new PointerType(elemType, Shape.Scalar), Shape.Scalar);
+
+    /// <inheritdoc/>
+    public override string ToString() => DType switch
+    {
+        PrimType ptype => ptype.GetDisplayName() + (Shape.IsScalar ? string.Empty : Shape.ToString()),
+        PointerType { ElemType: PrimType etype } => $"*{etype.GetDisplayName()}",
+        ValueType => $"{DType}",
+        _ => throw new NotSupportedException(DType.GetType().Name),
+    };
 }
 
 /// <summary>
diff --git a/src/Nncase.Core/IR/Op.cs b/src/Nncase.Core/IR/Op.cs
index 07d4bbcabb..8a478d530c 100644
--- a/src/Nncase.Core/IR/Op.cs
+++ b/src/Nncase.Core/IR/Op.cs
@@ -90,7 +90,7 @@ public Op()
     /// <summary>
     /// Gets get the parameters.
     /// </summary>
-    public IEnumerable<ParameterInfo> Parameters =>
+    public virtual IEnumerable<ParameterInfo> Parameters =>
         _parameters ??= (from p in GetType().GetFields(BindingFlags.Public | BindingFlags.Static)
                          where p.FieldType == typeof(ParameterInfo)
                          let param = (ParameterInfo)(p.GetValue(null) ?? throw new InvalidOperationException())
diff --git a/src/Nncase.Core/IR/Tensors/Boxing.cs b/src/Nncase.Core/IR/Tensors/Boxing.cs
new file mode 100644
index 0000000000..04496b8263
--- /dev/null
+++ b/src/Nncase.Core/IR/Tensors/Boxing.cs
@@ -0,0 +1,29 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.PatternMatch;
+
+namespace Nncase.IR.Tensors;
+
+/// <summary>
+/// Boxing expression.
+/// </summary>
+[PatternFunctionalGenerator]
+public sealed partial class Boxing : Op
+{
+    /// <summary>
+    /// Gets input.
+    /// </summary>
+    public static readonly ParameterInfo Input = new(typeof(Boxing), 0, "input");
+
+    public IRType NewType { get; }
+
+    /// <inheritdoc/>
+    public override string DisplayProperty() => $"{NewType}";
+}
diff --git a/src/Nncase.Core/IR/Tensors/Functional.cs b/src/Nncase.Core/IR/Tensors/Functional.cs
index 71c0bfc51c..f54b037f79 100644
--- a/src/Nncase.Core/IR/Tensors/Functional.cs
+++ b/src/Nncase.Core/IR/Tensors/Functional.cs
@@ -70,6 +70,9 @@ public static Call Bitcast(PrimType type, Expr input, PrimType newType, Expr sha
     public static Call Cast(Expr input, DataType newType, CastMode castMode = CastMode.KDefault) =>
         new Call(new Cast(newType, castMode), input);
 
+    public static Call Boxing(Expr input, IRType type) =>
+        new Call(new Boxing(type), input);
+
     public static Call Concat(Expr input, Expr axis) => new Call(new Concat(), input, axis);
 
     public static Call ConstantOfShape(Expr shape, Expr value) => new Call(new ConstantOfShape(), shape, value);
diff --git a/src/Nncase.Core/IR/TypeFunctor.cs b/src/Nncase.Core/IR/TypeFunctor.cs
index d63f56c101..9e3be8c506 100644
--- a/src/Nncase.Core/IR/TypeFunctor.cs
+++ b/src/Nncase.Core/IR/TypeFunctor.cs
@@ -32,6 +32,7 @@ public virtual TResult VisitType(IRType type, TContext context)
             TensorType t => VisitType(t, context),
             TupleType t => VisitType(t, context),
             CallableType t => VisitType(t, context),
+            DistTensorType t => VisitType(t, context),
             _ => DefaultVisitType(type, context),
         };
     }
@@ -92,6 +93,14 @@ public virtual TResult VisitType(IRType type, TContext context)
     /// <returns>Result.</returns>
     public virtual TResult VisitType(CallableType type, TContext context) => DefaultVisitType(type, context);
 
+    /// <summary>
+    /// Visit dist tensor type.
+    /// </summary>
+    /// <param name="type">dist tensor type.</param>
+    /// <param name="context">Context.</param>
+    /// <returns>Result.</returns>
+    public virtual TResult VisitType(DistTensorType type, TContext context) => DefaultVisitType(type, context);
+
     /// <summary>
     /// Default visit routine.
     /// </summary>
diff --git a/src/Nncase.Core/LinqExtensions.cs b/src/Nncase.Core/LinqExtensions.cs
index a4245953e8..ed5a5bfa16 100644
--- a/src/Nncase.Core/LinqExtensions.cs
+++ b/src/Nncase.Core/LinqExtensions.cs
@@ -14,6 +14,21 @@ namespace Nncase;
 /// </summary>
 public static class LinqExtensions
 {
+    /// <summary>
+    /// Get the ranges from range desc.
+    /// </summary>
+    /// <param name="stride">stride.</param>
+    /// <param name="start">start.</param>
+    /// <param name="stop">stop.</param>
+    /// <returns>Ranges.</returns>
+    public static IEnumerable<Range> Ranges(this int stride, int start, int stop)
+    {
+        for (int i = start; i < stop; i += stride)
+        {
+            yield return new Range(i, Math.Min(stop, i + stride));
+        }
+    }
+
     /// <summary>
     /// Get cartesian product.
     /// </summary>
diff --git a/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs b/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
index 93fa794679..00da741a3b 100644
--- a/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
@@ -274,6 +274,33 @@ public override string VisitType(CallableType type) =>
     public override string VisitType(TupleType type) =>
         $"({string.Join(", ", type.Fields.Select(VisitType))})";
 
+    /// <inheritdoc/>
+    public override string VisitType(DistTensorType type)
+    {
+        var shape = type.TensorType.Shape.ToArray();
+        foreach (var (s, r) in type.NdSbp.Select((s, r) => (s, r)))
+        {
+            if (s is SBPSplit split)
+            {
+                if (shape[split.Axis].IsFixed)
+                {
+                    shape[split.Axis] = shape[split.Axis] / type.Placement.Hierarchy[r];
+                }
+            }
+        }
+
+        var sshape = shape.Select(s => s.ToString()).ToArray();
+        foreach (var (s, r) in type.NdSbp.Select((s, r) => (s, r)))
+        {
+            if (s is SBPSplit split)
+            {
+                sshape[split.Axis] += $"@{type.Placement.Name[r]}";
+            }
+        }
+
+        return $"{{{VisitType(type.TensorType)}, ({string.Join(',', type.NdSbp)}), [{string.Join(',', sshape)}]}}";
+    }
+
     /// <inheritdoc/>
     protected override string VisitCall(Call expr)
     {
diff --git a/src/Nncase.Evaluator/Math/Unary.cs b/src/Nncase.Evaluator/Math/Unary.cs
index 64c3bfbfbf..e06a7b81ba 100644
--- a/src/Nncase.Evaluator/Math/Unary.cs
+++ b/src/Nncase.Evaluator/Math/Unary.cs
@@ -64,21 +64,26 @@ public IValue Visit(IEvaluateContext context, Unary unary)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Unary target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Unary.Input);
-        return Visit(input);
+        var inputType = context.GetArgumentType(target, Unary.Input);
+
+        return inputType switch
+        {
+            TensorType tensorType => Visit(tensorType),
+            DistTensorType distTensorType => Visit(distTensorType),
+            _ => new InvalidType($"Not support {inputType.GetType().Name}"),
+        };
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Unary target)
     {
-        var inputType = context.GetArgumentType<TensorType>(target, Unary.Input);
-        var outputType = context.GetReturnType<TensorType>();
-
-        return new()
+        var inputType = context.GetArgumentType<IRType>(target, Unary.Input);
+        var outputType = context.GetReturnType<IRType>();
+        return (inputType, outputType) switch
         {
-            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType),
-            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(outputType),
-            [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(outputType, CostUtility.GetCPUCyclesOfUnary(target.UnaryOp)),
+            (TensorType tensorType, TensorType tensorType1) => Visit(tensorType, tensorType1, target),
+            (DistTensorType distTensorType, DistTensorType distTensorType1) => Visit(distTensorType, distTensorType1, target),
+            _ => throw new NotSupportedException(string.Empty),
         };
     }
 
@@ -117,6 +122,11 @@ public Expr Visit(IShapeEvaluateContext context, Unary target)
         return context.GetArgumentShape(target, Unary.Input);
     }
 
+    private IRType Visit(DistTensorType distTensorType)
+    {
+        return distTensorType;
+    }
+
     private int Compute_int(int input, UnaryOp op) => op switch
     {
         UnaryOp.Ceil => input,
@@ -156,4 +166,26 @@ private IRType Visit(TensorType input)
     {
         return input;
     }
+
+    private Cost Visit(DistTensorType inType, DistTensorType outType, Unary target)
+    {
+        var inPartType = TypeInference.GetPartedTensorType(inType, out int inScale);
+        var outPartType = TypeInference.GetPartedTensorType(outType, out int outScale);
+        return new()
+        {
+            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inPartType) * (UInt128)inScale,
+            [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(outPartType, CostUtility.GetCPUCyclesOfUnary(target.UnaryOp)),
+            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(outPartType) * (UInt128)outScale,
+        };
+    }
+
+    private Cost Visit(TensorType inputType, TensorType outputType, Unary target)
+    {
+        return new()
+        {
+            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType),
+            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(outputType),
+            [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(outputType, CostUtility.GetCPUCyclesOfUnary(target.UnaryOp)),
+        };
+    }
 }
diff --git a/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs b/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
new file mode 100644
index 0000000000..0e20d55c4d
--- /dev/null
+++ b/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
@@ -0,0 +1,52 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Linq;
+using Nncase.CostModel;
+using Nncase.IR;
+using Nncase.IR.Tensors;
+
+namespace Nncase.Evaluator.Tensors;
+
+public sealed class BoxingEvaluator : ITypeInferencer<Boxing>, ICostEvaluator<Boxing>
+{
+    public IRType Visit(ITypeInferenceContext context, Boxing target)
+    {
+        return target.NewType;
+    }
+
+    public Cost Visit(ICostEvaluateContext context, Boxing target)
+    {
+        var inType = context.GetArgumentType<IRType>(target, Boxing.Input);
+        var returnType = context.GetReturnType<IRType>();
+
+        return (inType, returnType) switch
+        {
+            (TensorType tensorType, DistTensorType distTensorType) => Visit(tensorType, distTensorType),
+            (DistTensorType distTensorType, TensorType tensorType) => Visit(tensorType, distTensorType),
+            _ => throw new NotImplementedException(),
+        };
+    }
+
+    /// <summary>
+    /// calc the cost for load/store to distribute.
+    /// </summary>
+    /// <param name="tensorType">device tensor.</param>
+    /// <param name="distTensorType">distribute tensor.</param>
+    /// <returns>cost.</returns>
+    private Cost Visit(TensorType tensorType, DistTensorType distTensorType)
+    {
+        var shape = distTensorType.TensorType.Shape.ToValueArray();
+        foreach (var axis in distTensorType.NdSbp.OfType<SBPSplit>().Select(s => s.Axis))
+        {
+            shape[axis] /= axis;
+        }
+
+        return new Cost()
+        {
+            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(tensorType),
+            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(distTensorType.TensorType with { Shape = shape }),
+        };
+    }
+}
diff --git a/src/Nncase.Evaluator/Tensors/TensorsModule.cs b/src/Nncase.Evaluator/Tensors/TensorsModule.cs
index 15e3446a23..bb75b46c30 100644
--- a/src/Nncase.Evaluator/Tensors/TensorsModule.cs
+++ b/src/Nncase.Evaluator/Tensors/TensorsModule.cs
@@ -16,6 +16,7 @@ internal class TensorsModule : IApplicationPart
     public void ConfigureServices(IRegistrator registrator)
     {
         registrator.RegisterManyInterface<BroadcastEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<BoxingEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<BitcastEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<CastEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<ConcatEvaluator>(reuse: Reuse.Singleton);
diff --git a/src/Nncase.Evaluator/TypeInference.cs b/src/Nncase.Evaluator/TypeInference.cs
index a0749e8fdd..ce04581822 100644
--- a/src/Nncase.Evaluator/TypeInference.cs
+++ b/src/Nncase.Evaluator/TypeInference.cs
@@ -11,6 +11,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using NetFabric.Hyperlinq;
 using Nncase.IR;
+using Nncase.TIR;
 using static Nncase.IR.TypePatternUtility;
 
 namespace Nncase.Evaluator;
@@ -460,4 +461,22 @@ IRType CommonTypeImpl(TensorType a, TensorType b)
             _ => new InvalidType($"Inputs of if should be same IRType Kind, but then:{thenType}, else: {elseType}"),
         };
     }
+
+    public static TensorType GetPartedTensorType(DistTensorType distTensorType, out int notContiguous)
+    {
+        var shape = distTensorType.TensorType.Shape.ToValueArray();
+        var tiles = distTensorType.TensorType.Shape.ToValueArray();
+        foreach (var axis in distTensorType.NdSbp.OfType<SBPSplit>().Select(s => s.Axis))
+        {
+            tiles[axis] /= axis;
+        }
+
+        notContiguous = Enumerable.Range(0, tiles.Length).
+           Select(i => tiles[i].Ranges(0, shape[i])).
+           CartesianProduct().
+           Select(rgs => TensorUtilities.IsContiguousSlice(shape, rgs.ToArray())).
+           Count(b => b == false);
+
+        return distTensorType.TensorType with { Shape = shape };
+    }
 }
diff --git a/src/Nncase.Evaluator/TypeInferenceVisitor.cs b/src/Nncase.Evaluator/TypeInferenceVisitor.cs
index 5aad018362..36528fd045 100644
--- a/src/Nncase.Evaluator/TypeInferenceVisitor.cs
+++ b/src/Nncase.Evaluator/TypeInferenceVisitor.cs
@@ -71,7 +71,7 @@ protected override IRType VisitLeafBufferRegion(BufferRegion expr)
     /// <inheritdoc/>
     protected override IRType VisitLeafBuffer(Nncase.TIR.Buffer expr)
     {
-        VerifySubField(expr, expr.MemSpan, TypePatternUtility.IsPointer());
+        VerifySubField(expr, expr.MemSpan, TypePatternUtility.IsPointer() | TypePatternUtility.IsNoneType());
         foreach (var r in expr.Dimensions)
         {
             VerifySubField(expr, r, TypePatternUtility.IsIntegralScalar());
diff --git a/src/Nncase.Tests/Core/UnitTestExpression.cs b/src/Nncase.Tests/Core/UnitTestExpression.cs
index 59741a8735..00371b9077 100644
--- a/src/Nncase.Tests/Core/UnitTestExpression.cs
+++ b/src/Nncase.Tests/Core/UnitTestExpression.cs
@@ -526,6 +526,22 @@ public void TestIf()
         Assert.Equal(1, result2);
     }
 
+    [Fact]
+    public void TestBoxingEqual()
+    {
+        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
+        var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
+        var a = new DistTensorType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
+        var b = new DistTensorType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
+
+        var input = new Var(ttype);
+        var ea = IR.F.Tensors.Boxing(input, a);
+        var eb = IR.F.Tensors.Boxing(input, b);
+
+        Assert.Equal(ea.Target, eb.Target);
+        Assert.StrictEqual(ea.Target, eb.Target);
+    }
+
     private MyRange[] Conv2dBounds(MyRange[] output_range, int kh, int kw)
     {
         var new_output_range = new MyRange[output_range.Length];
diff --git a/src/Nncase.Tests/Distributed/UnitTestDistTensor.cs b/src/Nncase.Tests/Distributed/UnitTestDistTensor.cs
new file mode 100644
index 0000000000..db435fee8e
--- /dev/null
+++ b/src/Nncase.Tests/Distributed/UnitTestDistTensor.cs
@@ -0,0 +1,96 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Metadata;
+using Microsoft.Extensions.FileSystemGlobbing.Internal;
+using NetFabric.Hyperlinq;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.IR.Math;
+using Nncase.Passes;
+using Xunit;
+
+namespace Nncase.Tests.DistributedTest;
+
+[TestFixture.AutoSetupTestMethod(InitSession = true)]
+public sealed class UnitTestDistTensor : TestClassBase
+{
+    [Fact]
+    public void TestCreate()
+    {
+        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 2, 2 }, "bt");
+        IRArray<SBP> sbps = new[] { SBP.S(2), SBP.S(1), };
+        DistTensorType t = new(new TensorType(DataTypes.Float32, new[] { 1, 2, 8 }), sbps, placement);
+        var input = new Var("input", t);
+        var output = IR.F.Math.Unary(UnaryOp.Neg, input);
+        output.CheckedType = t;
+        CompilerServices.DumpDotIR(output, "create", Dumpper.Directory, false);
+    }
+
+    public IReadOnlyList<CallableType> GetCandidateSignatures(Unary unary, TensorType tensorType, Placement placement)
+    {
+        var layers = new List<List<(SBP, SBP)>>();
+        for (int i = 0; i < placement.Rank; i++)
+        {
+            var layer = new List<(SBP, SBP)>();
+            for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
+            {
+                if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && s > placement.Hierarchy[i])
+                {
+                    layer.Add((SBP.S(axis), SBP.S(axis)));
+                }
+            }
+
+            layer.Add((SBP.B, SBP.B));
+            layers.Add(layer);
+        }
+
+        return LinqExtensions.CartesianProduct(layers).Select(layer => layer.ToArray()).Select(layer =>
+        {
+            var inType = new DistTensorType(tensorType, Enumerable.Range(0, layers.Count).Select(i => layer[i].Item1).ToArray(), placement);
+            var outType = new DistTensorType(tensorType, Enumerable.Range(0, layers.Count).Select(i => layer[i].Item2).ToArray(), placement);
+            return new CallableType(outType, new[] { inType });
+        }).ToList();
+    }
+
+    [Fact]
+    public void TestGetLeafCandidateNDSBPs()
+    {
+        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
+        var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
+        var input = new Var(ttype);
+        var set = new HashSet<DistTensorType>(DistributeUtilities.GetLeafCandidateNDSBPs(ttype, placement).Select(ndsbp => new DistTensorType(ttype, ndsbp, placement)));
+        Assert.Equal(9, set.Count);
+    }
+
+    [Fact]
+    public void TestDistributeTypeEqual()
+    {
+        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
+        var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
+        var a = new DistTensorType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
+        var b = new DistTensorType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
+        Assert.Equal(a, b);
+        Assert.StrictEqual(a, b);
+    }
+
+    [Fact]
+    public void TestUnary()
+    {
+        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
+        var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
+        var input = new Var(ttype);
+        var output = IR.F.Math.Unary(UnaryOp.Neg, input);
+
+        var candidates = GetCandidateSignatures((Unary)output.Target, ttype, placement);
+        int i = 0;
+        foreach (var c in candidates)
+        {
+            input.CheckedType = c.Parameters[0];
+            output.CheckedType = c.ReturnType;
+            CompilerServices.DumpDotIR(output, $"unary_{i++}", Dumpper.Directory, false);
+        }
+    }
+}
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index db5c9c5567..3545052729 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -29,14 +29,15 @@ public UnitTestCPUTargetTiling()
     {
         DefaultTargetName = CPUTarget.Kind;
 #if DEBUG
-        CompileOptions.DumpFlags = Diagnostics.DumpFlags.PassIR | Diagnostics.DumpFlags.Rewrite | Diagnostics.DumpFlags.CodeGen;
+        CompileOptions.DumpFlags = Diagnostics.DumpFlags.PassIR | Diagnostics.DumpFlags.Rewrite | Diagnostics.DumpFlags.CodeGen | Diagnostics.DumpFlags.EGraphCost | Diagnostics.DumpFlags.Tiling;
 #endif
     }
 
     [Fact]
     public async Task TestCpuUnary()
     {
-        var input = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 2, 3, 4, 5 }));
+        var shape = new[] { 1, 384, 2048 };
+        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
         var main = new Function("main", IR.F.Math.Unary(UnaryOp.Asin, input), new[] { input });
         var module = new IR.IRModule(main);
 
@@ -48,13 +49,13 @@ public async Task TestCpuUnary()
             compiler.Gencode(fs);
         }
 
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 1, 2, 3, 4, 5 }).Evaluate().AsTensor();
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
         using (var fs = Dumpper.OpenFile("input_0.bin"))
         {
             fs.Write(input_tensor.BytesBuffer);
         }
 
-        Testing.RunKModel(File.ReadAllBytes(Path.Join(Dumpper.Directory, "test.kmodel")), Dumpper.Directory, new[] { input_tensor });
+        // Testing.RunKModel(File.ReadAllBytes(Path.Join(Dumpper.Directory, "test.kmodel")), Dumpper.Directory, new[] { input_tensor });
     }
 
     [Fact]

From 9a20a33e641730df6a7927b4725eaa46ad8967be Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 6 Sep 2023 14:24:34 +0800
Subject: [PATCH 155/308] fix head main

---
 modules/cpu/src/runtime/cmodel/tests/head/main.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
index 112e5d4955..600c1a6944 100644
--- a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
@@ -37,11 +37,11 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     Hidden_in = &input0;
 
     auto input1 = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[0], 8192 * 32000), {8192, 32000});
+        gsl::make_span((float *)inputs[1], 8192 * 32000), {8192, 32000});
     W = &input0;
 
     auto input2 = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[0], 384 * 32000), {1, 384, 32000});
+        gsl::make_span((float *)inputs[2], 384 * 32000), {1, 384, 32000});
     Output = &input0;
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;

From 70a539d5434b9f3c83e69f9045a4fa82c7e4d154 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 6 Sep 2023 16:03:19 +0800
Subject: [PATCH 156/308] pass norm case

---
 modules/cpu/src/runtime/cmodel/include/tdma.h |  2 +-
 .../runtime/cmodel/tests/demo4/kernel copy.h  | 28 -------------------
 .../src/runtime/cmodel/tests/norm/main.cpp    |  8 ++++--
 3 files changed, 7 insertions(+), 31 deletions(-)
 delete mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/kernel copy.h

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 5077800cd2..7d64e74632 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -61,7 +61,7 @@ void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest,
 
 template <class T, loc_t DestLoc, loc_t SrcLoc>
 void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
-    assert(dest.dimension() == src.dimension());
+    runtime_util.rt_assert(dest.dimension() == src.dimension(), (char*)"Dest and Src dimension mismatch in __tensor_copy_sync");
     apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
           [&](gsl::span<const size_t> index) -> void {
               dest.data()[offset(dest.strides(), index)] =
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/kernel copy.h b/modules/cpu/src/runtime/cmodel/tests/demo4/kernel copy.h
deleted file mode 100644
index 2269adad89..0000000000
--- a/modules/cpu/src/runtime/cmodel/tests/demo4/kernel copy.h	
+++ /dev/null
@@ -1,28 +0,0 @@
-// llama 65B
-// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
-// 1 chips, 8 blocks per chip, 4 threads per block
-
-#include "thread_context.h"
-using namespace shared;
-
-#define DUMP 0
-
-void stage1_kernel(
-    tensor<int64_t, loc_t::device> &Position_ids, /* [1, 384] */
-    tensor<float, loc_t::device> &GatherData,   /* [32000, 8192] */
-    tensor<float, loc_t::device> &Output          /* [1, 384, 8192] */
-) {
-    thread_context ctx(bid, tid);
-    tensor<int64_t> position_ids({1, 384});
-    tensor<float> gather_data({32000, 256});
-    tensor<float> output({1, 384, 256});
-
-    tdma_load_async(position_ids, std::move(Position_ids), ctx);
-    tdma_load_async(gather_data,
-                    GatherData({0, 256 * (CORES * bid + tid)}, {32000, 256}),
-                    ctx);
-    gather(gather_data, position_ids, output, 0);
-
-    tdma_store_async(
-        output, Output({0, 0, 256 * (CORES * bid + tid)}, {1, 384, 256}), ctx);
-}
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp b/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
index 2978d7b03b..7f2469b710 100644
--- a/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
@@ -25,8 +25,8 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
-void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt, nncase_mt_t *nncase_mt_impl,
-            uint8_t **inputs) {
+void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
     runtime_util = *rt_util_mt;
     nncase_mt = *nncase_mt_impl;
@@ -35,6 +35,10 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt, nncas
         gsl::make_span((float *)inputs[0], 384 * 8192), {1, 384, 8192});
     Hidden_in = &input0;
 
+    auto input1 = tensor<float, loc_t::device>(
+        gsl::make_span((float *)inputs[1], 384 * 8192), {1, 384, 8192});
+    Output = &input1;
+
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
     pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;

From a54866cab31722f25bac728241f751f2cf744e58 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 6 Sep 2023 16:19:29 +0800
Subject: [PATCH 157/308] update demo names

---
 .../{demo3 => decoder_layer}/cluster_def.h    |   0
 .../tests/{demo3 => decoder_layer}/golden.py  |   0
 .../tests/{demo3 => decoder_layer}/kernel.h   |   0
 .../tests/{demo3 => decoder_layer}/main.cpp   |   0
 .../{demo3 => decoder_layer}/shared_def.h     |   0
 .../cmodel/tests/demo4/cluster_def copy.h     | 171 ----------------
 .../runtime/cmodel/tests/demo4/cluster_def.h  | 171 ----------------
 .../src/runtime/cmodel/tests/demo4/golden.py  |  31 ---
 .../src/runtime/cmodel/tests/demo4/kernel.h   |  28 ---
 .../src/runtime/cmodel/tests/demo4/main.cpp   | 123 ------------
 .../runtime/cmodel/tests/demo4/shared_def.h   |   4 -
 .../src/runtime/cmodel/tests/embed/golden.py  |  10 +-
 .../src/runtime/cmodel/tests/embed/kernel.h   |  10 +-
 .../src/runtime/cmodel/tests/embed/main.cpp   | 186 +++++++++---------
 .../runtime/cmodel/tests/embed/shared_def.h   |   1 -
 15 files changed, 98 insertions(+), 637 deletions(-)
 rename modules/cpu/src/runtime/cmodel/tests/{demo3 => decoder_layer}/cluster_def.h (100%)
 rename modules/cpu/src/runtime/cmodel/tests/{demo3 => decoder_layer}/golden.py (100%)
 rename modules/cpu/src/runtime/cmodel/tests/{demo3 => decoder_layer}/kernel.h (100%)
 rename modules/cpu/src/runtime/cmodel/tests/{demo3 => decoder_layer}/main.cpp (100%)
 rename modules/cpu/src/runtime/cmodel/tests/{demo3 => decoder_layer}/shared_def.h (100%)
 delete mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def copy.h
 delete mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def.h
 delete mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/golden.py
 delete mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h
 delete mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
 delete mode 100644 modules/cpu/src/runtime/cmodel/tests/demo4/shared_def.h

diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/cluster_def.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/cluster_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo3/cluster_def.h
rename to modules/cpu/src/runtime/cmodel/tests/decoder_layer/cluster_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/golden.py b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/golden.py
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo3/golden.py
rename to modules/cpu/src/runtime/cmodel/tests/decoder_layer/golden.py
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo3/kernel.h
rename to modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo3/main.cpp
rename to modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo3/shared_def.h
rename to modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def copy.h b/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def copy.h
deleted file mode 100644
index 8fd5d84ed7..0000000000
--- a/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def copy.h	
+++ /dev/null
@@ -1,171 +0,0 @@
-#pragma once
-#include <hardware_context.h>
-#include <tdma.h>
-
-namespace block0 {
-#include "shared_def.h"
-constexpr size_t bid = 0;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block0
-
-namespace block1 {
-#include "shared_def.h"
-constexpr size_t bid = 1;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block1
-
-namespace block2 {
-#include "shared_def.h"
-constexpr size_t bid = 2;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block2
-
-namespace block3 {
-#include "shared_def.h"
-constexpr size_t bid = 3;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block3
-
-namespace block4 {
-#include "shared_def.h"
-constexpr size_t bid = 4;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block4
-
-namespace block5 {
-#include "shared_def.h"
-constexpr size_t bid = 5;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block5
-
-namespace block6 {
-#include "shared_def.h"
-constexpr size_t bid = 6;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block6
-
-namespace block7 {
-#include "shared_def.h"
-constexpr size_t bid = 7;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block7
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def.h b/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def.h
deleted file mode 100644
index 8fd5d84ed7..0000000000
--- a/modules/cpu/src/runtime/cmodel/tests/demo4/cluster_def.h
+++ /dev/null
@@ -1,171 +0,0 @@
-#pragma once
-#include <hardware_context.h>
-#include <tdma.h>
-
-namespace block0 {
-#include "shared_def.h"
-constexpr size_t bid = 0;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block0
-
-namespace block1 {
-#include "shared_def.h"
-constexpr size_t bid = 1;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block1
-
-namespace block2 {
-#include "shared_def.h"
-constexpr size_t bid = 2;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block2
-
-namespace block3 {
-#include "shared_def.h"
-constexpr size_t bid = 3;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block3
-
-namespace block4 {
-#include "shared_def.h"
-constexpr size_t bid = 4;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block4
-
-namespace block5 {
-#include "shared_def.h"
-constexpr size_t bid = 5;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block5
-
-namespace block6 {
-#include "shared_def.h"
-constexpr size_t bid = 6;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block6
-
-namespace block7 {
-#include "shared_def.h"
-constexpr size_t bid = 7;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block7
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/golden.py b/modules/cpu/src/runtime/cmodel/tests/demo4/golden.py
deleted file mode 100644
index 4ead78241d..0000000000
--- a/modules/cpu/src/runtime/cmodel/tests/demo4/golden.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import numpy as np
-from torch import nn
-import torch
-from scipy.special import softmax
-import os
-
-
-def rmsnorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray, eps=1e-05):
-    x = torch.from_numpy(x)
-    output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
-    output = output * torch.from_numpy(gamma) + torch.from_numpy(beta)
-    return output.detach().numpy()
-
-
-def layernorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray):
-    return nn.functional.layer_norm(torch.from_numpy(x), [x.shape[-1]], torch.from_numpy(gamma), torch.from_numpy(beta)).detach().numpy()
-
-
-def swish(x: np.ndarray):
-    return x / (1 + np.exp(-x))
-
-
-def gather(data: np.ndarray, axis: int, indices: np.ndarray):
-    return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
-
-
-hidden_in = np.random.rand(1, 384, 8192).astype(np.float32)
-hidden_in.tofile('hidden_in.bin')
-output = rmsnorm(hidden_in, np.ones([8192], np.float32), np.zeros([8192], np.float32))
-# f32[1,384,8192]
-output.tofile("output.bin")
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h b/modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h
deleted file mode 100644
index f3bf7d71a1..0000000000
--- a/modules/cpu/src/runtime/cmodel/tests/demo4/kernel.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// llama 65B
-// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
-// 1 chips, 8 blocks per chip, 4 threads per block
-
-#include "thread_context.h"
-using namespace shared;
-
-#define DUMP 0
-
-void stage1_kernel(
-    [[maybe_unused]] tensor<int64_t, loc_t::device> &Position_ids, /* [1, 384] */
-    [[maybe_unused]] tensor<float, loc_t::device> &GatherData,   /* [32000, 8192] */
-    [[maybe_unused]] tensor<float, loc_t::device> &Output          /* [1, 384, 8192] */
-) {
-    thread_context ctx(bid, tid);
-    tensor<int64_t> position_ids({1, 384});
-    tensor<float> gather_data({384, 256});
-    tensor<float> output({1, 384, 256});
-
-    tdma_load_async(position_ids, std::move(Position_ids), ctx);
-    tdma_load_async(gather_data,
-                    GatherData({0, 256 * (CORES * bid + tid)}, {384, 256}),
-                    ctx);
-    gather(gather_data, position_ids, output, 0);
-
-    tdma_store_async(
-        output, Output({0, 0, 256 * (CORES * bid + tid)}, {1, 384, 256}), ctx);
-}
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
deleted file mode 100644
index 98a85bec6c..0000000000
--- a/modules/cpu/src/runtime/cmodel/tests/demo4/main.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-#include "cluster_def.h"
-#include <runtime_utils.h>
-
-#define DEFINE_TFUNC(b, t)                                                     \
-    void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(*Position_ids, *GatherData,         \
-                                           *Output);                           \
-        return arg;                                                            \
-    }
-
-#define DEFINE_BFUNC(b)                                                        \
-    DEFINE_TFUNC(b, 0)                                                         \
-    DEFINE_TFUNC(b, 1)                                                         \
-    DEFINE_TFUNC(b, 2)                                                         \
-    DEFINE_TFUNC(b, 3)
-
-static tensor<int64_t, loc_t::device> *Position_ids;
-static tensor<float, loc_t::device> *GatherData;
-static tensor<float, loc_t::device> *Output;
-
-DEFINE_BFUNC(0)
-DEFINE_BFUNC(1)
-DEFINE_BFUNC(2)
-DEFINE_BFUNC(3)
-DEFINE_BFUNC(4)
-DEFINE_BFUNC(5)
-DEFINE_BFUNC(6)
-DEFINE_BFUNC(7)
-
-void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt, nncase_mt_t *nncase_mt_impl,
-            uint8_t **inputs) {
-    global_hardware_init(hw_ctx_impl);
-    runtime_util = *rt_util_mt;
-    nncase_mt = *nncase_mt_impl;
-
-    auto Position_ids_ = tensor<int64_t, loc_t::device>(
-        gsl::make_span((int64_t *)inputs[0], 384), {1, 384});
-    runtime_util.printf("1\n");
-
-    auto GatherData_ = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[1], 384 * 8192), {384, 8192});
-
-    runtime_util.printf("2\n");
-    auto Output_ = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[2], 384 * 8192), {1, 384, 8192});
-
-    runtime_util.printf("3\n");
-    Position_ids = &Position_ids_;
-    GatherData = &GatherData_;
-    Output = &Output_;
-    runtime_util.printf("%d\n", Position_ids->data().size());
-
-    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
-
-    runtime_util.create_thread(t_0_0, NULL, f_0_0);
-    runtime_util.create_thread(t_0_1, NULL, f_0_1);
-    runtime_util.create_thread(t_0_2, NULL, f_0_2);
-    runtime_util.create_thread(t_0_3, NULL, f_0_3);
-    runtime_util.create_thread(t_1_0, NULL, f_1_0);
-    runtime_util.create_thread(t_1_1, NULL, f_1_1);
-    runtime_util.create_thread(t_1_2, NULL, f_1_2);
-    runtime_util.create_thread(t_1_3, NULL, f_1_3);
-    runtime_util.create_thread(t_2_0, NULL, f_2_0);
-    runtime_util.create_thread(t_2_1, NULL, f_2_1);
-    runtime_util.create_thread(t_2_2, NULL, f_2_2);
-    runtime_util.create_thread(t_2_3, NULL, f_2_3);
-    runtime_util.create_thread(t_3_0, NULL, f_3_0);
-    runtime_util.create_thread(t_3_1, NULL, f_3_1);
-    runtime_util.create_thread(t_3_2, NULL, f_3_2);
-    runtime_util.create_thread(t_3_3, NULL, f_3_3);
-    runtime_util.create_thread(t_4_0, NULL, f_4_0);
-    runtime_util.create_thread(t_4_1, NULL, f_4_1);
-    runtime_util.create_thread(t_4_2, NULL, f_4_2);
-    runtime_util.create_thread(t_4_3, NULL, f_4_3);
-    runtime_util.create_thread(t_5_0, NULL, f_5_0);
-    runtime_util.create_thread(t_5_1, NULL, f_5_1);
-    runtime_util.create_thread(t_5_2, NULL, f_5_2);
-    runtime_util.create_thread(t_5_3, NULL, f_5_3);
-    runtime_util.create_thread(t_6_0, NULL, f_6_0);
-    runtime_util.create_thread(t_6_1, NULL, f_6_1);
-    runtime_util.create_thread(t_6_2, NULL, f_6_2);
-    runtime_util.create_thread(t_6_3, NULL, f_6_3);
-    runtime_util.create_thread(t_7_0, NULL, f_7_0);
-    runtime_util.create_thread(t_7_1, NULL, f_7_1);
-    runtime_util.create_thread(t_7_2, NULL, f_7_2);
-    runtime_util.create_thread(t_7_3, NULL, f_7_3);
-
-    runtime_util.join_thread(t_0_0);
-    runtime_util.join_thread(t_0_1);
-    runtime_util.join_thread(t_0_2);
-    runtime_util.join_thread(t_0_3);
-    runtime_util.join_thread(t_1_0);
-    runtime_util.join_thread(t_1_1);
-    runtime_util.join_thread(t_1_2);
-    runtime_util.join_thread(t_1_3);
-    runtime_util.join_thread(t_2_0);
-    runtime_util.join_thread(t_2_1);
-    runtime_util.join_thread(t_2_2);
-    runtime_util.join_thread(t_2_3);
-    runtime_util.join_thread(t_3_0);
-    runtime_util.join_thread(t_3_1);
-    runtime_util.join_thread(t_3_2);
-    runtime_util.join_thread(t_3_3);
-    runtime_util.join_thread(t_4_0);
-    runtime_util.join_thread(t_4_1);
-    runtime_util.join_thread(t_4_2);
-    runtime_util.join_thread(t_4_3);
-    runtime_util.join_thread(t_5_0);
-    runtime_util.join_thread(t_5_1);
-    runtime_util.join_thread(t_5_2);
-    runtime_util.join_thread(t_5_3);
-    runtime_util.join_thread(t_6_0);
-    runtime_util.join_thread(t_6_1);
-    runtime_util.join_thread(t_6_2);
-    runtime_util.join_thread(t_6_3);
-    runtime_util.join_thread(t_7_0);
-    runtime_util.join_thread(t_7_1);
-    runtime_util.join_thread(t_7_2);
-    runtime_util.join_thread(t_7_3);
-}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo4/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/demo4/shared_def.h
deleted file mode 100644
index b18a608408..0000000000
--- a/modules/cpu/src/runtime/cmodel/tests/demo4/shared_def.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#include <tdma.h>
-
-namespace shared {
-} // namespace shared
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/golden.py b/modules/cpu/src/runtime/cmodel/tests/embed/golden.py
index 19ba3da927..4ead78241d 100644
--- a/modules/cpu/src/runtime/cmodel/tests/embed/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/golden.py
@@ -24,10 +24,8 @@ def gather(data: np.ndarray, axis: int, indices: np.ndarray):
     return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
 
 
-position_ids = np.random.randint(0, 384, (1, 384), np.int64)
-position_ids.tofile('position_ids.bin')
-data = np.random.rand(32000,8192).astype(np.float32)
-data.tofile('data.bin')
-output = data[position_ids]
+hidden_in = np.random.rand(1, 384, 8192).astype(np.float32)
+hidden_in.tofile('hidden_in.bin')
+output = rmsnorm(hidden_in, np.ones([8192], np.float32), np.zeros([8192], np.float32))
 # f32[1,384,8192]
-output.tofile("output.bin")
\ No newline at end of file
+output.tofile("output.bin")
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h b/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
index 2269adad89..f3bf7d71a1 100644
--- a/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
@@ -8,18 +8,18 @@ using namespace shared;
 #define DUMP 0
 
 void stage1_kernel(
-    tensor<int64_t, loc_t::device> &Position_ids, /* [1, 384] */
-    tensor<float, loc_t::device> &GatherData,   /* [32000, 8192] */
-    tensor<float, loc_t::device> &Output          /* [1, 384, 8192] */
+    [[maybe_unused]] tensor<int64_t, loc_t::device> &Position_ids, /* [1, 384] */
+    [[maybe_unused]] tensor<float, loc_t::device> &GatherData,   /* [32000, 8192] */
+    [[maybe_unused]] tensor<float, loc_t::device> &Output          /* [1, 384, 8192] */
 ) {
     thread_context ctx(bid, tid);
     tensor<int64_t> position_ids({1, 384});
-    tensor<float> gather_data({32000, 256});
+    tensor<float> gather_data({384, 256});
     tensor<float> output({1, 384, 256});
 
     tdma_load_async(position_ids, std::move(Position_ids), ctx);
     tdma_load_async(gather_data,
-                    GatherData({0, 256 * (CORES * bid + tid)}, {32000, 256}),
+                    GatherData({0, 256 * (CORES * bid + tid)}, {384, 256}),
                     ctx);
     gather(gather_data, position_ids, output, 0);
 
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp b/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
index bab5899044..98a85bec6c 100644
--- a/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
@@ -1,11 +1,10 @@
 #include "cluster_def.h"
-#include <io_utils.h>
 #include <runtime_utils.h>
-// #include <pthread.h>
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(Position_ids, GatherData, Output);     \
+        block##b::thread##t::stage1_kernel(*Position_ids, *GatherData,         \
+                                           *Output);                           \
         return arg;                                                            \
     }
 
@@ -15,9 +14,9 @@
     DEFINE_TFUNC(b, 2)                                                         \
     DEFINE_TFUNC(b, 3)
 
-static tensor<int64_t, loc_t::device> Position_ids({1, 384});
-static tensor<float, loc_t::device> GatherData({32000, 8192});
-static tensor<float, loc_t::device> Output({1, 384, 8192});
+static tensor<int64_t, loc_t::device> *Position_ids;
+static tensor<float, loc_t::device> *GatherData;
+static tensor<float, loc_t::device> *Output;
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
@@ -28,104 +27,97 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
-#define LOAD_FILE(name, i, type)                                               \
-    {                                                                          \
-        auto src_##name = read_file(std::string(argv[(i)]));                   \
-        span_copy(name.data(), gsl::make_span(src_##name).as_span<type>());    \
-    }
+void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt, nncase_mt_t *nncase_mt_impl,
+            uint8_t **inputs) {
+    global_hardware_init(hw_ctx_impl);
+    runtime_util = *rt_util_mt;
+    nncase_mt = *nncase_mt_impl;
+
+    auto Position_ids_ = tensor<int64_t, loc_t::device>(
+        gsl::make_span((int64_t *)inputs[0], 384), {1, 384});
+    runtime_util.printf("1\n");
+
+    auto GatherData_ = tensor<float, loc_t::device>(
+        gsl::make_span((float *)inputs[1], 384 * 8192), {384, 8192});
 
-/**
- * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
- *
- * @param argc
- * @param argv
- * @return int
- */
-int main([[maybe_unused]] int argc, char **argv) {
-    // spdlog::set_level(spdlog::level::debug);
-    global_hardware_init();
+    runtime_util.printf("2\n");
+    auto Output_ = tensor<float, loc_t::device>(
+        gsl::make_span((float *)inputs[2], 384 * 8192), {1, 384, 8192});
 
-    LOAD_FILE(Position_ids, 1, int64_t);
-    LOAD_FILE(GatherData, 2, float);
+    runtime_util.printf("3\n");
+    Position_ids = &Position_ids_;
+    GatherData = &GatherData_;
+    Output = &Output_;
+    runtime_util.printf("%d\n", Position_ids->data().size());
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
     pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
     pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
-    pthread_create(&t_0_0, NULL, f_0_0, NULL);
-    pthread_create(&t_0_1, NULL, f_0_1, NULL);
-    pthread_create(&t_0_2, NULL, f_0_2, NULL);
-    pthread_create(&t_0_3, NULL, f_0_3, NULL);
-    pthread_create(&t_1_0, NULL, f_1_0, NULL);
-    pthread_create(&t_1_1, NULL, f_1_1, NULL);
-    pthread_create(&t_1_2, NULL, f_1_2, NULL);
-    pthread_create(&t_1_3, NULL, f_1_3, NULL);
-    pthread_create(&t_2_0, NULL, f_2_0, NULL);
-    pthread_create(&t_2_1, NULL, f_2_1, NULL);
-    pthread_create(&t_2_2, NULL, f_2_2, NULL);
-    pthread_create(&t_2_3, NULL, f_2_3, NULL);
-    pthread_create(&t_3_0, NULL, f_3_0, NULL);
-    pthread_create(&t_3_1, NULL, f_3_1, NULL);
-    pthread_create(&t_3_2, NULL, f_3_2, NULL);
-    pthread_create(&t_3_3, NULL, f_3_3, NULL);
-    pthread_create(&t_4_0, NULL, f_4_0, NULL);
-    pthread_create(&t_4_1, NULL, f_4_1, NULL);
-    pthread_create(&t_4_2, NULL, f_4_2, NULL);
-    pthread_create(&t_4_3, NULL, f_4_3, NULL);
-    pthread_create(&t_5_0, NULL, f_5_0, NULL);
-    pthread_create(&t_5_1, NULL, f_5_1, NULL);
-    pthread_create(&t_5_2, NULL, f_5_2, NULL);
-    pthread_create(&t_5_3, NULL, f_5_3, NULL);
-    pthread_create(&t_6_0, NULL, f_6_0, NULL);
-    pthread_create(&t_6_1, NULL, f_6_1, NULL);
-    pthread_create(&t_6_2, NULL, f_6_2, NULL);
-    pthread_create(&t_6_3, NULL, f_6_3, NULL);
-    pthread_create(&t_7_0, NULL, f_7_0, NULL);
-    pthread_create(&t_7_1, NULL, f_7_1, NULL);
-    pthread_create(&t_7_2, NULL, f_7_2, NULL);
-    pthread_create(&t_7_3, NULL, f_7_3, NULL);
-
-    pthread_join(t_0_0, NULL);
-    pthread_join(t_0_1, NULL);
-    pthread_join(t_0_2, NULL);
-    pthread_join(t_0_3, NULL);
-    pthread_join(t_1_0, NULL);
-    pthread_join(t_1_1, NULL);
-    pthread_join(t_1_2, NULL);
-    pthread_join(t_1_3, NULL);
-    pthread_join(t_2_0, NULL);
-    pthread_join(t_2_1, NULL);
-    pthread_join(t_2_2, NULL);
-    pthread_join(t_2_3, NULL);
-    pthread_join(t_3_0, NULL);
-    pthread_join(t_3_1, NULL);
-    pthread_join(t_3_2, NULL);
-    pthread_join(t_3_3, NULL);
-    pthread_join(t_4_0, NULL);
-    pthread_join(t_4_1, NULL);
-    pthread_join(t_4_2, NULL);
-    pthread_join(t_4_3, NULL);
-    pthread_join(t_5_0, NULL);
-    pthread_join(t_5_1, NULL);
-    pthread_join(t_5_2, NULL);
-    pthread_join(t_5_3, NULL);
-    pthread_join(t_6_0, NULL);
-    pthread_join(t_6_1, NULL);
-    pthread_join(t_6_2, NULL);
-    pthread_join(t_6_3, NULL);
-    pthread_join(t_7_0, NULL);
-    pthread_join(t_7_1, NULL);
-    pthread_join(t_7_2, NULL);
-    pthread_join(t_7_3, NULL);
-
-    {
-        auto src_output = read_file(std::string(argv[3]));
-        auto src_span = gsl::make_span(src_output).as_span<float>();
-        auto cos =
-            cosine(Output.data().data(), src_span.data(), src_span.size());
-        printf("Output cosine %f\n", cos);
-    }
+    runtime_util.create_thread(t_0_0, NULL, f_0_0);
+    runtime_util.create_thread(t_0_1, NULL, f_0_1);
+    runtime_util.create_thread(t_0_2, NULL, f_0_2);
+    runtime_util.create_thread(t_0_3, NULL, f_0_3);
+    runtime_util.create_thread(t_1_0, NULL, f_1_0);
+    runtime_util.create_thread(t_1_1, NULL, f_1_1);
+    runtime_util.create_thread(t_1_2, NULL, f_1_2);
+    runtime_util.create_thread(t_1_3, NULL, f_1_3);
+    runtime_util.create_thread(t_2_0, NULL, f_2_0);
+    runtime_util.create_thread(t_2_1, NULL, f_2_1);
+    runtime_util.create_thread(t_2_2, NULL, f_2_2);
+    runtime_util.create_thread(t_2_3, NULL, f_2_3);
+    runtime_util.create_thread(t_3_0, NULL, f_3_0);
+    runtime_util.create_thread(t_3_1, NULL, f_3_1);
+    runtime_util.create_thread(t_3_2, NULL, f_3_2);
+    runtime_util.create_thread(t_3_3, NULL, f_3_3);
+    runtime_util.create_thread(t_4_0, NULL, f_4_0);
+    runtime_util.create_thread(t_4_1, NULL, f_4_1);
+    runtime_util.create_thread(t_4_2, NULL, f_4_2);
+    runtime_util.create_thread(t_4_3, NULL, f_4_3);
+    runtime_util.create_thread(t_5_0, NULL, f_5_0);
+    runtime_util.create_thread(t_5_1, NULL, f_5_1);
+    runtime_util.create_thread(t_5_2, NULL, f_5_2);
+    runtime_util.create_thread(t_5_3, NULL, f_5_3);
+    runtime_util.create_thread(t_6_0, NULL, f_6_0);
+    runtime_util.create_thread(t_6_1, NULL, f_6_1);
+    runtime_util.create_thread(t_6_2, NULL, f_6_2);
+    runtime_util.create_thread(t_6_3, NULL, f_6_3);
+    runtime_util.create_thread(t_7_0, NULL, f_7_0);
+    runtime_util.create_thread(t_7_1, NULL, f_7_1);
+    runtime_util.create_thread(t_7_2, NULL, f_7_2);
+    runtime_util.create_thread(t_7_3, NULL, f_7_3);
 
-    return 0;
+    runtime_util.join_thread(t_0_0);
+    runtime_util.join_thread(t_0_1);
+    runtime_util.join_thread(t_0_2);
+    runtime_util.join_thread(t_0_3);
+    runtime_util.join_thread(t_1_0);
+    runtime_util.join_thread(t_1_1);
+    runtime_util.join_thread(t_1_2);
+    runtime_util.join_thread(t_1_3);
+    runtime_util.join_thread(t_2_0);
+    runtime_util.join_thread(t_2_1);
+    runtime_util.join_thread(t_2_2);
+    runtime_util.join_thread(t_2_3);
+    runtime_util.join_thread(t_3_0);
+    runtime_util.join_thread(t_3_1);
+    runtime_util.join_thread(t_3_2);
+    runtime_util.join_thread(t_3_3);
+    runtime_util.join_thread(t_4_0);
+    runtime_util.join_thread(t_4_1);
+    runtime_util.join_thread(t_4_2);
+    runtime_util.join_thread(t_4_3);
+    runtime_util.join_thread(t_5_0);
+    runtime_util.join_thread(t_5_1);
+    runtime_util.join_thread(t_5_2);
+    runtime_util.join_thread(t_5_3);
+    runtime_util.join_thread(t_6_0);
+    runtime_util.join_thread(t_6_1);
+    runtime_util.join_thread(t_6_2);
+    runtime_util.join_thread(t_6_3);
+    runtime_util.join_thread(t_7_0);
+    runtime_util.join_thread(t_7_1);
+    runtime_util.join_thread(t_7_2);
+    runtime_util.join_thread(t_7_3);
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h
index 99872569ef..b18a608408 100644
--- a/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h
@@ -1,5 +1,4 @@
 #include <tdma.h>
 
 namespace shared {
-
 } // namespace shared
\ No newline at end of file

From 6aae26ef924ae79e4bd406ecbe7a0dc4fdbcee60 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 7 Sep 2023 10:37:43 +0800
Subject: [PATCH 158/308] add xpu source gen

---
 .../Nncase.Modules.CPU/CPUApplicationPart.cs  |   3 +-
 .../CodeGen/CSourceBuiltn.cs                  | 140 +++++++++-
 .../CodeGen/CSourceConvertVisitor.cs          | 248 ++++++++++++++++++
 .../CodeGen/CSourceExtensions.cs              |  26 ++
 .../CodeGen/FunctionBuilder.cs                |  44 ----
 .../CodeGen/FunctionCSource.cs                |   8 +-
 .../CodeGen/LinkableModule.cs                 | 129 ++++-----
 .../Evaluator/CPU/CPUModule.cs                |   3 -
 .../TDMALoadEvaluator.cs => XPU/TDMALoad.cs}  |   8 +-
 .../TDMAStore.cs}                             |   8 +-
 .../{CPU/UnaryEvaluator.cs => XPU/Unary.cs}   |   2 +-
 .../Evaluator/XPU/XPUModule.cs                |  20 ++
 .../Nncase.Modules.CPU/IR/CPU/Functional.cs   |  15 --
 modules/Nncase.Modules.CPU/IR/CPU/TDMALoad.cs |  11 -
 .../Nncase.Modules.CPU/IR/CPU/TDMAStore.cs    |  13 -
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  29 ++
 modules/Nncase.Modules.CPU/IR/XPU/TDMALoad.cs |  15 ++
 .../Nncase.Modules.CPU/IR/XPU/TDMAStore.cs    |  16 ++
 .../IR/{CPU => XPU}/Unary.cs                  |   4 +-
 .../Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs  |   9 +
 .../Passes/Tile/SingleCPUFusionConverter.cs   |   9 +-
 .../Diagnostics/ScriptPrintVisitor.cs         |   2 +-
 22 files changed, 594 insertions(+), 168 deletions(-)
 rename modules/Nncase.Modules.CPU/Evaluator/{CPU/TDMALoadEvaluator.cs => XPU/TDMALoad.cs} (83%)
 rename modules/Nncase.Modules.CPU/Evaluator/{CPU/TDMAStoreEvaluator.cs => XPU/TDMAStore.cs} (84%)
 rename modules/Nncase.Modules.CPU/Evaluator/{CPU/UnaryEvaluator.cs => XPU/Unary.cs} (96%)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
 delete mode 100644 modules/Nncase.Modules.CPU/IR/CPU/TDMALoad.cs
 delete mode 100644 modules/Nncase.Modules.CPU/IR/CPU/TDMAStore.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/TDMALoad.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/TDMAStore.cs
 rename modules/Nncase.Modules.CPU/IR/{CPU => XPU}/Unary.cs (86%)
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs

diff --git a/modules/Nncase.Modules.CPU/CPUApplicationPart.cs b/modules/Nncase.Modules.CPU/CPUApplicationPart.cs
index 655138ddd4..ad0c637cf5 100644
--- a/modules/Nncase.Modules.CPU/CPUApplicationPart.cs
+++ b/modules/Nncase.Modules.CPU/CPUApplicationPart.cs
@@ -25,6 +25,7 @@ public static class CPUApplicationPart
     public static IRegistrator AddCPU(this IRegistrator registrator)
     {
         return registrator.RegisterModule<CPUModule>()
-            .RegisterModule<Evaluator.CPU.CPUModule>();
+            .RegisterModule<Evaluator.CPU.CPUModule>()
+            .RegisterModule<Evaluator.XPU.XPUModule>();
     }
 }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index 81c495da47..34917d7143 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -1,10 +1,144 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+#define MULTI_CORE_CPU
+using NetFabric.Hyperlinq;
 
 namespace Nncase.CodeGen.CPU;
 
 public static class CSourceBuiltn
 {
+#if MULTI_CORE_CPU
+    public const string KernelHeader = @"#include ""thread_context.h""
+using namespace shared;
+";
+
+    public static string MakeMain(TIR.PrimFunction primFunction)
+    {
+        string device_tensors = string.Join('\n', primFunction.Parameters.AsValueEnumerable().Select(b => $"static tensor<{b.ElemType.ToC()},{b.MemSpan.Location.ToC()}> *{b.Name};").ToArray());
+
+        string init_tensors = string.Join('\n', primFunction.Parameters.ToArray().Select((b, i) =>
+        {
+            var size = TensorUtilities.GetSize(b.CheckedShape.ToValueArray(), TensorUtilities.GetStrides(b.CheckedShape.ToValueArray()), 1);
+            return $@"auto {b.Name}_ = tensor<{b.ElemType.ToC()}, {b.MemSpan.Location.ToC()}>(gsl::make_span(({b.ElemType.ToC()}*)inputs[{i}], {size}), {{{string.Join(',', b.CheckedShape)}}});
+    Output = &{b.Name}_;";
+        }));
+
+        return @$"#include ""cluster_def.h""
+#include <runtime_utils.h>
+
+#define DEFINE_TFUNC(b, t)                                                     \
+    void *f_##b##_##t(void *arg) {{                                             \
+        block##b::thread##t::{primFunction.Name}({string.Join(',', primFunction.Parameters.AsValueEnumerable().Select(b => '*' + b.Name).ToArray())});               \
+        return arg;                                                            \
+    }}
+
+#define DEFINE_BFUNC(b)                                                        \
+    DEFINE_TFUNC(b, 0)                                                         \
+    DEFINE_TFUNC(b, 1)                                                         \
+    DEFINE_TFUNC(b, 2)                                                         \
+    DEFINE_TFUNC(b, 3)
+
+{device_tensors}
+
+DEFINE_BFUNC(0)
+DEFINE_BFUNC(1)
+DEFINE_BFUNC(2)
+DEFINE_BFUNC(3)
+DEFINE_BFUNC(4)
+DEFINE_BFUNC(5)
+DEFINE_BFUNC(6)
+DEFINE_BFUNC(7)
+
+void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {{global_hardware_init(hw_ctx_impl);
+    runtime_util = *rt_util_mt;
+    nncase_mt = *nncase_mt_impl;
+
+    {init_tensors}
+
+    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
+
+    runtime_util.create_thread(t_0_0, NULL, f_0_0);
+    runtime_util.create_thread(t_0_1, NULL, f_0_1);
+    runtime_util.create_thread(t_0_2, NULL, f_0_2);
+    runtime_util.create_thread(t_0_3, NULL, f_0_3);
+    runtime_util.create_thread(t_1_0, NULL, f_1_0);
+    runtime_util.create_thread(t_1_1, NULL, f_1_1);
+    runtime_util.create_thread(t_1_2, NULL, f_1_2);
+    runtime_util.create_thread(t_1_3, NULL, f_1_3);
+    runtime_util.create_thread(t_2_0, NULL, f_2_0);
+    runtime_util.create_thread(t_2_1, NULL, f_2_1);
+    runtime_util.create_thread(t_2_2, NULL, f_2_2);
+    runtime_util.create_thread(t_2_3, NULL, f_2_3);
+    runtime_util.create_thread(t_3_0, NULL, f_3_0);
+    runtime_util.create_thread(t_3_1, NULL, f_3_1);
+    runtime_util.create_thread(t_3_2, NULL, f_3_2);
+    runtime_util.create_thread(t_3_3, NULL, f_3_3);
+    runtime_util.create_thread(t_4_0, NULL, f_4_0);
+    runtime_util.create_thread(t_4_1, NULL, f_4_1);
+    runtime_util.create_thread(t_4_2, NULL, f_4_2);
+    runtime_util.create_thread(t_4_3, NULL, f_4_3);
+    runtime_util.create_thread(t_5_0, NULL, f_5_0);
+    runtime_util.create_thread(t_5_1, NULL, f_5_1);
+    runtime_util.create_thread(t_5_2, NULL, f_5_2);
+    runtime_util.create_thread(t_5_3, NULL, f_5_3);
+    runtime_util.create_thread(t_6_0, NULL, f_6_0);
+    runtime_util.create_thread(t_6_1, NULL, f_6_1);
+    runtime_util.create_thread(t_6_2, NULL, f_6_2);
+    runtime_util.create_thread(t_6_3, NULL, f_6_3);
+    runtime_util.create_thread(t_7_0, NULL, f_7_0);
+    runtime_util.create_thread(t_7_1, NULL, f_7_1);
+    runtime_util.create_thread(t_7_2, NULL, f_7_2);
+    runtime_util.create_thread(t_7_3, NULL, f_7_3);
+
+    runtime_util.join_thread(t_0_0);
+    runtime_util.join_thread(t_0_1);
+    runtime_util.join_thread(t_0_2);
+    runtime_util.join_thread(t_0_3);
+    runtime_util.join_thread(t_1_0);
+    runtime_util.join_thread(t_1_1);
+    runtime_util.join_thread(t_1_2);
+    runtime_util.join_thread(t_1_3);
+    runtime_util.join_thread(t_2_0);
+    runtime_util.join_thread(t_2_1);
+    runtime_util.join_thread(t_2_2);
+    runtime_util.join_thread(t_2_3);
+    runtime_util.join_thread(t_3_0);
+    runtime_util.join_thread(t_3_1);
+    runtime_util.join_thread(t_3_2);
+    runtime_util.join_thread(t_3_3);
+    runtime_util.join_thread(t_4_0);
+    runtime_util.join_thread(t_4_1);
+    runtime_util.join_thread(t_4_2);
+    runtime_util.join_thread(t_4_3);
+    runtime_util.join_thread(t_5_0);
+    runtime_util.join_thread(t_5_1);
+    runtime_util.join_thread(t_5_2);
+    runtime_util.join_thread(t_5_3);
+    runtime_util.join_thread(t_6_0);
+    runtime_util.join_thread(t_6_1);
+    runtime_util.join_thread(t_6_2);
+    runtime_util.join_thread(t_6_3);
+    runtime_util.join_thread(t_7_0);
+    runtime_util.join_thread(t_7_1);
+    runtime_util.join_thread(t_7_2);
+    runtime_util.join_thread(t_7_3);
+}}";
+    }
+
+    public static string MakeShared()
+    {
+        return @"#include <tdma.h>
+
+namespace shared {
+} // namespace shared";
+    }
+
+
+#else
     public const string BufferType = "buffer_t";
 
     public const string BufferStruct = @"typedef struct buffer {
@@ -77,10 +211,7 @@ public static class CSourceBuiltn
     void *(*thread_end)();
 } nncase_mt_t;";
 
-    public const string Include = @"#include <stdbool.h>
-#include <stdint.h>
-#include <stddef.h>
-";
+    public const string Include = @"#include <stdbool.h>\n#include <stdint.h>\n#include <stddef.h>";
 
     public const string FixedParameters = "nncase_mt_t* nncase_mt, uint8_t* data, const uint8_t* rdata";
 
@@ -95,4 +226,5 @@ public static class CSourceBuiltn
 
 {BufferStruct}
 ";
+#endif
 }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 1b05cacccf..29992c77cd 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -1,6 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
+#define MULTI_CORE_CPU
+
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -99,6 +101,251 @@ public void IndWrite(string? value)
     }
 }
 
+#if MULTI_CORE_CPU
+/// <summary>
+/// convert single prim function to c source.
+/// </summary>
+internal sealed class CSourceConvertVisitor : ExprFunctor<CSymbol, Unit>
+{
+    private readonly Dictionary<Expr, CSymbol> _exprMemo;
+    private readonly StringBuilder _kernelBuilder;
+
+    private readonly StringBuilder _sharedBuilder;
+    private readonly StringWriter _sharedWriter;
+
+    public CSourceConvertVisitor()
+    {
+        _kernelBuilder = new StringBuilder();
+        _sharedBuilder = new StringBuilder();
+        _sharedWriter = new StringWriter(_sharedBuilder);
+        _exprMemo = new(ReferenceEqualityComparer.Instance);
+    }
+
+    public PrimFunction VisitEntry => (TIR.PrimFunction)VisitRoot!;
+
+    public FunctionCSource GetFunctionCSource()
+    {
+        _exprMemo.Keys.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location == MemoryLocation.L2Data).ToList().ForEach(b =>
+        {
+            _sharedWriter.Write(_exprMemo[b]);
+            _sharedWriter.WriteLine(";");
+        });
+        return new(_sharedBuilder.ToString(), _kernelBuilder.ToString());
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitPrimFunction(PrimFunction expr)
+    {
+        if (_exprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        if (expr.CheckedType is not CallableType { ReturnType: TupleType r } || r != TupleType.Void)
+        {
+            throw new NotSupportedException("The PrimFunction must return void!");
+        }
+
+        var ctype = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(Visit).Select(s => s.ToString()).ToArray())})";
+
+        _sharedWriter.WriteLine(ctype + ";");
+        _sharedWriter.WriteLine();
+
+        using (var scope = new IndentScope(_kernelBuilder))
+        {
+            // 1. Function signature
+            IndentScope.Writer.IndWrite($"{ctype} {{\n");
+
+            // 2. Function body
+            using (_ = new IndentScope())
+            {
+                Visit(expr.Body);
+            }
+
+            // 3. Function closing
+            IndentScope.Writer.IndWrite("}\n");
+        }
+
+        symbol = new(ctype, expr.Name);
+        _exprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitMemSpan(MemSpan expr)
+    {
+        if (_exprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        var start = Visit(expr.Start);
+        _ = Visit(expr.Size);
+        string name = start.Name;
+        if (expr.Start is TensorConst or Call)
+        {
+            var loc = expr.Location switch
+            {
+                MemoryLocation.Rdata => "rdata",
+                MemoryLocation.Data => "data",
+                _ => throw new NotSupportedException(),
+            };
+            name = $"({loc} + {start.Name})";
+        }
+
+        symbol = new(start.Type, name);
+        _exprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    protected override CSymbol VisitBuffer(TIR.Buffer expr)
+    {
+        if (_exprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        var type = $"tensor<{expr.ElemType.ToC()}, {expr.MemSpan.Location.ToC()}> ";
+
+        symbol = new(type, expr.Name);
+        _exprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitCall(Call expr)
+    {
+        if (_exprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        string type = expr.CheckedType switch
+        {
+            TupleType x when x == TupleType.Void => string.Empty,
+            TensorType { IsScalar: true } x => x.DType.ToC(),
+            _ => throw new NotSupportedException(),
+        };
+
+        string str = string.Empty;
+        if (expr.Target is IR.XPU.XPUKernelOp xpuOp)
+        {
+            foreach (var item in expr.Arguments.ToArray().OfType<TIR.Buffer>())
+            {
+                DeclBuffer(item);
+            }
+
+            var args = expr.Arguments.ToArray().OfType<TIR.Buffer>().ToArray();
+            switch (xpuOp)
+            {
+                case IR.XPU.TDMALoad load:
+                    IndentScope.Writer.Write($"tdma_load_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{((TensorType)args[0].CheckedType).ToSlicing(load.NdSbp, load.Placement)})");
+                    break;
+                case IR.XPU.TDMAStore store:
+                    IndentScope.Writer.Write($"tdma_store_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{((TensorType)args[1].CheckedType).ToSlicing(store.NdSbp, store.Placement)})");
+                    break;
+                case IR.XPU.Unary unary:
+                    IndentScope.Writer.Write($"unary({Visit(args[0]).Name}, {Visit(args[1]).Name}, unary_op_t::{unary.UnaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
+                    break;
+            }
+        }
+        else
+        {
+            var arguments = expr.Arguments.AsValueEnumerable().Select(Visit).ToArray();
+            switch (expr.Target)
+            {
+                case IR.Math.Binary op:
+                    str = CSourceUtilities.ContertBinary(op, arguments);
+                    break;
+                case IR.Math.Unary op:
+                    str = CSourceUtilities.ContertUnary(op, arguments);
+                    break;
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        symbol = new(type, str);
+        _exprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitConst(Const expr)
+    {
+        if (_exprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        string type;
+        string str;
+        if (expr is TensorConst { Value: Tensor { ElementType: PrimType ptype, Shape: { IsScalar: true } } scalar })
+        {
+            str = scalar[0].ToString() switch
+            {
+                "True" => "1",
+                "False" => "0",
+                null => string.Empty,
+                var x => x,
+            };
+
+            type = ptype.ToC();
+        }
+        else if (expr is TensorConst { Value: Tensor { ElementType: PointerType { ElemType: PrimType }, Shape: { IsScalar: true } } pointer })
+        {
+            str = pointer.ToScalar<ulong>().ToString();
+            type = "uint8_t *";
+        }
+        else
+        {
+            throw new NotSupportedException();
+        }
+
+        symbol = new(type, str);
+        _exprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    /// <inheritdoc/>
+    protected override CSymbol VisitSequential(Sequential expr)
+    {
+        if (_exprMemo.TryGetValue(expr, out var symbol))
+        {
+            return symbol;
+        }
+
+        foreach (var field in expr.Fields)
+        {
+            if (field is Call call)
+            {
+                IndentScope.Writer.IndWrite(Visit(call).Name);
+                IndentScope.Writer.Write(";\n");
+            }
+            else
+            {
+                Visit(field);
+            }
+        }
+
+        symbol = new(string.Empty, string.Empty);
+        _exprMemo.Add(expr, symbol);
+        return symbol;
+    }
+
+    private void DeclBuffer(TIR.Buffer buffer)
+    {
+        if (_exprMemo.ContainsKey(buffer))
+        {
+            return;
+        }
+
+        var symbol = Visit(buffer);
+
+        IndentScope.Writer.IndWrite($"{symbol.Type} {symbol.Name}({{{string.Join(',', buffer.Dimensions.AsValueEnumerable().Select(Visit).Select(s => s.Name).ToArray())}}});\n");
+    }
+}
+#else
 /// <summary>
 /// convert single prim function to c source.
 /// </summary>
@@ -442,3 +689,4 @@ private string DeclThreadMessageStruct(IEnumerable<CSymbol> keyValues)
         return type;
     }
 }
+#endif
\ No newline at end of file
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index 43fda30de3..88547f5fc9 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -1,6 +1,9 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
+using Nncase.IR;
+using Nncase.TIR;
+
 namespace Nncase.CodeGen.CPU;
 
 /// <summary>
@@ -33,6 +36,29 @@ public static string ToC(this PrimType primType) =>
         _ => throw new NotSupportedException(dataType.ToString()),
     };
 
+    public static string ToC(this MemoryLocation location) => location switch
+    {
+        MemoryLocation.Output or MemoryLocation.Input => "loc_t::device",
+        MemoryLocation.L2Data => "loc_t::shared",
+        MemoryLocation.L1Data => "loc_t::local",
+        _ => throw new NotSupportedException(location.ToString()),
+    };
+
+    public static string ToSlicing(this TensorType tensorType, IRArray<SBP> ndsbp, Placement placement)
+    {
+        var begins = Enumerable.Repeat("0", tensorType.Shape.Rank).ToArray();
+        var hstrides = TensorUtilities.GetStrides(placement.Hierarchy.ToArray());
+        foreach (var (sbp, i) in ndsbp.Select((s, i) => (s, i)))
+        {
+            if (sbp is SBPSplit { Axis: int axis })
+            {
+                begins[axis] += $" + ({tensorType.Shape[axis]} * {hstrides[i]} * {placement.Name[i]}id)";
+            }
+        }
+
+        return $"({{{string.Join(',', begins)}}}, {{{string.Join(",", tensorType.Shape)}}})";
+    }
+
     public static string ToC(this BinaryOp binaryOp) => binaryOp switch
     {
         BinaryOp.Add => "+",
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
index 3ba264dbec..078e0b5175 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
@@ -72,50 +72,6 @@ public unsafe LinkableFunction Build(TIR.PrimFunction function)
 
         // 2. write the desc
         var descContent = new MemoryStream();
-        // using (var descWriter = new BinaryWriter(descContent, Encoding.UTF8))
-        // {
-        //     DescHeader header = new() { InputPoolSize = 0, OutputPoolSize = 0, Inputs = 0, Outputs = 0 };
-        //     long headerStart = descWriter.Position();
-        //     descWriter.Skip((ulong)sizeof(DescHeader));
-
-        //     foreach (var input in function.Parameters.AsValueEnumerable()
-        //                         .Where(buf => buf.MemLocation == TIR.MemoryLocation.Input))
-        //     {
-        //         header.Inputs++;
-        //         var rg = new MemoryRange { Start = checked((uint)input.Start), Size = checked((uint)input.Size) };
-        //         descWriter.Write(ref rg);
-        //         header.InputPoolSize = Math.Max(header.InputPoolSize, rg.Start + rg.Size);
-        //         descWriter.Write((uint)input.FixedDimensions.Length);
-        //         foreach (var dim in input.FixedDimensions)
-        //         {
-        //             descWriter.Write((uint)dim);
-        //         }
-        //         foreach (var s in input.FixedStrides)
-        //         {
-        //             descWriter.Write((uint)s);
-        //         }
-        //     }
-
-        //     foreach (var output in function.Parameters.AsValueEnumerable().Where(buf => buf.MemLocation == TIR.MemoryLocation.Output))
-        //     {
-        //         header.Outputs++;
-        //         var rg = new MemoryRange { Start = checked((uint)output.Start), Size = checked((uint)output.Size) };
-        //         descWriter.Write(ref rg);
-        //         header.OutputPoolSize = Math.Max(header.OutputPoolSize, rg.Start + rg.Size);
-        //         descWriter.Write((uint)output.FixedDimensions.Length);
-        //         foreach (var dim in output.FixedDimensions)
-        //         {
-        //             descWriter.Write((uint)dim);
-        //         }
-        //         foreach (var s in output.FixedStrides)
-        //         {
-        //             descWriter.Write((uint)s);
-        //         }
-        //     }
-
-        //     descWriter.Position(headerStart);
-        //     descWriter.Write(ref header);
-        // }
 
         // 3. write the rdata
         foreach (var (@const, range) in function.SchedResult.Rdatas)
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
index d08db57507..9cf490620c 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -1,6 +1,6 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
+#define MULTI_CORE_CPU
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -15,6 +15,11 @@
 
 namespace Nncase.CodeGen;
 
+#if MULTI_CORE_CPU
+internal sealed record FunctionCSource(string Shared, string Kernel)
+{
+}
+#else
 internal sealed class FunctionCSource
 {
     public FunctionCSource(string declaration, string implementation)
@@ -27,3 +32,4 @@ public FunctionCSource(string declaration, string implementation)
 
     public string Implementation { get; }
 }
+#endif
\ No newline at end of file
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index ad46c59d0b..98fcc8e877 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -30,84 +30,95 @@ public LinkableModule(byte[] rdata, IReadOnlyList<LinkableFunction> functions, C
 
     public ILinkedModule Link(ILinkContext linkContext)
     {
-        var csourcePath = LinkCSources();
+        // var csourcePath = LinkCSources();
         if (_options.DumpFlags.HasFlag(DumpFlags.CodeGen))
         {
-            var dumpPath = _options.DumpDir;
-            using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.h"), FileMode.Create))
+            foreach (var func in _functions)
             {
-                using (var writer = new StreamWriter(fs))
+                var dumpPath = Path.Join(_options.DumpDir, func.PrimFunction.Name);
+                if (!Directory.Exists(dumpPath))
                 {
-                    writer.Write(CSourceBuiltn.Header);
+                    Directory.CreateDirectory(dumpPath);
                 }
-            }
-
-            using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.c"), FileMode.Create))
-            {
-                File.Open(csourcePath, FileMode.Open, FileAccess.Read).CopyTo(fs);
-            }
-        }
-
-        var elfPath = CompileCSource(csourcePath);
-        var text = File.ReadAllBytes(elfPath);
-
-        if (_options.DumpFlags.HasFlag(DumpFlags.CodeGen))
-        {
-            var dumpPath = _options.DumpDir;
-            using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.elf"), FileMode.Create))
-            {
-                fs.Write(text);
-            }
-        }
-
-        var linkedFunctions = new List<LinkedFunction>();
-        foreach (var func in _functions)
-        {
-            linkedFunctions.Add(new LinkedFunction(func.Id, func.SourceFunction, 0, 0, func.Sections));
-        }
 
-        return new LinkedModule(linkedFunctions, text, _rdata);
-    }
-
-    private string LinkCSources()
-    {
-        var path = Path.GetTempFileName() + ".c";
-        using (var fs = File.OpenWrite(path))
-        {
-            using (var writer = new StreamWriter(fs))
-            {
-                writer.WriteLine(CSourceBuiltn.Header);
-
-                foreach (var func in _functions)
+                using (var fs = File.Open(Path.Join(dumpPath, "main.cpp"), FileMode.Create))
                 {
-                    writer.WriteLine(func.FunctionCSource.Declaration);
+                    using (var writer = new StreamWriter(fs))
+                    {
+                        writer.Write(CSourceBuiltn.MakeMain(func.PrimFunction));
+                    }
                 }
 
-                foreach (var func in _functions)
+                using (var fs = File.Open(Path.Join(dumpPath, "shared.h"), FileMode.Create))
                 {
-                    writer.WriteLine(func.FunctionCSource.Implementation);
+                    using (var writer = new StreamWriter(fs))
+                    {
+                        writer.Write(CSourceBuiltn.MakeShared());
+                    }
                 }
 
-                writer.WriteLine(CSourceBuiltn.MainPrologue);
-                writer.WriteLine($"  switch (func_id) {{");
-
-                foreach (var func in _functions)
+                using (var fs = File.Open(Path.Join(dumpPath, "kernel.h"), FileMode.Create))
                 {
-                    writer.WriteLine($"    case {func.Id}:");
-                    writer.WriteLine($"      {func.SourceFunction.Name}({string.Join(", ", Enumerable.Range(0, func.PrimFunction.Parameters.Length).Select(i => $"buffers[{i}]"))}, nncase_mt, data, rdata);");
-                    writer.WriteLine("    break;");
+                    using (var writer = new StreamWriter(fs))
+                    {
+                        writer.Write(CSourceBuiltn.KernelHeader);
+                        writer.Write(func.FunctionCSource.Kernel);
+                    }
                 }
-
-                writer.WriteLine("    default: ");
-                writer.WriteLine("    break;");
-                writer.WriteLine("  }");
-                writer.WriteLine(CSourceBuiltn.MainEpilogue);
             }
+
+            // using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.h"), FileMode.Create))
+            // {
+            //     using (var writer = new StreamWriter(fs))
+            //     {
+            //         writer.Write(CSourceBuiltn.Header);
+            //     }
+            // }
+
+            // using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.c"), FileMode.Create))
+            // {
+            //     File.Open(csourcePath, FileMode.Open, FileAccess.Read).CopyTo(fs);
+            // }
         }
 
-        return path;
+        // var elfPath = CompileCSource(csourcePath);
+        // var text = File.ReadAllBytes(elfPath);
+        var text = new byte[] { };
+
+        // if (_options.DumpFlags.HasFlag(DumpFlags.CodeGen))
+        // {
+        //     var dumpPath = _options.DumpDir;
+        //     using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.elf"), FileMode.Create))
+        //     {
+        //         fs.Write(text);
+        //     }
+        // }
+
+        var linkedFunctions = new List<LinkedFunction>();
+        // foreach (var func in _functions)
+        // {
+        //     linkedFunctions.Add(new LinkedFunction(func.Id, func.SourceFunction, 0, 0, func.Sections));
+        // }
+
+        return new LinkedModule(linkedFunctions, text, _rdata);
     }
 
+    // private string LinkCSources()
+    // {
+    // writer.WriteLine(CSourceBuiltn.MakeHeader(_functions));
+    // foreach (var func in _functions)
+    // {
+    //     var path = Path.GetTempFileName() + ".cpp";
+    //     using (var fs = File.OpenWrite(path))
+    //     {
+    //         using (var writer = new StreamWriter(fs))
+    //         {
+    //             writer.WriteLine(CSourceBuiltn.MakeHeader(_functions));
+    //         }
+    //     }
+    // }
+    // return path;
+    // }
     private string CompileCSource(string sourcePath)
     {
         var compiler = new CSourceCompiler();
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
index 41f7df8b4e..aa01122091 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
@@ -14,8 +14,5 @@ internal class CPUModule : IApplicationPart
     public void ConfigureServices(IRegistrator registrator)
     {
         registrator.RegisterManyInterface<CPUKernelOpEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<TDMALoadEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<TDMAStoreEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<UnaryEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/TDMALoadEvaluator.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs
similarity index 83%
rename from modules/Nncase.Modules.CPU/Evaluator/CPU/TDMALoadEvaluator.cs
rename to modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs
index bd92d7e349..63ed5df158 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/TDMALoadEvaluator.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs
@@ -2,16 +2,16 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.CPU;
+using Nncase.IR.XPU;
 
-namespace Nncase.Evaluator.CPU;
+namespace Nncase.Evaluator.XPU;
 
 public class TDMALoadEvaluator : ITypeInferencer<TDMALoad>
 {
     public IRType Visit(ITypeInferenceContext context, TDMALoad target)
     {
-        var inType = context.CheckArgumentType<TensorType>(target, TDMALoad.Input);
-        var outType = context.CheckArgumentType<TensorType>(target, TDMALoad.Output);
+        var inType = context.CheckArgumentType<TensorType>(target, TDMALoad.Dest);
+        var outType = context.CheckArgumentType<TensorType>(target, TDMALoad.Src);
         return TupleType.Void;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/TDMAStoreEvaluator.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs
similarity index 84%
rename from modules/Nncase.Modules.CPU/Evaluator/CPU/TDMAStoreEvaluator.cs
rename to modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs
index b30e06a3bb..48cc53739c 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/TDMAStoreEvaluator.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs
@@ -1,17 +1,17 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
-
 using Nncase.IR;
+using Nncase.IR.XPU;
 
-namespace Nncase.Evaluator.CPU;
+namespace Nncase.Evaluator.XPU;
 
 public sealed class TDMAStoreEvaluator : ITypeInferencer<TDMAStore>
 {
     public IRType Visit(ITypeInferenceContext context, TDMAStore target)
     {
-        var inType = context.CheckArgumentType<TensorType>(target, TDMAStore.Input);
-        var outType = context.CheckArgumentType<TensorType>(target, TDMAStore.Output);
+        var inType = context.CheckArgumentType<TensorType>(target, TDMAStore.Src);
+        var outType = context.CheckArgumentType<TensorType>(target, TDMAStore.Dest);
         return TupleType.Void;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/UnaryEvaluator.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Unary.cs
similarity index 96%
rename from modules/Nncase.Modules.CPU/Evaluator/CPU/UnaryEvaluator.cs
rename to modules/Nncase.Modules.CPU/Evaluator/XPU/Unary.cs
index 15d584e81a..e19fd7a1eb 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/UnaryEvaluator.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Unary.cs
@@ -3,7 +3,7 @@
 
 using Nncase.Evaluator;
 using Nncase.IR;
-using Nncase.IR.CPU;
+using Nncase.IR.XPU;
 
 namespace Nncase;
 
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
new file mode 100644
index 0000000000..f9ec1306e6
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -0,0 +1,20 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using DryIoc;
+using Nncase.Hosting;
+
+namespace Nncase.Evaluator.XPU;
+
+/// <summary>
+/// XPU module.
+/// </summary>
+internal class XPUModule : IApplicationPart
+{
+    public void ConfigureServices(IRegistrator registrator)
+    {
+        registrator.RegisterManyInterface<TDMALoadEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<TDMAStoreEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<UnaryEvaluator>(reuse: Reuse.Singleton);
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
index a69c97de6a..41d4ffa744 100644
--- a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
@@ -22,19 +22,4 @@ public static Call CPUKernel(Op target, params Expr[] inputs)
     {
         return new Call(new CPUKernelOp(target), inputs);
     }
-
-    public static Call TDMALoad(Expr input, Expr output)
-    {
-        return new Call(new TDMALoad(), input, output);
-    }
-
-    public static Call TDMAStore(Expr input, Expr output)
-    {
-        return new Call(new TDMAStore(), input, output);
-    }
-
-    public static Call Unary(UnaryOp unaryOp, Expr input, Expr output)
-    {
-        return new Call(new Unary(unaryOp), input, output);
-    }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/TDMALoad.cs b/modules/Nncase.Modules.CPU/IR/CPU/TDMALoad.cs
deleted file mode 100644
index f4b80f5866..0000000000
--- a/modules/Nncase.Modules.CPU/IR/CPU/TDMALoad.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-namespace Nncase.IR.CPU;
-
-public sealed class TDMALoad : Op
-{
-    public static readonly ParameterInfo Input = new(typeof(TDMALoad), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(TDMALoad), 1, "output");
-}
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/TDMAStore.cs b/modules/Nncase.Modules.CPU/IR/CPU/TDMAStore.cs
deleted file mode 100644
index a56ac8830c..0000000000
--- a/modules/Nncase.Modules.CPU/IR/CPU/TDMAStore.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-
-namespace Nncase;
-
-public sealed class TDMAStore : Op
-{
-    public static readonly ParameterInfo Input = new(typeof(TDMAStore), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(TDMAStore), 1, "output");
-}
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
new file mode 100644
index 0000000000..14b455a59f
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -0,0 +1,29 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR.XPU;
+
+namespace Nncase.IR.F;
+
+public partial class XPU
+{
+    public static Call TDMALoad(Expr dest, Expr src, IRArray<SBP> ndsbp, Placement placement)
+    {
+        return new Call(new TDMALoad(ndsbp, placement), dest, src);
+    }
+
+    public static Call TDMAStore(Expr src, Expr dest, IRArray<SBP> ndsbp, Placement placement)
+    {
+        return new Call(new TDMAStore(ndsbp, placement), src, dest);
+    }
+
+    public static Call Unary(UnaryOp unaryOp, Expr input, Expr output)
+    {
+        return new Call(new Unary(unaryOp), input, output);
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/TDMALoad.cs b/modules/Nncase.Modules.CPU/IR/XPU/TDMALoad.cs
new file mode 100644
index 0000000000..cb3be455d6
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/TDMALoad.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class TDMALoad : XPUKernelOp
+{
+    public static readonly ParameterInfo Dest = new(typeof(TDMALoad), 0, "dest");
+
+    public static readonly ParameterInfo Src = new(typeof(TDMALoad), 1, "src");
+
+    public IRArray<SBP> NdSbp { get; }
+
+    public Placement Placement { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/TDMAStore.cs b/modules/Nncase.Modules.CPU/IR/XPU/TDMAStore.cs
new file mode 100644
index 0000000000..b821a10011
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/TDMAStore.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class TDMAStore : XPUKernelOp
+{
+    public static readonly ParameterInfo Src = new(typeof(TDMAStore), 0, "src");
+
+    public static readonly ParameterInfo Dest = new(typeof(TDMAStore), 1, "dest");
+
+    public IRArray<SBP> NdSbp { get; }
+
+    public Placement Placement { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/Unary.cs b/modules/Nncase.Modules.CPU/IR/XPU/Unary.cs
similarity index 86%
rename from modules/Nncase.Modules.CPU/IR/CPU/Unary.cs
rename to modules/Nncase.Modules.CPU/IR/XPU/Unary.cs
index a76756e011..0b1876138d 100644
--- a/modules/Nncase.Modules.CPU/IR/CPU/Unary.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Unary.cs
@@ -1,9 +1,9 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
-namespace Nncase.IR.CPU;
+namespace Nncase.IR.XPU;
 
-public sealed partial class Unary : Op
+public sealed partial class Unary : XPUKernelOp
 {
     public static readonly ParameterInfo Input = new(typeof(Unary), 0, "input");
 
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs b/modules/Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs
new file mode 100644
index 0000000000..0277e7f0ab
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs
@@ -0,0 +1,9 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public abstract class XPUKernelOp : Op
+{
+
+}
\ No newline at end of file
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index b64cf46820..5e6827c117 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -170,13 +170,13 @@ private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call
             {
                 case (TensorType tensorType, DistTensorType distTensorType):
                     {
-                        _mainBody.Add(T.Block(nameof(Boxing)).Body(IR.F.CPU.TDMALoad(arguments[0], ret)).Build());
+                        _mainBody.Add(T.Block(nameof(Boxing)).Body(IR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSbp, distTensorType.Placement)).Build());
                     }
 
                     break;
                 case (DistTensorType distTensorType, TensorType tensorType):
                     {
-                        _mainBody.Add(T.Block(nameof(Boxing)).Body(IR.F.CPU.TDMAStore(arguments[0], ret)).Build());
+                        _mainBody.Add(T.Block(nameof(Boxing)).Body(IR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSbp, distTensorType.Placement)).Build());
                     }
 
                     break;
@@ -188,7 +188,7 @@ private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
             var input = arguments[IR.Math.Unary.Input.Index];
-            _mainBody.Add(T.Block(nameof(IR.Math.Unary)).Body(IR.F.CPU.Unary(unary.UnaryOp, input, ret)).Build());
+            _mainBody.Add(T.Block(nameof(IR.Math.Unary)).Body(IR.F.XPU.Unary(unary.UnaryOp, input, ret)).Build());
         }
 
 #if false
@@ -291,7 +291,7 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
 
         private (TensorType, MemoryLocation) GetTypeAndLocation(IRType type)
         {
-            MemoryLocation location;
+            MemoryLocation location = MemoryLocation.Data;
             if (type is DistTensorType distTensorType)
             {
                 if (distTensorType.Placement.Rank == 2)
@@ -304,7 +304,6 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
                 }
             }
 
-            location = MemoryLocation.Data;
             TensorType tensorType;
             if (type is DistTensorType distTensor)
             {
diff --git a/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs b/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
index b809dd559d..ac4b0e3a50 100644
--- a/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/ScriptPrintVisitor.cs
@@ -558,7 +558,7 @@ protected override IPrintSymbol VisitBuffer(TIR.Buffer expr)
 
         _scope.Push();
         var memSpan = Visit(expr.MemSpan);
-        _scope.Append($"T.Buffer({expr.Name}, {VisitType(expr.ElemType)}, {memSpan.Span})");
+        _scope.Append($"T.Buffer({expr.Name}, {VisitType(expr.ElemType)}, {memSpan.Span}, [{string.Join(',', expr.Dimensions.AsValueEnumerable().Select(Visit).Select(e => e.Span.ToString()).ToArray())}], [{string.Join(',', expr.Strides.AsValueEnumerable().Select(Visit).Select(e => e.Span.ToString()).ToArray())}])");
         doc = new(_scope.Pop(), expr.Name, true);
         _exprMemo.Add(expr, doc);
         return doc;

From eddaa9c7e2d56196495aff155d0d071e6f71da17 Mon Sep 17 00:00:00 2001
From: lerenhua <2532375005@qq.com>
Date: Thu, 7 Sep 2023 11:14:45 +0800
Subject: [PATCH 159/308] Fix head kernel segment fault

---
 .gitignore                                    |  4 +-
 .../cpu/src/runtime/cmodel/include/matmul.h   | 12 ++---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 51 +++++++++++--------
 .../src/runtime/cmodel/tests/head/kernel.h    |  4 +-
 .../src/runtime/cmodel/tests/head/main.cpp    | 17 ++++++-
 .../runtime/cmodel/tests/head/shared_def.h    |  2 +-
 modules/cpu/src/runtime/method_table_def.h    | 12 ++---
 modules/cpu/src/runtime/method_table_impl.h   | 26 +++++-----
 8 files changed, 75 insertions(+), 53 deletions(-)

diff --git a/.gitignore b/.gitignore
index b518626f74..d1c177c0b4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -68,7 +68,7 @@ artifacts/
 *.pidb
 *.svclog
 *.scc
-
+*.bin
 # Chutzpah Test files
 _Chutzpah*
 
@@ -303,4 +303,4 @@ cmake-build-*
 *gmodel_dump_dir*
 
 # Auto generated files
-# generated/
\ No newline at end of file
+# generated/
diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
index 5c8aa42cd4..5a668cdc89 100644
--- a/modules/cpu/src/runtime/cmodel/include/matmul.h
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -12,7 +12,7 @@ void matmul_unit_impl(const T *input_a, const T *input_b, T *output,
     int32_t b_cols = static_cast<int32_t>(in_b_shape[1]);
 
     for (int32_t oy = 0; oy < a_rows; oy++) {
-        T *values = new T[b_cols]();
+        T * values = (T *)runtime_util.malloc(sizeof(T) * b_cols);
         for (int32_t i = 0; i < a_cols; i++) {
             for (int32_t ox = 0; ox < b_cols; ox++) {
                 const auto a = input_a[oy * a_cols + i];
@@ -20,8 +20,8 @@ void matmul_unit_impl(const T *input_a, const T *input_b, T *output,
                 values[ox] += a * b;
             }
         }
-        std::copy_n(values, b_cols, output + oy * b_cols);
-        delete[] values;
+        runtime_util.memcpy(output + oy * b_cols, values, sizeof(T) * b_cols);
+        runtime_util.free(values);
     }
 }
 
@@ -35,9 +35,9 @@ void contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
     auto b_unit_size = new_b_shape[3] * new_b_shape[4];
     auto out_unit_size = new_a_shape[3] * new_b_shape[4];
 
-    auto dim0 = new_a_shape[0]> new_b_shape[0]? new_a_shape[0] : new_b_shape[0];
-    auto dim1 = new_a_shape[1]> new_b_shape[1]? new_a_shape[1] : new_b_shape[1];
-    auto dim2 = new_a_shape[2]> new_b_shape[2]? new_a_shape[2] : new_b_shape[2];
+    auto dim0 = new_a_shape[0] > new_b_shape[0] ? new_a_shape[0] : new_b_shape[0];
+    auto dim1 = new_a_shape[1] > new_b_shape[1] ? new_a_shape[1] : new_b_shape[1];
+    auto dim2 = new_a_shape[2] > new_b_shape[2] ? new_a_shape[2] : new_b_shape[2];
     auto ah_size = a_unit_size * new_a_shape[2];
     auto bh_size = b_unit_size * new_b_shape[2];
     auto oh_size = out_unit_size * dim2;
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 5077800cd2..00fb90dc81 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -1,4 +1,5 @@
 #pragma once
+#include "runtime_utils.h"
 #include <apply.h>
 #include <binary.h>
 #include <cassert>
@@ -14,7 +15,13 @@
 #include <thread_context.h>
 #include <transpose.h>
 #include <unary.h>
-#include "runtime_utils.h"
+
+#define __tdma_block_sync_apply_macro(func, ctx, ...)                          \
+    global_hardware_ctx.lock_block(ctx.bid());                                 \
+    int visited = global_hardware_ctx.mark_block_visit(ctx.bid(), ctx.tid());  \
+    func(visited, __VA_ARGS__);                                                \
+    global_hardware_ctx.unlock_block(ctx.bid());                               \
+    global_hardware_ctx.wait_block_sync(ctx.bid(), visited);
 
 template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &src) {
     auto new_dims = dims_t(src.dimension());
@@ -172,6 +179,23 @@ void concat(std::initializer_list<tensor<T, loc_t::local>> inits,
                     in_strides, output.strides(), axis, concat_dims);
 }
 
+template <typename T>
+void mma_visit(int visited, tensor<T, loc_t::shared> &c, tensor<T> &tmp,
+               bool &load_psum) {
+    if (load_psum) {
+        binary<T, loc_t::local, loc_t::shared, loc_t::shared>(tmp, c, c,
+                                                              binary_op_t::add);
+    } else {
+        if (visited == 1) {
+            binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
+                tmp, c, c, binary_op_t::add);
+        } else {
+            binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
+                tmp, c, c, binary_op_t::add);
+        }
+    }
+}
+
 /**
  * @brief Block 级别的 mma，每个 thread 执行自己的 mma，最终 psum 累加写入
  * shared memory
@@ -192,22 +216,7 @@ void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
     tensor<T> tmp(c.dimension());
     matmul(a, b, tmp);
 
-    __tdma_block_sync_apply(
-        [&](int visited) -> void {
-            if (load_psum) {
-                binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
-                    tmp, c, c, binary_op_t::add);
-            } else {
-                if (visited == 1) {
-                    binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
-                        tmp, c, c, binary_op_t::add);
-                } else {
-                    binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
-                        tmp, c, c, binary_op_t::add);
-                }
-            }
-        },
-        ctx);
+    __tdma_block_sync_apply_macro(mma_visit, ctx, c, tmp, load_psum);
 }
 
 void __tdma_block_sync_apply(std::function<void(int)> func,
@@ -274,7 +283,7 @@ void tdma_load_broadcast_async([[maybe_unused]] tensor<T, Dest> &dest,
                                [[maybe_unused]] tensor<T, Src> &src,
                                [[maybe_unused]] thread_context &ctx) {
     // throw std::system_error(std::make_error_code(std::errc::not_supported));
-    runtime_util.rt_assert(false, (char*)"not_supported");
+    runtime_util.rt_assert(false, (char *)"not_supported");
 }
 
 template <class T>
@@ -288,7 +297,8 @@ void tdma_reduce_async(tensor<T, loc_t::local> &src,
             new_dims.insert(new_dims.begin(), BLOCKS * CORES);
             if (visited == 1) {
                 if (global_hardware_ctx.global_var != nullptr) {
-                    runtime_util.rt_assert(false, (char*)"the global var has been used!");
+                    runtime_util.rt_assert(
+                        false, (char *)"the global var has been used!");
                 }
                 gather_tensor = new tensor<T>(new_dims);
                 global_hardware_ctx.global_var = (void *)gather_tensor;
@@ -360,7 +370,8 @@ void tdma_all_reduce_async(tensor<T, ALoc> &src, tensor<T, BLoc> &dest,
             new_dims.insert(new_dims.begin(), BLOCKS * CORES);
             if (visited == 1) {
                 if (global_hardware_ctx.global_var != nullptr) {
-                    runtime_util.rt_assert(false, (char*)"the global var has been used!");
+                    runtime_util.rt_assert(
+                        false, (char *)"the global var has been used!");
                 }
                 gather_tensor = new tensor<T>(new_dims);
                 global_hardware_ctx.global_var = (void *)gather_tensor;
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/kernel.h b/modules/cpu/src/runtime/cmodel/tests/head/kernel.h
index 7fa0e71e52..00a4e1b378 100644
--- a/modules/cpu/src/runtime/cmodel/tests/head/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/head/kernel.h
@@ -18,9 +18,9 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
     tdma_load_async(hidden_in,
                     Hidden_in({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
     tdma_load_async(w, W({2048 * tid, 0}, {2048, 32000}), ctx);
-    tensor_block_mma_sync(hidden_in, w, output, false, ctx);
+    tensor_block_mma_sync(hidden_in, w, *output, false, ctx);
 
-    auto output_1 = output({0, 0, 8000 * tid}, {1, 48, 8000});
+    auto output_1 = (*output)({0, 0, 8000 * tid}, {1, 48, 8000});
     tdma_store_async(output_1, Output({0, 48 * bid, 8000 * tid}, {1, 48, 8000}),
                      ctx);
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
index 600c1a6944..89c5e3106d 100644
--- a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
@@ -7,6 +7,10 @@
         return arg;                                                            \
     }
 
+#define MALLOC_SHARED(b, name, shape)                                                \
+    auto shared##b = tensor<float, loc_t::shared>(shape);                      \
+    block##b::shared::name = &shared##b;
+
 #define DEFINE_BFUNC(b)                                                        \
     DEFINE_TFUNC(b, 0)                                                         \
     DEFINE_TFUNC(b, 1)                                                         \
@@ -32,17 +36,26 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     runtime_util = *rt_util_mt;
     nncase_mt = *nncase_mt_impl;
 
+    MALLOC_SHARED(0, output, dims_t({1, 48, 32000}));
+    MALLOC_SHARED(1, output, dims_t({1, 48, 32000}));
+    MALLOC_SHARED(2, output, dims_t({1, 48, 32000}));
+    MALLOC_SHARED(3, output, dims_t({1, 48, 32000}));
+    MALLOC_SHARED(4, output, dims_t({1, 48, 32000}));
+    MALLOC_SHARED(5, output, dims_t({1, 48, 32000}));
+    MALLOC_SHARED(6, output, dims_t({1, 48, 32000}));
+    MALLOC_SHARED(7, output, dims_t({1, 48, 32000}));
+
     auto input0 = tensor<float, loc_t::device>(
         gsl::make_span((float *)inputs[0], 384 * 8192), {1, 384, 8192});
     Hidden_in = &input0;
 
     auto input1 = tensor<float, loc_t::device>(
         gsl::make_span((float *)inputs[1], 8192 * 32000), {8192, 32000});
-    W = &input0;
+    W = &input1;
 
     auto input2 = tensor<float, loc_t::device>(
         gsl::make_span((float *)inputs[2], 384 * 32000), {1, 384, 32000});
-    Output = &input0;
+    Output = &input2;
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/head/shared_def.h
index d7c69fe1ef..b99ccebe11 100644
--- a/modules/cpu/src/runtime/cmodel/tests/head/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/head/shared_def.h
@@ -1,5 +1,5 @@
 #include <tdma.h>
 
 namespace shared {
-tensor<float, loc_t::shared> output({1, 48, 32000});
+tensor<float, loc_t::shared> *output;
 } // namespace shared
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/method_table_def.h b/modules/cpu/src/runtime/method_table_def.h
index 87563ff3e2..7fa51761f0 100644
--- a/modules/cpu/src/runtime/method_table_def.h
+++ b/modules/cpu/src/runtime/method_table_def.h
@@ -3,7 +3,6 @@
 #include <functional>
 #include <nncase/runtime/cpu/compiler_defs.h>
 
-
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
 typedef struct nncase_method_table {
@@ -78,23 +77,22 @@ typedef struct buffer {
     uint32_t rank;
 } buffer_t;
 
-struct runtime_util_mt
-{
+struct runtime_util_mt {
     int (*printf)(const char *__restrict __format, ...);
     void *(*malloc)(size_t size);
     void (*free)(void *ptr);
     void (*create_thread)(pthread_t &pt, void *param_, void *(*call)(void *));
     void (*join_thread)(pthread_t &pt);
     void (*rt_assert)(bool condition, char *message);
+    void *(*memcpy)(void *dest, const void *src, size_t n);
 };
 
-struct hardware_context_mt
-{
+struct hardware_context_mt {
     void (*lock_block)(int bid);
     int (*mark_block_visit)(int bid, int tid);
     void (*unlock_block)(int bid);
-    void (*wait_block_sync)(
-        int bid, int visited, std::function<void()> callable);
+    void (*wait_block_sync)(int bid, int visited,
+                            std::function<void()> callable);
     void (*lock_all)();
     int (*mark_all_visit)(int bid, int tid);
     void (*unlock_all)();
diff --git a/modules/cpu/src/runtime/method_table_impl.h b/modules/cpu/src/runtime/method_table_impl.h
index 4ea5e7bccf..d738674dd9 100644
--- a/modules/cpu/src/runtime/method_table_impl.h
+++ b/modules/cpu/src/runtime/method_table_impl.h
@@ -1,4 +1,6 @@
 #pragma once
+#include "hardware_context.h"
+#include "method_table_def.h"
 #include "runtime_utils.h"
 #include "thread_pool.h"
 #include <functional>
@@ -7,8 +9,6 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
-#include "method_table_def.h"
-#include "hardware_context.h"
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
@@ -117,23 +117,23 @@ static nncase_mt_t nncase_mt = {fabsf,
                                 bool_binary_logical_xor};
 
 static runtime_util_mt runtime_util = {
-    printf, malloc,
-    free,
-    create_thread,
-    join_thread,
-    rt_assert
-};
+    printf, malloc, 
+    free, 
+    create_thread, 
+    join_thread, 
+    rt_assert, 
+    memcpy};
 
 static hardware_context_mt hw_ctx_mt = {
-    hardware_context::lock_block,
+    hardware_context::lock_block,   
     hardware_context::mark_block_visit,
-    hardware_context::unlock_block,
+    hardware_context::unlock_block, 
     hardware_context::wait_block_sync,
-    hardware_context::lock_all,
+    hardware_context::lock_all,     
     hardware_context::mark_all_visit,
-    hardware_context::unlock_all,
+    hardware_context::unlock_all,   
     hardware_context::wait_all_sync,
     hardware_context::init
-};
+    };
 
 END_NS_NNCASE_RT_MODULE
\ No newline at end of file

From 6561916e05eec9b07536386aba770e73f09b14f9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 7 Sep 2023 11:18:25 +0800
Subject: [PATCH 160/308] fix cost evaluator

---
 src/Nncase.Core/DistributeUtilities.cs        | 20 ++++++++
 src/Nncase.Evaluator/Math/Unary.cs            |  8 ++--
 .../Tensors/BoxingEvaluator.cs                | 46 +++++++++----------
 src/Nncase.Evaluator/TypeInference.cs         | 17 -------
 4 files changed, 45 insertions(+), 46 deletions(-)

diff --git a/src/Nncase.Core/DistributeUtilities.cs b/src/Nncase.Core/DistributeUtilities.cs
index a7c56ad9c3..b44624aef6 100644
--- a/src/Nncase.Core/DistributeUtilities.cs
+++ b/src/Nncase.Core/DistributeUtilities.cs
@@ -68,4 +68,24 @@ public static bool IsDivisible(int input, int divisor)
 
         return false;
     }
+
+    public static TensorType GetPartedDistTensorType(DistTensorType distTensorType, out float notContiguousScale)
+    {
+        var shape = distTensorType.TensorType.Shape.ToValueArray();
+        var tiles = distTensorType.TensorType.Shape.ToValueArray();
+        foreach (var (s, i) in distTensorType.NdSbp.OfType<SBPSplit>().Select((s, i) => (s, i)))
+        {
+            tiles[s.Axis] /= distTensorType.Placement.Hierarchy[i];
+        }
+
+        var isIsContiguous = Enumerable.Range(0, tiles.Length).
+                  Select(i => tiles[i].Ranges(0, shape[i])).
+                  CartesianProduct().
+                  Select(rgs => TensorUtilities.IsContiguousSlice(shape, rgs.ToArray()));
+        var allTiles = isIsContiguous.Count();
+        int notContiguous = isIsContiguous.Count(b => b == false);
+        notContiguousScale = ((float)notContiguous / allTiles) + 1.0f;
+
+        return distTensorType.TensorType with { Shape = tiles };
+    }
 }
diff --git a/src/Nncase.Evaluator/Math/Unary.cs b/src/Nncase.Evaluator/Math/Unary.cs
index e06a7b81ba..e6db1d9a05 100644
--- a/src/Nncase.Evaluator/Math/Unary.cs
+++ b/src/Nncase.Evaluator/Math/Unary.cs
@@ -169,13 +169,13 @@ private IRType Visit(TensorType input)
 
     private Cost Visit(DistTensorType inType, DistTensorType outType, Unary target)
     {
-        var inPartType = TypeInference.GetPartedTensorType(inType, out int inScale);
-        var outPartType = TypeInference.GetPartedTensorType(outType, out int outScale);
+        var inPartType = DistributeUtilities.GetPartedDistTensorType(inType, out float inScale);
+        var outPartType = DistributeUtilities.GetPartedDistTensorType(outType, out float outScale);
         return new()
         {
-            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inPartType) * (UInt128)inScale,
+            [CostFactorNames.MemoryLoad] = (UInt128)((float)CostUtility.GetMemoryAccess(inPartType) * inScale),
             [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(outPartType, CostUtility.GetCPUCyclesOfUnary(target.UnaryOp)),
-            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(outPartType) * (UInt128)outScale,
+            [CostFactorNames.MemoryStore] = (UInt128)((float)CostUtility.GetMemoryAccess(outPartType) * outScale),
         };
     }
 
diff --git a/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs b/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
index 0e20d55c4d..b4bddd0191 100644
--- a/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
+++ b/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
@@ -20,33 +20,29 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
     {
         var inType = context.GetArgumentType<IRType>(target, Boxing.Input);
         var returnType = context.GetReturnType<IRType>();
-
-        return (inType, returnType) switch
-        {
-            (TensorType tensorType, DistTensorType distTensorType) => Visit(tensorType, distTensorType),
-            (DistTensorType distTensorType, TensorType tensorType) => Visit(tensorType, distTensorType),
-            _ => throw new NotImplementedException(),
-        };
-    }
-
-    /// <summary>
-    /// calc the cost for load/store to distribute.
-    /// </summary>
-    /// <param name="tensorType">device tensor.</param>
-    /// <param name="distTensorType">distribute tensor.</param>
-    /// <returns>cost.</returns>
-    private Cost Visit(TensorType tensorType, DistTensorType distTensorType)
-    {
-        var shape = distTensorType.TensorType.Shape.ToValueArray();
-        foreach (var axis in distTensorType.NdSbp.OfType<SBPSplit>().Select(s => s.Axis))
+        Cost cost;
+        switch (inType, returnType)
         {
-            shape[axis] /= axis;
+            case (TensorType tensorType, DistTensorType distTensorType):
+                var partedOutType = DistributeUtilities.GetPartedDistTensorType(distTensorType, out _);
+                cost = new Cost()
+                {
+                    [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(tensorType),
+                    [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(partedOutType),
+                };
+                break;
+            case (DistTensorType distTensorType, TensorType tensorType):
+                var partedInType = DistributeUtilities.GetPartedDistTensorType(distTensorType, out _);
+                cost = new Cost()
+                {
+                    [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(partedInType),
+                    [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(tensorType),
+                };
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(context));
         }
 
-        return new Cost()
-        {
-            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(tensorType),
-            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(distTensorType.TensorType with { Shape = shape }),
-        };
+        return cost;
     }
 }
diff --git a/src/Nncase.Evaluator/TypeInference.cs b/src/Nncase.Evaluator/TypeInference.cs
index ce04581822..c06f6da7eb 100644
--- a/src/Nncase.Evaluator/TypeInference.cs
+++ b/src/Nncase.Evaluator/TypeInference.cs
@@ -462,21 +462,4 @@ IRType CommonTypeImpl(TensorType a, TensorType b)
         };
     }
 
-    public static TensorType GetPartedTensorType(DistTensorType distTensorType, out int notContiguous)
-    {
-        var shape = distTensorType.TensorType.Shape.ToValueArray();
-        var tiles = distTensorType.TensorType.Shape.ToValueArray();
-        foreach (var axis in distTensorType.NdSbp.OfType<SBPSplit>().Select(s => s.Axis))
-        {
-            tiles[axis] /= axis;
-        }
-
-        notContiguous = Enumerable.Range(0, tiles.Length).
-           Select(i => tiles[i].Ranges(0, shape[i])).
-           CartesianProduct().
-           Select(rgs => TensorUtilities.IsContiguousSlice(shape, rgs.ToArray())).
-           Count(b => b == false);
-
-        return distTensorType.TensorType with { Shape = shape };
-    }
 }

From e0601794ff6077ec446c03055c373c36fac1d4f3 Mon Sep 17 00:00:00 2001
From: lerenhua <2532375005@qq.com>
Date: Thu, 7 Sep 2023 11:26:56 +0800
Subject: [PATCH 161/308] Fix head kernel cos similarity

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt   |  2 +-
 modules/cpu/src/runtime/cmodel/include/matmul.h | 12 ++++++++----
 modules/cpu/src/runtime/method_table_def.h      |  1 +
 modules/cpu/src/runtime/method_table_impl.h     |  6 ++++--
 4 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index 053c023899..0d26e0bb93 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -38,7 +38,7 @@ endfunction(add_test)
 # add_test(demo1 tests/demo1)
 # add_test(demo2 tests/demo2)
 # add_test(demo3 tests/demo3)
-add_test(demo4 tests/demo4)
+# add_test(demo4 tests/demo4)
 add_test(norm tests/norm)
 # add_test(embed tests/embed)
 add_test(head tests/head)
diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
index 5a668cdc89..5bfd4b888d 100644
--- a/modules/cpu/src/runtime/cmodel/include/matmul.h
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -12,7 +12,8 @@ void matmul_unit_impl(const T *input_a, const T *input_b, T *output,
     int32_t b_cols = static_cast<int32_t>(in_b_shape[1]);
 
     for (int32_t oy = 0; oy < a_rows; oy++) {
-        T * values = (T *)runtime_util.malloc(sizeof(T) * b_cols);
+        T *values = (T *)runtime_util.malloc(sizeof(T) * b_cols);
+        runtime_util.memset(values, 0, sizeof(T) * b_cols);
         for (int32_t i = 0; i < a_cols; i++) {
             for (int32_t ox = 0; ox < b_cols; ox++) {
                 const auto a = input_a[oy * a_cols + i];
@@ -35,9 +36,12 @@ void contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
     auto b_unit_size = new_b_shape[3] * new_b_shape[4];
     auto out_unit_size = new_a_shape[3] * new_b_shape[4];
 
-    auto dim0 = new_a_shape[0] > new_b_shape[0] ? new_a_shape[0] : new_b_shape[0];
-    auto dim1 = new_a_shape[1] > new_b_shape[1] ? new_a_shape[1] : new_b_shape[1];
-    auto dim2 = new_a_shape[2] > new_b_shape[2] ? new_a_shape[2] : new_b_shape[2];
+    auto dim0 =
+        new_a_shape[0] > new_b_shape[0] ? new_a_shape[0] : new_b_shape[0];
+    auto dim1 =
+        new_a_shape[1] > new_b_shape[1] ? new_a_shape[1] : new_b_shape[1];
+    auto dim2 =
+        new_a_shape[2] > new_b_shape[2] ? new_a_shape[2] : new_b_shape[2];
     auto ah_size = a_unit_size * new_a_shape[2];
     auto bh_size = b_unit_size * new_b_shape[2];
     auto oh_size = out_unit_size * dim2;
diff --git a/modules/cpu/src/runtime/method_table_def.h b/modules/cpu/src/runtime/method_table_def.h
index 7fa51761f0..28d92a8e26 100644
--- a/modules/cpu/src/runtime/method_table_def.h
+++ b/modules/cpu/src/runtime/method_table_def.h
@@ -85,6 +85,7 @@ struct runtime_util_mt {
     void (*join_thread)(pthread_t &pt);
     void (*rt_assert)(bool condition, char *message);
     void *(*memcpy)(void *dest, const void *src, size_t n);
+    void *(*memset)(void *ptr, int value, size_t num);
 };
 
 struct hardware_context_mt {
diff --git a/modules/cpu/src/runtime/method_table_impl.h b/modules/cpu/src/runtime/method_table_impl.h
index d738674dd9..87d5d241bd 100644
--- a/modules/cpu/src/runtime/method_table_impl.h
+++ b/modules/cpu/src/runtime/method_table_impl.h
@@ -122,7 +122,9 @@ static runtime_util_mt runtime_util = {
     create_thread, 
     join_thread, 
     rt_assert, 
-    memcpy};
+    memcpy, 
+    memset
+};
 
 static hardware_context_mt hw_ctx_mt = {
     hardware_context::lock_block,   
@@ -134,6 +136,6 @@ static hardware_context_mt hw_ctx_mt = {
     hardware_context::unlock_all,   
     hardware_context::wait_all_sync,
     hardware_context::init
-    };
+};
 
 END_NS_NNCASE_RT_MODULE
\ No newline at end of file

From a6b0b8323e66a8ffa5a2869cd7dcf8efb3e02987 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 7 Sep 2023 14:04:04 +0800
Subject: [PATCH 162/308] decoder layer pass input layernorm

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |   5 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h | 119 +++--
 .../cmodel/tests/decoder_layer/kernel.h       | 134 +++--
 .../cmodel/tests/decoder_layer/main.cpp       | 493 +++++++++++-------
 .../cmodel/tests/decoder_layer/shared_def.h   |  26 +-
 5 files changed, 466 insertions(+), 311 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index 0d26e0bb93..30444e51e7 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -37,8 +37,7 @@ endfunction(add_test)
 
 # add_test(demo1 tests/demo1)
 # add_test(demo2 tests/demo2)
-# add_test(demo3 tests/demo3)
-# add_test(demo4 tests/demo4)
+add_test(decoder_layer tests/decoder_layer)
 add_test(norm tests/norm)
-# add_test(embed tests/embed)
+add_test(embed tests/embed)
 add_test(head tests/head)
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index c06edd584b..0a5c6e373b 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -68,7 +68,9 @@ void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest,
 
 template <class T, loc_t DestLoc, loc_t SrcLoc>
 void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
-    runtime_util.rt_assert(dest.dimension() == src.dimension(), (char*)"Dest and Src dimension mismatch in __tensor_copy_sync");
+    runtime_util.rt_assert(
+        dest.dimension() == src.dimension(),
+        (char *)"Dest and Src dimension mismatch in __tensor_copy_sync");
     apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
           [&](gsl::span<const size_t> index) -> void {
               dest.data()[offset(dest.strides(), index)] =
@@ -228,6 +230,13 @@ void __tdma_block_sync_apply(std::function<void(int)> func,
     global_hardware_ctx.wait_block_sync(ctx.bid(), visited);
 }
 
+#define __tdma_all_sync_apply_macro(apply_func, broadcast_func, ctx, ...)      \
+    global_hardware_ctx.lock_all();                                            \
+    int visited = global_hardware_ctx.mark_all_visit(ctx.bid(), ctx.tid());    \
+    apply_func(visited, ctx, __VA_ARGS__);                                     \
+    global_hardware_ctx.unlock_all();                                          \
+    global_hardware_ctx.wait_all_sync(visited, broadcast_func);
+
 void __tdma_all_sync_apply(std::function<void(int)> apply_func,
                            std::function<void()> broadcast_func,
                            thread_context &ctx) {
@@ -286,58 +295,72 @@ void tdma_load_broadcast_async([[maybe_unused]] tensor<T, Dest> &dest,
     runtime_util.rt_assert(false, (char *)"not_supported");
 }
 
+template <class T>
+void reduce_async_visit_func1(int visited, thread_context &ctx,
+                              tensor<T, loc_t::local> &src,
+                              tensor<T, loc_t::local> &dest) {
+    T *gather_span = nullptr;
+    auto new_dims = dims_t(src.dimension());
+    new_dims.insert(new_dims.begin(), BLOCKS * CORES);
+    if (visited == 1) {
+        if (global_hardware_ctx.global_var != nullptr) {
+            runtime_util.rt_assert(false,
+                                   (char *)"the global var has been used!");
+        }
+        gather_span =
+            (T *)runtime_util.malloc(sizeof(T) * compute_size(new_dims));
+        global_hardware_ctx.global_var = gather_span;
+    }
+    dims_t begin(new_dims.size(), 0);
+    dims_t shape(new_dims);
+    begin[0] = ctx.bid() * CORES + ctx.tid();
+    shape[0] = 1;
+    tensor<T> gather_tensor =
+        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
+                                 compute_size(new_dims)),
+                  new_dims);
+    __tensor_copy_sync<T, loc_t::local, loc_t::local>(
+        std::move((gather_tensor)(begin, shape)), std::move(unsqueeze(src)));
+}
+
+template <class T>
+void reduce_async_visit_func2(int visit, thread_context &ctx,
+                              tensor<T, loc_t::local> &src,
+                              tensor<T, loc_t::local> &dest,
+                              reduce_op_t reduce_op) {
+    auto new_dims = dims_t(src.dimension());
+    new_dims.insert(new_dims.begin(), BLOCKS * CORES);
+    tensor<T> gather_tensor =
+        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
+                                 compute_size(new_dims)),
+                  new_dims);
+    // auto new_dims = dims_t(gather_tensor.dimension());
+    new_dims[0] = CORES;
+    auto viewed_gather_tensor =
+        tensor<T>(gather_tensor.data().subspan(
+                      ctx.bid() * CORES * gather_tensor.strides()[0],
+                      CORES * gather_tensor.strides()[0]),
+                  new_dims, gather_tensor.strides());
+
+    reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
+           dims_t({0}), false);
+}
+
 template <class T>
 void tdma_reduce_async(tensor<T, loc_t::local> &src,
                        tensor<T, loc_t::local> &dest, reduce_op_t reduce_op,
                        thread_context &ctx) {
-    __tdma_all_sync_apply(
-        [&src, &ctx](int visited) -> void {
-            tensor<T> *gather_tensor = nullptr;
-            auto new_dims = dims_t(src.dimension());
-            new_dims.insert(new_dims.begin(), BLOCKS * CORES);
-            if (visited == 1) {
-                if (global_hardware_ctx.global_var != nullptr) {
-                    runtime_util.rt_assert(
-                        false, (char *)"the global var has been used!");
-                }
-                gather_tensor = new tensor<T>(new_dims);
-                global_hardware_ctx.global_var = (void *)gather_tensor;
-            } else {
-                gather_tensor =
-                    static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-            }
-            dims_t begin(new_dims.size(), 0);
-            dims_t shape(new_dims);
-            begin[0] = ctx.bid() * CORES + ctx.tid();
-            shape[0] = 1;
-            __tensor_copy_sync<T, loc_t::local, loc_t::local>(
-                std::move((*gather_tensor)(begin, shape)),
-                std::move(unsqueeze(src)));
-        },
-        []() -> void {}, ctx);
+    {__tdma_all_sync_apply_macro(reduce_async_visit_func1, ([]() -> void {}),
+                                 ctx, src, dest)}
 
-    __tdma_all_sync_apply(
-        [&]([[maybe_unused]] int visit) -> void {
-            tensor<T> *gather_tensor =
-                static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-            auto new_dims = dims_t(gather_tensor->dimension());
-            new_dims[0] = CORES;
-            auto viewed_gather_tensor =
-                tensor<T>(gather_tensor->data().subspan(
-                              ctx.bid() * CORES * gather_tensor->strides()[0],
-                              CORES * gather_tensor->strides()[0]),
-                          new_dims, gather_tensor->strides());
-
-            reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
-                   dims_t({0}), false);
-        },
-        []() -> void {
-            auto reduced_tensor =
-                static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-            delete reduced_tensor;
-            global_hardware_ctx.global_var = nullptr;
-        },
-        ctx);
+    {
+        __tdma_all_sync_apply_macro(
+            reduce_async_visit_func2, ([]() -> void {
+                free(global_hardware_ctx.global_var);
+                global_hardware_ctx.global_var = nullptr;
+            }),
+            ctx, src, dest, reduce_op)
+    }
 }
 
 enum class reduce_strategy_t : uint8_t {
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
index afccdb2ed7..90dd2f1030 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
@@ -6,18 +6,22 @@
 using namespace shared;
 
 static bool w_loaded;
-static tensor<float> v2_w({64, 2048, 128});
-static tensor<float> v16_w({64, 2048, 128});
-static tensor<float> v31_w({64, 2048, 128});
-static tensor<float> v35_w({2048, 8192});
-static tensor<float> v3_data({384, 32});
-static tensor<float> v11_data({384, 32});
-static tensor<int64_t> position_ids({1, 48});
-static tensor<float> v38_w({2048, 22016});
-static tensor<float> v40_w({2048, 22016});
-static tensor<float> v42_w({5504, 8192});
+static tensor<float> *v2_w;           // {64, 2048, 128}
+static tensor<float> *v16_w;          // {64, 2048, 128}
+static tensor<float> *v31_w;          // {64, 2048, 128}
+static tensor<float> *v35_w;          // {2048, 8192}
+static tensor<float> *v3_data;        // {384, 32}
+static tensor<float> *v11_data;       // {384, 32}
+static tensor<int64_t> *position_ids; // {1, 48}
+static tensor<float> *v38_w;          // {2048, 22016}
+static tensor<float> *v40_w;          // {2048, 22016}
+static tensor<float> *v42_w;          // {5504, 8192}
 #define DUMP 0
 
+#define MALLOC_STATIC(name, type, shape)                                       \
+    auto name##_tmp = tensor<type>(shape);                                     \
+    name = &name##_tmp;
+
 void stage1_kernel(
     tensor<float, loc_t::device> &Hidden_in,               /* [1, 384, 8192] */
     tensor<float, loc_t::device> &V0_gamma,                /* [8192] */
@@ -44,19 +48,32 @@ void stage1_kernel(
 
     tensor<float> attn_mask({1, 1, 48, 384});
 
+    MALLOC_STATIC(v2_w, float, dims_t({64, 2048, 128}))
+    MALLOC_STATIC(v16_w, float, dims_t({64, 2048, 128}))
+    MALLOC_STATIC(v31_w, float, dims_t({64, 2048, 128}))
+    MALLOC_STATIC(v35_w, float, dims_t({2048, 8192}))
+    MALLOC_STATIC(v3_data, float, dims_t({384, 32}))
+    MALLOC_STATIC(v11_data, float, dims_t({384, 32}))
+    MALLOC_STATIC(position_ids, int64_t, dims_t({1, 48}))
+    MALLOC_STATIC(v38_w, float, dims_t({2048, 22016}))
+    MALLOC_STATIC(v40_w, float, dims_t({2048, 22016}))
+    MALLOC_STATIC(v42_w, float, dims_t({5504, 8192}))
+
     if (!w_loaded) {
         tdma_load_async(v0_gamma, V0_gamma({tid * 2048}, {2048}), ctx);
         tdma_load_async(v0_beta, V0_beta({tid * 2048}, {2048}), ctx);
-        tdma_load_async(v2_w, V2_w({0, 2048 * tid, 0}, {64, 2048, 128}), ctx);
-        tdma_load_async(v16_w, V16_w({0, 2048 * tid, 0}, {64, 2048, 128}), ctx);
-        tdma_load_async(v31_w, V31_w({0, 2048 * tid, 0}, {64, 2048, 128}), ctx);
-        tdma_load_async(v35_w, V35_w({2048 * tid, 0}, {2048, 8192}), ctx);
-        tdma_load_async(v38_w, V38_w({2048 * tid, 0}, {2048, 22016}), ctx);
-        tdma_load_async(v40_w, V40_w({2048 * tid, 0}, {2048, 22016}), ctx);
-        tdma_load_async(v42_w, V42_w({5504 * tid, 0}, {5504, 8192}), ctx);
-        tdma_load_async(v3_data, V3_data({0, 32 * tid}, {384, 32}), ctx);
-        tdma_load_async(v11_data, V11_data({0, 32 * tid}, {384, 32}), ctx);
-        tdma_load_async(position_ids, Position_ids({0, 48 * bid}, {1, 48}),
+        tdma_load_async(*v2_w, V2_w({0, 2048 * tid, 0}, {64, 2048, 128}), ctx);
+        tdma_load_async(*v16_w, V16_w({0, 2048 * tid, 0}, {64, 2048, 128}),
+                        ctx);
+        tdma_load_async(*v31_w, V31_w({0, 2048 * tid, 0}, {64, 2048, 128}),
+                        ctx);
+        tdma_load_async(*v35_w, V35_w({2048 * tid, 0}, {2048, 8192}), ctx);
+        tdma_load_async(*v38_w, V38_w({2048 * tid, 0}, {2048, 22016}), ctx);
+        tdma_load_async(*v40_w, V40_w({2048 * tid, 0}, {2048, 22016}), ctx);
+        tdma_load_async(*v42_w, V42_w({5504 * tid, 0}, {5504, 8192}), ctx);
+        tdma_load_async(*v3_data, V3_data({0, 32 * tid}, {384, 32}), ctx);
+        tdma_load_async(*v11_data, V11_data({0, 32 * tid}, {384, 32}), ctx);
+        tdma_load_async(*position_ids, Position_ids({0, 48 * bid}, {1, 48}),
                         ctx);
         tdma_load_async(attn_mask,
                         Attn_mask({0, 0, 48 * bid, 0}, {1, 1, 48, 384}), ctx);
@@ -71,8 +88,8 @@ void stage1_kernel(
         tensor<float> v0_sum_sqr({1, 48});
         reduce_sum_sqr(v0, v0_sum, v0_sum_sqr);
         tdma_reduce_async(v0_sum, v0_sum, reduce_op_t::sum, ctx);
-        tdma_reduce_async(v0_sum_sqr, v0_sum_sqr, reduce_op_t::sum, ctx);
-        layernorm(v0, v0_sum, v0_sum_sqr, v0, 2, 8192, true);
+        // tdma_reduce_async(v0_sum_sqr, v0_sum_sqr, reduce_op_t::sum, ctx);
+        // layernorm(v0, v0_sum, v0_sum_sqr, v0, 2, 8192, true);
 #if DUMP
         {
             tdma_store_async(
@@ -82,12 +99,13 @@ void stage1_kernel(
 #endif
     } // v0 [1, 384, 8192] [1, 48@b, 8192]
 
+#if 0
     auto v1 = unsqueeze(v0); // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
     /*
       [1, 1, 384, 8192]    @ [64, 8192, 128]  -> [1, 64, 384, 128]
       [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1, 64, 48@b, 128] @ shared
      */
-    tensor_block_mma_sync(v1, v2_w, V2, false, ctx);
+    tensor_block_mma_sync(v1, *v2_w, (*V2), false, ctx);
 #if DUMP
     if (tid == 0) {
         tdma_store_async(
@@ -101,7 +119,7 @@ void stage1_kernel(
       [384, 32@t][[1, 48@b]] -> [1, 48@b, 32@t]
     */
     tensor<float> v3({1, 48, 32});
-    gather(v3_data, position_ids, v3, 0);
+    gather(*v3_data, *position_ids, v3, 0);
 #if DUMP
     {
         tdma_store_async(
@@ -115,26 +133,27 @@ void stage1_kernel(
       [1, 64, 48@b, 32@t] @ shared X   [1, 1, 48@b, 32@t] ->  [1, 64, 48@b,
       32@t] @ shared
     */
-    auto v5_ = V5({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-    auto v2_ = V2({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    auto v5_ = (*V5)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    auto v2_ = (*V2)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     binary(v2_, v4, v5_, binary_op_t::mul);
 
     /*
       [1, 64, 384, 64:] -> [1, 64, 384, 64:]
       [1, 64, 48@b, 16@t]@shared ->  [1, 16@t, 48@b, 16@t]
     */
-    auto v6 = V2({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16});
+    auto v6 = (*V2)({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16});
     tensor<float> v7({1, 64, 48, 16});
     tdma_wait(ctx);
     unary(v6, v7, unary_op_t::neg);
 
-    __tensor_copy_sync(V2({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16}),
-                       V2({0, 0, 0, 16 * tid}, {1, 64, 48, 16}));
-    __tensor_copy_sync(V2({0, 0, 0, 16 * tid}, {1, 64, 48, 16}), std::move(v7));
+    __tensor_copy_sync((*V2)({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16}),
+                       (*V2)({0, 0, 0, 16 * tid}, {1, 64, 48, 16}));
+    __tensor_copy_sync((*V2)({0, 0, 0, 16 * tid}, {1, 64, 48, 16}),
+                       std::move(v7));
     tdma_wait(ctx);
 
     /* v10 为concat(v7,v8), 实际来源于V2，因此无需实际动作 */
-    auto v10 = V2({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    auto v10 = (*V2)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
 #if DUMP
     {
         tdma_store_async(
@@ -148,7 +167,7 @@ void stage1_kernel(
       [384, 32@t][[1, 48@b]] -> [1, 48@b, 32@t]
     */
     tensor<float> v11({1, 48, 32});
-    gather(v11_data, position_ids, v11, 0);
+    gather(*v11_data, *position_ids, v11, 0);
     auto v12 = unsqueeze(v11); // [1, 1, 384, 128] [1, 1, 48@b, 32@t]
 
     /*
@@ -156,7 +175,7 @@ void stage1_kernel(
       [1, 64, 48@b, 32@t] @ shared X   [1, 1, 48@b, 32@t] ->  [1, 64, 48@b,
       32@t] @ shared
     */
-    auto v13_ = V13({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    auto v13_ = (*V13)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     // auto v2_ = V2({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     binary(v2_, v12, v13_, binary_op_t::mul);
 
@@ -167,8 +186,8 @@ void stage1_kernel(
     [1, 64, 48@b, 32@t] + [1, 64, 48@b, 32@t] -> [1, 64, 48@b, 32@t]
     */
     tensor<float> v14({1, 64, 48, 32});
-    auto v5__ = V5({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-    auto v13__ = V13({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    auto v5__ = (*V5)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    auto v13__ = (*V13)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     binary(v5__, v13__, v14, binary_op_t::add);
 #if DUMP
     {
@@ -182,14 +201,14 @@ void stage1_kernel(
       [1,1,384,8192] @ [64, 8192, 128] -> [1,64,384,128]
       [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1,64,48@b,128]@shared
     */
-    tensor_block_mma_sync(v15, v16_w, V16, false, ctx);
+    tensor_block_mma_sync(v15, *v16_w, *V16, false, ctx);
 
     /*
       [1,64,384,128] X [1,64,384,128] -> [1,64,384,128]
       [1,64,48@b,32@t]@shared X [1,1,48@b,32@t] ->  [1,64,48@b,32@t]
     */
     tensor<float> v17({1, 64, 48, 32});
-    auto v16 = V16({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    auto v16 = (*V16)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     binary(v16, v4, v17, binary_op_t ::mul);
 
     /*
@@ -197,12 +216,12 @@ void stage1_kernel(
       [1, 64, 48@b, 64]@shared ->  [1, 16@t, 48@b, 64]@shared
     */
     tensor<float> v19({1, 64, 48, 16});
-    auto v18 = V16({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16});
+    auto v18 = (*V16)({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16});
     tdma_wait(ctx);
     unary(v18, v19, unary_op_t::neg);
-    __tensor_copy_sync(V16({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16}),
-                       V16({0, 0, 0, 16 * tid}, {1, 64, 48, 16}));
-    __tensor_copy_sync(V16({0, 0, 0, 16 * tid}, {1, 64, 48, 16}),
+    __tensor_copy_sync((*V16)({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16}),
+                       (*V16)({0, 0, 0, 16 * tid}, {1, 64, 48, 16}));
+    __tensor_copy_sync((*V16)({0, 0, 0, 16 * tid}, {1, 64, 48, 16}),
                        std::move(v19));
 
     /*
@@ -210,7 +229,7 @@ void stage1_kernel(
       [1, 64, 48@b, 32@t]@shared x [1, 1, 48@b, 32@t] -> [1, 64, 48@b, 32@t]
     */
     tensor<float> v23({1, 64, 48, 32});
-    auto v22 = V16({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
+    auto v22 = (*V16)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
     tdma_wait(ctx);
     binary(v22, v12, v23, binary_op_t::mul);
 #if DUMP
@@ -241,12 +260,12 @@ void stage1_kernel(
     tensor<float> v25_1({1, 64, 32, 384});
     tdma_load_async(v25_1, V25({0, 0, 32 * tid, 0}, {1, 64, 32, 384}), ctx);
     tdma_all_wait(ctx);
-    tensor_block_mma_sync(v14, v25_1, V26, false, ctx);
+    tensor_block_mma_sync(v14, v25_1, *V26, false, ctx);
 
     /* [1, 64, 384, 384]           / 11.31370  -> [1, 64, 384, 384]
        [1, 16@t, 48@b, 384]@shared   / 11.31370 -> [1, 16@t, 48@b, 384]
     */
-    auto v26 = V26({0, 16 * tid, 0, 0}, {1, 16, 48, 384});
+    auto v26 = (*V26)({0, 16 * tid, 0, 0}, {1, 16, 48, 384});
     tensor<float> v27({1, 16, 48, 384});
     auto v26_c = tensor<float>({1, 1, 1, 1});
     tdma_fill_async(v26_c, 11.313708f);
@@ -277,10 +296,10 @@ void stage1_kernel(
       [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1, 64, 48@b, 128]@shared
     */
     auto &v30 = v1;
-    tensor_block_mma_sync(v30, v31_w, V31, false, ctx);
+    tensor_block_mma_sync(v30, *v31_w, *V31, false, ctx);
 
     /* need resplit V */
-    auto v31 = V31({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
+    auto v31 = (*V31)({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
     tdma_store_async(v31, GV31({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}),
                      ctx);
 
@@ -292,7 +311,7 @@ void stage1_kernel(
     tensor<float> v31_resplit({1, 16, 384, 128});
     tdma_load_async(v31_resplit, GV31({0, 16 * tid, 0, 0}, {1, 16, 384, 128}),
                     ctx);
-    auto v32 = V32({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
+    auto v32 = (*V32)({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
     matmul(v29, v31_resplit, v32);
     tdma_wait(ctx);
 #if DUMP
@@ -306,17 +325,17 @@ void stage1_kernel(
       [1, 64, 384, 128] -> [1, 384, 64, 128]
       [1, 64, 48@b, 128]@shared -> [1, 48@b, 64, 128]@shared
      */
-    auto v33 = V33({0, 0, 16 * tid, 0}, {1, 48, 16, 128});
+    auto v33 = (*V33)({0, 0, 16 * tid, 0}, {1, 48, 16, 128});
     transpose(v32, v33, {0, 2, 1, 3});
 
     /*
     [1, 384, 8192] @ [8192, 8192] -> [1,384,8192]
     [1, 48@b, 2048@t]@shared @ [2048@t, 8192] -> [1, 48@b, 8192]@shared
      */
-    auto V34 = view(V33, {1, 48, 8192});
+    auto V34 = view(*V33, {1, 48, 8192});
     auto v34 = V34({0, 0, 2048 * tid}, {1, 48, 2048});
     tdma_wait(ctx);
-    tensor_block_mma_sync(v34, v35_w, V35, false, ctx);
+    tensor_block_mma_sync(v34, *v35_w, *V35, false, ctx);
 #if DUMP
     {
         auto v35 = V35({0, 0, tid * 2048}, {1, 48, 2048});
@@ -331,7 +350,7 @@ void stage1_kernel(
      */
     tdma_load_async(var_5, Hidden_in({0, bid * 48, tid * 2048}, {1, 48, 2048}),
                     ctx);
-    auto v35 = V35({0, 0, tid * 2048}, {1, 48, 2048});
+    auto v35 = (*V35)({0, 0, tid * 2048}, {1, 48, 2048});
     tensor<float> v36({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t] */
     binary(var_5, v35, v36, binary_op_t::add);
 
@@ -348,7 +367,7 @@ void stage1_kernel(
       [1,384,8192] @ [8192, 22016] -> [1,384, 22016]
       [1, 48@b, 2048@t] @ [2048@t, 22016] -> [1, 48@b, 22016]@shared
     */
-    tensor_block_mma_sync(v37, v38_w, V38, false, ctx);
+    tensor_block_mma_sync(v37, *v38_w, *V38, false, ctx);
 #if DUMP
     {
         auto v38 = V38({0, 0, 5504 * tid}, {1, 48, 5504});
@@ -361,33 +380,33 @@ void stage1_kernel(
       [1,384, 22016] -> [1,384, 22016]
       [1, 48@b, 5504@t]@shared -> [1, 48@b, 5504@t]@shared
     */
-    auto v39 = V38({0, 0, 5504 * tid}, {1, 48, 5504});
+    auto v39 = (*V38)({0, 0, 5504 * tid}, {1, 48, 5504});
     unary(v39, v39, unary_op_t::swish);
 
     /* [1, 384, 8192]    @ [8192, 22016] -> [1, 384, 22016]
        [1, 48@b, 2048@t] @  [2048@t, 22016] -> [1, 48@b, 22016] @shared
     */
-    tensor_block_mma_sync(v37, v40_w, V40, false, ctx);
+    tensor_block_mma_sync(v37, *v40_w, *V40, false, ctx);
     /*
     [1, 384, 22016] X  [1, 384, 22016] -> [1, 384, 22016]
     [1, 48@b, 5504@t]@shared X [1,48@b,5504@t]@shared -> [1, 48@b, 5504@t]@local
     */
     tensor<float> v41({1, 48, 5504});
-    auto v40 = V40({0, 0, 5504 * tid}, {1, 48, 5504});
+    auto v40 = (*V40)({0, 0, 5504 * tid}, {1, 48, 5504});
     binary(v39, v40, v41, binary_op_t::mul);
 
     /*
       [1, 384, 22016] @ [22016, 8192] -> [1, 384, 8192]
       [1, 48@b, 5504@t] @ [5504@t, 8192] -> [1, 48@b, 8192] @shared
     */
-    tensor_block_mma_sync(v41, v42_w, V42, false, ctx);
+    tensor_block_mma_sync(v41, *v42_w, *V42, false, ctx);
 
     /*
       [1, 384, 8192] + [1, 384, 8192] -> [1, 384, 8192]
       [1, 48@b, 2048@t] + [1, 48@b, 2048@t] @shared -> [1, 48@b, 2048@t]
     */
     tensor<float> v43({1, 48, 2048});
-    auto v42 = V42({0, 0, 2048 * tid}, {1, 48, 2048});
+    auto v42 = (*V42)({0, 0, 2048 * tid}, {1, 48, 2048});
     binary(v36, v42, v43, binary_op_t::add);
     tdma_store_async(v43, Hidden_in({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
                      ctx);
@@ -397,4 +416,5 @@ void stage1_kernel(
             v43, ImmOutputs[10]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
     }
 #endif
+#endif
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
index 2f4bdf72b6..eff551a0ba 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
@@ -1,15 +1,12 @@
 #include "cluster_def.h"
-#include <chrono>
-#include <io_utils.h>
 #include <runtime_utils.h>
-// #include <pthread.h>
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {                                             \
         block##b::thread##t::stage1_kernel(                                    \
-            Hidden_in, V0_gamma, V0_beta, V2_w, V16_w, V31_w, V35_w, V3_data,  \
-            V11_data, Attn_mask, V38_w, V40_w, V42_w, Position_ids, Output,    \
-            V25, GV31, ImmOutputs);                                            \
+            *Hidden_in, *V0_gamma, *V0_beta, *V2_w, *V16_w, *V31_w, *V35_w,    \
+            *V3_data, *V11_data, *Attn_mask, *V38_w, *V40_w, *V42_w,           \
+            *Position_ids, *Output, *V25, *GV31, ImmOutputs);                  \
         return arg;                                                            \
     }
 
@@ -19,39 +16,25 @@
     DEFINE_TFUNC(b, 2)                                                         \
     DEFINE_TFUNC(b, 3)
 
-static tensor<float, loc_t::device> Hidden_in({1, 384, 8192});
-static tensor<float, loc_t::device> V0_gamma({8192});
-static tensor<float, loc_t::device> V0_beta({8192});
-static tensor<float, loc_t::device> V2_w({64, 8192, 128});
-static tensor<float, loc_t::device> V16_w({64, 8192, 128});
-static tensor<float, loc_t::device> V31_w({64, 8192, 128});
-static tensor<float, loc_t::device> V35_w({8192, 8192});
-static tensor<float, loc_t::device> V3_data({384, 128});
-static tensor<float, loc_t::device> V11_data({384, 128});
-static tensor<float, loc_t::device> Attn_mask({1, 1, 384, 384});
-static tensor<float, loc_t::device> V38_w({8192, 22016});
-static tensor<float, loc_t::device> V40_w({8192, 22016});
-static tensor<float, loc_t::device> V42_w({22016, 8192});
-static tensor<int64_t, loc_t::device> Position_ids({1, 384});
-static tensor<float, loc_t::device> Output({1, 384, 8192});
-static tensor<float, loc_t::device> V25({1, 64, 128, 384});
-static tensor<float, loc_t::device> GV31({1, 64, 384, 128});
+static tensor<float, loc_t::device> *Hidden_in;      // ({1, 384, 8192})
+static tensor<float, loc_t::device> *V0_gamma;       // ({8192})
+static tensor<float, loc_t::device> *V0_beta;        // ({8192})
+static tensor<float, loc_t::device> *V2_w;           // ({64, 8192, 128})
+static tensor<float, loc_t::device> *V16_w;          // ({64, 8192, 128})
+static tensor<float, loc_t::device> *V31_w;          // ({64, 8192, 128})
+static tensor<float, loc_t::device> *V35_w;          // ({8192, 8192})
+static tensor<float, loc_t::device> *V3_data;        // ({384, 128})
+static tensor<float, loc_t::device> *V11_data;       // ({384, 128})
+static tensor<float, loc_t::device> *Attn_mask;      // ({1, 1, 384, 384})
+static tensor<float, loc_t::device> *V38_w;          // ({8192, 22016})
+static tensor<float, loc_t::device> *V40_w;          // ({8192, 22016})
+static tensor<float, loc_t::device> *V42_w;          // ({22016, 8192})
+static tensor<int64_t, loc_t::device> *Position_ids; // ({1, 384})
+static tensor<float, loc_t::device> *Output;         // ({1, 384, 8192})
+static tensor<float, loc_t::device> *V25;            // ({1, 64, 128, 384})
+static tensor<float, loc_t::device> *GV31;           // ({1, 64, 384, 128})
 
 constexpr int OutNum = 11;
-static tensor<float, loc_t::device> goldenImmOutputs[OutNum] = {
-    tensor<float, loc_t::device>({1, 384, 8192}),    // v0
-    tensor<float, loc_t::device>({1, 64, 384, 128}), // v2
-    tensor<float, loc_t::device>({1, 64, 384, 128}), // v10
-    tensor<float, loc_t::device>({1, 64, 384, 128}), // v14
-    tensor<float, loc_t::device>({1, 384, 128}),     // v3
-    tensor<float, loc_t::device>({1, 64, 384, 128}), // v16
-    tensor<float, loc_t::device>({1, 64, 384, 384}), // v28
-    tensor<float, loc_t::device>({1, 64, 384, 128}), // v32
-    tensor<float, loc_t::device>({1, 384, 8192}),    // v35
-    tensor<float, loc_t::device>({1, 384, 22016}),   // v38
-    tensor<float, loc_t::device>({1, 384, 8192}),    // v43
-};
-
 static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
     tensor<float, loc_t::device>({1, 384, 8192}),
     tensor<float, loc_t::device>({1, 64, 384, 128}),
@@ -75,160 +58,290 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
-#define LOAD_FILE(name, i, type)                                               \
-    {                                                                          \
-        auto src_##name = read_file(std::string(argv[(i)]));                   \
-        span_copy(name.data(), gsl::make_span(src_##name).as_span<type>());    \
-    }
+#define MALLOC_GLOBAL(i, name, type, size, shape)                              \
+    auto g_##name = tensor<type, loc_t::device>(                               \
+        gsl::make_span((type *)inputs[i], size), shape);                       \
+    name = &g_##name;
+
+#define MALLOC_SHARED(name, b, type, size, shape)                              \
+    auto shared##b##name = tensor<type, loc_t::shared>(shape);                 \
+    block##b::shared::name = &shared##b##name;
 
 #define CLEAR_SHARED(i)                                                        \
-    tdma_fill_async<float>(block##i::shared::V2, 0);                           \
-    tdma_fill_async<float>(block##i::shared::V5, 0);                           \
-    tdma_fill_async<float>(block##i::shared::V13, 0);                          \
-    tdma_fill_async<float>(block##i::shared::V16, 0);                          \
-    tdma_fill_async<float>(block##i::shared::V25, 0);                          \
-    tdma_fill_async<float>(block##i::shared::V26, 0);                          \
-    tdma_fill_async<float>(block##i::shared::V31, 0);                          \
-    tdma_fill_async<float>(block##i::shared::V32, 0);                          \
-    tdma_fill_async<float>(block##i::shared::V33, 0);                          \
-    tdma_fill_async<float>(block##i::shared::V35, 0);                          \
-    tdma_fill_async<float>(block##i::shared::V38, 0);                          \
-    tdma_fill_async<float>(block##i::shared::V40, 0);                          \
-    tdma_fill_async<float>(block##i::shared::V42, 0);
-
-/**
- * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
- *
- * @param argc
- * @param argv
- * @return int
- */
-int main([[maybe_unused]] int argc, char **argv) {
-    global_hardware_init();
-    LOAD_FILE(Hidden_in, 1, float);
-    LOAD_FILE(Attn_mask, 10, float);
-    LOAD_FILE(Position_ids, 14, int64_t);
-    for (auto index = 0; index < 80; index++) {
-        // spdlog::set_level(spdlog::level::debug);
-        auto start = std::chrono::steady_clock::now();
-
-        LOAD_FILE(V0_gamma, 2, float);
-        LOAD_FILE(V0_beta, 3, float);
-        LOAD_FILE(V2_w, 4, float);
-        LOAD_FILE(V16_w, 5, float);
-        LOAD_FILE(V31_w, 6, float);
-        LOAD_FILE(V35_w, 7, float);
-        LOAD_FILE(V3_data, 8, float);
-        LOAD_FILE(V11_data, 9, float);
-        LOAD_FILE(V38_w, 11, float);
-        LOAD_FILE(V40_w, 12, float);
-        LOAD_FILE(V42_w, 13, float);
-
-        for (auto o = 0; o < argc - 16; o++) {
-            auto src_output = read_file(std::string(argv[(16 + o)]));
-            span_copy(goldenImmOutputs[o].data(),
-                      gsl::make_span(src_output).as_span<float>());
-        }
-
-        pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-        pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-        pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-        pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
-
-        pthread_create(&t_0_0, NULL, f_0_0, NULL);
-        pthread_create(&t_0_1, NULL, f_0_1, NULL);
-        pthread_create(&t_0_2, NULL, f_0_2, NULL);
-        pthread_create(&t_0_3, NULL, f_0_3, NULL);
-        pthread_create(&t_1_0, NULL, f_1_0, NULL);
-        pthread_create(&t_1_1, NULL, f_1_1, NULL);
-        pthread_create(&t_1_2, NULL, f_1_2, NULL);
-        pthread_create(&t_1_3, NULL, f_1_3, NULL);
-        pthread_create(&t_2_0, NULL, f_2_0, NULL);
-        pthread_create(&t_2_1, NULL, f_2_1, NULL);
-        pthread_create(&t_2_2, NULL, f_2_2, NULL);
-        pthread_create(&t_2_3, NULL, f_2_3, NULL);
-        pthread_create(&t_3_0, NULL, f_3_0, NULL);
-        pthread_create(&t_3_1, NULL, f_3_1, NULL);
-        pthread_create(&t_3_2, NULL, f_3_2, NULL);
-        pthread_create(&t_3_3, NULL, f_3_3, NULL);
-        pthread_create(&t_4_0, NULL, f_4_0, NULL);
-        pthread_create(&t_4_1, NULL, f_4_1, NULL);
-        pthread_create(&t_4_2, NULL, f_4_2, NULL);
-        pthread_create(&t_4_3, NULL, f_4_3, NULL);
-        pthread_create(&t_5_0, NULL, f_5_0, NULL);
-        pthread_create(&t_5_1, NULL, f_5_1, NULL);
-        pthread_create(&t_5_2, NULL, f_5_2, NULL);
-        pthread_create(&t_5_3, NULL, f_5_3, NULL);
-        pthread_create(&t_6_0, NULL, f_6_0, NULL);
-        pthread_create(&t_6_1, NULL, f_6_1, NULL);
-        pthread_create(&t_6_2, NULL, f_6_2, NULL);
-        pthread_create(&t_6_3, NULL, f_6_3, NULL);
-        pthread_create(&t_7_0, NULL, f_7_0, NULL);
-        pthread_create(&t_7_1, NULL, f_7_1, NULL);
-        pthread_create(&t_7_2, NULL, f_7_2, NULL);
-        pthread_create(&t_7_3, NULL, f_7_3, NULL);
-
-        pthread_join(t_0_0, NULL);
-        pthread_join(t_0_1, NULL);
-        pthread_join(t_0_2, NULL);
-        pthread_join(t_0_3, NULL);
-        pthread_join(t_1_0, NULL);
-        pthread_join(t_1_1, NULL);
-        pthread_join(t_1_2, NULL);
-        pthread_join(t_1_3, NULL);
-        pthread_join(t_2_0, NULL);
-        pthread_join(t_2_1, NULL);
-        pthread_join(t_2_2, NULL);
-        pthread_join(t_2_3, NULL);
-        pthread_join(t_3_0, NULL);
-        pthread_join(t_3_1, NULL);
-        pthread_join(t_3_2, NULL);
-        pthread_join(t_3_3, NULL);
-        pthread_join(t_4_0, NULL);
-        pthread_join(t_4_1, NULL);
-        pthread_join(t_4_2, NULL);
-        pthread_join(t_4_3, NULL);
-        pthread_join(t_5_0, NULL);
-        pthread_join(t_5_1, NULL);
-        pthread_join(t_5_2, NULL);
-        pthread_join(t_5_3, NULL);
-        pthread_join(t_6_0, NULL);
-        pthread_join(t_6_1, NULL);
-        pthread_join(t_6_2, NULL);
-        pthread_join(t_6_3, NULL);
-        pthread_join(t_7_0, NULL);
-        pthread_join(t_7_1, NULL);
-        pthread_join(t_7_2, NULL);
-        pthread_join(t_7_3, NULL);
-
-        auto stop = std::chrono::steady_clock::now();
-        double duration =
-            std::chrono::duration<double, std::milli>(stop - start).count();
-        std::cout << "Demo run: " << duration / 1000 << " secs" << std::endl;
-        
-        for (auto o = 0; o < argc - 16; o++) {
-            auto cos = cosine(ImmOutputs[o].data().begin(),
-                              goldenImmOutputs[o].data().begin(),
-                              goldenImmOutputs[o].data().size());
-            printf("%s cosine %f\n", argv[16 + o], cos);
-        }
-        {
-            auto src_output = read_file(std::string(argv[15]));
-            auto src_span = gsl::make_span(src_output).as_span<float>();
-            auto cos = cosine(Hidden_in.data().data(), src_span.data(),
-                              src_span.size());
-            printf("Output cosine %f\n", cos);
-        }
-
-        CLEAR_SHARED(0);
-        CLEAR_SHARED(1);
-        CLEAR_SHARED(2);
-        CLEAR_SHARED(3);
-        CLEAR_SHARED(4);
-        CLEAR_SHARED(5);
-        CLEAR_SHARED(6);
-        CLEAR_SHARED(7);
-    }
+    tdma_fill_async<float>(*block##i::shared::V2, 0);                           \
+    tdma_fill_async<float>(*block##i::shared::V5, 0);                           \
+    tdma_fill_async<float>(*block##i::shared::V13, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V16, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V25, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V26, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V31, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V32, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V33, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V35, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V38, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V40, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V42, 0);
+
+void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
+    global_hardware_init(hw_ctx_impl);
+    runtime_util = *rt_util_mt;
+    nncase_mt = *nncase_mt_impl;
+
+    MALLOC_GLOBAL(0, Hidden_in, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_GLOBAL(1, V0_gamma, float, (8192), dims_t({8192}))
+    MALLOC_GLOBAL(2, V0_beta, float, (8192), dims_t({8192}))
+    MALLOC_GLOBAL(3, V2_w, float, (64 * 8192 * 128), dims_t({64, 8192, 128}))
+    MALLOC_GLOBAL(4, V16_w, float, (64 * 8192 * 128), dims_t({64, 8192, 128}))
+    MALLOC_GLOBAL(5, V31_w, float, (64 * 8192 * 128), dims_t({64, 8192, 128}))
+    MALLOC_GLOBAL(6, V35_w, float, (8192 * 8192), dims_t({8192, 8192}))
+    MALLOC_GLOBAL(7, V3_data, float, (384 * 128), dims_t({384, 128}))
+    MALLOC_GLOBAL(8, V11_data, float, (384 * 128), dims_t({384, 128}))
+    MALLOC_GLOBAL(9, Attn_mask, float, (1 * 1 * 384 * 384), dims_t({1, 1, 384, 384}))
+    MALLOC_GLOBAL(10, V38_w, float, (8192 * 22016), dims_t({8192, 22016}))
+    MALLOC_GLOBAL(11, V40_w, float, (8192 * 22016), dims_t({8192, 22016}))
+    MALLOC_GLOBAL(12, V42_w, float, (22016 * 8192), dims_t({22016, 8192}))
+    MALLOC_GLOBAL(13, Position_ids, int64_t, (1 * 384), dims_t({1, 384}))
+    MALLOC_GLOBAL(14, Output, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    auto V25_tmp = tensor<float, loc_t::device>(dims_t({1, 64, 128, 384}));
+    auto GV31_tmp = tensor<float, loc_t::device>(dims_t({1, 64, 384, 128}));
+    V25 = &V25_tmp;
+    GV31 = &GV31_tmp;
+    
+    MALLOC_SHARED(V2, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V2, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V2, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V2, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V2, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V2, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V2, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V2, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+
+    MALLOC_SHARED(V5, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V5, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V5, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V5, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V5, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V5, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V5, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V5, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+
+    MALLOC_SHARED(V13, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V13, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V13, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V13, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V13, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V13, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V13, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V13, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+
+    MALLOC_SHARED(V16, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V16, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V16, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V16, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V16, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V16, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V16, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V16, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+
+    MALLOC_SHARED(V25, 0, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 128}))
+    MALLOC_SHARED(V25, 1, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 128}))
+    MALLOC_SHARED(V25, 2, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 128}))
+    MALLOC_SHARED(V25, 3, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 128}))
+    MALLOC_SHARED(V25, 4, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 128}))
+    MALLOC_SHARED(V25, 5, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 128}))
+    MALLOC_SHARED(V25, 6, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 128}))
+    MALLOC_SHARED(V25, 7, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 128}))
+
+    MALLOC_SHARED(V26, 0, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V26, 1, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V26, 2, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V26, 3, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V26, 4, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V26, 5, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V26, 6, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V26, 7, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+
+    MALLOC_SHARED(V31, 0, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V31, 1, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V31, 2, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V31, 3, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V31, 4, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V31, 5, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V31, 6, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V31, 7, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+
+    MALLOC_SHARED(V32, 0, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V32, 1, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V32, 2, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V32, 3, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V32, 4, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V32, 5, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V32, 6, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V32, 7, float, (1 * 64 * 384 * 128),
+                  dims_t({1, 64, 384, 384}))
+
+    MALLOC_SHARED(V33, 0, float, (1 * 384 * 64 * 128),
+                  dims_t({1, 384, 64, 384}))
+    MALLOC_SHARED(V33, 1, float, (1 * 384 * 64 * 128),
+                  dims_t({1, 384, 64, 384}))
+    MALLOC_SHARED(V33, 2, float, (1 * 384 * 64 * 128),
+                  dims_t({1, 384, 64, 384}))
+    MALLOC_SHARED(V33, 3, float, (1 * 384 * 64 * 128),
+                  dims_t({1, 384, 64, 384}))
+    MALLOC_SHARED(V33, 4, float, (1 * 384 * 64 * 128),
+                  dims_t({1, 384, 64, 384}))
+    MALLOC_SHARED(V33, 5, float, (1 * 384 * 64 * 128),
+                  dims_t({1, 384, 64, 384}))
+    MALLOC_SHARED(V33, 6, float, (1 * 384 * 64 * 128),
+                  dims_t({1, 384, 64, 384}))
+    MALLOC_SHARED(V33, 7, float, (1 * 384 * 64 * 128),
+                  dims_t({1, 384, 64, 384}))
+
+    MALLOC_SHARED(V35, 0, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V35, 1, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V35, 2, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V35, 3, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V35, 4, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V35, 5, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V35, 6, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V35, 7, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+
+    MALLOC_SHARED(V38, 0, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V38, 1, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V38, 2, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V38, 3, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V38, 4, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V38, 5, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V38, 6, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V38, 7, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+
+    MALLOC_SHARED(V40, 0, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
+    MALLOC_SHARED(V40, 1, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
+    MALLOC_SHARED(V40, 2, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
+    MALLOC_SHARED(V40, 3, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
+    MALLOC_SHARED(V40, 4, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
+    MALLOC_SHARED(V40, 5, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
+    MALLOC_SHARED(V40, 6, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
+    MALLOC_SHARED(V40, 7, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
+
+    MALLOC_SHARED(V42, 0, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V42, 1, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V42, 2, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V42, 3, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V42, 4, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V42, 5, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V42, 6, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V42, 7, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+
+    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
+
+    runtime_util.create_thread(t_0_0, NULL, f_0_0);
+    runtime_util.create_thread(t_0_1, NULL, f_0_1);
+    runtime_util.create_thread(t_0_2, NULL, f_0_2);
+    runtime_util.create_thread(t_0_3, NULL, f_0_3);
+    runtime_util.create_thread(t_1_0, NULL, f_1_0);
+    runtime_util.create_thread(t_1_1, NULL, f_1_1);
+    runtime_util.create_thread(t_1_2, NULL, f_1_2);
+    runtime_util.create_thread(t_1_3, NULL, f_1_3);
+    runtime_util.create_thread(t_2_0, NULL, f_2_0);
+    runtime_util.create_thread(t_2_1, NULL, f_2_1);
+    runtime_util.create_thread(t_2_2, NULL, f_2_2);
+    runtime_util.create_thread(t_2_3, NULL, f_2_3);
+    runtime_util.create_thread(t_3_0, NULL, f_3_0);
+    runtime_util.create_thread(t_3_1, NULL, f_3_1);
+    runtime_util.create_thread(t_3_2, NULL, f_3_2);
+    runtime_util.create_thread(t_3_3, NULL, f_3_3);
+    runtime_util.create_thread(t_4_0, NULL, f_4_0);
+    runtime_util.create_thread(t_4_1, NULL, f_4_1);
+    runtime_util.create_thread(t_4_2, NULL, f_4_2);
+    runtime_util.create_thread(t_4_3, NULL, f_4_3);
+    runtime_util.create_thread(t_5_0, NULL, f_5_0);
+    runtime_util.create_thread(t_5_1, NULL, f_5_1);
+    runtime_util.create_thread(t_5_2, NULL, f_5_2);
+    runtime_util.create_thread(t_5_3, NULL, f_5_3);
+    runtime_util.create_thread(t_6_0, NULL, f_6_0);
+    runtime_util.create_thread(t_6_1, NULL, f_6_1);
+    runtime_util.create_thread(t_6_2, NULL, f_6_2);
+    runtime_util.create_thread(t_6_3, NULL, f_6_3);
+    runtime_util.create_thread(t_7_0, NULL, f_7_0);
+    runtime_util.create_thread(t_7_1, NULL, f_7_1);
+    runtime_util.create_thread(t_7_2, NULL, f_7_2);
+    runtime_util.create_thread(t_7_3, NULL, f_7_3);
+
+    runtime_util.join_thread(t_0_0);
+    runtime_util.join_thread(t_0_1);
+    runtime_util.join_thread(t_0_2);
+    runtime_util.join_thread(t_0_3);
+    runtime_util.join_thread(t_1_0);
+    runtime_util.join_thread(t_1_1);
+    runtime_util.join_thread(t_1_2);
+    runtime_util.join_thread(t_1_3);
+    runtime_util.join_thread(t_2_0);
+    runtime_util.join_thread(t_2_1);
+    runtime_util.join_thread(t_2_2);
+    runtime_util.join_thread(t_2_3);
+    runtime_util.join_thread(t_3_0);
+    runtime_util.join_thread(t_3_1);
+    runtime_util.join_thread(t_3_2);
+    runtime_util.join_thread(t_3_3);
+    runtime_util.join_thread(t_4_0);
+    runtime_util.join_thread(t_4_1);
+    runtime_util.join_thread(t_4_2);
+    runtime_util.join_thread(t_4_3);
+    runtime_util.join_thread(t_5_0);
+    runtime_util.join_thread(t_5_1);
+    runtime_util.join_thread(t_5_2);
+    runtime_util.join_thread(t_5_3);
+    runtime_util.join_thread(t_6_0);
+    runtime_util.join_thread(t_6_1);
+    runtime_util.join_thread(t_6_2);
+    runtime_util.join_thread(t_6_3);
+    runtime_util.join_thread(t_7_0);
+    runtime_util.join_thread(t_7_1);
+    runtime_util.join_thread(t_7_2);
+    runtime_util.join_thread(t_7_3);
 
-    return 0;
+    CLEAR_SHARED(0);
+    CLEAR_SHARED(1);
+    CLEAR_SHARED(2);
+    CLEAR_SHARED(3);
+    CLEAR_SHARED(4);
+    CLEAR_SHARED(5);
+    CLEAR_SHARED(6);
+    CLEAR_SHARED(7);
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
index 0e9c8d924d..0c7a5333c1 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
@@ -2,36 +2,36 @@
 
 namespace shared {
 static tensor<float, loc_t::shared>
-    V2({1, 64, 48, 128}); // [1, 64, 384, 128] [1, 64, 48@b, 128]
+    *V2; // [1, 64, 384, 128] [1, 64, 48@b, 128]
 
-static tensor<float, loc_t::shared> V5({1, 64, 48, 128});
+static tensor<float, loc_t::shared> *V5; // {1, 64, 48, 128}
 
-static tensor<float, loc_t::shared> V13({1, 64, 48, 128});
+static tensor<float, loc_t::shared> *V13; // {1, 64, 48, 128}
 
 static tensor<float, loc_t::shared>
-    V16({1, 64, 48, 128}); // [1, 64, 48, 128] [1, 64, 48@b, 128]
+    *V16; // [1, 64, 48, 128] [1, 64, 48@b, 128]
 
 static tensor<float, loc_t::shared>
-    V25({1, 64, 128, 384}); // [1, 64, 384, 128] [1, 8@b, 384, 384]
+    *V25; // [1, 64, 384, 128] [1, 8@b, 384, 384]
 static tensor<float, loc_t::shared>
-    V26({1, 64, 48, 384}); // [1, 64, 384, 128] [1, 64, 48@b, 384]
+    *V26; // [1, 64, 384, 128] [1, 64, 48@b, 384]
 
 static tensor<float, loc_t::shared>
-    V31({1, 64, 48, 128}); // [1, 64, 384, 128] [1, 64, 48@b, 128]
+    *V31; // [1, 64, 384, 128] [1, 64, 48@b, 128]
 
 static tensor<float, loc_t::shared>
-    V32({1, 64, 48, 128}); // [1, 64, 384, 128] [1, 64, 48@b, 128]
+    *V32; // [1, 64, 384, 128] [1, 64, 48@b, 128]
 static tensor<float, loc_t::shared>
-    V33({1, 48, 64, 128}); // [1, 384, 64, 128] [1, 48@b, 64, 128]
+    *V33; // [1, 384, 64, 128] [1, 48@b, 64, 128]
 
-static tensor<float, loc_t::shared> V35({1, 48, 8192}); // [1, 384, 8192]
+static tensor<float, loc_t::shared> *V35; // [1, 384, 8192]
 
 static tensor<float, loc_t::shared>
-    V38({1, 48, 22016}); // [1, 384, 8192] [1, 48@b, 22016]
+    *V38; // [1, 384, 22016] [1, 48@b, 22016]
 
 static tensor<float, loc_t::shared>
-    V40({1, 48, 22016}); // [1, 384, 8192] [1, 48@b, 22016]
+    *V40; // [1, 384, 8192] [1, 48@b, 22016]
 
 static tensor<float, loc_t::shared>
-    V42({1, 48, 8192}); // [1, 384, 8192] [1, 48@b, 8192]
+    *V42; // [1, 384, 8192] [1, 48@b, 8192]
 } // namespace shared
\ No newline at end of file

From 7ea7252639e7e1c214078304ca8b3c9f7272420f Mon Sep 17 00:00:00 2001
From: lerenhua <2532375005@qq.com>
Date: Thu, 7 Sep 2023 15:14:52 +0800
Subject: [PATCH 163/308] Add uanry demo

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |   1 +
 .../runtime/cmodel/tests/unary/cluster_def.h  | 171 ++++++++++++++++++
 .../src/runtime/cmodel/tests/unary/golden.py  |  12 ++
 .../src/runtime/cmodel/tests/unary/kernel.h   |  21 +++
 .../src/runtime/cmodel/tests/unary/main.cpp   | 111 ++++++++++++
 .../runtime/cmodel/tests/unary/shared_def.h   |   4 +
 6 files changed, 320 insertions(+)
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/unary/cluster_def.h
 create mode 100644 modules/cpu/src/runtime/cmodel/tests/unary/golden.py
 create mode 100755 modules/cpu/src/runtime/cmodel/tests/unary/kernel.h
 create mode 100755 modules/cpu/src/runtime/cmodel/tests/unary/main.cpp
 create mode 100755 modules/cpu/src/runtime/cmodel/tests/unary/shared_def.h

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index 0d26e0bb93..c637479f4e 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -42,3 +42,4 @@ endfunction(add_test)
 add_test(norm tests/norm)
 # add_test(embed tests/embed)
 add_test(head tests/head)
+add_test(unary tests/unary)
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/cluster_def.h b/modules/cpu/src/runtime/cmodel/tests/unary/cluster_def.h
new file mode 100644
index 0000000000..8fd5d84ed7
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/unary/cluster_def.h
@@ -0,0 +1,171 @@
+#pragma once
+#include <hardware_context.h>
+#include <tdma.h>
+
+namespace block0 {
+#include "shared_def.h"
+constexpr size_t bid = 0;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block0
+
+namespace block1 {
+#include "shared_def.h"
+constexpr size_t bid = 1;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block1
+
+namespace block2 {
+#include "shared_def.h"
+constexpr size_t bid = 2;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block2
+
+namespace block3 {
+#include "shared_def.h"
+constexpr size_t bid = 3;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block3
+
+namespace block4 {
+#include "shared_def.h"
+constexpr size_t bid = 4;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block4
+
+namespace block5 {
+#include "shared_def.h"
+constexpr size_t bid = 5;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block5
+
+namespace block6 {
+#include "shared_def.h"
+constexpr size_t bid = 6;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block6
+
+namespace block7 {
+#include "shared_def.h"
+constexpr size_t bid = 7;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include "kernel.h"
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include "kernel.h"
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include "kernel.h"
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include "kernel.h"
+} // namespace thread3
+} // namespace block7
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/golden.py b/modules/cpu/src/runtime/cmodel/tests/unary/golden.py
new file mode 100644
index 0000000000..94a6b18ae5
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/unary/golden.py
@@ -0,0 +1,12 @@
+import numpy as np
+from torch import nn
+import torch
+from scipy.special import softmax
+import os
+
+hidden_in = np.random.rand(1, 384, 2048).astype(np.float32)
+hidden_in.tofile('hidden_in.bin')
+
+output = np.arcsin(hidden_in)
+
+output.tofile("output.bin")
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/kernel.h b/modules/cpu/src/runtime/cmodel/tests/unary/kernel.h
new file mode 100755
index 0000000000..b7ad95e512
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/unary/kernel.h
@@ -0,0 +1,21 @@
+#include "thread_context.h"
+using namespace shared;
+void Unary_0(tensor<float, loc_t::device> &buffer_0,
+             tensor<float, loc_t::device> &buffer_3) {
+    thread_context ctx(bid, tid);
+    tensor<float, loc_t::local> buffer_1({1, 12, 2048});
+    tdma_load_async(
+        buffer_1,
+        buffer_0({0, 0 + (12 * 4 * bid) + (12 * 1 * tid), 0}, {1, 12, 2048}),
+        ctx);
+    tensor<float, loc_t::local> buffer_2({1, 12, 2048});
+    unary(buffer_1, buffer_2, unary_op_t::asin);
+    // tdma_store_async(
+    //     buffer_2,
+    //     buffer_3({0, 0 + (384 * 4 * bid) + (384 * 1 * tid), 0}, {1, 384,
+    //     2048}), ctx);
+    tdma_store_async(
+        buffer_2,
+        buffer_3({0, 0 + (12 * 4 * bid) + (12 * 1 * tid), 0}, {1, 12, 2048}),
+        ctx);
+}
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp b/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp
new file mode 100755
index 0000000000..cc62abe23f
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp
@@ -0,0 +1,111 @@
+#include "cluster_def.h"
+#include <runtime_utils.h>
+
+#define DEFINE_TFUNC(b, t)                                                     \
+    void *f_##b##_##t(void *arg) {                                             \
+        block##b::thread##t::Unary_0(*buffer_0, *buffer_3);                    \
+        return arg;                                                            \
+    }
+
+#define DEFINE_BFUNC(b)                                                        \
+    DEFINE_TFUNC(b, 0)                                                         \
+    DEFINE_TFUNC(b, 1)                                                         \
+    DEFINE_TFUNC(b, 2)                                                         \
+    DEFINE_TFUNC(b, 3)
+
+static tensor<float, loc_t::device> *buffer_0;
+static tensor<float, loc_t::device> *buffer_3;
+
+DEFINE_BFUNC(0)
+DEFINE_BFUNC(1)
+DEFINE_BFUNC(2)
+DEFINE_BFUNC(3)
+DEFINE_BFUNC(4)
+DEFINE_BFUNC(5)
+DEFINE_BFUNC(6)
+DEFINE_BFUNC(7)
+
+void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
+    global_hardware_init(hw_ctx_impl);
+    runtime_util = *rt_util_mt;
+    nncase_mt = *nncase_mt_impl;
+
+    auto buffer_0_ = tensor<float, loc_t::device>(
+        gsl::make_span((float *)inputs[0], 786432), {1, 384, 2048});
+    buffer_0 = &buffer_0_;
+    auto buffer_3_ = tensor<float, loc_t::device>(
+        gsl::make_span((float *)inputs[1], 786432), {1, 384, 2048});
+    buffer_3 = &buffer_3_;
+
+    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
+    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
+    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
+    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
+
+    runtime_util.create_thread(t_0_0, NULL, f_0_0);
+    runtime_util.create_thread(t_0_1, NULL, f_0_1);
+    runtime_util.create_thread(t_0_2, NULL, f_0_2);
+    runtime_util.create_thread(t_0_3, NULL, f_0_3);
+    runtime_util.create_thread(t_1_0, NULL, f_1_0);
+    runtime_util.create_thread(t_1_1, NULL, f_1_1);
+    runtime_util.create_thread(t_1_2, NULL, f_1_2);
+    runtime_util.create_thread(t_1_3, NULL, f_1_3);
+    runtime_util.create_thread(t_2_0, NULL, f_2_0);
+    runtime_util.create_thread(t_2_1, NULL, f_2_1);
+    runtime_util.create_thread(t_2_2, NULL, f_2_2);
+    runtime_util.create_thread(t_2_3, NULL, f_2_3);
+    runtime_util.create_thread(t_3_0, NULL, f_3_0);
+    runtime_util.create_thread(t_3_1, NULL, f_3_1);
+    runtime_util.create_thread(t_3_2, NULL, f_3_2);
+    runtime_util.create_thread(t_3_3, NULL, f_3_3);
+    runtime_util.create_thread(t_4_0, NULL, f_4_0);
+    runtime_util.create_thread(t_4_1, NULL, f_4_1);
+    runtime_util.create_thread(t_4_2, NULL, f_4_2);
+    runtime_util.create_thread(t_4_3, NULL, f_4_3);
+    runtime_util.create_thread(t_5_0, NULL, f_5_0);
+    runtime_util.create_thread(t_5_1, NULL, f_5_1);
+    runtime_util.create_thread(t_5_2, NULL, f_5_2);
+    runtime_util.create_thread(t_5_3, NULL, f_5_3);
+    runtime_util.create_thread(t_6_0, NULL, f_6_0);
+    runtime_util.create_thread(t_6_1, NULL, f_6_1);
+    runtime_util.create_thread(t_6_2, NULL, f_6_2);
+    runtime_util.create_thread(t_6_3, NULL, f_6_3);
+    runtime_util.create_thread(t_7_0, NULL, f_7_0);
+    runtime_util.create_thread(t_7_1, NULL, f_7_1);
+    runtime_util.create_thread(t_7_2, NULL, f_7_2);
+    runtime_util.create_thread(t_7_3, NULL, f_7_3);
+
+    runtime_util.join_thread(t_0_0);
+    runtime_util.join_thread(t_0_1);
+    runtime_util.join_thread(t_0_2);
+    runtime_util.join_thread(t_0_3);
+    runtime_util.join_thread(t_1_0);
+    runtime_util.join_thread(t_1_1);
+    runtime_util.join_thread(t_1_2);
+    runtime_util.join_thread(t_1_3);
+    runtime_util.join_thread(t_2_0);
+    runtime_util.join_thread(t_2_1);
+    runtime_util.join_thread(t_2_2);
+    runtime_util.join_thread(t_2_3);
+    runtime_util.join_thread(t_3_0);
+    runtime_util.join_thread(t_3_1);
+    runtime_util.join_thread(t_3_2);
+    runtime_util.join_thread(t_3_3);
+    runtime_util.join_thread(t_4_0);
+    runtime_util.join_thread(t_4_1);
+    runtime_util.join_thread(t_4_2);
+    runtime_util.join_thread(t_4_3);
+    runtime_util.join_thread(t_5_0);
+    runtime_util.join_thread(t_5_1);
+    runtime_util.join_thread(t_5_2);
+    runtime_util.join_thread(t_5_3);
+    runtime_util.join_thread(t_6_0);
+    runtime_util.join_thread(t_6_1);
+    runtime_util.join_thread(t_6_2);
+    runtime_util.join_thread(t_6_3);
+    runtime_util.join_thread(t_7_0);
+    runtime_util.join_thread(t_7_1);
+    runtime_util.join_thread(t_7_2);
+    runtime_util.join_thread(t_7_3);
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/unary/shared_def.h
new file mode 100755
index 0000000000..b18a608408
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/tests/unary/shared_def.h
@@ -0,0 +1,4 @@
+#include <tdma.h>
+
+namespace shared {
+} // namespace shared
\ No newline at end of file

From 7df34a71d3346dfb25950580910ca3ec240db49d Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 7 Sep 2023 15:30:13 +0800
Subject: [PATCH 164/308] pass v30 of decoder layer

---
 .../runtime/cmodel/include/runtime_utils.h    |   8 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h | 173 +++++++++++-------
 .../cmodel/tests/decoder_layer/golden.py      |   2 +-
 .../cmodel/tests/decoder_layer/kernel.h       |   8 +-
 4 files changed, 111 insertions(+), 80 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index f01bf1568a..11fa133119 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -196,8 +196,8 @@ inline dims_t get_reduced_offset(gsl::span<const size_t> in_offset,
 
 inline dims_t get_reduced_shape(gsl::span<const size_t> in_shape,
                                 gsl::span<const size_t> axis, bool keep_dims) {
-    dims_t shape;
-    shape.reserve(in_shape.size() - (keep_dims ? 0 : axis.size()));
+    dims_t shape(in_shape.size() - (keep_dims ? 0 : axis.size()));
+    auto count = 0;
     for (size_t i = 0; i < in_shape.size(); i++) {
         bool found = false;
         for (size_t j = 0; j < axis.size(); j++) {
@@ -207,10 +207,10 @@ inline dims_t get_reduced_shape(gsl::span<const size_t> in_shape,
             }
         }
         if (!found) {
-            shape.push_back(in_shape[i]);
+            shape[count++] = in_shape[i];
         } else {
             if (keep_dims)
-                shape.push_back(1);
+                shape[count++] = 1;
         }
     }
     return shape;
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 0a5c6e373b..9b4a9350e5 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -354,12 +354,12 @@ void tdma_reduce_async(tensor<T, loc_t::local> &src,
                                  ctx, src, dest)}
 
     {
-        __tdma_all_sync_apply_macro(
-            reduce_async_visit_func2, ([]() -> void {
-                free(global_hardware_ctx.global_var);
-                global_hardware_ctx.global_var = nullptr;
-            }),
-            ctx, src, dest, reduce_op)
+        __tdma_all_sync_apply_macro(reduce_async_visit_func2, ([]() -> void {
+                                        free(global_hardware_ctx.global_var);
+                                        global_hardware_ctx.global_var =
+                                            nullptr;
+                                    }),
+                                    ctx, src, dest, reduce_op)
     }
 }
 
@@ -368,6 +368,89 @@ enum class reduce_strategy_t : uint8_t {
     by_block,
 };
 
+template <class T, loc_t ALoc>
+void all_reduce_async_visit_func1(int visited, thread_context &ctx,
+                                  tensor<T, ALoc> &src) {
+
+    T *gather_span = nullptr;
+    auto new_dims = dims_t(src.dimension());
+    new_dims.insert(new_dims.begin(), BLOCKS * CORES);
+    if (visited == 1) {
+        if (global_hardware_ctx.global_var != nullptr) {
+            runtime_util.rt_assert(false,
+                                   (char *)"the global var has been used!");
+        }
+        gather_span =
+            (T *)runtime_util.malloc(sizeof(T) * compute_size(new_dims));
+        global_hardware_ctx.global_var = (void *)gather_span;
+    }
+    dims_t begin(new_dims.size(), 0);
+    dims_t shape(new_dims);
+    begin[0] = ctx.bid() * CORES + ctx.tid();
+    shape[0] = 1;
+    tensor<T> gather_tensor =
+        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
+                                 compute_size(new_dims)),
+                  new_dims);
+    __tensor_copy_sync<T, loc_t::local, ALoc>(
+        std::move((gather_tensor)(begin, shape)), std::move(unsqueeze(src)));
+}
+
+template <class T, loc_t ALoc, loc_t BLoc>
+void all_reduce_async_visit_func2_all(int visit, tensor<T, ALoc> &src,
+                                      tensor<T, BLoc> &dest,
+                                      reduce_op_t reduce_op) {
+
+    T *gather_span = nullptr;
+    T *reduced_span = nullptr;
+    auto new_dims = dims_t(src.dimension());
+    new_dims.insert(new_dims.begin(), BLOCKS * CORES);
+    auto reduced_shape = get_reduced_shape(new_dims, dims_t({0}), false);
+
+    if (visit == 1) {
+        gather_span = global_hardware_ctx.global_var;
+        tensor<T> gather_tensor =
+            tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
+                                     compute_size(new_dims)),
+                      new_dims);
+        reduced_span =
+            (T *)runtime_util.malloc(sizeof(T) * compute_size(reduced_shape));
+        tensor<T> reduced_tensor = tensor<T>(reduced_shape);
+        reduce(gather_tensor, reduced_tensor, reduce_op, (T)0, dims_t({0}),
+               false);
+        free(gather_span);
+        global_hardware_ctx.global_var = reduced_span;
+    } else {
+        tensor<T> reduced_tensor =
+            tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
+                                     compute_size(reduced_shape)),
+                      reduced_shape);
+        __tensor_copy_sync(std::move(dest), std::move(reduced_tensor));
+    }
+}
+
+template <class T, loc_t ALoc, loc_t BLoc>
+void all_reduce_async_visit_func2_by_block(int visit, tensor<T, ALoc> &src,
+                                           tensor<T, BLoc> &dest,
+                                           reduce_op_t reduce_op) {
+    auto new_dims = dims_t(src.dimension());
+    new_dims.insert(new_dims.begin(), CORES * BLOCKS);
+
+    tensor<T> gather_tensor =
+        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
+                                 compute_size(new_dims)),
+                  new_dims);
+
+    auto new_strides = dims_t(gather_tensor.strides());
+    new_dims[0] = BLOCKS;
+    new_strides[0] *= CORES;
+
+    auto viewed_gather_tensor = view(gather_tensor, new_dims, new_strides);
+
+    reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
+           dims_t({0}), false);
+}
+
 /**
  * @brief reduce across BLOCKS * CORES
  *  1. stack the src to gather tensor, shape = [BLOCKS , CORES , ...]
@@ -386,85 +469,33 @@ template <class T, loc_t ALoc, loc_t BLoc>
 void tdma_all_reduce_async(tensor<T, ALoc> &src, tensor<T, BLoc> &dest,
                            reduce_op_t reduce_op, reduce_strategy_t strategy,
                            thread_context &ctx) {
-    __tdma_all_sync_apply(
-        [&src, &ctx](int visited) -> void {
-            tensor<T> *gather_tensor = nullptr;
-            auto new_dims = dims_t(src.dimension());
-            new_dims.insert(new_dims.begin(), BLOCKS * CORES);
-            if (visited == 1) {
-                if (global_hardware_ctx.global_var != nullptr) {
-                    runtime_util.rt_assert(
-                        false, (char *)"the global var has been used!");
-                }
-                gather_tensor = new tensor<T>(new_dims);
-                global_hardware_ctx.global_var = (void *)gather_tensor;
-            } else {
-                gather_tensor =
-                    static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-            }
-            dims_t begin(new_dims.size(), 0);
-            dims_t shape(new_dims);
-            begin[0] = ctx.bid() * CORES + ctx.tid();
-            shape[0] = 1;
-            __tensor_copy_sync<T, loc_t::local, ALoc>(
-                std::move((*gather_tensor)(begin, shape)),
-                std::move(unsqueeze(src)));
-        },
-        []() -> void {}, ctx);
+    {
+        __tdma_all_sync_apply_macro(
+            all_reduce_async_visit_func1, []() -> void {}, ctx, src)
+    }
     switch (strategy) {
-    case reduce_strategy_t::all:
-        __tdma_all_sync_apply(
-            [&]([[maybe_unused]] int visit) -> void {
-                tensor<T> *gather_tensor = nullptr;
-                tensor<T> *reduced_tensor = nullptr;
-                if (visit == 1) {
-                    gather_tensor = static_cast<tensor<T> *>(
-                        global_hardware_ctx.global_var);
-                    auto reduced_shape = get_reduced_shape(
-                        gather_tensor->dimension(), dims_t({0}), false);
-                    reduced_tensor = new tensor<T>(reduced_shape);
-                    reduce(*gather_tensor, *reduced_tensor, reduce_op, (T)0,
-                           dims_t({0}), false);
-                    delete gather_tensor;
-                    global_hardware_ctx.global_var = reduced_tensor;
-                } else {
-                    reduced_tensor = static_cast<tensor<T> *>(
-                        global_hardware_ctx.global_var);
-                    __tensor_copy_sync(std::move(dest),
-                                       std::move(*reduced_tensor));
-                }
-            },
+    case reduce_strategy_t::all: {
+        __tdma_all_sync_apply_macro(
+            all_reduce_async_visit_func2_all,
             []() -> void {
                 auto reduced_tensor =
                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
                 delete reduced_tensor;
                 global_hardware_ctx.global_var = nullptr;
             },
-            ctx);
-        break;
-    case reduce_strategy_t::by_block:
+            src, dest, reduce_op);
+    } break;
+    case reduce_strategy_t::by_block: {
         __tdma_all_sync_apply(
-            [&]([[maybe_unused]] int visit) -> void {
-                tensor<T> *gather_tensor =
-                    static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-                auto new_dims = dims_t(src.dimension());
-                new_dims.insert(new_dims.begin(), BLOCKS);
-                auto new_strides = dims_t(gather_tensor->strides());
-                new_strides[0] *= CORES;
-                auto viewed_gather_tensor =
-                    view(*gather_tensor, new_dims, new_strides);
-
-                reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
-                       dims_t({0}), false);
-            },
+            all_reduce_async_visit_func2_by_block,
             []() -> void {
                 auto reduced_tensor =
                     static_cast<tensor<T> *>(global_hardware_ctx.global_var);
                 delete reduced_tensor;
                 global_hardware_ctx.global_var = nullptr;
             },
-            ctx);
-        break;
+            src, dest, reduce_op);
+    } break;
     default:
         break;
     }
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/golden.py b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/golden.py
index c1341091d1..2f50bb66cf 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/golden.py
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/golden.py
@@ -43,7 +43,7 @@ def gather(data:np.ndarray, axis:int, indices:np.ndarray):
 mlp_up_weights = np.reshape(np.fromfile(os.path.join(const_dir,"_mlp_up_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (8192, 22016))
 mlp_down_weights = np.reshape(np.fromfile(os.path.join(const_dir,"_mlp_down_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (22016, 8192))
 
-for index in range(80):
+for index in range(1):
     # np.random.rand(8192).astype(np.float32), np.random.rand(8192).astype(np.float32)
     v0 = rmsnorm(hidden_in, input_ln_gamma, input_ln_beta) # f32[1,384,8192]
     # v0.tofile("v0.bin")
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
index 90dd2f1030..7a5feb78de 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
@@ -88,8 +88,8 @@ void stage1_kernel(
         tensor<float> v0_sum_sqr({1, 48});
         reduce_sum_sqr(v0, v0_sum, v0_sum_sqr);
         tdma_reduce_async(v0_sum, v0_sum, reduce_op_t::sum, ctx);
-        // tdma_reduce_async(v0_sum_sqr, v0_sum_sqr, reduce_op_t::sum, ctx);
-        // layernorm(v0, v0_sum, v0_sum_sqr, v0, 2, 8192, true);
+        tdma_reduce_async(v0_sum_sqr, v0_sum_sqr, reduce_op_t::sum, ctx);
+        layernorm(v0, v0_sum, v0_sum_sqr, v0, 2, 8192, true);
 #if DUMP
         {
             tdma_store_async(
@@ -99,7 +99,6 @@ void stage1_kernel(
 #endif
     } // v0 [1, 384, 8192] [1, 48@b, 8192]
 
-#if 0
     auto v1 = unsqueeze(v0); // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
     /*
       [1, 1, 384, 8192]    @ [64, 8192, 128]  -> [1, 64, 384, 128]
@@ -289,7 +288,7 @@ void stage1_kernel(
       [1, 16@t, 48@b, 384]@shared -> [1, 16@t, 48@b, 384]
     */
     tensor<float> v29({1, 16, 48, 384}); //[1, 64, 384, 384] [1, 8@b, 96@t, 384]
-    softmax(v28, v29, 3);
+    // softmax(v28, v29, 3);
 
     /*
       [1,1,384,8192] @ [64, 8192, 128] -> [1,64,384,128]
@@ -297,6 +296,7 @@ void stage1_kernel(
     */
     auto &v30 = v1;
     tensor_block_mma_sync(v30, *v31_w, *V31, false, ctx);
+#if 0
 
     /* need resplit V */
     auto v31 = (*V31)({0, 16 * tid, 0, 0}, {1, 16, 48, 128});

From 48071612cd95bc42cf96fe257dec21fe6daeb44b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 8 Sep 2023 10:18:40 +0800
Subject: [PATCH 165/308] fix softmax

---
 .../cpu/src/runtime/cmodel/include/matmul.h   |   6 +-
 .../cpu/src/runtime/cmodel/include/softmax.h  |  11 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h |   4 +-
 .../cmodel/tests/decoder_layer/kernel.h       |   6 +-
 .../cmodel/tests/decoder_layer/main.cpp       | 221 ++++++++----------
 modules/cpu/src/runtime/method_table_impl.h   |  33 ++-
 6 files changed, 128 insertions(+), 153 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
index 5bfd4b888d..4707583a54 100644
--- a/modules/cpu/src/runtime/cmodel/include/matmul.h
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -13,7 +13,7 @@ void matmul_unit_impl(const T *input_a, const T *input_b, T *output,
 
     for (int32_t oy = 0; oy < a_rows; oy++) {
         T *values = (T *)runtime_util.malloc(sizeof(T) * b_cols);
-        runtime_util.memset(values, 0, sizeof(T) * b_cols);
+        // runtime_util.memset(values, 0, sizeof(T) * b_cols);
         for (int32_t i = 0; i < a_cols; i++) {
             for (int32_t ox = 0; ox < b_cols; ox++) {
                 const auto a = input_a[oy * a_cols + i];
@@ -99,7 +99,7 @@ void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                 T *out_ptr = output + n * new_out_stride[0] +
                              c * new_out_stride[1] + h * new_out_stride[2];
                 for (size_t m = 0; m < new_a_shape[3]; m++) {
-                    T *values = new T[new_b_shape[4]]();
+                    T *values = (T*)runtime_util.malloc(new_b_shape[4] * sizeof(T));
                     for (size_t k = 0; k < new_a_shape[4]; k++) {
                         for (size_t n = 0; n < new_b_shape[4]; n++) {
                             values[n] += in_a_ptr[m * new_a_stride[3] +
@@ -112,7 +112,7 @@ void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                         out_ptr[m * new_out_stride[3] + n * new_out_stride[4]] =
                             values[n];
                     }
-                    delete[] values;
+                    runtime_util.free(values);
                 }
             }
         }
diff --git a/modules/cpu/src/runtime/cmodel/include/softmax.h b/modules/cpu/src/runtime/cmodel/include/softmax.h
index 89ca7fc448..f672b0f05c 100644
--- a/modules/cpu/src/runtime/cmodel/include/softmax.h
+++ b/modules/cpu/src/runtime/cmodel/include/softmax.h
@@ -14,6 +14,7 @@
  */
 #include <cmath>
 #include <runtime_utils.h>
+#include <type_traits>
 
 using namespace nncase::runtime::cpu;
 
@@ -71,7 +72,13 @@ void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
 
         const auto out_index = get_reduced_offset(index, axes, true);
         auto out_idx = offset(reduced_strides, out_index);
-        output[in_idx] = expf(in);
+        if (std::is_same_v<T, float>) {
+            output[in_idx] = nncase_mt.float_unary_exp(in);
+        } else {
+            runtime_util.rt_assert(false,
+                                   (char *)"Not supported Type in softmax!");
+        }
+
         tmp[out_idx] += output[in_idx];
     }));
 
@@ -93,6 +100,8 @@ void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
             }
         }
     }));
+
+    runtime_util.free(tmp);
 }
 } // namespace
 void softmax(const float *input, float *output,
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 9b4a9350e5..1db4e9cfe0 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -355,7 +355,7 @@ void tdma_reduce_async(tensor<T, loc_t::local> &src,
 
     {
         __tdma_all_sync_apply_macro(reduce_async_visit_func2, ([]() -> void {
-                                        free(global_hardware_ctx.global_var);
+                                        runtime_util.free(global_hardware_ctx.global_var);
                                         global_hardware_ctx.global_var =
                                             nullptr;
                                     }),
@@ -418,7 +418,7 @@ void all_reduce_async_visit_func2_all(int visit, tensor<T, ALoc> &src,
         tensor<T> reduced_tensor = tensor<T>(reduced_shape);
         reduce(gather_tensor, reduced_tensor, reduce_op, (T)0, dims_t({0}),
                false);
-        free(gather_span);
+        runtime_util.free(gather_span);
         global_hardware_ctx.global_var = reduced_span;
     } else {
         tensor<T> reduced_tensor =
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
index 7a5feb78de..6bb3ee9019 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
@@ -288,15 +288,14 @@ void stage1_kernel(
       [1, 16@t, 48@b, 384]@shared -> [1, 16@t, 48@b, 384]
     */
     tensor<float> v29({1, 16, 48, 384}); //[1, 64, 384, 384] [1, 8@b, 96@t, 384]
-    // softmax(v28, v29, 3);
-
+    softmax(v28, v29, 3);
+    
     /*
       [1,1,384,8192] @ [64, 8192, 128] -> [1,64,384,128]
       [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1, 64, 48@b, 128]@shared
     */
     auto &v30 = v1;
     tensor_block_mma_sync(v30, *v31_w, *V31, false, ctx);
-#if 0
 
     /* need resplit V */
     auto v31 = (*V31)({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
@@ -336,6 +335,7 @@ void stage1_kernel(
     auto v34 = V34({0, 0, 2048 * tid}, {1, 48, 2048});
     tdma_wait(ctx);
     tensor_block_mma_sync(v34, *v35_w, *V35, false, ctx);
+#if 0
 #if DUMP
     {
         auto v35 = V35({0, 0, tid * 2048}, {1, 48, 2048});
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
index eff551a0ba..aa3795da4a 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
@@ -68,18 +68,18 @@ DEFINE_BFUNC(7)
     block##b::shared::name = &shared##b##name;
 
 #define CLEAR_SHARED(i)                                                        \
-    tdma_fill_async<float>(*block##i::shared::V2, 0);                           \
-    tdma_fill_async<float>(*block##i::shared::V5, 0);                           \
-    tdma_fill_async<float>(*block##i::shared::V13, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V16, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V25, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V26, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V31, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V32, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V33, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V35, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V38, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V40, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V2, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V5, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V13, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V16, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V25, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V26, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V31, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V32, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V33, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V35, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V38, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V40, 0);                         \
     tdma_fill_async<float>(*block##i::shared::V42, 0);
 
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
@@ -97,7 +97,8 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     MALLOC_GLOBAL(6, V35_w, float, (8192 * 8192), dims_t({8192, 8192}))
     MALLOC_GLOBAL(7, V3_data, float, (384 * 128), dims_t({384, 128}))
     MALLOC_GLOBAL(8, V11_data, float, (384 * 128), dims_t({384, 128}))
-    MALLOC_GLOBAL(9, Attn_mask, float, (1 * 1 * 384 * 384), dims_t({1, 1, 384, 384}))
+    MALLOC_GLOBAL(9, Attn_mask, float, (1 * 1 * 384 * 384),
+                  dims_t({1, 1, 384, 384}))
     MALLOC_GLOBAL(10, V38_w, float, (8192 * 22016), dims_t({8192, 22016}))
     MALLOC_GLOBAL(11, V40_w, float, (8192 * 22016), dims_t({8192, 22016}))
     MALLOC_GLOBAL(12, V42_w, float, (22016 * 8192), dims_t({22016, 8192}))
@@ -107,7 +108,7 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     auto GV31_tmp = tensor<float, loc_t::device>(dims_t({1, 64, 384, 128}));
     V25 = &V25_tmp;
     GV31 = &GV31_tmp;
-    
+
     MALLOC_SHARED(V2, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
     MALLOC_SHARED(V2, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
     MALLOC_SHARED(V2, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
@@ -144,126 +145,94 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     MALLOC_SHARED(V16, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
     MALLOC_SHARED(V16, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
 
-    MALLOC_SHARED(V25, 0, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 128}))
-    MALLOC_SHARED(V25, 1, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 128}))
-    MALLOC_SHARED(V25, 2, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 128}))
-    MALLOC_SHARED(V25, 3, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 128}))
-    MALLOC_SHARED(V25, 4, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 128}))
-    MALLOC_SHARED(V25, 5, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 128}))
-    MALLOC_SHARED(V25, 6, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 128}))
-    MALLOC_SHARED(V25, 7, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 128}))
+    MALLOC_SHARED(V25, 0, float, (1 * 64 * 128 * 384),
+                  dims_t({1, 64, 128, 384}))
+    MALLOC_SHARED(V25, 1, float, (1 * 64 * 128 * 384),
+                  dims_t({1, 64, 128, 384}))
+    MALLOC_SHARED(V25, 2, float, (1 * 64 * 128 * 384),
+                  dims_t({1, 64, 128, 384}))
+    MALLOC_SHARED(V25, 3, float, (1 * 64 * 128 * 384),
+                  dims_t({1, 64, 128, 384}))
+    MALLOC_SHARED(V25, 4, float, (1 * 64 * 128 * 384),
+                  dims_t({1, 64, 128, 384}))
+    MALLOC_SHARED(V25, 5, float, (1 * 64 * 128 * 384),
+                  dims_t({1, 64, 128, 384}))
+    MALLOC_SHARED(V25, 6, float, (1 * 64 * 128 * 384),
+                  dims_t({1, 64, 128, 384}))
+    MALLOC_SHARED(V25, 7, float, (1 * 64 * 128 * 384),
+                  dims_t({1, 64, 128, 384}))
 
-    MALLOC_SHARED(V26, 0, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V26, 1, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V26, 2, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V26, 3, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V26, 4, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V26, 5, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V26, 6, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V26, 7, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V26, 0, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
+    MALLOC_SHARED(V26, 1, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
+    MALLOC_SHARED(V26, 2, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
+    MALLOC_SHARED(V26, 3, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
+    MALLOC_SHARED(V26, 4, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
+    MALLOC_SHARED(V26, 5, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
+    MALLOC_SHARED(V26, 6, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
+    MALLOC_SHARED(V26, 7, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
 
-    MALLOC_SHARED(V31, 0, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V31, 1, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V31, 2, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V31, 3, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V31, 4, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V31, 5, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V31, 6, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V31, 7, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V31, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V31, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V31, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V31, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V31, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V31, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V31, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V31, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
 
-    MALLOC_SHARED(V32, 0, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V32, 1, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V32, 2, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V32, 3, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V32, 4, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V32, 5, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V32, 6, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
-    MALLOC_SHARED(V32, 7, float, (1 * 64 * 384 * 128),
-                  dims_t({1, 64, 384, 384}))
+    MALLOC_SHARED(V32, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V32, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V32, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V32, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V32, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V32, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V32, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
+    MALLOC_SHARED(V32, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
 
-    MALLOC_SHARED(V33, 0, float, (1 * 384 * 64 * 128),
-                  dims_t({1, 384, 64, 384}))
-    MALLOC_SHARED(V33, 1, float, (1 * 384 * 64 * 128),
-                  dims_t({1, 384, 64, 384}))
-    MALLOC_SHARED(V33, 2, float, (1 * 384 * 64 * 128),
-                  dims_t({1, 384, 64, 384}))
-    MALLOC_SHARED(V33, 3, float, (1 * 384 * 64 * 128),
-                  dims_t({1, 384, 64, 384}))
-    MALLOC_SHARED(V33, 4, float, (1 * 384 * 64 * 128),
-                  dims_t({1, 384, 64, 384}))
-    MALLOC_SHARED(V33, 5, float, (1 * 384 * 64 * 128),
-                  dims_t({1, 384, 64, 384}))
-    MALLOC_SHARED(V33, 6, float, (1 * 384 * 64 * 128),
-                  dims_t({1, 384, 64, 384}))
-    MALLOC_SHARED(V33, 7, float, (1 * 384 * 64 * 128),
-                  dims_t({1, 384, 64, 384}))
+    MALLOC_SHARED(V33, 0, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
+    MALLOC_SHARED(V33, 1, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
+    MALLOC_SHARED(V33, 2, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
+    MALLOC_SHARED(V33, 3, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
+    MALLOC_SHARED(V33, 4, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
+    MALLOC_SHARED(V33, 5, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
+    MALLOC_SHARED(V33, 6, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
+    MALLOC_SHARED(V33, 7, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
 
-    MALLOC_SHARED(V35, 0, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V35, 1, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V35, 2, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V35, 3, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V35, 4, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V35, 5, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V35, 6, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V35, 7, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V35, 0, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V35, 1, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V35, 2, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V35, 3, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V35, 4, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V35, 5, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V35, 6, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V35, 7, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
 
-    MALLOC_SHARED(V38, 0, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V38, 1, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V38, 2, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V38, 3, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V38, 4, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V38, 5, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V38, 6, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V38, 7, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V38, 0, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V38, 1, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V38, 2, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V38, 3, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V38, 4, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V38, 5, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V38, 6, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V38, 7, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
 
-    MALLOC_SHARED(V40, 0, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
-    MALLOC_SHARED(V40, 1, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
-    MALLOC_SHARED(V40, 2, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
-    MALLOC_SHARED(V40, 3, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
-    MALLOC_SHARED(V40, 4, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
-    MALLOC_SHARED(V40, 5, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
-    MALLOC_SHARED(V40, 6, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
-    MALLOC_SHARED(V40, 7, float, (1 * 384 * 22016), dims_t({1, 384, 22016}))
+    MALLOC_SHARED(V40, 0, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V40, 1, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V40, 2, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V40, 3, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V40, 4, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V40, 5, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V40, 6, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
+    MALLOC_SHARED(V40, 7, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
 
-    MALLOC_SHARED(V42, 0, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V42, 1, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V42, 2, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V42, 3, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V42, 4, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V42, 5, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V42, 6, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_SHARED(V42, 7, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
+    MALLOC_SHARED(V42, 0, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V42, 1, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V42, 2, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V42, 3, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V42, 4, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V42, 5, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V42, 6, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
+    MALLOC_SHARED(V42, 7, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
diff --git a/modules/cpu/src/runtime/method_table_impl.h b/modules/cpu/src/runtime/method_table_impl.h
index 87d5d241bd..c6e0f78c25 100644
--- a/modules/cpu/src/runtime/method_table_impl.h
+++ b/modules/cpu/src/runtime/method_table_impl.h
@@ -116,26 +116,23 @@ static nncase_mt_t nncase_mt = {fabsf,
                                 bool_binary_logical_or,
                                 bool_binary_logical_xor};
 
+inline void *rt_malloc(size_t size) { return (void *)new uint8_t[size]; }
+
 static runtime_util_mt runtime_util = {
-    printf, malloc, 
-    free, 
-    create_thread, 
-    join_thread, 
-    rt_assert, 
-    memcpy, 
-    memset
-};
+    printf,
+    rt_malloc,
+    free,
+    create_thread,
+    join_thread,
+    rt_assert,
+    memcpy,
+    memset};
 
 static hardware_context_mt hw_ctx_mt = {
-    hardware_context::lock_block,   
-    hardware_context::mark_block_visit,
-    hardware_context::unlock_block, 
-    hardware_context::wait_block_sync,
-    hardware_context::lock_all,     
-    hardware_context::mark_all_visit,
-    hardware_context::unlock_all,   
-    hardware_context::wait_all_sync,
-    hardware_context::init
-};
+    hardware_context::lock_block,   hardware_context::mark_block_visit,
+    hardware_context::unlock_block, hardware_context::wait_block_sync,
+    hardware_context::lock_all,     hardware_context::mark_all_visit,
+    hardware_context::unlock_all,   hardware_context::wait_all_sync,
+    hardware_context::init};
 
 END_NS_NNCASE_RT_MODULE
\ No newline at end of file

From bff357218b2358db182208bfeddd9b230b02eb33 Mon Sep 17 00:00:00 2001
From: lerenhua <2532375005@qq.com>
Date: Fri, 8 Sep 2023 10:21:52 +0800
Subject: [PATCH 166/308] Enable ImmOutput

---
 .../cmodel/tests/decoder_layer/kernel.h       | 19 ++---
 .../cmodel/tests/decoder_layer/main.cpp       | 75 ++++++++++++-------
 2 files changed, 58 insertions(+), 36 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
index 7a5feb78de..68a911887b 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
@@ -16,7 +16,7 @@ static tensor<int64_t> *position_ids; // {1, 48}
 static tensor<float> *v38_w;          // {2048, 22016}
 static tensor<float> *v40_w;          // {2048, 22016}
 static tensor<float> *v42_w;          // {5504, 8192}
-#define DUMP 0
+#define DUMP 1
 
 #define MALLOC_STATIC(name, type, shape)                                       \
     auto name##_tmp = tensor<type>(shape);                                     \
@@ -39,7 +39,7 @@ void stage1_kernel(
     tensor<int64_t, loc_t::device> &Position_ids,          /* [1,384] */
     [[maybe_unused]] tensor<float, loc_t::device> &Output, /* [1,384,8192] */
     tensor<float, loc_t::device> &V25, tensor<float, loc_t::device> &GV31,
-    [[maybe_unused]] tensor<float, loc_t::device> *ImmOutputs) {
+    [[maybe_unused]] tensor<float, loc_t::device> **ImmOutputs) {
     thread_context ctx(bid, tid);
     tensor<float> v0_gamma({2048});
     tensor<float> v0_beta({2048});
@@ -93,7 +93,7 @@ void stage1_kernel(
 #if DUMP
         {
             tdma_store_async(
-                v0, ImmOutputs[0]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
+                v0, (*ImmOutputs[0])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
                 ctx);
         }
 #endif
@@ -108,10 +108,11 @@ void stage1_kernel(
 #if DUMP
     if (tid == 0) {
         tdma_store_async(
-            V2, ImmOutputs[1]({0, 0, 48 * bid, 0}, {1, 64, 48, 128}), ctx);
+            *V2, (*ImmOutputs[1])({0, 0, 48 * bid, 0}, {1, 64, 48, 128}), ctx);
     }
     tdma_all_wait(ctx);
 #endif
+    // #if 0
 
     /*
       [384, 128][[1, 384]] -> [1, 384, 128]
@@ -122,7 +123,7 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v3, ImmOutputs[4]({0, 48 * bid, 32 * tid}, {1, 48, 32}), ctx);
+            v3, (*ImmOutputs[4])({0, 48 * bid, 32 * tid}, {1, 48, 32}), ctx);
     }
 #endif
     auto v4 = unsqueeze(v3); /* 1, 1, 48, 32 */
@@ -156,7 +157,7 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v10, ImmOutputs[2]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
+            v10, (*ImmOutputs[2])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
             ctx);
     }
 #endif
@@ -191,7 +192,7 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v14, ImmOutputs[3]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
+            v14, (*ImmOutputs[3])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
             ctx);
     }
 #endif
@@ -234,7 +235,7 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v22, ImmOutputs[5]({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
+            v22, (*ImmOutputs[5])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
             ctx);
     }
 #endif
@@ -279,7 +280,7 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v28, ImmOutputs[6]({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 384}),
+            v28, (*ImmOutputs[6])({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 384}),
             ctx);
     }
 #endif
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
index eff551a0ba..4aafb4d706 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
@@ -35,19 +35,20 @@ static tensor<float, loc_t::device> *V25;            // ({1, 64, 128, 384})
 static tensor<float, loc_t::device> *GV31;           // ({1, 64, 384, 128})
 
 constexpr int OutNum = 11;
-static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
-    tensor<float, loc_t::device>({1, 384, 8192}),
-    tensor<float, loc_t::device>({1, 64, 384, 128}),
-    tensor<float, loc_t::device>({1, 64, 384, 128}),
-    tensor<float, loc_t::device>({1, 64, 384, 128}),
-    tensor<float, loc_t::device>({1, 384, 128}),
-    tensor<float, loc_t::device>({1, 64, 384, 128}),
-    tensor<float, loc_t::device>({1, 64, 384, 384}),
-    tensor<float, loc_t::device>({1, 64, 384, 128}),
-    tensor<float, loc_t::device>({1, 384, 8192}),
-    tensor<float, loc_t::device>({1, 384, 22016}),
-    tensor<float, loc_t::device>({1, 384, 8192}),
-};
+// static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
+//     tensor<float, loc_t::device>({1, 384, 8192}),
+//     tensor<float, loc_t::device>({1, 64, 384, 128}),
+//     tensor<float, loc_t::device>({1, 64, 384, 128}),
+//     tensor<float, loc_t::device>({1, 64, 384, 128}),
+//     tensor<float, loc_t::device>({1, 384, 128}),
+//     tensor<float, loc_t::device>({1, 64, 384, 128}),
+//     tensor<float, loc_t::device>({1, 64, 384, 384}),
+//     tensor<float, loc_t::device>({1, 64, 384, 128}),
+//     tensor<float, loc_t::device>({1, 384, 8192}),
+//     tensor<float, loc_t::device>({1, 384, 22016}),
+//     tensor<float, loc_t::device>({1, 384, 8192}),
+// };
+static tensor<float, loc_t::device> *ImmOutputs[OutNum];
 
 DEFINE_BFUNC(0)
 DEFINE_BFUNC(1)
@@ -63,23 +64,28 @@ DEFINE_BFUNC(7)
         gsl::make_span((type *)inputs[i], size), shape);                       \
     name = &g_##name;
 
+#define MALLOC_IMM(i, name, type, size, shape)                                 \
+    auto g_##i = tensor<type, loc_t::device>(                                  \
+        gsl::make_span((type *)inputs[i], size), shape);                       \
+    name = &g_##i;
+
 #define MALLOC_SHARED(name, b, type, size, shape)                              \
     auto shared##b##name = tensor<type, loc_t::shared>(shape);                 \
     block##b::shared::name = &shared##b##name;
 
 #define CLEAR_SHARED(i)                                                        \
-    tdma_fill_async<float>(*block##i::shared::V2, 0);                           \
-    tdma_fill_async<float>(*block##i::shared::V5, 0);                           \
-    tdma_fill_async<float>(*block##i::shared::V13, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V16, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V25, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V26, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V31, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V32, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V33, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V35, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V38, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V40, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V2, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V5, 0);                          \
+    tdma_fill_async<float>(*block##i::shared::V13, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V16, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V25, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V26, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V31, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V32, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V33, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V35, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V38, 0);                         \
+    tdma_fill_async<float>(*block##i::shared::V40, 0);                         \
     tdma_fill_async<float>(*block##i::shared::V42, 0);
 
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
@@ -88,6 +94,20 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     runtime_util = *rt_util_mt;
     nncase_mt = *nncase_mt_impl;
 
+    MALLOC_IMM(15, ImmOutputs[0], float, (1 * 384 * 8192),
+               dims_t({1, 384, 8192}))
+    MALLOC_IMM(16, ImmOutputs[1], float, (1 * 64 * 384 * 128),
+               dims_t({1, 64, 384, 128}))
+    MALLOC_IMM(17, ImmOutputs[2], float, (1 * 64 * 384 * 128),
+               dims_t({1, 64, 384, 128}))
+    MALLOC_IMM(18, ImmOutputs[3], float, (1 * 64 * 384 * 128),
+               dims_t({1, 64, 384, 128}))
+    MALLOC_IMM(19, ImmOutputs[4], float, (1 * 384 * 128), dims_t({1, 384, 128}))
+    MALLOC_IMM(20, ImmOutputs[5], float, (1 * 64 * 384 * 128),
+               dims_t({1, 64, 384, 128}))
+    MALLOC_IMM(21, ImmOutputs[6], float, (1 * 64 * 384 * 384),
+               dims_t({1, 64, 384, 384}))
+
     MALLOC_GLOBAL(0, Hidden_in, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
     MALLOC_GLOBAL(1, V0_gamma, float, (8192), dims_t({8192}))
     MALLOC_GLOBAL(2, V0_beta, float, (8192), dims_t({8192}))
@@ -97,7 +117,8 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     MALLOC_GLOBAL(6, V35_w, float, (8192 * 8192), dims_t({8192, 8192}))
     MALLOC_GLOBAL(7, V3_data, float, (384 * 128), dims_t({384, 128}))
     MALLOC_GLOBAL(8, V11_data, float, (384 * 128), dims_t({384, 128}))
-    MALLOC_GLOBAL(9, Attn_mask, float, (1 * 1 * 384 * 384), dims_t({1, 1, 384, 384}))
+    MALLOC_GLOBAL(9, Attn_mask, float, (1 * 1 * 384 * 384),
+                  dims_t({1, 1, 384, 384}))
     MALLOC_GLOBAL(10, V38_w, float, (8192 * 22016), dims_t({8192, 22016}))
     MALLOC_GLOBAL(11, V40_w, float, (8192 * 22016), dims_t({8192, 22016}))
     MALLOC_GLOBAL(12, V42_w, float, (22016 * 8192), dims_t({22016, 8192}))
@@ -107,7 +128,7 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     auto GV31_tmp = tensor<float, loc_t::device>(dims_t({1, 64, 384, 128}));
     V25 = &V25_tmp;
     GV31 = &GV31_tmp;
-    
+
     MALLOC_SHARED(V2, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
     MALLOC_SHARED(V2, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
     MALLOC_SHARED(V2, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))

From 856fdf0cf14414cec36b482cb9d9c49410c5529e Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 8 Sep 2023 10:43:53 +0800
Subject: [PATCH 167/308] fix malloc

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 2 +-
 modules/cpu/src/runtime/method_table_impl.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 1db4e9cfe0..7fc7c0e5a3 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -44,7 +44,7 @@ tensor<T, Loc> view_transpose(tensor<T, Loc> &src, dims_t perm) {
 
 template <class T, loc_t Loc>
 tensor<T, Loc> view(tensor<T, Loc> &src, dims_t new_dims) {
-    return tensor<T, Loc>(src.data(), new_dims, (new_dims));
+    return tensor<T, Loc>(src.data(), new_dims, get_default_strides(new_dims));
 }
 
 template <class T, loc_t Loc>
diff --git a/modules/cpu/src/runtime/method_table_impl.h b/modules/cpu/src/runtime/method_table_impl.h
index c6e0f78c25..1c55881c58 100644
--- a/modules/cpu/src/runtime/method_table_impl.h
+++ b/modules/cpu/src/runtime/method_table_impl.h
@@ -116,7 +116,7 @@ static nncase_mt_t nncase_mt = {fabsf,
                                 bool_binary_logical_or,
                                 bool_binary_logical_xor};
 
-inline void *rt_malloc(size_t size) { return (void *)new uint8_t[size]; }
+inline void *rt_malloc(size_t size) { return (void *)new uint8_t[size](); }
 
 static runtime_util_mt runtime_util = {
     printf,

From 0cb4895714f12d35c50383ac130b58fb84ebe74f Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 8 Sep 2023 10:49:32 +0800
Subject: [PATCH 168/308] remove debug macro

---
 modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
index 6bb3ee9019..707a490232 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
@@ -335,7 +335,6 @@ void stage1_kernel(
     auto v34 = V34({0, 0, 2048 * tid}, {1, 48, 2048});
     tdma_wait(ctx);
     tensor_block_mma_sync(v34, *v35_w, *V35, false, ctx);
-#if 0
 #if DUMP
     {
         auto v35 = V35({0, 0, tid * 2048}, {1, 48, 2048});
@@ -416,5 +415,4 @@ void stage1_kernel(
             v43, ImmOutputs[10]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
     }
 #endif
-#endif
 }

From 42a29462f2323bc37028fa505c0ccc328578fd75 Mon Sep 17 00:00:00 2001
From: lerenhua <2532375005@qq.com>
Date: Fri, 8 Sep 2023 11:24:34 +0800
Subject: [PATCH 169/308] Add ImmOut

---
 .../cmodel/tests/decoder_layer/kernel.h       | 23 +++++++++++--------
 .../cmodel/tests/decoder_layer/main.cpp       | 13 +++++++++++
 2 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
index 9606f7042b..55332fa0d6 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
@@ -290,7 +290,7 @@ void stage1_kernel(
     */
     tensor<float> v29({1, 16, 48, 384}); //[1, 64, 384, 384] [1, 8@b, 96@t, 384]
     softmax(v28, v29, 3);
-    
+
     /*
       [1,1,384,8192] @ [64, 8192, 128] -> [1,64,384,128]
       [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1, 64, 48@b, 128]@shared
@@ -317,10 +317,12 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v32, ImmOutputs[7]({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}),
+            v32, (*ImmOutputs[7])({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}),
             ctx);
     }
 #endif
+    // #if 0
+
     /*
       [1, 64, 384, 128] -> [1, 384, 64, 128]
       [1, 64, 48@b, 128]@shared -> [1, 48@b, 64, 128]@shared
@@ -336,12 +338,13 @@ void stage1_kernel(
     auto v34 = V34({0, 0, 2048 * tid}, {1, 48, 2048});
     tdma_wait(ctx);
     tensor_block_mma_sync(v34, *v35_w, *V35, false, ctx);
-#if 0
+// #if 0
 #if DUMP
     {
-        auto v35 = V35({0, 0, tid * 2048}, {1, 48, 2048});
+        auto v35 = (*V35)({0, 0, tid * 2048}, {1, 48, 2048});
         tdma_store_async(
-            v35, ImmOutputs[8]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
+            v35, (*ImmOutputs[8])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
+            ctx);
     }
 #endif
 
@@ -371,9 +374,10 @@ void stage1_kernel(
     tensor_block_mma_sync(v37, *v38_w, *V38, false, ctx);
 #if DUMP
     {
-        auto v38 = V38({0, 0, 5504 * tid}, {1, 48, 5504});
+        auto v38 = (*V38)({0, 0, 5504 * tid}, {1, 48, 5504});
         tdma_store_async(
-            v38, ImmOutputs[9]({0, 48 * bid, 5504 * tid}, {1, 48, 5504}), ctx);
+            v38, (*ImmOutputs[9])({0, 48 * bid, 5504 * tid}, {1, 48, 5504}),
+            ctx);
     }
 #endif
 
@@ -414,8 +418,9 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v43, ImmOutputs[10]({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
+            v43, (*ImmOutputs[10])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
+            ctx);
     }
 #endif
-#endif
+    // #endif
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
index 2552e1d28f..62744a89f6 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
@@ -107,6 +107,19 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
                dims_t({1, 64, 384, 128}))
     MALLOC_IMM(21, ImmOutputs[6], float, (1 * 64 * 384 * 384),
                dims_t({1, 64, 384, 384}))
+    // v32
+    MALLOC_IMM(22, ImmOutputs[7], float, (1 * 64 * 384 * 128),
+               dims_t({1, 64, 384, 128}))
+    // v35
+    MALLOC_IMM(23, ImmOutputs[8], float, (1 * 384 * 8192),
+               dims_t({1, 384, 8192}))
+    // v38
+    MALLOC_IMM(24, ImmOutputs[9], float, (1 * 384 * 22016),
+               dims_t({1, 384, 22016}))
+
+    // v43
+    MALLOC_IMM(25, ImmOutputs[10], float, (1 * 384 * 8192),
+               dims_t({1, 384, 8192}))
 
     MALLOC_GLOBAL(0, Hidden_in, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
     MALLOC_GLOBAL(1, V0_gamma, float, (8192), dims_t({8192}))

From 424176dc9a4f48a77a962a35bc7dc289770427af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 8 Sep 2023 15:23:17 +0800
Subject: [PATCH 170/308] fix tdma store

---
 .../CodeGen/CSourceBuiltn.cs                  |  1 -
 .../CodeGen/CSourceConvertVisitor.cs          |  9 ++-
 .../CodeGen/FunctionCSource.cs                |  2 +-
 .../CodeGen/LinkableModule.cs                 |  5 +-
 .../Evaluator/XPU/Binary.cs                   | 16 ++++
 .../Evaluator/XPU/BlockMMA.cs                 | 12 +++
 .../Evaluator/XPU/Matmul.cs                   | 11 +++
 .../Evaluator/XPU/TDMALoad.cs                 |  4 +-
 .../Evaluator/XPU/TDMAStore.cs                |  4 +-
 .../Evaluator/XPU/XPUModule.cs                |  3 +
 modules/Nncase.Modules.CPU/IR/XPU/Binary.cs   | 21 ++++++
 modules/Nncase.Modules.CPU/IR/XPU/BlockMMA.cs | 15 ++++
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   | 15 ++++
 modules/Nncase.Modules.CPU/IR/XPU/Matmul.cs   | 13 ++++
 .../Nncase.Modules.CPU/IR/XPU/TDMAStore.cs    |  1 -
 .../Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs  |  5 +-
 .../Passes/Tile/SingleCPUFusionConverter.cs   | 55 +++++++++-----
 src/Nncase.Core/CostModel/Cost.cs             |  2 +
 .../{DistTensorType.cs => DistributedType.cs} | 16 ++--
 ...teUtilities.cs => DistributedUtilities.cs} |  4 +-
 src/Nncase.Core/IR/ExprFunctor.cs             |  4 +-
 src/Nncase.Core/IR/TypeFunctor.cs             |  4 +-
 .../Diagnostics/ILPrintVisitor.cs             |  2 +-
 src/Nncase.Evaluator/Math/Binary.cs           | 72 ++++++++++++++++--
 src/Nncase.Evaluator/Math/MatMul.cs           | 75 ++++++++++++++++++-
 src/Nncase.Evaluator/Math/Unary.cs            | 12 +--
 .../Tensors/BoxingEvaluator.cs                |  8 +-
 src/Nncase.Evaluator/TypeInference.cs         |  1 -
 src/Nncase.Tests/Core/UnitTestExpression.cs   |  4 +-
 .../Distributed/UnitTestDistTensor.cs         | 14 ++--
 .../Targets/UnitTestCPUTargetTiling.cs        | 52 ++++++-------
 31 files changed, 360 insertions(+), 102 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Binary.cs
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/BlockMMA.cs
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Matmul.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Binary.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/BlockMMA.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Matmul.cs
 rename src/Nncase.Core/{DistTensorType.cs => DistributedType.cs} (85%)
 rename src/Nncase.Core/{DistributeUtilities.cs => DistributedUtilities.cs} (94%)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index 34917d7143..2f7a610a63 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -137,7 +137,6 @@ namespace shared {
 } // namespace shared";
     }
 
-
 #else
     public const string BufferType = "buffer_t";
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 29992c77cd..702cdab985 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -242,11 +242,16 @@ protected override CSymbol VisitCall(Call expr)
                     IndentScope.Writer.Write($"tdma_load_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{((TensorType)args[0].CheckedType).ToSlicing(load.NdSbp, load.Placement)})");
                     break;
                 case IR.XPU.TDMAStore store:
-                    IndentScope.Writer.Write($"tdma_store_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{((TensorType)args[1].CheckedType).ToSlicing(store.NdSbp, store.Placement)})");
+                    IndentScope.Writer.Write($"tdma_store_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{((TensorType)args[0].CheckedType).ToSlicing(store.NdSbp, store.Placement)})");
                     break;
                 case IR.XPU.Unary unary:
                     IndentScope.Writer.Write($"unary({Visit(args[0]).Name}, {Visit(args[1]).Name}, unary_op_t::{unary.UnaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
                     break;
+                case IR.XPU.Binary binary:
+                    IndentScope.Writer.Write($"binary({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, binary_op_t::{binary.BinaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
+                    break;
+                default:
+                    throw new NotSupportedException(xpuOp.ToString());
             }
         }
         else
@@ -689,4 +694,4 @@ private string DeclThreadMessageStruct(IEnumerable<CSymbol> keyValues)
         return type;
     }
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
index 9cf490620c..e2df1f8015 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -32,4 +32,4 @@ public FunctionCSource(string declaration, string implementation)
 
     public string Implementation { get; }
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index 98fcc8e877..9a1188422d 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -83,7 +83,7 @@ public ILinkedModule Link(ILinkContext linkContext)
 
         // var elfPath = CompileCSource(csourcePath);
         // var text = File.ReadAllBytes(elfPath);
-        var text = new byte[] { };
+        var text = Array.Empty<byte>();
 
         // if (_options.DumpFlags.HasFlag(DumpFlags.CodeGen))
         // {
@@ -93,13 +93,12 @@ public ILinkedModule Link(ILinkContext linkContext)
         //         fs.Write(text);
         //     }
         // }
-
         var linkedFunctions = new List<LinkedFunction>();
+
         // foreach (var func in _functions)
         // {
         //     linkedFunctions.Add(new LinkedFunction(func.Id, func.SourceFunction, 0, 0, func.Sections));
         // }
-
         return new LinkedModule(linkedFunctions, text, _rdata);
     }
 
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Binary.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Binary.cs
new file mode 100644
index 0000000000..b8fa9f2206
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Binary.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class BinaryEvaluator : ITypeInferencer<Binary>
+{
+    public IRType Visit(ITypeInferenceContext context, Binary target)
+    {
+        return TupleType.Void;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/BlockMMA.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/BlockMMA.cs
new file mode 100644
index 0000000000..09fc41aa34
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/BlockMMA.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class BlockMMAEvaluator : ITypeInferencer<BlockMMA>
+{
+    public IRType Visit(ITypeInferenceContext context, BlockMMA target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Matmul.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Matmul.cs
new file mode 100644
index 0000000000..631fc4fe3c
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Matmul.cs
@@ -0,0 +1,11 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+namespace Nncase.Evaluator.XPU;
+
+public sealed class MatmulEvaluator : ITypeInferencer<Matmul>
+{
+    public IRType Visit(ITypeInferenceContext context, Matmul target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs
index 63ed5df158..e97789d522 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs
@@ -10,8 +10,8 @@ public class TDMALoadEvaluator : ITypeInferencer<TDMALoad>
 {
     public IRType Visit(ITypeInferenceContext context, TDMALoad target)
     {
-        var inType = context.CheckArgumentType<TensorType>(target, TDMALoad.Dest);
-        var outType = context.CheckArgumentType<TensorType>(target, TDMALoad.Src);
+        _ = context.CheckArgumentType<TensorType>(target, TDMALoad.Dest);
+        _ = context.CheckArgumentType<TensorType>(target, TDMALoad.Src);
         return TupleType.Void;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs
index 48cc53739c..027aa2a88f 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs
@@ -10,8 +10,8 @@ public sealed class TDMAStoreEvaluator : ITypeInferencer<TDMAStore>
 {
     public IRType Visit(ITypeInferenceContext context, TDMAStore target)
     {
-        var inType = context.CheckArgumentType<TensorType>(target, TDMAStore.Src);
-        var outType = context.CheckArgumentType<TensorType>(target, TDMAStore.Dest);
+        _ = context.CheckArgumentType<TensorType>(target, TDMAStore.Src);
+        _ = context.CheckArgumentType<TensorType>(target, TDMAStore.Dest);
         return TupleType.Void;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index f9ec1306e6..941167e411 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -16,5 +16,8 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<TDMALoadEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<TDMAStoreEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<UnaryEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<BinaryEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<MatmulEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<BlockMMAEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs b/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs
new file mode 100644
index 0000000000..b616ba8d16
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Binary : XPUKernelOp
+{
+    public static readonly ParameterInfo Lhs = new(typeof(Binary), 0, "input");
+    
+    public static readonly ParameterInfo Rhs = new(typeof(Binary), 1, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(Binary), 2, "output");
+
+    public BinaryOp BinaryOp { get; }
+
+    /// <inheritdoc/>
+    public override string DisplayProperty()
+    {
+        return $"BinaryOp.{BinaryOp}";
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/BlockMMA.cs b/modules/Nncase.Modules.CPU/IR/XPU/BlockMMA.cs
new file mode 100644
index 0000000000..c69a5077e7
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/BlockMMA.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+
+public sealed partial class BlockMMA : XPUKernelOp
+{
+    public static readonly ParameterInfo Lhs = new(typeof(BlockMMA), 0, "input");
+
+    public static readonly ParameterInfo Rhs = new(typeof(BlockMMA), 1, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(BlockMMA), 2, "output");
+
+}
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 14b455a59f..3f76e7cae2 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -26,4 +26,19 @@ public static Call Unary(UnaryOp unaryOp, Expr input, Expr output)
     {
         return new Call(new Unary(unaryOp), input, output);
     }
+
+    public static Call Binary(BinaryOp binaryOp, Expr lhs, Expr rhs, Expr output)
+    {
+        return new Call(new Binary(binaryOp), lhs, rhs, output);
+    }
+
+    public static Call Matmul(Expr lhs, Expr rhs, Expr output)
+    {
+        return new Call(new Matmul(), lhs, rhs, output);
+    }
+
+    public static Call BlockMMA(Expr lhs, Expr rhs, Expr output)
+    {
+        return new Call(new Matmul(), lhs, rhs, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Matmul.cs b/modules/Nncase.Modules.CPU/IR/XPU/Matmul.cs
new file mode 100644
index 0000000000..4053e2c5c4
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Matmul.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Matmul : XPUKernelOp
+{
+    public static readonly ParameterInfo Lhs = new(typeof(Matmul), 0, "lhs");
+
+    public static readonly ParameterInfo Rhs = new(typeof(Matmul), 1, "rhs");
+
+    public static readonly ParameterInfo Output = new(typeof(Matmul), 2, "output");
+}
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/TDMAStore.cs b/modules/Nncase.Modules.CPU/IR/XPU/TDMAStore.cs
index b821a10011..845878ede4 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/TDMAStore.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/TDMAStore.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
-
 namespace Nncase.IR.XPU;
 
 public sealed partial class TDMAStore : XPUKernelOp
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs b/modules/Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs
index 0277e7f0ab..6c12cd006b 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs
@@ -1,9 +1,8 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 namespace Nncase.IR.XPU;
 
 public abstract class XPUKernelOp : Op
 {
-
-}
\ No newline at end of file
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 5e6827c117..3fd776a997 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -85,15 +85,15 @@ protected override IReadOnlyList<Expr> DefaultVisitLeaf(Expr expr)
         protected override IReadOnlyList<Expr> VisitLeafVar(Var expr)
         {
             var type = (TensorType)expr.TypeAnnotation;
-            return DistributeUtilities.GetLeafCandidateNDSBPs(type, Placement).
-                Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistTensorType(type, ndsbp, Placement))).
+            return DistributedUtilities.GetLeafCandidateNDSBPs(type, Placement).
+                Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistributedType(type, ndsbp, Placement))).
                 ToArray();
         }
 
         protected override IReadOnlyList<Expr> VisitLeafConst(Const expr)
         {
-            return DistributeUtilities.GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, Placement)
-                .Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistTensorType((TensorType)expr.CheckedType, ndsbp, Placement))).
+            return DistributedUtilities.GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, Placement)
+                .Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, Placement))).
                 ToArray();
         }
 
@@ -139,16 +139,15 @@ protected override Unit VisitLeafCall(Call expr)
                 case CPUKernelOp kernelOp:
                     switch (kernelOp.Target)
                     {
-                        case IR.Math.Unary unary:
+                        case Unary unary:
                             GenerateUnary(unary, arguments, ret);
                             break;
-
-                        // case Binary binary:
-                        //     GenerateBinary(binary, arguments, ret, expr);
-                        //     break;
-                        // case MatMul matmul:
-                        //     GenerateMatMul(arguments, ret, expr);
-                        //     break;
+                        case Binary binary:
+                            GenerateBinary(binary, arguments, ret);
+                            break;
+                        case MatMul matmul:
+                            GenerateMatmul(matmul, arguments, ret);
+                            break;
                         default:
                             throw new NotSupportedException();
                     }
@@ -168,13 +167,13 @@ private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call
         {
             switch (expr.Arguments[0].CheckedType, boxing.NewType)
             {
-                case (TensorType tensorType, DistTensorType distTensorType):
+                case (TensorType tensorType, DistributedType distTensorType):
                     {
                         _mainBody.Add(T.Block(nameof(Boxing)).Body(IR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSbp, distTensorType.Placement)).Build());
                     }
 
                     break;
-                case (DistTensorType distTensorType, TensorType tensorType):
+                case (DistributedType distTensorType, TensorType tensorType):
                     {
                         _mainBody.Add(T.Block(nameof(Boxing)).Body(IR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSbp, distTensorType.Placement)).Build());
                     }
@@ -191,6 +190,23 @@ private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments,
             _mainBody.Add(T.Block(nameof(IR.Math.Unary)).Body(IR.F.XPU.Unary(unary.UnaryOp, input, ret)).Build());
         }
 
+        private void GenerateBinary(Binary binary, Buffer[] arguments, Buffer ret)
+        {
+            _mainBody.Add(T.Block(nameof(IR.Math.Unary)).Body(IR.F.XPU.Binary(binary.BinaryOp, arguments[0], arguments[1], ret)).Build());
+        }
+
+        private void GenerateMatmul(MatMul matmul, Buffer[] arguments, Buffer ret)
+        {
+            if (ret.MemSpan.Location == MemoryLocation.L2Data)
+            {
+                _mainBody.Add(T.Block(nameof(XPU.BlockMMA)).Body(IR.F.XPU.Matmul(arguments[0], arguments[1], ret)).Build());
+            }
+            else
+            {
+                _mainBody.Add(T.Block(nameof(XPU.Matmul)).Body(IR.F.XPU.Matmul(arguments[0], arguments[1], ret)).Build());
+            }
+        }
+
 #if false
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
@@ -255,7 +271,7 @@ private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffe
                 final);
             _mainBody.Add(body.Build());
         }
-#endif 
+#endif
 
         private TIR.Buffer TryAllocateBuffer(Expr expr)
         {
@@ -292,7 +308,7 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
         private (TensorType, MemoryLocation) GetTypeAndLocation(IRType type)
         {
             MemoryLocation location = MemoryLocation.Data;
-            if (type is DistTensorType distTensorType)
+            if (type is DistributedType distTensorType)
             {
                 if (distTensorType.Placement.Rank == 2)
                 {
@@ -305,9 +321,12 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
             }
 
             TensorType tensorType;
-            if (type is DistTensorType distTensor)
+            if (type is DistributedType distTensor)
             {
-                DistributeUtilities.IsDistributable(distTensor.TensorType, distTensor.NdSbp.ToArray(), distTensor.Placement, out tensorType);
+                if (!DistributedUtilities.IsDistributable(distTensor.TensorType, distTensor.NdSbp.ToArray(), distTensor.Placement, out tensorType))
+                {
+                    throw new NotSupportedException();
+                }
             }
             else if (type is TensorType ttype)
             {
diff --git a/src/Nncase.Core/CostModel/Cost.cs b/src/Nncase.Core/CostModel/Cost.cs
index b989507457..b09193ccb9 100644
--- a/src/Nncase.Core/CostModel/Cost.cs
+++ b/src/Nncase.Core/CostModel/Cost.cs
@@ -204,6 +204,7 @@ public static UInt128 GetMemoryAccess(IRType type)
         {
             TensorType t => (UInt128)(t.Shape.Aggregate(1D, (acc, x) => acc * (x.IsFixed ? x.FixedValue : 1)) * t.DType.SizeInBytes),
             TupleType t => t.Fields.Sum(GetMemoryAccess),
+            DistributedType t => (UInt128)((float)GetMemoryAccess(DistributedUtilities.GetDividedTensorType(t, out var scale)) * scale),
             _ => 0,
         };
     }
@@ -229,6 +230,7 @@ public static UInt128 GetCPUCycles(IRType type, double cyclesPerElement = 1)
         {
             TensorType t => (UInt128)(t.Shape.Aggregate(1D, (acc, x) => acc * (x.IsFixed ? x.FixedValue : 1)) * cyclesPerElement),
             TupleType t => t.Fields.Sum(GetMemoryAccess),
+            DistributedType t => GetCPUCycles(DistributedUtilities.GetDividedTensorType(t, out _)),
             _ => 0,
         };
     }
diff --git a/src/Nncase.Core/DistTensorType.cs b/src/Nncase.Core/DistributedType.cs
similarity index 85%
rename from src/Nncase.Core/DistTensorType.cs
rename to src/Nncase.Core/DistributedType.cs
index 71e1a26715..d113fec72b 100644
--- a/src/Nncase.Core/DistTensorType.cs
+++ b/src/Nncase.Core/DistributedType.cs
@@ -15,11 +15,11 @@ namespace Nncase.IR;
 
 public abstract record SBP
 {
-    public static SBPSumParallel P => SBPSumParallel.Instance;
-
-    public static SBPSplit S(int axis) => new SBPSplit(axis);
+    public static SBPPartialSum P => SBPPartialSum.Instance;
 
     public static SBPBroadCast B => SBPBroadCast.Instance;
+
+    public static SBPSplit S(int axis) => new SBPSplit(axis);
 }
 
 public sealed record SBPSplit(int Axis) : SBP
@@ -27,11 +27,11 @@ public sealed record SBPSplit(int Axis) : SBP
     public override string ToString() => $"S({Axis})";
 }
 
-public sealed record SBPSumParallel : SBP
+public sealed record SBPPartialSum : SBP
 {
-    public static readonly SBPSumParallel Instance = new SBPSumParallel();
+    public static readonly SBPPartialSum Instance = new SBPPartialSum();
 
-    private SBPSumParallel()
+    private SBPPartialSum()
     {
     }
 
@@ -77,9 +77,9 @@ public enum DeviceKind : uint
     public override string ToString() => $"@{Kind} [{string.Join(',', Hierarchy.Zip(Name).Select(t => t.First.ToString() + '@' + t.Second.ToString()))}]";
 }
 
-public sealed record DistTensorType : IRType
+public sealed record DistributedType : IRType
 {
-    public DistTensorType(TensorType tensorType, IRArray<SBP> ndsbp, Placement placement)
+    public DistributedType(TensorType tensorType, IRArray<SBP> ndsbp, Placement placement)
     {
         if (placement.Hierarchy.Count != ndsbp.Count)
         {
diff --git a/src/Nncase.Core/DistributeUtilities.cs b/src/Nncase.Core/DistributedUtilities.cs
similarity index 94%
rename from src/Nncase.Core/DistributeUtilities.cs
rename to src/Nncase.Core/DistributedUtilities.cs
index b44624aef6..6787e8c588 100644
--- a/src/Nncase.Core/DistributeUtilities.cs
+++ b/src/Nncase.Core/DistributedUtilities.cs
@@ -6,7 +6,7 @@
 
 namespace Nncase;
 
-public static class DistributeUtilities
+public static class DistributedUtilities
 {
     public static IReadOnlyList<IRArray<SBP>> GetLeafCandidateNDSBPs(TensorType tensorType, Placement placement)
     {
@@ -69,7 +69,7 @@ public static bool IsDivisible(int input, int divisor)
         return false;
     }
 
-    public static TensorType GetPartedDistTensorType(DistTensorType distTensorType, out float notContiguousScale)
+    public static TensorType GetDividedTensorType(DistributedType distTensorType, out float notContiguousScale)
     {
         var shape = distTensorType.TensorType.Shape.ToValueArray();
         var tiles = distTensorType.TensorType.Shape.ToValueArray();
diff --git a/src/Nncase.Core/IR/ExprFunctor.cs b/src/Nncase.Core/IR/ExprFunctor.cs
index 5664b5a77b..2d19dbc1b3 100644
--- a/src/Nncase.Core/IR/ExprFunctor.cs
+++ b/src/Nncase.Core/IR/ExprFunctor.cs
@@ -128,7 +128,7 @@ public partial class ExprFunctor<TExprResult, TTypeResult> : ExprFunctor<TExprRe
     /// </summary>
     /// <param name="type">Callable type.</param>
     /// <returns>Result.</returns>
-    public virtual TTypeResult VisitType(DistTensorType type) => base.VisitType(type, default);
+    public virtual TTypeResult VisitType(DistributedType type) => base.VisitType(type, default);
 
     /// <summary>
     /// Default visit routine.
@@ -159,7 +159,7 @@ public partial class ExprFunctor<TExprResult, TTypeResult> : ExprFunctor<TExprRe
     public sealed override TTypeResult VisitType(CallableType type, Unit context) => VisitType(type);
 
     /// <inheritdoc/>
-    public sealed override TTypeResult VisitType(DistTensorType type, Unit context) => VisitType(type);
+    public sealed override TTypeResult VisitType(DistributedType type, Unit context) => VisitType(type);
 
     /// <inheritdoc/>
     public sealed override TTypeResult DefaultVisitType(IRType type, Unit context) => DefaultVisitType(type);
diff --git a/src/Nncase.Core/IR/TypeFunctor.cs b/src/Nncase.Core/IR/TypeFunctor.cs
index 9e3be8c506..f11ec869a4 100644
--- a/src/Nncase.Core/IR/TypeFunctor.cs
+++ b/src/Nncase.Core/IR/TypeFunctor.cs
@@ -32,7 +32,7 @@ public virtual TResult VisitType(IRType type, TContext context)
             TensorType t => VisitType(t, context),
             TupleType t => VisitType(t, context),
             CallableType t => VisitType(t, context),
-            DistTensorType t => VisitType(t, context),
+            DistributedType t => VisitType(t, context),
             _ => DefaultVisitType(type, context),
         };
     }
@@ -99,7 +99,7 @@ public virtual TResult VisitType(IRType type, TContext context)
     /// <param name="type">dist tensor type.</param>
     /// <param name="context">Context.</param>
     /// <returns>Result.</returns>
-    public virtual TResult VisitType(DistTensorType type, TContext context) => DefaultVisitType(type, context);
+    public virtual TResult VisitType(DistributedType type, TContext context) => DefaultVisitType(type, context);
 
     /// <summary>
     /// Default visit routine.
diff --git a/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs b/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
index 00da741a3b..3f65d387b8 100644
--- a/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
@@ -275,7 +275,7 @@ public override string VisitType(TupleType type) =>
         $"({string.Join(", ", type.Fields.Select(VisitType))})";
 
     /// <inheritdoc/>
-    public override string VisitType(DistTensorType type)
+    public override string VisitType(DistributedType type)
     {
         var shape = type.TensorType.Shape.ToArray();
         foreach (var (s, r) in type.NdSbp.Select((s, r) => (s, r)))
diff --git a/src/Nncase.Evaluator/Math/Binary.cs b/src/Nncase.Evaluator/Math/Binary.cs
index 0b5515ca28..2d994a40c5 100755
--- a/src/Nncase.Evaluator/Math/Binary.cs
+++ b/src/Nncase.Evaluator/Math/Binary.cs
@@ -2,9 +2,11 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
+using DryIoc;
 using Nncase.CostModel;
 using Nncase.IR;
 using Nncase.IR.Math;
+using Nncase.IR.Tensors;
 using Nncase.Utilities;
 using OrtKISharp;
 
@@ -54,17 +56,22 @@ public IValue Visit(IEvaluateContext context, Binary binary)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Binary target)
     {
-        var lhs = context.CheckArgumentType<TensorType>(target, Binary.Lhs);
-        var rhs = context.CheckArgumentType<TensorType>(target, Binary.Rhs);
-        return Visit(target, lhs, rhs);
+        var lhs = context.CheckArgumentType<IRType>(target, Binary.Lhs);
+        var rhs = context.CheckArgumentType<IRType>(target, Binary.Rhs);
+        return (lhs, rhs) switch
+        {
+            (TensorType a, TensorType b) => Visit(target, a, b),
+            (DistributedType a, DistributedType b) => Visit(target, a, b),
+            _ => new InvalidType("invalid binary type"),
+        };
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Binary target)
     {
-        var lhsType = context.GetArgumentType<TensorType>(target, Binary.Lhs);
-        var rhsType = context.GetArgumentType<TensorType>(target, Binary.Rhs);
-        var outputType = context.GetReturnType<TensorType>();
+        var lhsType = context.GetArgumentType<IRType>(target, Binary.Lhs);
+        var rhsType = context.GetArgumentType<IRType>(target, Binary.Rhs);
+        var outputType = context.GetReturnType<IRType>();
 
         return new()
         {
@@ -121,6 +128,59 @@ public Expr Visit(IShapeEvaluateContext context, Binary target)
         return IR.F.Tensors.Cast(ShapeExprUtility.BroadcastShape(lhs, rhs), DataTypes.Int32);
     }
 
+    private IRType Visit(Binary target, DistributedType a, DistributedType b)
+    {
+        if (a.Placement != b.Placement)
+        {
+            return new InvalidType("lhs rhs have different placement");
+        }
+
+        var ndsbp = new SBP[a.Placement.Rank];
+        for (int i = 0; i < a.Placement.Rank; i++)
+        {
+            switch (a.NdSbp[i], b.NdSbp[i])
+            {
+                case (SBPSplit sa, SBPSplit sb):
+                    if (sa != sb)
+                    {
+                        return new InvalidType("lhs rhs sbp at {i} not equal");
+                    }
+
+                    ndsbp[i] = sa;
+                    break;
+                case (SBPSplit s1, SBPBroadCast):
+                    ndsbp[i] = s1;
+                    break;
+                case (SBPBroadCast, SBPSplit s2):
+                    ndsbp[i] = s2;
+                    break;
+                case (SBPBroadCast, SBPBroadCast):
+                    ndsbp[i] = SBP.B;
+                    break;
+                case (SBPPartialSum, _):
+                case (_, SBPPartialSum):
+                    if (target.BinaryOp == BinaryOp.Add)
+                    {
+                        ndsbp[i] = SBP.P;
+                    }
+                    else
+                    {
+                        return new InvalidType("lhs rhs have partialsum only can add");
+                    }
+
+                    break;
+            }
+        }
+
+        var rType = Visit(target, a.TensorType, b.TensorType);
+        if (rType is not TensorType tensorType)
+        {
+            return rType;
+        }
+
+        return new DistributedType(tensorType, ndsbp, a.Placement);
+    }
+
     private int Compute(BinaryOp op, int a, int b) => op switch
     {
         BinaryOp.Add => a + b,
diff --git a/src/Nncase.Evaluator/Math/MatMul.cs b/src/Nncase.Evaluator/Math/MatMul.cs
index 444d221c28..1c295c0382 100644
--- a/src/Nncase.Evaluator/Math/MatMul.cs
+++ b/src/Nncase.Evaluator/Math/MatMul.cs
@@ -30,9 +30,14 @@ public IValue Visit(IEvaluateContext context, MatMul matMul)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, MatMul target)
     {
-        var lhs = context.CheckArgumentType<TensorType>(target, MatMul.Lhs);
-        var rhs = context.CheckArgumentType<TensorType>(target, MatMul.Rhs);
-        return Visit(lhs, rhs);
+        var lhs = context.CheckArgumentType<IRType>(target, MatMul.Lhs);
+        var rhs = context.CheckArgumentType<IRType>(target, MatMul.Rhs);
+        return (lhs, rhs) switch
+        {
+            (DistributedType a, DistributedType b) => Visit(a, b),
+            (TensorType a, TensorType b) => Visit(a, b),
+            _ => new InvalidType(string.Empty),
+        };
     }
 
     /// <inheritdoc/>
@@ -74,6 +79,70 @@ public Expr Visit(IShapeEvaluateContext context, MatMul target)
         return Cast(IR.F.ShapeExpr.MatMulShape(lhs, rhs), DataTypes.Int32);
     }
 
+    private IRType Visit(DistributedType a, DistributedType b)
+    {
+        if (Visit(a.TensorType, b.TensorType) is not TensorType outType)
+        {
+            return new InvalidType(string.Empty);
+        }
+
+        if (a.Placement != b.Placement)
+        {
+            return new InvalidType("placement not equal");
+        }
+
+        var aRank = a.TensorType.Shape.Rank;
+        var bRank = a.TensorType.Shape.Rank;
+
+        var ndsbp = new SBP[a.Placement.Rank];
+        for (int i = 0; i < a.Placement.Rank; i++)
+        {
+            var invalid = new InvalidType($"({a.NdSbp[i]}, {b.NdSbp[i]}) not support");
+            switch (a.NdSbp[i], b.NdSbp[i])
+            {
+                // split on k
+                case (SBPSplit { Axis: int ax }, SBPSplit { Axis: int bx }):
+                    if (ax == (aRank - 1) && bx == (bRank - 2))
+                    {
+                        ndsbp[i] = SBP.P;
+                    }
+                    else
+                    {
+                        if (ax == bx)
+                        {
+                            ndsbp[i] = SBP.S(ax);
+                        }
+                        else
+                        {
+                            return invalid;
+                        }
+                    }
+
+                    break;
+                case (SBPSplit { Axis: int ax }, SBPBroadCast):
+                    if (ax == aRank - 1)
+                    {
+                        return invalid;
+                    }
+
+                    ndsbp[i] = SBP.S(ax);
+                    break;
+                case (SBPBroadCast, SBPSplit { Axis: int bx }):
+                    if (bx == bRank - 2)
+                    {
+                        return invalid;
+                    }
+
+                    ndsbp[i] = SBP.S(bx);
+                    break;
+                default:
+                    return invalid;
+            }
+        }
+
+        return new DistributedType(outType, ndsbp, a.Placement);
+    }
+
     private IRType Visit(TensorType lhs, TensorType rhs)
     {
         if (lhs.Shape.IsUnranked || rhs.Shape.IsUnranked)
diff --git a/src/Nncase.Evaluator/Math/Unary.cs b/src/Nncase.Evaluator/Math/Unary.cs
index e6db1d9a05..7e7b682226 100644
--- a/src/Nncase.Evaluator/Math/Unary.cs
+++ b/src/Nncase.Evaluator/Math/Unary.cs
@@ -69,7 +69,7 @@ public IRType Visit(ITypeInferenceContext context, Unary target)
         return inputType switch
         {
             TensorType tensorType => Visit(tensorType),
-            DistTensorType distTensorType => Visit(distTensorType),
+            DistributedType distTensorType => Visit(distTensorType),
             _ => new InvalidType($"Not support {inputType.GetType().Name}"),
         };
     }
@@ -82,7 +82,7 @@ public Cost Visit(ICostEvaluateContext context, Unary target)
         return (inputType, outputType) switch
         {
             (TensorType tensorType, TensorType tensorType1) => Visit(tensorType, tensorType1, target),
-            (DistTensorType distTensorType, DistTensorType distTensorType1) => Visit(distTensorType, distTensorType1, target),
+            (DistributedType distTensorType, DistributedType distTensorType1) => Visit(distTensorType, distTensorType1, target),
             _ => throw new NotSupportedException(string.Empty),
         };
     }
@@ -122,7 +122,7 @@ public Expr Visit(IShapeEvaluateContext context, Unary target)
         return context.GetArgumentShape(target, Unary.Input);
     }
 
-    private IRType Visit(DistTensorType distTensorType)
+    private IRType Visit(DistributedType distTensorType)
     {
         return distTensorType;
     }
@@ -167,10 +167,10 @@ private IRType Visit(TensorType input)
         return input;
     }
 
-    private Cost Visit(DistTensorType inType, DistTensorType outType, Unary target)
+    private Cost Visit(DistributedType inType, DistributedType outType, Unary target)
     {
-        var inPartType = DistributeUtilities.GetPartedDistTensorType(inType, out float inScale);
-        var outPartType = DistributeUtilities.GetPartedDistTensorType(outType, out float outScale);
+        var inPartType = DistributedUtilities.GetDividedTensorType(inType, out float inScale);
+        var outPartType = DistributedUtilities.GetDividedTensorType(outType, out float outScale);
         return new()
         {
             [CostFactorNames.MemoryLoad] = (UInt128)((float)CostUtility.GetMemoryAccess(inPartType) * inScale),
diff --git a/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs b/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
index b4bddd0191..491bf4979f 100644
--- a/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
+++ b/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
@@ -23,16 +23,16 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
         Cost cost;
         switch (inType, returnType)
         {
-            case (TensorType tensorType, DistTensorType distTensorType):
-                var partedOutType = DistributeUtilities.GetPartedDistTensorType(distTensorType, out _);
+            case (TensorType tensorType, DistributedType distTensorType):
+                var partedOutType = DistributedUtilities.GetDividedTensorType(distTensorType, out _);
                 cost = new Cost()
                 {
                     [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(tensorType),
                     [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(partedOutType),
                 };
                 break;
-            case (DistTensorType distTensorType, TensorType tensorType):
-                var partedInType = DistributeUtilities.GetPartedDistTensorType(distTensorType, out _);
+            case (DistributedType distTensorType, TensorType tensorType):
+                var partedInType = DistributedUtilities.GetDividedTensorType(distTensorType, out _);
                 cost = new Cost()
                 {
                     [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(partedInType),
diff --git a/src/Nncase.Evaluator/TypeInference.cs b/src/Nncase.Evaluator/TypeInference.cs
index c06f6da7eb..bbe74d1739 100644
--- a/src/Nncase.Evaluator/TypeInference.cs
+++ b/src/Nncase.Evaluator/TypeInference.cs
@@ -461,5 +461,4 @@ IRType CommonTypeImpl(TensorType a, TensorType b)
             _ => new InvalidType($"Inputs of if should be same IRType Kind, but then:{thenType}, else: {elseType}"),
         };
     }
-
 }
diff --git a/src/Nncase.Tests/Core/UnitTestExpression.cs b/src/Nncase.Tests/Core/UnitTestExpression.cs
index 00371b9077..d5869529fd 100644
--- a/src/Nncase.Tests/Core/UnitTestExpression.cs
+++ b/src/Nncase.Tests/Core/UnitTestExpression.cs
@@ -531,8 +531,8 @@ public void TestBoxingEqual()
     {
         Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
         var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
-        var a = new DistTensorType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
-        var b = new DistTensorType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
+        var a = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
+        var b = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
 
         var input = new Var(ttype);
         var ea = IR.F.Tensors.Boxing(input, a);
diff --git a/src/Nncase.Tests/Distributed/UnitTestDistTensor.cs b/src/Nncase.Tests/Distributed/UnitTestDistTensor.cs
index db435fee8e..e04b2ae252 100644
--- a/src/Nncase.Tests/Distributed/UnitTestDistTensor.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestDistTensor.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;
@@ -22,7 +22,7 @@ public void TestCreate()
     {
         Placement placement = new(Placement.DeviceKind.CPU, new int[] { 2, 2 }, "bt");
         IRArray<SBP> sbps = new[] { SBP.S(2), SBP.S(1), };
-        DistTensorType t = new(new TensorType(DataTypes.Float32, new[] { 1, 2, 8 }), sbps, placement);
+        DistributedType t = new(new TensorType(DataTypes.Float32, new[] { 1, 2, 8 }), sbps, placement);
         var input = new Var("input", t);
         var output = IR.F.Math.Unary(UnaryOp.Neg, input);
         output.CheckedType = t;
@@ -49,8 +49,8 @@ public IReadOnlyList<CallableType> GetCandidateSignatures(Unary unary, TensorTyp
 
         return LinqExtensions.CartesianProduct(layers).Select(layer => layer.ToArray()).Select(layer =>
         {
-            var inType = new DistTensorType(tensorType, Enumerable.Range(0, layers.Count).Select(i => layer[i].Item1).ToArray(), placement);
-            var outType = new DistTensorType(tensorType, Enumerable.Range(0, layers.Count).Select(i => layer[i].Item2).ToArray(), placement);
+            var inType = new DistributedType(tensorType, Enumerable.Range(0, layers.Count).Select(i => layer[i].Item1).ToArray(), placement);
+            var outType = new DistributedType(tensorType, Enumerable.Range(0, layers.Count).Select(i => layer[i].Item2).ToArray(), placement);
             return new CallableType(outType, new[] { inType });
         }).ToList();
     }
@@ -61,7 +61,7 @@ public void TestGetLeafCandidateNDSBPs()
         Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
         var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
         var input = new Var(ttype);
-        var set = new HashSet<DistTensorType>(DistributeUtilities.GetLeafCandidateNDSBPs(ttype, placement).Select(ndsbp => new DistTensorType(ttype, ndsbp, placement)));
+        var set = new HashSet<DistributedType>(DistributedUtilities.GetLeafCandidateNDSBPs(ttype, placement).Select(ndsbp => new DistributedType(ttype, ndsbp, placement)));
         Assert.Equal(9, set.Count);
     }
 
@@ -70,8 +70,8 @@ public void TestDistributeTypeEqual()
     {
         Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
         var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
-        var a = new DistTensorType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
-        var b = new DistTensorType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
+        var a = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
+        var b = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
         Assert.Equal(a, b);
         Assert.StrictEqual(a, b);
     }
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 3545052729..8f3d87e106 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -40,34 +40,44 @@ public async Task TestCpuUnary()
         var input = new Var("input", new TensorType(DataTypes.Float32, shape));
         var main = new Function("main", IR.F.Math.Unary(UnaryOp.Asin, input), new[] { input });
         var module = new IR.IRModule(main);
-
-        var compiler = CompileSession.Compiler;
-        compiler.ImportIRModule(module);
-        await compiler.CompileAsync();
-        using (var fs = Dumpper.OpenFile("test.kmodel"))
-        {
-            compiler.Gencode(fs);
-        }
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
-        using (var fs = Dumpper.OpenFile("input_0.bin"))
-        {
-            fs.Write(input_tensor.BytesBuffer);
-        }
+        await Compile(module);
 
         // Testing.RunKModel(File.ReadAllBytes(Path.Join(Dumpper.Directory, "test.kmodel")), Dumpper.Directory, new[] { input_tensor });
     }
 
+    [Fact]
+    public async Task TestCpuBinary()
+    {
+        var lhsShape = new[] { 1, 64, 384, 128 };
+        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, lhsShape));
+        var rhsShape = new[] { 1, 1, 384, 128 };
+        var rhs = new Var("lhs", new TensorType(DataTypes.Float32, rhsShape));
+        var main = new Function("main", lhs * rhs, new[] { lhs, rhs });
+        var module = new IR.IRModule(main);
+        await Compile(module);
+    }
+
     [Fact]
     public async Task TestCpuMatMul()
     {
-        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, new[] { 3, 4 }));
-        var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, new[] { 4, 6 });
+        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, new[] { 1, 1, 384, 8192 }));
+        var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, new[] { 1, 64, 8192, 128 });
 
-        // new Var("rhs", new TensorType(DataTypes.Float32, new[] { 4, 6 }));
         var main = new Function("main", IR.F.Tensors.MatMul(lhs, rhs), new[] { lhs });
         var module = new IR.IRModule(main);
+        await Compile(module);
+
+        // var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 3, 4 }).Evaluate().AsTensor();
+        // using (var fs = Dumpper.OpenFile("input_0.bin"))
+        // {
+        //     fs.Write(input_tensor.BytesBuffer);
+        // }
+
+        // Testing.RunKModel(File.ReadAllBytes(Path.Join(Dumpper.Directory, "test.kmodel")), Dumpper.Directory, new[] { input_tensor });
+    }
 
+    private async Task Compile(IRModule module)
+    {
         var compiler = CompileSession.Compiler;
         compiler.ImportIRModule(module);
         await compiler.CompileAsync();
@@ -75,13 +85,5 @@ public async Task TestCpuMatMul()
         {
             compiler.Gencode(fs);
         }
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 3, 4 }).Evaluate().AsTensor();
-        using (var fs = Dumpper.OpenFile("input_0.bin"))
-        {
-            fs.Write(input_tensor.BytesBuffer);
-        }
-
-        Testing.RunKModel(File.ReadAllBytes(Path.Join(Dumpper.Directory, "test.kmodel")), Dumpper.Directory, new[] { input_tensor });
     }
 }

From daa22a76ba14ffa30d505b375c90f2e17c157277 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 13 Sep 2023 14:31:21 +0800
Subject: [PATCH 171/308] refactor cpu runtime

---
 .../CodeGen/CSourceBuiltn.cs                  |  221 +-
 .../CodeGen/CSourceCompiler.cs                |    6 +-
 .../CodeGen/CSourceConvertVisitor.cs          |    2 +-
 .../CodeGen/LinkableModule.cs                 |   48 +-
 .../nncase/runtime/cpu/compiler_defs.h        |   12 +-
 modules/cpu/src/runtime/CMakeLists.txt        |    5 +-
 modules/cpu/src/runtime/cmodel/CMakeLists.txt |    4 +-
 .../cpu/src/runtime/cmodel/include/apply.h    |    2 +-
 .../cpu/src/runtime/cmodel/include/binary.h   |    2 +-
 .../cpu/src/runtime/cmodel/include/gather.h   |    2 +-
 .../cpu/src/runtime/cmodel/include/reduce.h   |    2 +-
 .../runtime/cmodel/include/runtime_types.h    |    2 +-
 .../runtime/cmodel/include/runtime_utils.h    |    2 +-
 .../cpu/src/runtime/cmodel/include/slice.h    |    2 +-
 .../runtime/cmodel/include/small_vector.hpp   | 1003 ++++
 modules/cpu/src/runtime/cmodel/include/tdma.h |   10 +-
 .../cpu/src/runtime/cmodel/include/tensor.h   |    2 +-
 .../src/runtime/cmodel/include/transpose.h    |    2 +-
 .../cpu/src/runtime/cmodel/include/unary.h    |    2 +-
 .../cmodel/tests/decoder_layer/kernel.h       |   80 +-
 .../src/runtime/cmodel/tests/embed/kernel.h   |    7 +-
 .../src/runtime/cmodel/tests/head/kernel.h    |    7 +-
 .../src/runtime/cmodel/tests/norm/kernel.h    |    5 +-
 .../src/runtime/cmodel/tests/unary/kernel.h   |    6 +-
 modules/cpu/src/runtime/elfloader.cpp         |    9 +-
 modules/cpu/src/runtime/elfloader.h           |   12 +-
 modules/cpu/src/runtime/gsl-lite.hpp          | 4156 +++++++++++++++++
 modules/cpu/src/runtime/io_utils.h            |    2 +-
 modules/cpu/src/runtime/method_table_impl.h   |    6 +-
 modules/cpu/src/runtime/runtime_function.cpp  |    9 +-
 modules/cpu/src/runtime/runtime_function.h    |    1 +
 modules/cpu/src/runtime/runtime_types.h       |   52 -
 modules/cpu/src/runtime/runtime_utils.h       |    6 +-
 modules/cpu/src/runtime/thread_pool.cpp       |    1 +
 src/Native/src/test_cli.cpp                   |    2 +-
 .../Targets/UnitTestCPUTargetTiling.cs        |   10 +-
 36 files changed, 5515 insertions(+), 187 deletions(-)
 create mode 100644 modules/cpu/src/runtime/cmodel/include/small_vector.hpp
 create mode 100644 modules/cpu/src/runtime/gsl-lite.hpp
 delete mode 100644 modules/cpu/src/runtime/runtime_types.h

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index 2f7a610a63..ff51290c96 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 #define MULTI_CORE_CPU
+using System.Runtime.CompilerServices;
 using NetFabric.Hyperlinq;
 
 namespace Nncase.CodeGen.CPU;
@@ -8,6 +9,224 @@ namespace Nncase.CodeGen.CPU;
 public static class CSourceBuiltn
 {
 #if MULTI_CORE_CPU
+    public static string ClusterDef()
+    {
+        return @"#pragma once
+#include <hardware_context.h>
+#include <tdma.h>
+
+namespace block0 {
+#include ""shared.h""
+constexpr size_t bid = 0;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include ""kernel.h""
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include ""kernel.h""
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include ""kernel.h""
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include ""kernel.h""
+} // namespace thread3
+} // namespace block0
+
+namespace block1 {
+#include ""shared.h""
+constexpr size_t bid = 1;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include ""kernel.h""
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include ""kernel.h""
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include ""kernel.h""
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include ""kernel.h""
+} // namespace thread3
+} // namespace block1
+
+namespace block2 {
+#include ""shared.h""
+constexpr size_t bid = 2;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include ""kernel.h""
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include ""kernel.h""
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include ""kernel.h""
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include ""kernel.h""
+} // namespace thread3
+} // namespace block2
+
+namespace block3 {
+#include ""shared.h""
+constexpr size_t bid = 3;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include ""kernel.h""
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include ""kernel.h""
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include ""kernel.h""
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include ""kernel.h""
+} // namespace thread3
+} // namespace block3
+
+namespace block4 {
+#include ""shared.h""
+constexpr size_t bid = 4;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include ""kernel.h""
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include ""kernel.h""
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include ""kernel.h""
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include ""kernel.h""
+} // namespace thread3
+} // namespace block4
+
+namespace block5 {
+#include ""shared.h""
+constexpr size_t bid = 5;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include ""kernel.h""
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include ""kernel.h""
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include ""kernel.h""
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include ""kernel.h""
+} // namespace thread3
+} // namespace block5
+
+namespace block6 {
+#include ""shared.h""
+constexpr size_t bid = 6;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include ""kernel.h""
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include ""kernel.h""
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include ""kernel.h""
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include ""kernel.h""
+} // namespace thread3
+} // namespace block6
+
+namespace block7 {
+#include ""shared.h""
+constexpr size_t bid = 7;
+namespace thread0 {
+constexpr size_t tid = 0;
+#include ""kernel.h""
+} // namespace thread0
+namespace thread1 {
+constexpr size_t tid = 1;
+#include ""kernel.h""
+} // namespace thread1
+namespace thread2 {
+constexpr size_t tid = 2;
+#include ""kernel.h""
+} // namespace thread2
+namespace thread3 {
+constexpr size_t tid = 3;
+#include ""kernel.h""
+} // namespace thread3
+} // namespace block7
+";
+    }
+
+    public static string CMakeDef(string name, [CallerFilePath] string? callerFilePath = null)
+    {
+        var solutionPath = Path.GetFullPath(Path.Join(callerFilePath!, "../../../.."));
+        return $@"project(cpu)
+cmake_minimum_required(VERSION 3.13)
+
+add_library(
+  cpu_cmodel STATIC
+  {solutionPath}/modules/cpu/src/runtime/cmodel/src/dummy.cpp
+  {solutionPath}/modules/cpu/src/runtime/hardware_context.cpp)
+
+set(CMAKE_CXX_STANDARD 20)
+
+target_include_directories(
+  cpu_cmodel
+  PUBLIC
+    {solutionPath}/modules/cpu/src/runtime/cmodel/include
+)
+target_include_directories(
+  cpu_cmodel
+  PUBLIC {solutionPath}/modules/cpu/include)
+target_include_directories(
+  cpu_cmodel
+  PUBLIC {solutionPath}/modules/cpu/src/runtime/)
+set_target_properties(cpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+if(CMAKE_BUILD_TYPE STREQUAL ""Release"")
+  add_compile_options(-O1)
+endif()
+add_link_options(
+  -no-pie
+  -nostartfiles
+  -fPIC
+  -fno-stack-protector
+  -static
+  -Wl,-e,_Z6_startPN6nncase7runtime3cpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPh
+)
+add_executable({name} ""main.cpp"")
+target_link_libraries({name} cpu_cmodel)
+";
+    }
+
     public const string KernelHeader = @"#include ""thread_context.h""
 using namespace shared;
 ";
@@ -20,7 +239,7 @@ public static string MakeMain(TIR.PrimFunction primFunction)
         {
             var size = TensorUtilities.GetSize(b.CheckedShape.ToValueArray(), TensorUtilities.GetStrides(b.CheckedShape.ToValueArray()), 1);
             return $@"auto {b.Name}_ = tensor<{b.ElemType.ToC()}, {b.MemSpan.Location.ToC()}>(gsl::make_span(({b.ElemType.ToC()}*)inputs[{i}], {size}), {{{string.Join(',', b.CheckedShape)}}});
-    Output = &{b.Name}_;";
+    {b.Name} = &{b.Name}_;";
         }));
 
         return @$"#include ""cluster_def.h""
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
index 691fe6cd24..e6c368629b 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
@@ -90,7 +90,7 @@ public string Compile(string sourcePath, string outPath)
     /// create the temp dll file and compile source
     /// <see cref="Compile(string, string)"/>.
     /// </summary>
-    public string Compile(string sourcePath) => Compile(sourcePath, CodeGenUtil.GetTempFileName(Ext));
+    public string Compile(string sourcePath) => Compile(sourcePath, Path.Join(sourcePath, "build", Path.GetFileName(sourcePath)));
 
     /// <summary>
     /// select current pattern's exe.
@@ -100,7 +100,7 @@ private void PlatformSpecific()
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
-            _exe = "gcc";
+            _exe = "/bin/bash";
             _ext = "so";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
@@ -134,7 +134,7 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
-            return $"{sourcePath} -nostdlib -static -no-pie -fPIC -fno-stack-protector -o {outPath}";
+            return $"-c \"cd {sourcePath} && mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Debug && cmake --build .\"";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
         {
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 702cdab985..c2bc888555 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -146,7 +146,7 @@ protected override CSymbol VisitPrimFunction(PrimFunction expr)
             throw new NotSupportedException("The PrimFunction must return void!");
         }
 
-        var ctype = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(Visit).Select(s => s.ToString()).ToArray())})";
+        var ctype = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(Visit).Select(s => $"{s.Type} &{s.Name}").ToArray())})";
 
         _sharedWriter.WriteLine(ctype + ";");
         _sharedWriter.WriteLine();
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index 9a1188422d..089c0330fd 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -41,6 +41,14 @@ public ILinkedModule Link(ILinkContext linkContext)
                     Directory.CreateDirectory(dumpPath);
                 }
 
+                using (var fs = File.Open(Path.Join(dumpPath, "cluster_def.h"), FileMode.Create))
+                {
+                    using (var writer = new StreamWriter(fs))
+                    {
+                        writer.Write(CSourceBuiltn.ClusterDef());
+                    }
+                }
+
                 using (var fs = File.Open(Path.Join(dumpPath, "main.cpp"), FileMode.Create))
                 {
                     using (var writer = new StreamWriter(fs))
@@ -65,6 +73,14 @@ public ILinkedModule Link(ILinkContext linkContext)
                         writer.Write(func.FunctionCSource.Kernel);
                     }
                 }
+
+                using (var fs = File.Open(Path.Join(dumpPath, "CMakeLists.txt"), FileMode.Create))
+                {
+                    using (var writer = new StreamWriter(fs))
+                    {
+                        writer.Write(CSourceBuiltn.CMakeDef(func.PrimFunction.Name));
+                    }
+                }
             }
 
             // using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.h"), FileMode.Create))
@@ -81,25 +97,21 @@ public ILinkedModule Link(ILinkContext linkContext)
             // }
         }
 
-        // var elfPath = CompileCSource(csourcePath);
-        // var text = File.ReadAllBytes(elfPath);
-        var text = Array.Empty<byte>();
-
-        // if (_options.DumpFlags.HasFlag(DumpFlags.CodeGen))
-        // {
-        //     var dumpPath = _options.DumpDir;
-        //     using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.elf"), FileMode.Create))
-        //     {
-        //         fs.Write(text);
-        //     }
-        // }
+        var text = new List<byte>();
         var linkedFunctions = new List<LinkedFunction>();
+        int offset = 0;
+        foreach (var func in _functions)
+        {
+            var dumpPath = Path.Join(_options.DumpDir, func.PrimFunction.Name);
+            var elfPath = CompileCSource(dumpPath);
+
+            var func_text = File.ReadAllBytes(elfPath);
+            text.AddRange(func_text);
+            linkedFunctions.Add(new LinkedFunction(func.Id, func.SourceFunction, (uint)offset, (uint)func_text.Length, func.Sections));
+            offset += func_text.Length;
+        }
 
-        // foreach (var func in _functions)
-        // {
-        //     linkedFunctions.Add(new LinkedFunction(func.Id, func.SourceFunction, 0, 0, func.Sections));
-        // }
-        return new LinkedModule(linkedFunctions, text, _rdata);
+        return new LinkedModule(linkedFunctions, text.ToArray(), _rdata);
     }
 
     // private string LinkCSources()
@@ -121,6 +133,6 @@ public ILinkedModule Link(ILinkContext linkContext)
     private string CompileCSource(string sourcePath)
     {
         var compiler = new CSourceCompiler();
-        return compiler.Compile(sourcePath, Path.GetTempFileName() + ".elf");
+        return compiler.Compile(sourcePath, Path.Join(sourcePath, "build", Path.GetFileName(sourcePath)));
     }
 }
diff --git a/modules/cpu/include/nncase/runtime/cpu/compiler_defs.h b/modules/cpu/include/nncase/runtime/cpu/compiler_defs.h
index fa7dcceef0..1bebad4b9d 100644
--- a/modules/cpu/include/nncase/runtime/cpu/compiler_defs.h
+++ b/modules/cpu/include/nncase/runtime/cpu/compiler_defs.h
@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 #pragma once
-#include <nncase/compiler_defs.h>
+#include <cstdint>
 
 #if defined(_MSC_VER)
 #ifdef NNCASE_MODULES_CPU_DLL
@@ -26,3 +26,13 @@
 #else
 #define NNCASE_MODULES_CPU_API __attribute__((visibility("default")))
 #endif
+
+#define BEGIN_NS_NNCASE_RT_MODULE(MODULE)                                      \
+    namespace nncase {                                                         \
+    namespace runtime {                                                        \
+    namespace MODULE {
+
+#define END_NS_NNCASE_RT_MODULE                                                \
+    }                                                                          \
+    }                                                                          \
+    }
diff --git a/modules/cpu/src/runtime/CMakeLists.txt b/modules/cpu/src/runtime/CMakeLists.txt
index a0d8e42910..aba9f8da01 100644
--- a/modules/cpu/src/runtime/CMakeLists.txt
+++ b/modules/cpu/src/runtime/CMakeLists.txt
@@ -10,12 +10,13 @@ set(SRCS runtime_module.cpp
          elfreloc_aarch64.cpp
          elfreloc_amd64.cpp
          elfreloc_i386.cpp
-         elfreloc_riscv64.cpp)
+         elfreloc_riscv64.cpp
+         hardware_context.cpp)
 
 if (BUILDING_RUNTIME)
     if (ENABLE_CPU_RUNTIME)
         add_library(runtime_cpu OBJECT ${SRCS})
-        target_link_libraries(runtime_cpu PUBLIC nncaseruntime pthread)
+        target_link_libraries(runtime_cpu PUBLIC nncaseruntime cpu_cmodel pthread)
         set_target_properties(runtime_cpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
         install(TARGETS runtime_cpu EXPORT nncaseruntimeTargets)
     endif()
diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index 59a38a154f..de2b939392 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -9,10 +9,10 @@ add_library(cpu_cmodel STATIC
 set(CMAKE_CXX_STANDARD 20)
 
 target_include_directories(cpu_cmodel PUBLIC include)
-target_include_directories(cpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../src/Native/include)
+# target_include_directories(cpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../src/Native/include)
 target_include_directories(cpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../include)
 target_include_directories(cpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../runtime)
-target_include_directories(cpu_cmodel PUBLIC /root/.conan/data/gsl-lite/0.37.0/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/)
+# target_include_directories(cpu_cmodel PUBLIC /root/.conan/data/gsl-lite/0.37.0/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/)
 # target_link_libraries(cpu_cmodel PUBLIC gsl::gsl-lite)
 # if(NOT APPLE AND NOT MSVC)
 #   target_link_libraries(cpu_cmodel PRIVATE rt)
diff --git a/modules/cpu/src/runtime/cmodel/include/apply.h b/modules/cpu/src/runtime/cmodel/include/apply.h
index 6b519f8c48..bfb500444f 100644
--- a/modules/cpu/src/runtime/cmodel/include/apply.h
+++ b/modules/cpu/src/runtime/cmodel/include/apply.h
@@ -1,5 +1,5 @@
 #pragma once
-#include <gsl/gsl-lite.hpp>
+#include "../../gsl-lite.hpp"
 
 namespace detail {
 #define APPLY_IMPL_FOR(i) for (index[i] = 0; index[i] < shape[i]; index[i]++)
diff --git a/modules/cpu/src/runtime/cmodel/include/binary.h b/modules/cpu/src/runtime/cmodel/include/binary.h
index bbadf375d1..348741cac9 100644
--- a/modules/cpu/src/runtime/cmodel/include/binary.h
+++ b/modules/cpu/src/runtime/cmodel/include/binary.h
@@ -14,7 +14,7 @@
  */
 
 #include <apply.h>
-#include <gsl/gsl-lite.hpp>
+#include "../../gsl-lite.hpp"
 #include <runtime_utils.h>
 
 using namespace nncase::runtime::cpu;
diff --git a/modules/cpu/src/runtime/cmodel/include/gather.h b/modules/cpu/src/runtime/cmodel/include/gather.h
index fd5ef81564..c867196437 100644
--- a/modules/cpu/src/runtime/cmodel/include/gather.h
+++ b/modules/cpu/src/runtime/cmodel/include/gather.h
@@ -14,7 +14,7 @@
  */
 
 #include <apply.h>
-#include <gsl/gsl-lite.hpp>
+#include "../../gsl-lite.hpp"
 #include <runtime_utils.h>
 
 namespace kernels {
diff --git a/modules/cpu/src/runtime/cmodel/include/reduce.h b/modules/cpu/src/runtime/cmodel/include/reduce.h
index 79ec08d853..dbfb037b4e 100644
--- a/modules/cpu/src/runtime/cmodel/include/reduce.h
+++ b/modules/cpu/src/runtime/cmodel/include/reduce.h
@@ -14,7 +14,7 @@
  */
 
 #include <apply.h>
-#include <gsl/gsl-lite.hpp>
+#include "../../gsl-lite.hpp"
 #include <runtime_utils.h>
 
 enum class reduce_op_t : uint8_t {
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_types.h b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
index 0fa69d7913..8dd1ce6ad2 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_types.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
@@ -1,5 +1,5 @@
 #pragma once
-#include <nncase/runtime/small_vector.hpp>
+#include "small_vector.hpp"
 
 using dims_t = itlib::small_vector<size_t, 8>;
 using strides_t = itlib::small_vector<size_t, 8>;
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 11fa133119..5d32f27413 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <cstddef>
-#include <gsl/gsl-lite.hpp>
+#include "../../gsl-lite.hpp"
 #include <runtime_types.h>
 #include "../../method_table_def.h"
 
diff --git a/modules/cpu/src/runtime/cmodel/include/slice.h b/modules/cpu/src/runtime/cmodel/include/slice.h
index d0815d1c8c..080858d4e7 100644
--- a/modules/cpu/src/runtime/cmodel/include/slice.h
+++ b/modules/cpu/src/runtime/cmodel/include/slice.h
@@ -14,7 +14,7 @@
  */
 
 #include <apply.h>
-#include <gsl/gsl-lite.hpp>
+#include "../../gsl-lite.hpp"
 #include <runtime_utils.h>
 
 namespace kernels {
diff --git a/modules/cpu/src/runtime/cmodel/include/small_vector.hpp b/modules/cpu/src/runtime/cmodel/include/small_vector.hpp
new file mode 100644
index 0000000000..839ae8eb2e
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/small_vector.hpp
@@ -0,0 +1,1003 @@
+// itlib-small-vector v1.00
+//
+// std::vector-like class with a static buffer for initial capacity
+//
+// MIT License:
+// Copyright(c) 2016-2018 Chobolabs Inc.
+// Copyright(c) 2020 Borislav Stanimirov
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files(the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and / or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions :
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//
+//                  VERSION HISTORY
+//
+//  1.00 (2020-10-14) Rebranded release from chobo-small-vector
+//
+//
+//                  DOCUMENTATION
+//
+// Simply include this file wherever you need.
+// It defines the class itlib::small_vector, which is a drop-in replacement of
+// std::vector, but with an initial capacity as a template argument.
+// It gives you the benefits of using std::vector, at the cost of having a
+// statically allocated buffer for the initial capacity, which gives you
+// cache-local data when the vector is small (smaller than the initial
+// capacity).
+//
+// When the size exceeds the capacity, the vector allocates memory via the
+// provided allocator, falling back to classic std::vector behavior.
+//
+// The second size_t template argument, RevertToStaticSize, is used when a
+// small_vector which has already switched to dynamically allocated size reduces
+// its size to a number smaller than that. In this case the vector's buffer
+// switches back to the staticallly allocated one
+//
+// A default value for the initial static capacity is provided so a replacement
+// in an existing code is possible with minimal changes to it.
+//
+// Example:
+//
+// itlib::small_vector<int, 4, 5> myvec; // a small_vector of size 0, initial
+// capacity 4, and revert size 4 (smaller than 5) myvec.resize(2); // vector is
+// {0,0} in static buffer myvec[1] = 11; // vector is {0,11} in static buffer
+// myvec.push_back(7); // vector is {0,11,7}  in static buffer
+// myvec.insert(myvec.begin() + 1, 3); // vector is {0,3,11,7} in static buffer
+// myvec.push_back(5); // vector is {0,3,11,7,5} in dynamically allocated memory
+// buffer myvec.erase(myvec.begin());  // vector is {3,11,7,5} back in static
+// buffer myvec.resize(5); // vector is {3,11,7,5,0} back in dynamically
+// allocated memory
+//
+//
+// Reference:
+//
+// itlib::small_vector is fully compatible with std::vector with
+// the following exceptions:
+// * when reducing the size with erase or resize the new size may fall below
+//   RevertToStaticSize (if it is not 0). In such a case the vector will
+//   revert to using its static buffer, invalidating all iterators (contrary
+//   to the standard)
+// * a method is added `revert_to_static()` which reverts to the static buffer
+//   if possible, but doesn't free the dynamically allocated one
+//
+// Other notes:
+//
+// * the default value for RevertToStaticSize is zero. This means that once a
+// dynamic
+//   buffer is allocated the data will never be put into the static one, even if
+//   the size allows it. Even if clear() is called. The only way to do so is to
+//   call shrink_to_fit() or revert_to_static()
+// * shrink_to_fit will free and reallocate if size != capacity and the data
+//   doesn't fit into the static buffer. It also will revert to the static
+//   buffer whenever possible regardless of the RevertToStaticSize value
+//
+//
+//                  Configuration
+//
+// The library has two configuration options. They can be set as #define-s
+// before including the header file, but it is recommended to change the code
+// of the library itself with the values you want, especially if you include
+// the library in many compilation units (as opposed to, say, a precompiled
+// header or a central header).
+//
+//                  Config out of range error handling
+//
+// An out of range error is a runtime error which is triggered when a method is
+// called with an iterator that doesn't belong to the vector's current range.
+// For example: vec.erase(vec.end() + 1);
+//
+// This is set by defining ITLIB_SMALL_VECTOR_ERROR_HANDLING to one of the
+// following values:
+// * ITLIB_SMALL_VECTOR_ERROR_HANDLING_NONE - no error handling. Crashes WILL
+//      ensue if the error is triggered.
+// * ITLIB_SMALL_VECTOR_ERROR_HANDLING_THROW - std::out_of_range is thrown.
+// * ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT - asserions are triggered.
+// * ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT_AND_THROW - combines assert and
+//      throw to catch errors more easily in debug mode
+//
+// To set this setting by editing the file change the line:
+// ```
+// #   define ITLIB_SMALL_VECTOR_ERROR_HANDLING
+// ITLIB_SMALL_VECTOR_ERROR_HANDLING_THROW
+// ```
+// to the default setting of your choice
+//
+//                  Config bounds checks:
+//
+// By default bounds checks are made in debug mode (via an asser) when accessing
+// elements (with `at` or `[]`). Iterators are not checked (yet...)
+//
+// To disable them, you can define ITLIB_SMALL_VECTOR_NO_DEBUG_BOUNDS_CHECK
+// before including the header.
+//
+//
+//                  TESTS
+//
+// You can find unit tests for small_vector in its official repo:
+// https://github.com/iboB/itlib/blob/master/test/
+//
+#pragma once
+
+#include <cstddef>
+#include "gsl-lite.hpp"
+#include <memory>
+#include <type_traits>
+
+#define ITLIB_SMALL_VECTOR_ERROR_HANDLING_NONE 0
+#define ITLIB_SMALL_VECTOR_ERROR_HANDLING_THROW 1
+#define ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT 2
+#define ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT_AND_THROW 3
+
+#if !defined(ITLIB_SMALL_VECTOR_ERROR_HANDLING)
+#define ITLIB_SMALL_VECTOR_ERROR_HANDLING                                      \
+    ITLIB_SMALL_VECTOR_ERROR_HANDLING_THROW
+#endif
+
+#if ITLIB_SMALL_VECTOR_ERROR_HANDLING == ITLIB_SMALL_VECTOR_ERROR_HANDLING_NONE
+#define I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(cond)
+#elif ITLIB_SMALL_VECTOR_ERROR_HANDLING ==                                     \
+    ITLIB_SMALL_VECTOR_ERROR_HANDLING_THROW
+#include <stdexcept>
+#define I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(cond)                             \
+    if (cond)                                                                  \
+    throw std::out_of_range("itlib::small_vector out of range")
+#elif ITLIB_SMALL_VECTOR_ERROR_HANDLING ==                                     \
+    ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT
+#include <cassert>
+#define I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(cond, rescue_return)              \
+    assert(!(cond) && "itlib::small_vector out of range")
+#elif ITLIB_SMALL_VECTOR_ERROR_HANDLING ==                                     \
+    ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT_AND_THROW
+#include <cassert>
+#include <stdexcept>
+#define I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(cond, rescue_return)              \
+    do {                                                                       \
+        if (cond) {                                                            \
+            assert(false && "itlib::small_vector out of range");               \
+            throw std::out_of_range("itlib::small_vector out of range");       \
+        }                                                                      \
+    } while (false)
+#else
+#error "Unknown ITLIB_SMALL_VECTOR_ERRROR_HANDLING"
+#endif
+
+#if defined(ITLIB_SMALL_VECTOR_NO_DEBUG_BOUNDS_CHECK)
+#define I_ITLIB_SMALL_VECTOR_BOUNDS_CHECK(i)
+#else
+#include <cassert>
+#define I_ITLIB_SMALL_VECTOR_BOUNDS_CHECK(i) assert((i) < this->size())
+#endif
+
+namespace itlib {
+
+template <typename T, size_t StaticCapacity = 16, size_t RevertToStaticSize = 0,
+          class Alloc = std::allocator<T>>
+struct small_vector : Alloc {
+    static_assert(RevertToStaticSize <= StaticCapacity + 1,
+                  "itlib::small_vector: the revert-to-static size shouldn't "
+                  "exceed the static capacity by more than one");
+
+    using atraits = std::allocator_traits<Alloc>;
+
+  public:
+    using allocator_type = Alloc;
+    using value_type = typename atraits::value_type;
+    using size_type = typename atraits::size_type;
+    using difference_type = typename atraits::difference_type;
+    using reference = T &;
+    using const_reference = const T &;
+    using pointer = typename atraits::pointer;
+    using const_pointer = typename atraits::const_pointer;
+    using iterator = pointer;
+    using const_iterator = const_pointer;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    static constexpr size_t static_capacity = StaticCapacity;
+    static constexpr intptr_t revert_to_static_size = RevertToStaticSize;
+
+    small_vector() : small_vector(Alloc()) {}
+
+    small_vector(const Alloc &alloc)
+        : Alloc(alloc),
+          m_capacity(StaticCapacity),
+          m_dynamic_capacity(0),
+          m_dynamic_data(nullptr) {
+        m_begin = m_end = static_begin_ptr();
+    }
+
+    explicit small_vector(size_t count, const Alloc &alloc = Alloc())
+        : small_vector(alloc) {
+        resize(count);
+    }
+
+    explicit small_vector(size_t count, const T &value,
+                          const Alloc &alloc = Alloc())
+        : small_vector(alloc) {
+        assign_impl(count, value);
+    }
+
+    template <class InputIterator,
+              typename = decltype(*std::declval<InputIterator>())>
+    small_vector(InputIterator first, InputIterator last,
+                 const Alloc &alloc = Alloc())
+        : small_vector(alloc) {
+        assign_impl(first, last);
+    }
+
+    small_vector(std::initializer_list<T> l, const Alloc &alloc = Alloc())
+        : small_vector(alloc) {
+        assign_impl(l);
+    }
+
+    template <class U>
+    small_vector(gsl::span<U> c, const Alloc &alloc = Alloc())
+        : small_vector(alloc) {
+        assign_impl(c.begin(), c.end());
+    }
+
+    small_vector(const small_vector &v)
+        : small_vector(v, atraits::select_on_container_copy_construction(
+                              v.get_allocator())) {}
+
+    small_vector(const small_vector &v, const Alloc &alloc)
+        : Alloc(alloc), m_dynamic_capacity(0), m_dynamic_data(nullptr) {
+        if (v.size() > StaticCapacity) {
+            m_dynamic_capacity = v.size();
+            m_begin = m_end = m_dynamic_data =
+                atraits::allocate(get_alloc(), m_dynamic_capacity);
+            m_capacity = v.size();
+        } else {
+            m_begin = m_end = static_begin_ptr();
+            m_capacity = StaticCapacity;
+        }
+
+        for (auto p = v.m_begin; p != v.m_end; ++p) {
+            atraits::construct(get_alloc(), m_end, *p);
+            ++m_end;
+        }
+    }
+
+    small_vector(small_vector &&v)
+        : Alloc(std::move(v.get_alloc())),
+          m_capacity(v.m_capacity),
+          m_dynamic_capacity(v.m_dynamic_capacity),
+          m_dynamic_data(v.m_dynamic_data) {
+        if (v.m_begin == v.static_begin_ptr()) {
+            m_begin = m_end = static_begin_ptr();
+            for (auto p = v.m_begin; p != v.m_end; ++p) {
+                atraits::construct(get_alloc(), m_end, std::move(*p));
+                ++m_end;
+            }
+
+            v.clear();
+        } else {
+            m_begin = v.m_begin;
+            m_end = v.m_end;
+        }
+
+        v.m_dynamic_capacity = 0;
+        v.m_dynamic_data = nullptr;
+        v.m_begin = v.m_end = v.static_begin_ptr();
+        v.m_capacity = StaticCapacity;
+    }
+
+    ~small_vector() {
+        clear();
+
+        if (m_dynamic_data) {
+            atraits::deallocate(get_alloc(), m_dynamic_data,
+                                m_dynamic_capacity);
+        }
+    }
+
+    small_vector &operator=(const small_vector &v) {
+        if (this == &v) {
+            // prevent self usurp
+            return *this;
+        }
+
+        clear();
+
+        m_begin = m_end = choose_data(v.size());
+
+        for (auto p = v.m_begin; p != v.m_end; ++p) {
+            atraits::construct(get_alloc(), m_end, *p);
+            ++m_end;
+        }
+
+        update_capacity();
+
+        return *this;
+    }
+
+    small_vector &operator=(small_vector &&v) {
+        clear();
+
+        get_alloc() = std::move(v.get_alloc());
+        m_capacity = v.m_capacity;
+        m_dynamic_capacity = v.m_dynamic_capacity;
+        m_dynamic_data = v.m_dynamic_data;
+
+        if (v.m_begin == v.static_begin_ptr()) {
+            m_begin = m_end = static_begin_ptr();
+            for (auto p = v.m_begin; p != v.m_end; ++p) {
+                atraits::construct(get_alloc(), m_end, std::move(*p));
+                ++m_end;
+            }
+
+            v.clear();
+        } else {
+            m_begin = v.m_begin;
+            m_end = v.m_end;
+        }
+
+        v.m_dynamic_capacity = 0;
+        v.m_dynamic_data = nullptr;
+        v.m_begin = v.m_end = v.static_begin_ptr();
+        v.m_capacity = StaticCapacity;
+
+        return *this;
+    }
+
+    void assign(size_type count, const T &value) {
+        clear();
+        assign_impl(count, value);
+    }
+
+    template <class InputIterator,
+              typename = decltype(*std::declval<InputIterator>())>
+    void assign(InputIterator first, InputIterator last) {
+        clear();
+        assign_impl(first, last);
+    }
+
+    void assign(std::initializer_list<T> ilist) {
+        clear();
+        assign_impl(ilist);
+    }
+
+    allocator_type get_allocator() const { return get_alloc(); }
+
+    const_reference at(size_type i) const {
+        I_ITLIB_SMALL_VECTOR_BOUNDS_CHECK(i);
+        return *(m_begin + i);
+    }
+
+    reference at(size_type i) {
+        I_ITLIB_SMALL_VECTOR_BOUNDS_CHECK(i);
+        return *(m_begin + i);
+    }
+
+    const_reference operator[](size_type i) const { return at(i); }
+
+    reference operator[](size_type i) { return at(i); }
+
+    const_reference front() const { return at(0); }
+
+    reference front() { return at(0); }
+
+    const_reference back() const { return *(m_end - 1); }
+
+    reference back() { return *(m_end - 1); }
+
+    const_pointer data() const noexcept { return m_begin; }
+
+    pointer data() noexcept { return m_begin; }
+
+    // iterators
+    iterator begin() noexcept { return m_begin; }
+
+    const_iterator begin() const noexcept { return m_begin; }
+
+    const_iterator cbegin() const noexcept { return m_begin; }
+
+    iterator end() noexcept { return m_end; }
+
+    const_iterator end() const noexcept { return m_end; }
+
+    const_iterator cend() const noexcept { return m_end; }
+
+    reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
+
+    const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    const_reverse_iterator crbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
+
+    const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    const_reverse_iterator crend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    // capacity
+    bool empty() const noexcept { return m_begin == m_end; }
+
+    size_t size() const noexcept { return m_end - m_begin; }
+
+    size_t max_size() const noexcept { return atraits::max_size(); }
+
+    void reserve(size_type new_cap) {
+        if (new_cap <= m_capacity)
+            return;
+
+        auto new_buf = choose_data(new_cap);
+
+        assert(new_buf !=
+               m_begin); // should've been handled by new_cap <= m_capacity
+        assert(
+            new_buf !=
+            static_begin_ptr()); // we should never reserve into static memory
+
+        const auto s = size();
+        if (s < RevertToStaticSize) {
+            // we've allocated enough memory for the dynamic buffer but don't
+            // move there until we have to
+            return;
+        }
+
+        // now we need to transfer the existing elements into the new buffer
+        for (size_type i = 0; i < s; ++i) {
+            atraits::construct(get_alloc(), new_buf + i,
+                               std::move(*(m_begin + i)));
+        }
+
+        // free old elements
+        for (size_type i = 0; i < s; ++i) {
+            atraits::destroy(get_alloc(), m_begin + i);
+        }
+
+        if (m_begin != static_begin_ptr()) {
+            // we've moved from dyn to dyn memory, so deallocate the old one
+            atraits::deallocate(get_alloc(), m_begin, m_capacity);
+        }
+
+        m_begin = new_buf;
+        m_end = new_buf + s;
+        m_capacity = m_dynamic_capacity;
+    }
+
+    size_t capacity() const noexcept { return m_capacity; }
+
+    void shrink_to_fit() {
+        const auto s = size();
+
+        if (s == m_capacity)
+            return;
+        if (m_begin == static_begin_ptr())
+            return;
+
+        auto old_end = m_end;
+
+        if (s < StaticCapacity) {
+            // revert to static capacity
+            m_begin = m_end = static_begin_ptr();
+            m_capacity = StaticCapacity;
+        } else {
+            // alloc new smaller buffer
+            m_begin = m_end = atraits::allocate(get_alloc(), s);
+            m_capacity = s;
+        }
+
+        for (auto p = m_dynamic_data; p != old_end; ++p) {
+            atraits::construct(get_alloc(), m_end, std::move(*p));
+            ++m_end;
+            atraits::destroy(get_alloc(), p);
+        }
+
+        atraits::deallocate(get_alloc(), m_dynamic_data, m_dynamic_capacity);
+        m_dynamic_data = nullptr;
+        m_dynamic_capacity = 0;
+    }
+
+    void revert_to_static() {
+        const auto s = size();
+        if (m_begin == static_begin_ptr())
+            return; // we're already there
+        if (s > StaticCapacity)
+            return; // nothing we can do
+
+        // revert to static capacity
+        auto old_end = m_end;
+        m_begin = m_end = static_begin_ptr();
+        m_capacity = StaticCapacity;
+        for (auto p = m_dynamic_data; p != old_end; ++p) {
+            atraits::construct(get_alloc(), m_end, std::move(*p));
+            ++m_end;
+            atraits::destroy(get_alloc(), p);
+        }
+    }
+
+    // modifiers
+    void clear() noexcept {
+        for (auto p = m_begin; p != m_end; ++p) {
+            atraits::destroy(get_alloc(), p);
+        }
+
+        if (RevertToStaticSize > 0) {
+            m_begin = m_end = static_begin_ptr();
+            m_capacity = StaticCapacity;
+        } else {
+            m_end = m_begin;
+        }
+    }
+
+    iterator insert(const_iterator position, const value_type &val) {
+        auto pos = grow_at(position, 1);
+        atraits::construct(get_alloc(), pos, val);
+        return pos;
+    }
+
+    iterator insert(const_iterator position, value_type &&val) {
+        auto pos = grow_at(position, 1);
+        atraits::construct(get_alloc(), pos, std::move(val));
+        return pos;
+    }
+
+    iterator insert(const_iterator position, size_type count,
+                    const value_type &val) {
+        auto pos = grow_at(position, count);
+        for (size_type i = 0; i < count; ++i) {
+            atraits::construct(get_alloc(), pos + i, val);
+        }
+        return pos;
+    }
+
+    template <typename InputIterator,
+              typename = decltype(*std::declval<InputIterator>())>
+    iterator insert(const_iterator position, InputIterator first,
+                    InputIterator last) {
+        auto pos = grow_at(position, last - first);
+        auto np = pos;
+        for (auto p = first; p != last; ++p, ++np) {
+            atraits::construct(get_alloc(), np, *p);
+        }
+        return pos;
+    }
+
+    iterator insert(const_iterator position, std::initializer_list<T> ilist) {
+        auto pos = grow_at(position, ilist.size());
+        size_type i = 0;
+        for (auto &elem : ilist) {
+            atraits::construct(get_alloc(), pos + i, elem);
+            ++i;
+        }
+        return pos;
+    }
+
+    template <typename... Args>
+    iterator emplace(const_iterator position, Args &&...args) {
+        auto pos = grow_at(position, 1);
+        atraits::construct(get_alloc(), pos, std::forward<Args>(args)...);
+        return pos;
+    }
+
+    iterator erase(const_iterator position) { return shrink_at(position, 1); }
+
+    iterator erase(const_iterator first, const_iterator last) {
+        I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(first > last);
+        return shrink_at(first, last - first);
+    }
+
+    void push_back(const_reference val) {
+        auto pos = grow_at(m_end, 1);
+        atraits::construct(get_alloc(), pos, val);
+    }
+
+    void push_back(T &&val) {
+        auto pos = grow_at(m_end, 1);
+        atraits::construct(get_alloc(), pos, std::move(val));
+    }
+
+    template <typename... Args> reference emplace_back(Args &&...args) {
+        auto pos = grow_at(m_end, 1);
+        atraits::construct(get_alloc(), pos, std::forward<Args>(args)...);
+        return *pos;
+    }
+
+    void pop_back() { shrink_at(m_end - 1, 1); }
+
+    void resize(size_type n, const value_type &v) {
+        auto new_buf = choose_data(n);
+
+        if (new_buf == m_begin) {
+            // no special transfers needed
+
+            auto new_end = m_begin + n;
+
+            while (m_end > new_end) {
+                atraits::destroy(get_alloc(), --m_end);
+            }
+
+            while (new_end > m_end) {
+                atraits::construct(get_alloc(), m_end++, v);
+            }
+        } else {
+            // we need to transfer the elements into the new buffer
+
+            const auto s = size();
+            const auto num_transfer = n < s ? n : s;
+
+            for (size_type i = 0; i < num_transfer; ++i) {
+                atraits::construct(get_alloc(), new_buf + i,
+                                   std::move(*(m_begin + i)));
+            }
+
+            // free obsoletes
+            for (size_type i = 0; i < s; ++i) {
+                atraits::destroy(get_alloc(), m_begin + i);
+            }
+
+            // construct new elements
+            for (size_type i = num_transfer; i < n; ++i) {
+                atraits::construct(get_alloc(), new_buf + i, v);
+            }
+
+            if (m_begin != static_begin_ptr()) {
+                // we've moved from dyn to dyn memory, so deallocate the old one
+                atraits::deallocate(get_alloc(), m_begin, m_capacity);
+            }
+
+            if (new_buf == static_begin_ptr()) {
+                m_capacity = StaticCapacity;
+            } else {
+                m_capacity = m_dynamic_capacity;
+            }
+
+            m_begin = new_buf;
+            m_end = new_buf + n;
+        }
+    }
+
+    void resize(size_type n) {
+        auto new_buf = choose_data(n);
+
+        if (new_buf == m_begin) {
+            // no special transfers needed
+
+            auto new_end = m_begin + n;
+
+            while (m_end > new_end) {
+                atraits::destroy(get_alloc(), --m_end);
+            }
+
+            while (new_end > m_end) {
+                atraits::construct(get_alloc(), m_end++);
+            }
+        } else {
+            // we need to transfer the elements into the new buffer
+
+            const auto s = size();
+            const auto num_transfer = n < s ? n : s;
+
+            for (size_type i = 0; i < num_transfer; ++i) {
+                atraits::construct(get_alloc(), new_buf + i,
+                                   std::move(*(m_begin + i)));
+            }
+
+            // free obsoletes
+            for (size_type i = 0; i < n; ++i) {
+                atraits::destroy(get_alloc(), m_begin + i);
+            }
+
+            // construct new elements
+            for (size_type i = num_transfer; i < s; ++i) {
+                atraits::construct(get_alloc(), new_buf + i);
+            }
+
+            if (m_begin != static_begin_ptr()) {
+                // we've moved from dyn to dyn memory, so deallocate the old one
+                atraits::deallocate(get_alloc(), m_begin, m_capacity);
+            }
+
+            if (new_buf == static_begin_ptr()) {
+                m_capacity = StaticCapacity;
+            } else {
+                m_capacity = m_dynamic_capacity;
+            }
+
+            m_begin = new_buf;
+            m_end = new_buf + n;
+        }
+    }
+
+  private:
+    T *static_begin_ptr() {
+        return reinterpret_cast<pointer>(m_static_data + 0);
+    }
+
+    // increase the size by splicing the elements in such a way that
+    // a hole of uninitialized elements is left at position, with size num
+    // returns the (potentially new) address of the hole
+    T *grow_at(const T *cp, size_t num) {
+        auto position = const_cast<T *>(cp);
+
+        I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(position < m_begin ||
+                                             position > m_end);
+
+        const auto s = size();
+        auto new_buf = choose_data(s + num);
+
+        if (new_buf == m_begin) {
+            // no special transfers needed
+
+            m_end = m_begin + s + num;
+
+            for (auto p = m_end - num - 1; p >= position; --p) {
+                atraits::construct(get_alloc(), p + num, std::move(*p));
+                atraits::destroy(get_alloc(), p);
+            }
+
+            return position;
+        } else {
+            // we need to transfer the elements into the new buffer
+
+            position = new_buf + (position - m_begin);
+
+            auto p = m_begin;
+            auto np = new_buf;
+
+            for (; np != position; ++p, ++np) {
+                atraits::construct(get_alloc(), np, std::move(*p));
+            }
+
+            np += num;
+            for (; p != m_end; ++p, ++np) {
+                atraits::construct(get_alloc(), np, std::move(*p));
+            }
+
+            // destroy old
+            for (p = m_begin; p != m_end; ++p) {
+                atraits::destroy(get_alloc(), p);
+            }
+
+            if (m_begin != static_begin_ptr()) {
+                // we've moved from dyn to dyn memory, so deallocate the old one
+                atraits::deallocate(get_alloc(), m_begin, m_capacity);
+            }
+
+            m_capacity = m_dynamic_capacity;
+
+            m_begin = new_buf;
+            m_end = new_buf + s + num;
+
+            return position;
+        }
+    }
+
+    T *shrink_at(const T *cp, size_t num) {
+        auto position = const_cast<T *>(cp);
+
+        I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(
+            position < m_begin || position > m_end || position + num > m_end);
+
+        const auto s = size();
+        if (s - num == 0) {
+            clear();
+            return m_end;
+        }
+
+        auto new_buf = choose_data(s - num);
+
+        if (new_buf == m_begin) {
+            // no special transfers needed
+
+            for (auto p = position, np = position + num; np != m_end;
+                 ++p, ++np) {
+                atraits::destroy(get_alloc(), p);
+                atraits::construct(get_alloc(), p, std::move(*np));
+            }
+
+            for (auto p = m_end - num; p != m_end; ++p) {
+                atraits::destroy(get_alloc(), p);
+            }
+
+            m_end -= num;
+        } else {
+            // we need to transfer the elements into the new buffer
+
+            assert(new_buf ==
+                   static_begin_ptr()); // since we're shrinking that's the only
+                                        // way to have a new buffer
+
+            m_capacity = StaticCapacity;
+
+            auto p = m_begin, np = new_buf;
+            for (; p != position; ++p, ++np) {
+                atraits::construct(get_alloc(), np, std::move(*p));
+                atraits::destroy(get_alloc(), p);
+            }
+
+            for (; p != position + num; ++p) {
+                atraits::destroy(get_alloc(), p);
+            }
+
+            for (; np != new_buf + s - num; ++p, ++np) {
+                atraits::construct(get_alloc(), np, std::move(*p));
+                atraits::destroy(get_alloc(), p);
+            }
+
+            position = new_buf + (position - m_begin);
+            m_begin = new_buf;
+            m_end = np;
+        }
+
+        return ++position;
+    }
+
+    void assign_impl(size_type count, const T &value) {
+        assert(m_begin);
+        assert(m_begin == m_end);
+
+        m_begin = m_end = choose_data(count);
+        for (size_type i = 0; i < count; ++i) {
+            atraits::construct(get_alloc(), m_end, value);
+            ++m_end;
+        }
+
+        update_capacity();
+    }
+
+    template <class InputIterator>
+    void assign_impl(InputIterator first, InputIterator last) {
+        assert(m_begin);
+        assert(m_begin == m_end);
+
+        m_begin = m_end = choose_data(last - first);
+        for (auto p = first; p != last; ++p) {
+            atraits::construct(get_alloc(), m_end, *p);
+            ++m_end;
+        }
+
+        update_capacity();
+    }
+
+    void assign_impl(std::initializer_list<T> ilist) {
+        assert(m_begin);
+        assert(m_begin == m_end);
+
+        m_begin = m_end = choose_data(ilist.size());
+        for (auto &elem : ilist) {
+            atraits::construct(get_alloc(), m_end, elem);
+            ++m_end;
+        }
+
+        update_capacity();
+    }
+
+    void update_capacity() {
+        if (m_begin == static_begin_ptr()) {
+            m_capacity = StaticCapacity;
+        } else {
+            m_capacity = m_dynamic_capacity;
+        }
+    }
+
+    T *choose_data(size_t desired_capacity) {
+        if (m_begin == m_dynamic_data) {
+            // we're at the dyn buffer, so see if it needs resize or revert to
+            // static
+
+            if (desired_capacity > m_dynamic_capacity) {
+                while (m_dynamic_capacity < desired_capacity) {
+                    // grow by roughly 1.5
+                    m_dynamic_capacity *= 3;
+                    ++m_dynamic_capacity;
+                    m_dynamic_capacity /= 2;
+                }
+
+                m_dynamic_data =
+                    atraits::allocate(get_alloc(), m_dynamic_capacity);
+                return m_dynamic_data;
+            } else if (desired_capacity < RevertToStaticSize) {
+                // we're reverting to the static buffer
+                return static_begin_ptr();
+            } else {
+                // if the capacity and we don't revert to static, just do
+                // nothing
+                return m_dynamic_data;
+            }
+        } else {
+            assert(m_begin == static_begin_ptr()); // corrupt begin ptr?
+
+            if (desired_capacity > StaticCapacity) {
+                // we must move to dyn memory
+
+                // see if we have enough
+                if (desired_capacity > m_dynamic_capacity) {
+                    // we need to allocate more
+                    // we don't have anything to destroy, so we can also
+                    // deallocate the buffer
+                    if (m_dynamic_data) {
+                        atraits::deallocate(get_alloc(), m_dynamic_data,
+                                            m_dynamic_capacity);
+                    }
+
+                    m_dynamic_capacity = desired_capacity;
+                    m_dynamic_data =
+                        atraits::allocate(get_alloc(), m_dynamic_capacity);
+                }
+
+                return m_dynamic_data;
+            } else {
+                // we have enough capacity as it is
+                return static_begin_ptr();
+            }
+        }
+    }
+
+    allocator_type &get_alloc() { return static_cast<allocator_type &>(*this); }
+    const allocator_type &get_alloc() const {
+        return static_cast<const allocator_type &>(*this);
+    }
+
+    pointer m_begin;
+    pointer m_end;
+
+    size_t m_capacity;
+    typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type
+        m_static_data[StaticCapacity];
+
+    size_t m_dynamic_capacity;
+    pointer m_dynamic_data;
+};
+
+template <typename T, size_t StaticCapacity, size_t RevertToStaticSize,
+          class Alloc>
+bool operator==(
+    const small_vector<T, StaticCapacity, RevertToStaticSize, Alloc> &a,
+    const small_vector<T, StaticCapacity, RevertToStaticSize, Alloc> &b) {
+    if (a.size() != b.size()) {
+        return false;
+    }
+
+    for (size_t i = 0; i < a.size(); ++i) {
+        if (a[i] != b[i])
+            return false;
+    }
+
+    return true;
+}
+
+template <typename T, size_t StaticCapacity, size_t RevertToStaticSize,
+          class Alloc>
+bool operator!=(
+    const small_vector<T, StaticCapacity, RevertToStaticSize, Alloc> &a,
+    const small_vector<T, StaticCapacity, RevertToStaticSize, Alloc> &b) {
+    if (a.size() != b.size()) {
+        return true;
+    }
+
+    for (size_t i = 0; i < a.size(); ++i) {
+        if (a[i] != b[i])
+            return true;
+    }
+
+    return false;
+}
+
+} // namespace itlib
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 7fc7c0e5a3..9c871b18e8 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -248,15 +248,13 @@ void __tdma_all_sync_apply(std::function<void(int)> apply_func,
 }
 
 template <class T, loc_t DestLoc>
-void tdma_load_async(tensor<T, DestLoc> &dest, tensor<T, loc_t::device> &&src,
-                     [[maybe_unused]] thread_context &ctx) {
+void tdma_load_async(tensor<T, DestLoc> &dest, tensor<T, loc_t::device> &&src) {
     __tensor_copy_sync(std::forward<tensor<T, DestLoc>>(dest),
                        std::forward<tensor<T, loc_t::device>>(src));
 }
 
 template <class T, loc_t SrcLoc>
-void tdma_store_async(tensor<T, SrcLoc> &src, tensor<T, loc_t::device> &&dest,
-                      [[maybe_unused]] thread_context &ctx) {
+void tdma_store_async(tensor<T, SrcLoc> &src, tensor<T, loc_t::device> &&dest) {
     __tensor_copy_sync(std::forward<tensor<T, loc_t::device>>(dest),
                        std::forward<tensor<T, SrcLoc>>(src));
 }
@@ -298,7 +296,7 @@ void tdma_load_broadcast_async([[maybe_unused]] tensor<T, Dest> &dest,
 template <class T>
 void reduce_async_visit_func1(int visited, thread_context &ctx,
                               tensor<T, loc_t::local> &src,
-                              tensor<T, loc_t::local> &dest) {
+                              [[maybe_unused]] tensor<T, loc_t::local> &dest) {
     T *gather_span = nullptr;
     auto new_dims = dims_t(src.dimension());
     new_dims.insert(new_dims.begin(), BLOCKS * CORES);
@@ -324,7 +322,7 @@ void reduce_async_visit_func1(int visited, thread_context &ctx,
 }
 
 template <class T>
-void reduce_async_visit_func2(int visit, thread_context &ctx,
+void reduce_async_visit_func2([[maybe_unused]] int visit, thread_context &ctx,
                               tensor<T, loc_t::local> &src,
                               tensor<T, loc_t::local> &dest,
                               reduce_op_t reduce_op) {
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index da9393cbf8..f52a63ab43 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <cstddef>
-#include <gsl/gsl-lite.hpp>
+#include "../../gsl-lite.hpp"
 #include <hardware_def.h>
 #include <runtime_utils.h>
 #include "../../method_table_def.h"
diff --git a/modules/cpu/src/runtime/cmodel/include/transpose.h b/modules/cpu/src/runtime/cmodel/include/transpose.h
index c787f77d08..2979efe69a 100644
--- a/modules/cpu/src/runtime/cmodel/include/transpose.h
+++ b/modules/cpu/src/runtime/cmodel/include/transpose.h
@@ -14,7 +14,7 @@
  */
 
 #include <apply.h>
-#include <gsl/gsl-lite.hpp>
+#include "../../gsl-lite.hpp"
 #include <runtime_utils.h>
 
 namespace kernels {
diff --git a/modules/cpu/src/runtime/cmodel/include/unary.h b/modules/cpu/src/runtime/cmodel/include/unary.h
index ede62b8019..9d2b33c0f0 100644
--- a/modules/cpu/src/runtime/cmodel/include/unary.h
+++ b/modules/cpu/src/runtime/cmodel/include/unary.h
@@ -14,7 +14,7 @@
  */
 
 #include <apply.h>
-#include <gsl/gsl-lite.hpp>
+#include "../../gsl-lite.hpp"
 #include <runtime_utils.h>
 
 using namespace nncase::runtime::cpu;
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
index 7ed928c313..9a32d3345d 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
@@ -60,29 +60,25 @@ void stage1_kernel(
     MALLOC_STATIC(v42_w, float, dims_t({5504, 8192}))
 
     if (!w_loaded) {
-        tdma_load_async(v0_gamma, V0_gamma({tid * 2048}, {2048}), ctx);
-        tdma_load_async(v0_beta, V0_beta({tid * 2048}, {2048}), ctx);
-        tdma_load_async(*v2_w, V2_w({0, 2048 * tid, 0}, {64, 2048, 128}), ctx);
-        tdma_load_async(*v16_w, V16_w({0, 2048 * tid, 0}, {64, 2048, 128}),
-                        ctx);
-        tdma_load_async(*v31_w, V31_w({0, 2048 * tid, 0}, {64, 2048, 128}),
-                        ctx);
-        tdma_load_async(*v35_w, V35_w({2048 * tid, 0}, {2048, 8192}), ctx);
-        tdma_load_async(*v38_w, V38_w({2048 * tid, 0}, {2048, 22016}), ctx);
-        tdma_load_async(*v40_w, V40_w({2048 * tid, 0}, {2048, 22016}), ctx);
-        tdma_load_async(*v42_w, V42_w({5504 * tid, 0}, {5504, 8192}), ctx);
-        tdma_load_async(*v3_data, V3_data({0, 32 * tid}, {384, 32}), ctx);
-        tdma_load_async(*v11_data, V11_data({0, 32 * tid}, {384, 32}), ctx);
-        tdma_load_async(*position_ids, Position_ids({0, 48 * bid}, {1, 48}),
-                        ctx);
+        tdma_load_async(v0_gamma, V0_gamma({tid * 2048}, {2048}));
+        tdma_load_async(v0_beta, V0_beta({tid * 2048}, {2048}));
+        tdma_load_async(*v2_w, V2_w({0, 2048 * tid, 0}, {64, 2048, 128}));
+        tdma_load_async(*v16_w, V16_w({0, 2048 * tid, 0}, {64, 2048, 128}));
+        tdma_load_async(*v31_w, V31_w({0, 2048 * tid, 0}, {64, 2048, 128}));
+        tdma_load_async(*v35_w, V35_w({2048 * tid, 0}, {2048, 8192}));
+        tdma_load_async(*v38_w, V38_w({2048 * tid, 0}, {2048, 22016}));
+        tdma_load_async(*v40_w, V40_w({2048 * tid, 0}, {2048, 22016}));
+        tdma_load_async(*v42_w, V42_w({5504 * tid, 0}, {5504, 8192}));
+        tdma_load_async(*v3_data, V3_data({0, 32 * tid}, {384, 32}));
+        tdma_load_async(*v11_data, V11_data({0, 32 * tid}, {384, 32}));
+        tdma_load_async(*position_ids, Position_ids({0, 48 * bid}, {1, 48}));
         tdma_load_async(attn_mask,
-                        Attn_mask({0, 0, 48 * bid, 0}, {1, 1, 48, 384}), ctx);
+                        Attn_mask({0, 0, 48 * bid, 0}, {1, 1, 48, 384}));
 
         tdma_wait(ctx);
     }
 
-    tdma_load_async(v0, Hidden_in({0, bid * 48, tid * 2048}, {1, 48, 2048}),
-                    ctx);
+    tdma_load_async(v0, Hidden_in({0, bid * 48, tid * 2048}, {1, 48, 2048}));
     {
         tensor<float> v0_sum({1, 48});
         tensor<float> v0_sum_sqr({1, 48});
@@ -93,8 +89,7 @@ void stage1_kernel(
 #if DUMP
         {
             tdma_store_async(
-                v0, (*ImmOutputs[0])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
-                ctx);
+                v0, (*ImmOutputs[0])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}));
         }
 #endif
     } // v0 [1, 384, 8192] [1, 48@b, 8192]
@@ -108,7 +103,7 @@ void stage1_kernel(
 #if DUMP
     if (tid == 0) {
         tdma_store_async(
-            *V2, (*ImmOutputs[1])({0, 0, 48 * bid, 0}, {1, 64, 48, 128}), ctx);
+            *V2, (*ImmOutputs[1])({0, 0, 48 * bid, 0}, {1, 64, 48, 128}));
     }
     tdma_all_wait(ctx);
 #endif
@@ -123,7 +118,7 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v3, (*ImmOutputs[4])({0, 48 * bid, 32 * tid}, {1, 48, 32}), ctx);
+            v3, (*ImmOutputs[4])({0, 48 * bid, 32 * tid}, {1, 48, 32}));
     }
 #endif
     auto v4 = unsqueeze(v3); /* 1, 1, 48, 32 */
@@ -157,8 +152,7 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v10, (*ImmOutputs[2])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
-            ctx);
+            v10, (*ImmOutputs[2])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}));
     }
 #endif
 
@@ -192,8 +186,7 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v14, (*ImmOutputs[3])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
-            ctx);
+            v14, (*ImmOutputs[3])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}));
     }
 #endif
     tensor<float> &v15 = v0;
@@ -235,8 +228,7 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v22, (*ImmOutputs[5])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}),
-            ctx);
+            v22, (*ImmOutputs[5])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}));
     }
 #endif
 
@@ -254,11 +246,10 @@ void stage1_kernel(
       [1, 64, 384, 128] @ [1, 64, 128, 384] -> [1, 64, 384, 384]
       [1, 64, 48@b, 32@t] @ [1, 64, 32@t, 384] -> [1, 64, 48@b, 384]@shared
     */
-    tdma_store_async(v25, V25({0, 0, 32 * tid, 48 * bid}, {1, 64, 32, 48}),
-                     ctx);
+    tdma_store_async(v25, V25({0, 0, 32 * tid, 48 * bid}, {1, 64, 32, 48}));
     tdma_all_wait(ctx); /* for store */
     tensor<float> v25_1({1, 64, 32, 384});
-    tdma_load_async(v25_1, V25({0, 0, 32 * tid, 0}, {1, 64, 32, 384}), ctx);
+    tdma_load_async(v25_1, V25({0, 0, 32 * tid, 0}, {1, 64, 32, 384}));
     tdma_all_wait(ctx);
     tensor_block_mma_sync(v14, v25_1, *V26, false, ctx);
 
@@ -280,8 +271,7 @@ void stage1_kernel(
 #if DUMP
     {
         tdma_store_async(
-            v28, (*ImmOutputs[6])({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 384}),
-            ctx);
+            v28, (*ImmOutputs[6])({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 384}));
     }
 #endif
     /*
@@ -300,8 +290,7 @@ void stage1_kernel(
 
     /* need resplit V */
     auto v31 = (*V31)({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
-    tdma_store_async(v31, GV31({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}),
-                     ctx);
+    tdma_store_async(v31, GV31({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}));
 
     /*
       [1,64,384,384] @ [1,64,384,128] ->  [1,64,384,128]
@@ -309,16 +298,14 @@ void stage1_kernel(
     */
     tdma_all_wait(ctx);
     tensor<float> v31_resplit({1, 16, 384, 128});
-    tdma_load_async(v31_resplit, GV31({0, 16 * tid, 0, 0}, {1, 16, 384, 128}),
-                    ctx);
+    tdma_load_async(v31_resplit, GV31({0, 16 * tid, 0, 0}, {1, 16, 384, 128}));
     auto v32 = (*V32)({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
     matmul(v29, v31_resplit, v32);
     tdma_wait(ctx);
 #if DUMP
     {
         tdma_store_async(
-            v32, (*ImmOutputs[7])({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}),
-            ctx);
+            v32, (*ImmOutputs[7])({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}));
     }
 #endif
     // #if 0
@@ -342,8 +329,7 @@ void stage1_kernel(
     {
         auto v35 = (*V35)({0, 0, tid * 2048}, {1, 48, 2048});
         tdma_store_async(
-            v35, (*ImmOutputs[8])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
-            ctx);
+            v35, (*ImmOutputs[8])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}));
     }
 #endif
 
@@ -351,8 +337,7 @@ void stage1_kernel(
     [1,384,8192] +  [1,384,8192]  -> [1,384,8192]
     [1, 48@b, 2048@tid]@shared +  [1, 48@b, 2048@tid] -> [1, 48@b, 2048@tid]
      */
-    tdma_load_async(var_5, Hidden_in({0, bid * 48, tid * 2048}, {1, 48, 2048}),
-                    ctx);
+    tdma_load_async(var_5, Hidden_in({0, bid * 48, tid * 2048}, {1, 48, 2048}));
     auto v35 = (*V35)({0, 0, tid * 2048}, {1, 48, 2048});
     tensor<float> v36({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t] */
     binary(var_5, v35, v36, binary_op_t::add);
@@ -375,8 +360,7 @@ void stage1_kernel(
     {
         auto v38 = (*V38)({0, 0, 5504 * tid}, {1, 48, 5504});
         tdma_store_async(
-            v38, (*ImmOutputs[9])({0, 48 * bid, 5504 * tid}, {1, 48, 5504}),
-            ctx);
+            v38, (*ImmOutputs[9])({0, 48 * bid, 5504 * tid}, {1, 48, 5504}));
     }
 #endif
 
@@ -412,13 +396,11 @@ void stage1_kernel(
     tensor<float> v43({1, 48, 2048});
     auto v42 = (*V42)({0, 0, 2048 * tid}, {1, 48, 2048});
     binary(v36, v42, v43, binary_op_t::add);
-    tdma_store_async(v43, Hidden_in({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
-                     ctx);
+    tdma_store_async(v43, Hidden_in({0, 48 * bid, 2048 * tid}, {1, 48, 2048}));
 #if DUMP
     {
         tdma_store_async(
-            v43, (*ImmOutputs[10])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}),
-            ctx);
+            v43, (*ImmOutputs[10])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}));
     }
 #endif
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h b/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
index f3bf7d71a1..5a845739d3 100644
--- a/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
@@ -17,12 +17,11 @@ void stage1_kernel(
     tensor<float> gather_data({384, 256});
     tensor<float> output({1, 384, 256});
 
-    tdma_load_async(position_ids, std::move(Position_ids), ctx);
+    tdma_load_async(position_ids, std::move(Position_ids));
     tdma_load_async(gather_data,
-                    GatherData({0, 256 * (CORES * bid + tid)}, {384, 256}),
-                    ctx);
+                    GatherData({0, 256 * (CORES * bid + tid)}, {384, 256}));
     gather(gather_data, position_ids, output, 0);
 
     tdma_store_async(
-        output, Output({0, 0, 256 * (CORES * bid + tid)}, {1, 384, 256}), ctx);
+        output, Output({0, 0, 256 * (CORES * bid + tid)}, {1, 384, 256}));
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/kernel.h b/modules/cpu/src/runtime/cmodel/tests/head/kernel.h
index 00a4e1b378..b71794212e 100644
--- a/modules/cpu/src/runtime/cmodel/tests/head/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/head/kernel.h
@@ -16,11 +16,10 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
     tensor<float> w({2048, 32000});
 
     tdma_load_async(hidden_in,
-                    Hidden_in({0, 48 * bid, 2048 * tid}, {1, 48, 2048}), ctx);
-    tdma_load_async(w, W({2048 * tid, 0}, {2048, 32000}), ctx);
+                    Hidden_in({0, 48 * bid, 2048 * tid}, {1, 48, 2048}));
+    tdma_load_async(w, W({2048 * tid, 0}, {2048, 32000}));
     tensor_block_mma_sync(hidden_in, w, *output, false, ctx);
 
     auto output_1 = (*output)({0, 0, 8000 * tid}, {1, 48, 8000});
-    tdma_store_async(output_1, Output({0, 48 * bid, 8000 * tid}, {1, 48, 8000}),
-                     ctx);
+    tdma_store_async(output_1, Output({0, 48 * bid, 8000 * tid}, {1, 48, 8000}));
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h b/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h
index 76e9a2767b..9da86e34e5 100644
--- a/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h
@@ -14,12 +14,11 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
     tensor<float> hidden_in({1, 12, 8192});
     tensor<float> output({1, 12, 8192});
     tdma_load_async(hidden_in,
-                    Hidden_in({0, 12 * (CORES * bid + tid), 0}, {1, 12, 8192}),
-                    ctx);
+                    Hidden_in({0, 12 * (CORES * bid + tid), 0}, {1, 12, 8192}));
     tensor<float> sum({1, 12});
     tensor<float> sum_sqr({1, 12});
     reduce_sum_sqr(hidden_in, sum, sum_sqr);
     layernorm(hidden_in, sum, sum_sqr, output, 2, 8192, true);
     tdma_store_async(
-        output, Output({0, 12 * (CORES * bid + tid), 0}, {1, 12, 8192}), ctx);
+        output, Output({0, 12 * (CORES * bid + tid), 0}, {1, 12, 8192}));
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/kernel.h b/modules/cpu/src/runtime/cmodel/tests/unary/kernel.h
index b7ad95e512..95f9112fba 100755
--- a/modules/cpu/src/runtime/cmodel/tests/unary/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/unary/kernel.h
@@ -6,8 +6,7 @@ void Unary_0(tensor<float, loc_t::device> &buffer_0,
     tensor<float, loc_t::local> buffer_1({1, 12, 2048});
     tdma_load_async(
         buffer_1,
-        buffer_0({0, 0 + (12 * 4 * bid) + (12 * 1 * tid), 0}, {1, 12, 2048}),
-        ctx);
+        buffer_0({0, 0 + (12 * 4 * bid) + (12 * 1 * tid), 0}, {1, 12, 2048}));
     tensor<float, loc_t::local> buffer_2({1, 12, 2048});
     unary(buffer_1, buffer_2, unary_op_t::asin);
     // tdma_store_async(
@@ -16,6 +15,5 @@ void Unary_0(tensor<float, loc_t::device> &buffer_0,
     //     2048}), ctx);
     tdma_store_async(
         buffer_2,
-        buffer_3({0, 0 + (12 * 4 * bid) + (12 * 1 * tid), 0}, {1, 12, 2048}),
-        ctx);
+        buffer_3({0, 0 + (12 * 4 * bid) + (12 * 1 * tid), 0}, {1, 12, 2048}));
 }
diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/cpu/src/runtime/elfloader.cpp
index da4cc1f71f..84e00a6922 100644
--- a/modules/cpu/src/runtime/elfloader.cpp
+++ b/modules/cpu/src/runtime/elfloader.cpp
@@ -5,8 +5,8 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace nncase::runtime::cpu;
 
-int elfloader::invoke_elf(size_t id, uint8_t **buffers, nncase_mt_t *nncase_mt,
-                          void *data, const uint8_t *rdata) {
+int elfloader::invoke_elf(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
 
     check(el_init(&ctx_), "initialising");
 
@@ -33,10 +33,7 @@ int elfloader::invoke_elf(size_t id, uint8_t **buffers, nncase_mt_t *nncase_mt,
     // printf("Binary entrypoint is %" PRIxPTR "; invoking %p\n",
     //        (uintptr_t)ctx_.ehdr.e_entry, (void *)epaddr);
 
-    nncase::runtime::cpu::thread_pool::paddr_offset = (uintptr_t)buf_;
-    nncase_mt->thread_start = thread_pool::thread_start;
-    nncase_mt->thread_end = thread_pool::thread_end;
-    ep(id, buffers, nncase_mt, data, rdata);
+    ep(hw_ctx_impl, rt_util_mt, nncase_mt_impl, inputs);
 
     free(ptr_);
 
diff --git a/modules/cpu/src/runtime/elfloader.h b/modules/cpu/src/runtime/elfloader.h
index 0f9d73e5f7..f37fbf6c74 100644
--- a/modules/cpu/src/runtime/elfloader.h
+++ b/modules/cpu/src/runtime/elfloader.h
@@ -1,5 +1,5 @@
 #pragma once
-#include "cpu_common.h"
+#include "hardware_def.h"
 #include "elfload.h"
 #include <inttypes.h>
 #include <math.h>
@@ -9,13 +9,13 @@
 #include <string.h>
 #if defined(__linux__)
 #include <sys/mman.h>
+#include "method_table_impl.h"
 #endif
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
-typedef void (*entrypoint_t)(size_t id, uint8_t **buffers,
-                             nncase_mt_t *nncase_mt, void *data,
-                             const uint8_t *rdata);
+typedef void (*entrypoint_t)(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs);
 
 class elfloader {
   public:
@@ -50,8 +50,8 @@ class elfloader {
         }
     }
 
-    int invoke_elf(size_t id, uint8_t **buffers, nncase_mt_t *nncase_mt,
-                   void *data, const uint8_t *rdata);
+    int invoke_elf(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs);
 
   private:
     void *ptr_;
diff --git a/modules/cpu/src/runtime/gsl-lite.hpp b/modules/cpu/src/runtime/gsl-lite.hpp
new file mode 100644
index 0000000000..859f9ccc58
--- /dev/null
+++ b/modules/cpu/src/runtime/gsl-lite.hpp
@@ -0,0 +1,4156 @@
+//
+// gsl-lite is based on GSL: Guidelines Support Library.
+// For more information see https://github.com/gsl-lite/gsl-lite
+//
+// Copyright (c) 2015-2018 Martin Moene
+// Copyright (c) 2015-2018 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#ifndef GSL_GSL_LITE_HPP_INCLUDED
+#define GSL_GSL_LITE_HPP_INCLUDED
+
+#include <algorithm> // for swap() [pre-C++11], equal(), lexicographical_compare()
+#include <exception> // for exception, terminate(), uncaught_exceptions()
+#include <iterator>  // for data(), size(), reverse_iterator<>, iterator_traits<>
+#include <limits>
+#include <memory>    // for addressof(), unique_ptr<>, shared_ptr<>
+#include <iosfwd>    // for basic_ostream<>
+#include <ios>       // for ios_base, streamsize
+#include <stdexcept> // for logic_error
+#include <string>
+#include <utility>   // for move(), forward<>(), swap()
+#include <cstddef>   // for size_t, ptrdiff_t, nullptr_t
+
+#define  gsl_lite_MAJOR  0
+#define  gsl_lite_MINOR  37
+#define  gsl_lite_PATCH  0
+
+#define  gsl_lite_VERSION  gsl_STRINGIFY(gsl_lite_MAJOR) "." gsl_STRINGIFY(gsl_lite_MINOR) "." gsl_STRINGIFY(gsl_lite_PATCH)
+
+// gsl-lite backward compatibility:
+
+#if !defined( gsl_CONFIG_DEFAULTS_VERSION )
+# define gsl_CONFIG_DEFAULTS_VERSION gsl_lite_MAJOR
+#endif
+
+#ifdef gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR
+# define gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR  gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR
+# pragma message ("gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR is deprecated since gsl-lite 0.7; replace with gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR, or consider span(with_container, cont).")
+#endif
+
+#if defined( gsl_CONFIG_CONTRACT_LEVEL_ON )
+# pragma message ("gsl_CONFIG_CONTRACT_LEVEL_ON is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_ON.")
+# define gsl_CONFIG_CONTRACT_CHECKING_ON
+#endif
+#if defined( gsl_CONFIG_CONTRACT_LEVEL_OFF )
+# pragma message ("gsl_CONFIG_CONTRACT_LEVEL_OFF is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_OFF.")
+# define gsl_CONFIG_CONTRACT_CHECKING_OFF
+#endif
+#if   defined( gsl_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY )
+# pragma message ("gsl_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF.")
+# define gsl_CONFIG_CONTRACT_CHECKING_ON
+# define gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF
+#elif defined( gsl_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY )
+# pragma message ("gsl_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF.")
+# define gsl_CONFIG_CONTRACT_CHECKING_ON
+# define gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF
+#endif
+
+// M-GSL compatibility:
+
+#if defined( GSL_THROW_ON_CONTRACT_VIOLATION )
+# define gsl_CONFIG_CONTRACT_VIOLATION_THROWS
+#endif
+
+#if defined( GSL_TERMINATE_ON_CONTRACT_VIOLATION )
+# define gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES
+#endif
+
+#if defined( GSL_UNENFORCED_ON_CONTRACT_VIOLATION )
+# define gsl_CONFIG_CONTRACT_CHECKING_OFF
+#endif
+
+// Configuration: Features
+
+#ifndef  gsl_FEATURE_WITH_CONTAINER_TO_STD
+# define gsl_FEATURE_WITH_CONTAINER_TO_STD  99
+#endif
+
+#ifndef  gsl_FEATURE_MAKE_SPAN_TO_STD
+# define gsl_FEATURE_MAKE_SPAN_TO_STD  99
+#endif
+
+#ifndef  gsl_FEATURE_BYTE_SPAN_TO_STD
+# define gsl_FEATURE_BYTE_SPAN_TO_STD  99
+#endif
+
+#ifndef  gsl_FEATURE_IMPLICIT_MACRO
+# define gsl_FEATURE_IMPLICIT_MACRO  0
+#endif
+
+#ifndef  gsl_FEATURE_OWNER_MACRO
+# define gsl_FEATURE_OWNER_MACRO  (gsl_CONFIG_DEFAULTS_VERSION == 0)
+#endif
+
+#ifndef  gsl_FEATURE_EXPERIMENTAL_RETURN_GUARD
+# define gsl_FEATURE_EXPERIMENTAL_RETURN_GUARD  0
+#endif
+
+#ifndef  gsl_FEATURE_GSL_LITE_NAMESPACE
+# define gsl_FEATURE_GSL_LITE_NAMESPACE  (gsl_CONFIG_DEFAULTS_VERSION >= 1)
+#endif
+
+// Configuration: Other
+
+#if defined( gsl_CONFIG_TRANSPARENT_NOT_NULL ) && gsl_CONFIG_TRANSPARENT_NOT_NULL && defined( gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF )
+# error configuration option gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF is meaningless if gsl_CONFIG_TRANSPARENT_NOT_NULL=1
+#endif
+
+#ifndef  gsl_CONFIG_DEPRECATE_TO_LEVEL
+# if gsl_CONFIG_DEFAULTS_VERSION >= 1
+#  define gsl_CONFIG_DEPRECATE_TO_LEVEL  6
+# else
+#  define gsl_CONFIG_DEPRECATE_TO_LEVEL  0
+# endif
+#endif
+
+#ifndef  gsl_CONFIG_SPAN_INDEX_TYPE
+# define gsl_CONFIG_SPAN_INDEX_TYPE  std::size_t
+#endif
+
+#ifndef  gsl_CONFIG_INDEX_TYPE
+# if gsl_CONFIG_DEFAULTS_VERSION >= 1
+// p0122r3 uses std::ptrdiff_t
+#  define gsl_CONFIG_INDEX_TYPE  std::ptrdiff_t
+# else
+#  define gsl_CONFIG_INDEX_TYPE  gsl_CONFIG_SPAN_INDEX_TYPE
+# endif
+#endif
+
+#ifndef  gsl_CONFIG_NOT_NULL_EXPLICIT_CTOR
+# define gsl_CONFIG_NOT_NULL_EXPLICIT_CTOR  (gsl_CONFIG_DEFAULTS_VERSION >= 1)
+#endif
+
+#ifndef  gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF
+# define gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF  0
+#endif
+
+#ifndef  gsl_CONFIG_TRANSPARENT_NOT_NULL
+# define gsl_CONFIG_TRANSPARENT_NOT_NULL  (gsl_CONFIG_DEFAULTS_VERSION >= 1)
+#endif
+
+#ifndef  gsl_CONFIG_CONFIRMS_COMPILATION_ERRORS
+# define gsl_CONFIG_CONFIRMS_COMPILATION_ERRORS  0
+#endif
+
+#ifndef  gsl_CONFIG_ALLOWS_SPAN_COMPARISON
+# define gsl_CONFIG_ALLOWS_SPAN_COMPARISON  (gsl_CONFIG_DEFAULTS_VERSION == 0)
+#endif
+
+#ifndef  gsl_CONFIG_ALLOWS_NONSTRICT_SPAN_COMPARISON
+# define gsl_CONFIG_ALLOWS_NONSTRICT_SPAN_COMPARISON  1
+#endif
+
+#ifndef  gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR
+# define gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR  0
+#endif
+
+#ifndef  gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION
+# define gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION  (gsl_CONFIG_DEFAULTS_VERSION >= 1)
+#endif
+
+#if 1 < defined( gsl_CONFIG_CONTRACT_CHECKING_AUDIT ) + defined( gsl_CONFIG_CONTRACT_CHECKING_ON ) + defined( gsl_CONFIG_CONTRACT_CHECKING_OFF )
+# error only one of gsl_CONFIG_CONTRACT_CHECKING_AUDIT, gsl_CONFIG_CONTRACT_CHECKING_ON, and gsl_CONFIG_CONTRACT_CHECKING_OFF may be defined
+#endif
+#if 1 < defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS ) + defined( gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES ) + defined( gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER )
+# error only one of gsl_CONFIG_CONTRACT_VIOLATION_THROWS, gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES, and gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER may be defined
+#endif
+#if 1 < defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME ) + defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE )
+# error only one of gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME and gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE may be defined
+#endif
+
+// C++ language version detection (C++20 is speculative):
+// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
+
+#ifndef   gsl_CPLUSPLUS
+# if defined(_MSVC_LANG ) && !defined(__clang__)
+#  define gsl_CPLUSPLUS  (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
+# else
+#  define gsl_CPLUSPLUS  __cplusplus
+# endif
+#endif
+
+#define gsl_CPP98_OR_GREATER  ( gsl_CPLUSPLUS >= 199711L )
+#define gsl_CPP11_OR_GREATER  ( gsl_CPLUSPLUS >= 201103L )
+#define gsl_CPP14_OR_GREATER  ( gsl_CPLUSPLUS >= 201402L )
+#define gsl_CPP17_OR_GREATER  ( gsl_CPLUSPLUS >= 201703L )
+#define gsl_CPP20_OR_GREATER  ( gsl_CPLUSPLUS >= 202000L )
+
+// C++ language version (represent 98 as 3):
+
+#define gsl_CPLUSPLUS_V  ( gsl_CPLUSPLUS / 100 - (gsl_CPLUSPLUS > 200000 ? 2000 : 1994) )
+
+// half-open range [lo..hi):
+#define gsl_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
+
+// Compiler versions:
+
+// MSVC++  6.0  _MSC_VER == 1200  gsl_COMPILER_MSVC_VERSION ==  60  (Visual Studio 6.0)
+// MSVC++  7.0  _MSC_VER == 1300  gsl_COMPILER_MSVC_VERSION ==  70  (Visual Studio .NET 2002)
+// MSVC++  7.1  _MSC_VER == 1310  gsl_COMPILER_MSVC_VERSION ==  71  (Visual Studio .NET 2003)
+// MSVC++  8.0  _MSC_VER == 1400  gsl_COMPILER_MSVC_VERSION ==  80  (Visual Studio 2005)
+// MSVC++  9.0  _MSC_VER == 1500  gsl_COMPILER_MSVC_VERSION ==  90  (Visual Studio 2008)
+// MSVC++ 10.0  _MSC_VER == 1600  gsl_COMPILER_MSVC_VERSION == 100  (Visual Studio 2010)
+// MSVC++ 11.0  _MSC_VER == 1700  gsl_COMPILER_MSVC_VERSION == 110  (Visual Studio 2012)
+// MSVC++ 12.0  _MSC_VER == 1800  gsl_COMPILER_MSVC_VERSION == 120  (Visual Studio 2013)
+// MSVC++ 14.0  _MSC_VER == 1900  gsl_COMPILER_MSVC_VERSION == 140  (Visual Studio 2015)
+// MSVC++ 14.1  _MSC_VER >= 1910  gsl_COMPILER_MSVC_VERSION == 141  (Visual Studio 2017)
+// MSVC++ 14.2  _MSC_VER >= 1920  gsl_COMPILER_MSVC_VERSION == 142  (Visual Studio 2019)
+
+#if defined(_MSC_VER ) && !defined(__clang__)
+# define gsl_COMPILER_MSVC_VER           (_MSC_VER )
+# define gsl_COMPILER_MSVC_VERSION       (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )
+# define gsl_COMPILER_MSVC_VERSION_FULL  (_MSC_VER - 100 * ( 5 + (_MSC_VER < 1900 ) ) )
+#else
+# define gsl_COMPILER_MSVC_VER           0
+# define gsl_COMPILER_MSVC_VERSION       0
+# define gsl_COMPILER_MSVC_VERSION_FULL  0
+#endif
+
+#define gsl_COMPILER_VERSION( major, minor, patch ) ( 10 * ( 10 * (major) + (minor) ) + (patch) )
+
+// AppleClang  7.0.0  __apple_build_version__ ==  7000172  gsl_COMPILER_APPLECLANG_VERSION ==  700  (Xcode 7.0, 7.0.1)          (LLVM 3.7.0)
+// AppleClang  7.0.0  __apple_build_version__ ==  7000176  gsl_COMPILER_APPLECLANG_VERSION ==  700  (Xcode 7.1)                 (LLVM 3.7.0)
+// AppleClang  7.0.2  __apple_build_version__ ==  7000181  gsl_COMPILER_APPLECLANG_VERSION ==  702  (Xcode 7.2, 7.2.1)          (LLVM 3.7.0)
+// AppleClang  7.3.0  __apple_build_version__ ==  7030029  gsl_COMPILER_APPLECLANG_VERSION ==  730  (Xcode 7.3)                 (LLVM 3.8.0)
+// AppleClang  7.3.0  __apple_build_version__ ==  7030031  gsl_COMPILER_APPLECLANG_VERSION ==  730  (Xcode 7.3.1)               (LLVM 3.8.0)
+// AppleClang  8.0.0  __apple_build_version__ ==  8000038  gsl_COMPILER_APPLECLANG_VERSION ==  800  (Xcode 8.0)                 (LLVM 3.9.0)
+// AppleClang  8.0.0  __apple_build_version__ ==  8000042  gsl_COMPILER_APPLECLANG_VERSION ==  800  (Xcode 8.1, 8.2, 8.2.1)     (LLVM 3.9.0)
+// AppleClang  8.1.0  __apple_build_version__ ==  8020038  gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3)                 (LLVM 3.9.0)
+// AppleClang  8.1.0  __apple_build_version__ ==  8020041  gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3.1)               (LLVM 3.9.0)
+// AppleClang  8.1.0  __apple_build_version__ ==  8020042  gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3.2, 8.3.3)        (LLVM 3.9.0)
+// AppleClang  9.0.0  __apple_build_version__ ==  9000037  gsl_COMPILER_APPLECLANG_VERSION ==  900  (Xcode 9.0)                 (LLVM 4.0.0?)
+// AppleClang  9.0.0  __apple_build_version__ ==  9000038  gsl_COMPILER_APPLECLANG_VERSION ==  900  (Xcode 9.1)                 (LLVM 4.0.0?)
+// AppleClang  9.0.0  __apple_build_version__ ==  9000039  gsl_COMPILER_APPLECLANG_VERSION ==  900  (Xcode 9.2)                 (LLVM 4.0.0?)
+// AppleClang  9.1.0  __apple_build_version__ ==  9020039  gsl_COMPILER_APPLECLANG_VERSION ==  910  (Xcode 9.3, 9.3.1)          (LLVM 5.0.2?)
+// AppleClang  9.1.0  __apple_build_version__ ==  9020039  gsl_COMPILER_APPLECLANG_VERSION ==  910  (Xcode 9.4, 9.4.1)          (LLVM 5.0.2?)
+// AppleClang 10.0.0  __apple_build_version__ == 10001145  gsl_COMPILER_APPLECLANG_VERSION == 1000  (Xcode 10.0, 10.1)          (LLVM 6.0.1?)
+// AppleClang 10.0.1  __apple_build_version__ == 10010046  gsl_COMPILER_APPLECLANG_VERSION == 1001  (Xcode 10.2, 10.2.1, 10.3)  (LLVM 7.0.0?)
+// AppleClang 11.0.0  __apple_build_version__ == 11000033  gsl_COMPILER_APPLECLANG_VERSION == 1100  (Xcode 11.1, 11.2, 11.3)    (LLVM 8.0.0?)
+
+#if defined( __apple_build_version__ )
+# define gsl_COMPILER_APPLECLANG_VERSION gsl_COMPILER_VERSION( __clang_major__, __clang_minor__, __clang_patchlevel__ )
+# define gsl_COMPILER_CLANG_VERSION 0
+#elif defined( __clang__ )
+# define gsl_COMPILER_APPLECLANG_VERSION 0
+# define gsl_COMPILER_CLANG_VERSION gsl_COMPILER_VERSION( __clang_major__, __clang_minor__, __clang_patchlevel__ )
+#else
+# define gsl_COMPILER_APPLECLANG_VERSION 0
+# define gsl_COMPILER_CLANG_VERSION 0
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__)
+# define gsl_COMPILER_GNUC_VERSION gsl_COMPILER_VERSION( __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__ )
+#else
+# define gsl_COMPILER_GNUC_VERSION 0
+#endif
+
+// Compiler non-strict aliasing:
+
+#if defined(__clang__) || defined(__GNUC__)
+# define gsl_may_alias  __attribute__((__may_alias__))
+#else
+# define gsl_may_alias
+#endif
+
+// Presence of gsl, language and library features:
+
+#define gsl_IN_STD( v )  ( ((v) == 98 ? 3 : (v)) >= gsl_CPLUSPLUS_V )
+
+#define gsl_DEPRECATE_TO_LEVEL( level )  ( level <= gsl_CONFIG_DEPRECATE_TO_LEVEL )
+#define gsl_FEATURE_TO_STD(   feature )  ( gsl_IN_STD( gsl_FEATURE( feature##_TO_STD ) ) )
+#define gsl_FEATURE(          feature )  ( gsl_FEATURE_##feature )
+#define gsl_CONFIG(           feature )  ( gsl_CONFIG_##feature )
+#define gsl_HAVE(             feature )  ( gsl_HAVE_##feature )
+
+// Presence of wide character support:
+
+#ifdef __DJGPP__
+# define gsl_HAVE_WCHAR 0
+#else
+# define gsl_HAVE_WCHAR 1
+#endif
+
+// Presence of language & library features:
+
+#if gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 500) || gsl_BETWEEN(gsl_COMPILER_CLANG_VERSION, 1, 360) || gsl_COMPILER_APPLECLANG_VERSION
+# ifdef __EXCEPTIONS
+#  define gsl_HAVE_EXCEPTIONS  1
+# else
+#  define gsl_HAVE_EXCEPTIONS  0
+# endif // __EXCEPTIONS
+#elif gsl_COMPILER_GNUC_VERSION >= 500 || gsl_COMPILER_CLANG_VERSION >= 500
+# ifdef __cpp_exceptions
+#  define gsl_HAVE_EXCEPTIONS  1
+# else
+#  define gsl_HAVE_EXCEPTIONS  0
+# endif // __cpp_exceptions
+#elif gsl_COMPILER_MSVC_VERSION
+# ifdef _CPPUNWIND
+#  define gsl_HAVE_EXCEPTIONS  1
+# else
+#  define gsl_HAVE_EXCEPTIONS  0
+# endif // _CPPUNWIND
+#else
+// For all other compilers, assume exceptions are always enabled.
+# define  gsl_HAVE_EXCEPTIONS  1
+#endif
+
+#if defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS ) && !gsl_HAVE( EXCEPTIONS )
+# error Cannot use gsl_CONFIG_CONTRACT_VIOLATION_THROWS if exceptions are disabled.
+#endif // defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS ) && !gsl_HAVE( EXCEPTIONS )
+
+#ifdef _HAS_CPP0X
+# define gsl_HAS_CPP0X  _HAS_CPP0X
+#else
+# define gsl_HAS_CPP0X  0
+#endif
+
+#define gsl_CPP11_100  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1600)
+#define gsl_CPP11_110  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1700)
+#define gsl_CPP11_120  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1800)
+#define gsl_CPP11_140  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
+
+#define gsl_CPP14_000  (gsl_CPP14_OR_GREATER)
+#define gsl_CPP14_120  (gsl_CPP14_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1800)
+#define gsl_CPP14_140  (gsl_CPP14_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
+
+#define gsl_CPP17_000  (gsl_CPP17_OR_GREATER)
+#define gsl_CPP17_140  (gsl_CPP17_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
+
+#define gsl_CPP11_140_CPP0X_90   (gsl_CPP11_140 || (gsl_COMPILER_MSVC_VER >= 1500 && gsl_HAS_CPP0X))
+#define gsl_CPP11_140_CPP0X_100  (gsl_CPP11_140 || (gsl_COMPILER_MSVC_VER >= 1600 && gsl_HAS_CPP0X))
+
+// Presence of C++11 language features:
+
+#define gsl_HAVE_AUTO                   gsl_CPP11_100
+#define gsl_HAVE_NULLPTR                gsl_CPP11_100
+#define gsl_HAVE_RVALUE_REFERENCE       gsl_CPP11_100
+#define gsl_HAVE_FUNCTION_REF_QUALIFIER ( gsl_CPP14_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 481 ) )
+
+#define gsl_HAVE_ENUM_CLASS             gsl_CPP11_110
+
+#define gsl_HAVE_ALIAS_TEMPLATE         gsl_CPP11_120
+#define gsl_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG  gsl_CPP11_120
+#define gsl_HAVE_EXPLICIT               gsl_CPP11_120
+#define gsl_HAVE_INITIALIZER_LIST       gsl_CPP11_120
+#define gsl_HAVE_VARIADIC_TEMPLATE      gsl_CPP11_120
+#define gsl_HAVE_IS_DELETE              gsl_CPP11_120
+
+#define gsl_HAVE_CONSTEXPR_11           gsl_CPP11_140
+#define gsl_HAVE_IS_DEFAULT             gsl_CPP11_140
+#define gsl_HAVE_NOEXCEPT               gsl_CPP11_140
+#define gsl_HAVE_NORETURN               ( gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 480 ) )
+
+#define gsl_HAVE_EXPRESSION_SFINAE      gsl_CPP11_140
+
+#if gsl_CPP11_OR_GREATER
+// see above
+#endif
+
+// Presence of C++14 language features:
+
+#define gsl_HAVE_CONSTEXPR_14           ( gsl_CPP14_000 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 600 ) )
+#define gsl_HAVE_DECLTYPE_AUTO          gsl_CPP14_140
+#define gsl_HAVE_DEPRECATED             ( gsl_CPP14_140 && ! gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 142 ) )
+
+// Presence of C++17 language features:
+// MSVC: template parameter deduction guides since Visual Studio 2017 v15.7
+
+#define gsl_HAVE_ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE  gsl_CPP17_000
+#define gsl_HAVE_DEDUCTION_GUIDES       ( gsl_CPP17_000 && ! gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION_FULL, 1, 1414 ) )
+#define gsl_HAVE_NODISCARD              gsl_CPP17_000
+#define gsl_HAVE_CONSTEXPR_17           gsl_CPP17_OR_GREATER
+
+// Presence of C++20 language features:
+
+#define gsl_HAVE_CONSTEXPR_20           gsl_CPP20_OR_GREATER
+
+// Presence of C++ library features:
+
+#define gsl_HAVE_ADDRESSOF              gsl_CPP17_000
+#define gsl_HAVE_ARRAY                  gsl_CPP11_110
+#define gsl_HAVE_TYPE_TRAITS            gsl_CPP11_110
+#define gsl_HAVE_TR1_TYPE_TRAITS        gsl_CPP11_110
+
+#define gsl_HAVE_CONTAINER_DATA_METHOD  gsl_CPP11_140_CPP0X_90
+#define gsl_HAVE_STD_DATA               gsl_CPP17_000
+#ifdef __cpp_lib_ssize
+# define gsl_HAVE_STD_SSIZE             1
+#else
+# define gsl_HAVE_STD_SSIZE             ( gsl_COMPILER_GNUC_VERSION >= 1000 && __cplusplus > 201703L )
+#endif
+
+#define gsl_HAVE_SIZED_TYPES            gsl_CPP11_140
+
+#define gsl_HAVE_MAKE_SHARED            gsl_CPP11_140_CPP0X_100
+#define gsl_HAVE_SHARED_PTR             gsl_CPP11_140_CPP0X_100
+#define gsl_HAVE_UNIQUE_PTR             gsl_CPP11_140_CPP0X_100
+
+#define gsl_HAVE_MAKE_UNIQUE            gsl_CPP14_120
+
+#define gsl_HAVE_UNCAUGHT_EXCEPTIONS    gsl_CPP17_140
+
+#define gsl_HAVE_ADD_CONST              gsl_HAVE_TYPE_TRAITS
+#define gsl_HAVE_INTEGRAL_CONSTANT      gsl_HAVE_TYPE_TRAITS
+#define gsl_HAVE_REMOVE_CONST           gsl_HAVE_TYPE_TRAITS
+#define gsl_HAVE_REMOVE_REFERENCE       gsl_HAVE_TYPE_TRAITS
+#define gsl_HAVE_REMOVE_CVREF           gsl_CPP20_OR_GREATER
+
+#define gsl_HAVE_TR1_ADD_CONST          gsl_HAVE_TR1_TYPE_TRAITS
+#define gsl_HAVE_TR1_INTEGRAL_CONSTANT  gsl_HAVE_TR1_TYPE_TRAITS
+#define gsl_HAVE_TR1_REMOVE_CONST       gsl_HAVE_TR1_TYPE_TRAITS
+#define gsl_HAVE_TR1_REMOVE_REFERENCE   gsl_HAVE_TR1_TYPE_TRAITS
+
+// C++ feature usage:
+
+#if gsl_HAVE( ADDRESSOF )
+# define gsl_ADDRESSOF(x)  std::addressof(x)
+#else
+# define gsl_ADDRESSOF(x)  (&x)
+#endif
+
+#if gsl_HAVE( CONSTEXPR_11 )
+# define gsl_constexpr constexpr
+#else
+# define gsl_constexpr /*constexpr*/
+#endif
+
+#if gsl_HAVE( CONSTEXPR_14 )
+# define gsl_constexpr14 constexpr
+#else
+# define gsl_constexpr14 /*constexpr*/
+#endif
+
+#if gsl_HAVE( CONSTEXPR_17 )
+# define gsl_constexpr17 constexpr
+#else
+# define gsl_constexpr17 /*constexpr*/
+#endif
+
+#if gsl_HAVE( CONSTEXPR_20 )
+# define gsl_constexpr20 constexpr
+#else
+# define gsl_constexpr20 /*constexpr*/
+#endif
+
+#if gsl_HAVE( EXPLICIT )
+# define gsl_explicit explicit
+#else
+# define gsl_explicit /*explicit*/
+#endif
+
+#if gsl_FEATURE( IMPLICIT_MACRO )
+# define implicit /*implicit*/
+#endif
+
+#if gsl_HAVE( IS_DELETE )
+# define gsl_is_delete = delete
+#else
+# define gsl_is_delete
+#endif
+
+#if gsl_HAVE( IS_DELETE )
+# define gsl_is_delete_access public
+#else
+# define gsl_is_delete_access private
+#endif
+
+#if !gsl_HAVE( NOEXCEPT ) || defined( gsl_TESTING_ )
+# define gsl_noexcept /*noexcept*/
+#else
+# define gsl_noexcept noexcept
+#endif
+
+#if gsl_HAVE( NULLPTR )
+# define gsl_nullptr  nullptr
+#else
+# define gsl_nullptr  NULL
+#endif
+
+#if gsl_HAVE( NODISCARD )
+# define gsl_NODISCARD [[nodiscard]]
+#else
+# define gsl_NODISCARD
+#endif
+
+#if gsl_HAVE( NORETURN )
+# define gsl_NORETURN [[noreturn]]
+#elif defined(_MSC_VER)
+# define gsl_NORETURN __declspec(noreturn)
+#else
+# define gsl_NORETURN
+#endif
+
+#if gsl_HAVE( DEPRECATED ) && !defined( gsl_TESTING_ )
+# define gsl_DEPRECATED             [[deprecated]]
+# define gsl_DEPRECATED_MSG( msg )  [[deprecated( msg )]]
+#else
+# define gsl_DEPRECATED
+# define gsl_DEPRECATED_MSG( msg )
+#endif
+
+#if gsl_HAVE( TYPE_TRAITS )
+
+#define gsl_DEFINE_ENUM_BITMASK_OPERATORS_( ENUM )                    \
+    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM                   \
+    operator~( ENUM val ) gsl_noexcept                                \
+    {                                                                 \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
+        return ENUM( ~U( val ) );                                     \
+    }                                                                 \
+    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM                   \
+    operator|( ENUM lhs, ENUM rhs ) gsl_noexcept                      \
+    {                                                                 \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
+        return ENUM( U( lhs ) | U( rhs ) );                           \
+    }                                                                 \
+    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM                   \
+    operator&( ENUM lhs, ENUM rhs ) gsl_noexcept                      \
+    {                                                                 \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
+        return ENUM( U( lhs ) & U( rhs ) );                           \
+    }                                                                 \
+    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM                   \
+    operator^( ENUM lhs, ENUM rhs ) gsl_noexcept                      \
+    {                                                                 \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
+        return ENUM( U( lhs ) ^ U( rhs ) );                           \
+    }                                                                 \
+    gsl_api inline gsl_constexpr14 ENUM &                             \
+    operator|=( ENUM & lhs, ENUM rhs ) gsl_noexcept                   \
+    {                                                                 \
+        return lhs = lhs | rhs;                                       \
+    }                                                                 \
+    gsl_api inline gsl_constexpr14 ENUM &                             \
+    operator&=( ENUM & lhs, ENUM rhs ) gsl_noexcept                   \
+    {                                                                 \
+        return lhs = lhs & rhs;                                       \
+    }                                                                 \
+    gsl_api inline gsl_constexpr14 ENUM &                             \
+    operator^=( ENUM & lhs, ENUM rhs ) gsl_noexcept                   \
+    {                                                                 \
+        return lhs = lhs ^ rhs;                                       \
+    }
+
+#define gsl_DEFINE_ENUM_RELATIONAL_OPERATORS_( ENUM )                 \
+    gsl_NODISCARD gsl_api inline gsl_constexpr bool                   \
+    operator<( ENUM lhs, ENUM rhs ) gsl_noexcept                      \
+    {                                                                 \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
+        return U( lhs ) < U( rhs );                                   \
+    }                                                                 \
+    gsl_NODISCARD gsl_api inline gsl_constexpr bool                   \
+    operator>( ENUM lhs, ENUM rhs ) gsl_noexcept                      \
+    {                                                                 \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
+        return U( lhs ) > U( rhs );                                   \
+    }                                                                 \
+    gsl_NODISCARD gsl_api inline gsl_constexpr bool                   \
+    operator<=( ENUM lhs, ENUM rhs ) gsl_noexcept                     \
+    {                                                                 \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
+        return U( lhs ) <= U( rhs );                                  \
+    }                                                                 \
+    gsl_NODISCARD gsl_api inline gsl_constexpr bool                   \
+    operator>=( ENUM lhs, ENUM rhs ) gsl_noexcept                     \
+    {                                                                 \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
+        return U( lhs ) >= U( rhs );                                  \
+    }
+
+    //
+    // Defines bitmask operators `|`, `&`, `^`, `~`, `|=`, `&=`, and `^=` for the given enum type.
+    //ᅟ
+    //ᅟ    enum class Vegetables {
+    //ᅟ        tomato   = 0b001,
+    //ᅟ        onion    = 0b010,
+    //ᅟ        eggplant = 0b100
+    //ᅟ    };
+    //ᅟ    gsl_DEFINE_ENUM_BITMASK_OPERATORS( Vegetables )
+    //
+#define gsl_DEFINE_ENUM_BITMASK_OPERATORS( ENUM ) gsl_DEFINE_ENUM_BITMASK_OPERATORS_( ENUM )
+
+    //
+    // Defines relational operators `<`, `>`, `<=`, `>=` for the given enum type.
+    //ᅟ
+    //ᅟ    enum class OperatorPrecedence {
+    //ᅟ        additive = 0,
+    //ᅟ        multiplicative = 1,
+    //ᅟ        power = 2
+    //ᅟ    };
+    //ᅟ    gsl_DEFINE_ENUM_RELATIONAL_OPERATORS( OperatorPrecedence )
+    //
+#define gsl_DEFINE_ENUM_RELATIONAL_OPERATORS( ENUM ) gsl_DEFINE_ENUM_RELATIONAL_OPERATORS_( ENUM )
+
+#endif // gsl_HAVE( TYPE_TRAITS )
+
+#define gsl_DIMENSION_OF( a ) ( sizeof(a) / sizeof(0[a]) )
+
+
+// Method enabling (C++98, VC120 (VS2013) cannot use __VA_ARGS__)
+
+#if gsl_HAVE( EXPRESSION_SFINAE )
+# define gsl_DECLTYPE_(T, EXPR) decltype( EXPR )
+#else
+# define gsl_DECLTYPE_(T, EXPR) T
+#endif
+
+// NOTE: When using SFINAE in gsl-lite, please note that overloads of function templates must always use SFINAE with non-type default arguments
+//       as explained in https://en.cppreference.com/w/cpp/types/enable_if#Notes. `gsl_ENABLE_IF_()` implements graceful fallback to default
+//       type arguments (for compilers that don't support non-type default arguments); please verify that this is appropriate in the given
+//       situation, and add additional checks if necessary.
+//
+//       Also, please note that `gsl_ENABLE_IF_()` doesn't enforce the constraint at all if no compiler/library support is available (i.e. pre-C++11).
+
+#if gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+# if !gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 140 ) // VS 2013 seems to have trouble with SFINAE for default non-type arguments
+#  define gsl_ENABLE_IF_(VA) , typename std::enable_if< ( VA ), int >::type = 0
+# else
+#  define gsl_ENABLE_IF_(VA) , typename = typename std::enable_if< ( VA ), ::gsl::detail::enabler >::type
+# endif
+#else
+# define  gsl_ENABLE_IF_(VA)
+#endif
+
+
+// Other features:
+
+#define gsl_HAVE_CONSTRAINED_SPAN_CONTAINER_CTOR  \
+    ( gsl_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG && gsl_HAVE_CONTAINER_DATA_METHOD )
+
+// Note: !defined(__NVCC__) doesn't work with nvcc here:
+#define gsl_HAVE_UNCONSTRAINED_SPAN_CONTAINER_CTOR  \
+    ( gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR && (__NVCC__== 0) )
+
+// GSL API (e.g. for CUDA platform):
+
+// Guidelines for using `gsl_api`:
+//
+// NVCC imposes the restriction that a function annotated `__host__ __device__` cannot call host-only or device-only functions.
+// This makes `gsl_api` inappropriate for generic functions that call unknown code, e.g. the template constructors of `span<>`
+// or functions like `finally()` which accept an arbitrary  function object.
+// It is often preferable to annotate functions only with `gsl_constexpr` or `gsl_constexpr14`. The "extended constexpr" mode
+// of NVCC (currently an experimental feature) will implicitly consider constexpr functions `__host__ __device__` functions
+// but tolerates calls to host-only or device-only functions.
+
+#ifndef   gsl_api
+# ifdef   __CUDACC__
+#  define gsl_api __host__ __device__
+# else
+#  define gsl_api /*gsl_api*/
+# endif
+#endif
+
+// Additional includes:
+
+#if gsl_HAVE( ARRAY )
+# include <array>
+#endif
+
+#if !gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR ) || !gsl_HAVE( AUTO )
+# include <vector>
+#endif
+
+#if gsl_HAVE( INITIALIZER_LIST )
+# include <initializer_list>
+#endif
+
+#if gsl_HAVE( TYPE_TRAITS )
+# include <type_traits> // for enable_if<>,
+                        // add_const<>, add_pointer<>, common_type<>, make_signed<>, remove_cv<>, remove_const<>, remove_volatile<>, remove_reference<>, remove_cvref<>, remove_pointer<>, underlying_type<>,
+                        // is_assignable<>, is_constructible<>, is_const<>, is_convertible<>, is_integral<>, is_pointer<>, is_signed<>,
+                        // integral_constant<>, declval()
+#elif gsl_HAVE( TR1_TYPE_TRAITS )
+# include <tr1/type_traits> // for add_const<>, remove_cv<>, remove_const<>, remove_volatile<>, remove_reference<>, integral_constant<>
+#endif
+
+// MSVC warning suppression macros:
+
+#if gsl_COMPILER_MSVC_VERSION >= 140 && !defined(__NVCC__)
+# define gsl_SUPPRESS_MSGSL_WARNING(expr)        [[gsl::suppress(expr)]]
+# define gsl_SUPPRESS_MSVC_WARNING(code, descr)  __pragma(warning(suppress: code) )
+# define gsl_DISABLE_MSVC_WARNINGS(codes)        __pragma(warning(push))  __pragma(warning(disable: codes))
+# define gsl_RESTORE_MSVC_WARNINGS()             __pragma(warning(pop ))
+#else
+// TODO: define for Clang
+# define gsl_SUPPRESS_MSGSL_WARNING(expr)
+# define gsl_SUPPRESS_MSVC_WARNING(code, descr)
+# define gsl_DISABLE_MSVC_WARNINGS(codes)
+# define gsl_RESTORE_MSVC_WARNINGS()
+#endif
+
+// Suppress the following MSVC GSL warnings:
+// - C26432: gsl::c.21 : if you define or delete any default operation in the type '...', define or delete them all
+// - C26410: gsl::r.32 : the parameter 'ptr' is a reference to const unique pointer, use const T* or const T& instead
+// - C26415: gsl::r.30 : smart pointer parameter 'ptr' is used only to access contained pointer. Use T* or T& instead
+// - C26418: gsl::r.36 : shared pointer parameter 'ptr' is not copied or moved. Use T* or T& instead
+// - C26472: gsl::t.1  : don't use a static_cast for arithmetic conversions;
+//                       use brace initialization, gsl::narrow_cast or gsl::narrow
+// - C26439: gsl::f.6  : special function 'function' can be declared 'noexcept'
+// - C26440: gsl::f.6  : function 'function' can be declared 'noexcept'
+// - C26455: gsl::f.6  : default constructor may not throw. Declare it 'noexcept'
+// - C26473: gsl::t.1  : don't cast between pointer types where the source type and the target type are the same
+// - C26481: gsl::b.1  : don't use pointer arithmetic. Use span instead
+// - C26482: gsl::b.2  : only index into arrays using constant expressions
+// - C26446: gdl::b.4  : prefer to use gsl::at() instead of unchecked subscript operator
+// - C26490: gsl::t.1  : don't use reinterpret_cast
+// - C26487: gsl::l.4  : don't return a pointer '(<some number>'s result)' that may be invalid
+
+gsl_DISABLE_MSVC_WARNINGS( 26432 26410 26415 26418 26472 26439 26440 26455 26473 26481 26482 26446 26490 26487 )
+
+namespace gsl {
+
+// forward declare span<>:
+
+template< class T >
+class span;
+
+// C++11 emulation:
+
+namespace std11 {
+
+#if gsl_HAVE( ADD_CONST )
+
+using std::add_const;
+
+#elif gsl_HAVE( TR1_ADD_CONST )
+
+using std::tr1::add_const;
+
+#else
+
+template< class T > struct add_const { typedef const T type; };
+
+#endif // gsl_HAVE( ADD_CONST )
+
+#if gsl_HAVE( REMOVE_CONST )
+
+using std::remove_cv;
+using std::remove_const;
+using std::remove_volatile;
+
+#elif gsl_HAVE( TR1_REMOVE_CONST )
+
+using std::tr1::remove_cv;
+using std::tr1::remove_const;
+using std::tr1::remove_volatile;
+
+#else
+
+template< class T > struct remove_const          { typedef T type; };
+template< class T > struct remove_const<T const> { typedef T type; };
+
+template< class T > struct remove_volatile             { typedef T type; };
+template< class T > struct remove_volatile<T volatile> { typedef T type; };
+
+template< class T >
+struct remove_cv
+{
+    typedef typename remove_volatile<typename remove_const<T>::type>::type type;
+};
+
+#endif // gsl_HAVE( REMOVE_CONST )
+
+#if gsl_HAVE( REMOVE_REFERENCE )
+
+using std::remove_reference;
+
+#elif gsl_HAVE( TR1_REMOVE_REFERENCE )
+
+using std::tr1::remove_reference;
+
+#else
+
+template< class T > struct remove_reference { typedef T type; };
+template< class T > struct remove_reference<T&> { typedef T type; };
+# if gsl_HAVE( RVALUE_REFERENCE )
+template< class T > struct remove_reference<T&&> { typedef T type; };
+# endif
+
+#endif // gsl_HAVE( REMOVE_REFERENCE )
+
+
+#if gsl_HAVE( INTEGRAL_CONSTANT )
+
+using std::integral_constant;
+using std::true_type;
+using std::false_type;
+
+#elif gsl_HAVE( TR1_INTEGRAL_CONSTANT )
+
+using std::tr1::integral_constant;
+using std::tr1::true_type;
+using std::tr1::false_type;
+
+#else
+
+template< class T, T v > struct integral_constant { enum { value = v }; };
+typedef integral_constant< bool, true  > true_type;
+typedef integral_constant< bool, false > false_type;
+
+#endif
+
+#if gsl_HAVE( TYPE_TRAITS )
+
+using std::underlying_type;
+
+#elif gsl_HAVE( TR1_TYPE_TRAITS )
+
+using std::tr1::underlying_type;
+
+#else
+
+// We could try to define `underlying_type<>` for pre-C++11 here, but let's not until someone actually needs it.
+
+#endif
+
+} // namespace std11
+
+// C++14 emulation:
+
+namespace std14 {
+
+#if gsl_HAVE( UNIQUE_PTR )
+# if gsl_HAVE( MAKE_UNIQUE )
+
+using std::make_unique;
+
+# elif gsl_HAVE( VARIADIC_TEMPLATE )
+
+template< class T, class... Args >
+std::unique_ptr<T> make_unique( Args &&... args )
+{
+    return std::unique_ptr<T>( new T( std::forward<Args>( args )... ) );
+}
+
+# endif // gsl_HAVE( MAKE_UNIQUE ), gsl_HAVE( VARIADIC_TEMPLATE )
+#endif // gsl_HAVE( UNIQUE_PTR )
+
+} // namespace std14
+
+namespace detail {
+
+#if gsl_HAVE( VARIADIC_TEMPLATE )
+
+template < bool V0, class T0, class... Ts > struct conjunction_ { using type = T0; };
+template < class T0, class T1, class... Ts > struct conjunction_<true, T0, T1, Ts...> : conjunction_<T1::value, T1, Ts...> { };
+template < bool V0, class T0, class... Ts > struct disjunction_ { using type = T0; };
+template < class T0, class T1, class... Ts > struct disjunction_<false, T0, T1, Ts...> : disjunction_<T1::value, T1, Ts...> { };
+
+#endif
+
+} // namespace detail
+
+// C++17 emulation:
+
+namespace std17 {
+
+template< bool v > struct bool_constant : std11::integral_constant<bool, v>{};
+
+#if gsl_CPP11_120
+
+template < class... Ts > struct conjunction;
+template < > struct conjunction< > : std11::true_type { };
+template < class T0, class... Ts > struct conjunction<T0, Ts...> : detail::conjunction_<T0::value, T0, Ts...>::type { };
+template < class... Ts > struct disjunction;
+template < > struct disjunction< > : std11::false_type { };
+template < class T0, class... Ts > struct disjunction<T0, Ts...> : detail::disjunction_<T0::value, T0, Ts...>::type { };
+template < class T > struct negation : std11::integral_constant<bool, !T::value> { };
+
+# if gsl_CPP14_OR_GREATER
+
+template < class... Ts > constexpr bool conjunction_v = conjunction<Ts...>::value;
+template < class... Ts > constexpr bool disjunction_v = disjunction<Ts...>::value;
+template < class T > constexpr bool negation_v = negation<T>::value;
+
+# endif // gsl_CPP14_OR_GREATER
+
+template< class... Ts >
+struct make_void { typedef void type; };
+
+template< class... Ts >
+using void_t = typename make_void< Ts... >::type;
+
+#endif // gsl_CPP11_120
+
+#if gsl_HAVE( STD_DATA )
+
+using std::data;
+using std::size;
+
+#elif gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+
+template< class T, size_t N >
+gsl_api inline gsl_constexpr auto size( T const(&)[N] ) gsl_noexcept -> size_t
+{
+    return N;
+}
+
+template< class C >
+inline gsl_constexpr auto size( C const & cont ) -> decltype( cont.size() )
+{
+    return cont.size();
+}
+
+template< class T, size_t N >
+gsl_api inline gsl_constexpr auto data( T(&arr)[N] ) gsl_noexcept -> T*
+{
+    return &arr[0];
+}
+
+template< class C >
+inline gsl_constexpr auto data( C & cont ) -> decltype( cont.data() )
+{
+    return cont.data();
+}
+
+template< class C >
+inline gsl_constexpr auto data( C const & cont ) -> decltype( cont.data() )
+{
+    return cont.data();
+}
+
+template< class E >
+inline gsl_constexpr auto data( std::initializer_list<E> il ) gsl_noexcept -> E const *
+{
+    return il.begin();
+}
+
+#endif // span_HAVE( DATA )
+
+} // namespace std17
+
+// C++20 emulation:
+
+namespace std20 {
+
+#if gsl_CPP11_100
+
+struct identity
+{
+    template < class T >
+    gsl_constexpr T && operator ()( T && arg ) const gsl_noexcept
+    {
+        return std::forward<T>( arg );
+    }
+};
+
+#endif // gsl_CPP11_100
+
+template< class T >
+struct type_identity
+{
+    typedef T type;
+};
+#if gsl_HAVE( ALIAS_TEMPLATE )
+template< class T >
+using type_identity_t = typename type_identity<T>::type;
+#endif // gsl_HAVE( ALIAS_TEMPLATE )
+
+#if gsl_HAVE( STD_SSIZE )
+
+using std::ssize;
+
+#elif gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+
+template < class C >
+gsl_constexpr auto ssize( C const & c )
+    -> typename std::common_type<std::ptrdiff_t, typename std::make_signed<decltype(c.size())>::type>::type
+{
+    using R = typename std::common_type<std::ptrdiff_t, typename std::make_signed<decltype(c.size())>::type>::type;
+    return static_cast<R>( c.size() );
+}
+
+template <class T, std::size_t N>
+gsl_constexpr auto ssize( T const(&)[N] ) gsl_noexcept -> std::ptrdiff_t
+{
+    return std::ptrdiff_t( N );
+}
+
+#endif // gsl_HAVE( STD_SSIZE )
+
+#if gsl_HAVE( REMOVE_CVREF )
+
+using std::remove_cvref;
+
+#else
+
+template< class T > struct remove_cvref { typedef typename std11::remove_cv< typename std11::remove_reference< T >::type >::type type; };
+
+#endif // gsl_HAVE( REMOVE_CVREF )
+
+} // namespace std20
+
+namespace detail {
+
+/// for nsel_REQUIRES_T
+
+/*enum*/ class enabler{};
+
+#if gsl_HAVE( TYPE_TRAITS )
+
+template< class Q >
+struct is_span_oracle : std::false_type{};
+
+template< class T>
+struct is_span_oracle< span<T> > : std::true_type{};
+
+template< class Q >
+struct is_span : is_span_oracle< typename std::remove_cv<Q>::type >{};
+
+template< class Q >
+struct is_std_array_oracle : std::false_type{};
+
+#if gsl_HAVE( ARRAY )
+
+template< class T, std::size_t Extent >
+struct is_std_array_oracle< std::array<T, Extent> > : std::true_type{};
+
+#endif
+
+template< class Q >
+struct is_std_array : is_std_array_oracle< typename std::remove_cv<Q>::type >{};
+
+template< class Q >
+struct is_array : std::false_type{};
+
+template< class T >
+struct is_array<T[]> : std::true_type{};
+
+template< class T, std::size_t N >
+struct is_array<T[N]> : std::true_type{};
+
+# if gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 )
+
+template< class, class = void >
+struct has_size_and_data : std::false_type{};
+
+template< class C >
+struct has_size_and_data
+<
+    C, std17::void_t<
+        decltype( std17::size(std::declval<C>()) ),
+        decltype( std17::data(std::declval<C>()) ) >
+> : std::true_type{};
+
+template< class, class, class = void >
+struct is_compatible_element : std::false_type {};
+
+template< class C, class E >
+struct is_compatible_element
+<
+    C, E, std17::void_t<
+        decltype( std17::data(std::declval<C>()) ),
+        typename std::remove_pointer<decltype( std17::data( std::declval<C&>() ) )>::type(*)[] >
+> : std::is_convertible< typename std::remove_pointer<decltype( std17::data( std::declval<C&>() ) )>::type(*)[], E(*)[] >{};
+
+template< class C >
+struct is_container : std17::bool_constant
+<
+    ! is_span< C >::value
+    && ! is_array< C >::value
+    && ! is_std_array< C >::value
+    &&   has_size_and_data< C >::value
+>{};
+
+template< class C, class E >
+struct is_compatible_container : std17::bool_constant
+<
+    is_container<C>::value
+    && is_compatible_element<C,E>::value
+>{};
+
+# else // ^^^ gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 ) ^^^ / vvv ! gsl_CPP11_140 || gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 ) vvv
+
+template<
+    class C, class E
+        , typename = typename std::enable_if<
+            ! is_span< C >::value
+            && ! is_array< C >::value
+            && ! is_std_array< C >::value
+            && ( std::is_convertible< typename std::remove_pointer<decltype( std17::data( std::declval<C&>() ) )>::type(*)[], E(*)[] >::value)
+        //  &&   has_size_and_data< C >::value
+        , enabler>::type
+        , class = decltype( std17::size(std::declval<C>()) )
+        , class = decltype( std17::data(std::declval<C>()) )
+>
+#  if gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 140 )
+// VS2013 has insufficient support for expression SFINAE; we cannot make `is_compatible_container<>` a proper type trait here
+struct is_compatible_container : std::true_type { };
+#  else
+struct is_compatible_container_r { is_compatible_container_r(int); };
+template< class C, class E >
+std::true_type  is_compatible_container_f( is_compatible_container_r<C, E> );
+template< class C, class E >
+std::false_type is_compatible_container_f( ... );
+
+template< class C, class E >
+struct is_compatible_container : decltype( is_compatible_container_f< C, E >( 0 ) ) { };
+#  endif // gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 140 )
+
+# endif // gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 )
+
+#endif // gsl_HAVE( TYPE_TRAITS )
+
+} // namespace detail
+
+//
+// GSL.util: utilities
+//
+
+// Integer type for indices (e.g. in a loop).
+typedef gsl_CONFIG_INDEX_TYPE index;
+
+//
+// GSL.owner: ownership pointers
+//
+#if gsl_HAVE( SHARED_PTR )
+  using std::unique_ptr;
+  using std::shared_ptr;
+  using std::make_shared;
+# if gsl_HAVE( MAKE_UNIQUE ) || gsl_HAVE( VARIADIC_TEMPLATE )
+  using std14::make_unique;
+# endif
+#endif
+
+#if  gsl_HAVE( ALIAS_TEMPLATE )
+  template< class T
+#if gsl_HAVE( TYPE_TRAITS )
+          , typename = typename std::enable_if< std::is_pointer<T>::value >::type
+#endif
+  >
+  using owner = T;
+#elif gsl_CONFIG_DEFAULTS_VERSION == 0
+  // TODO vNext: remove
+  template< class T > struct owner { typedef T type; };
+#endif
+
+#define gsl_HAVE_OWNER_TEMPLATE  gsl_HAVE_ALIAS_TEMPLATE
+
+// TODO vNext: remove
+#if gsl_FEATURE( OWNER_MACRO )
+# if gsl_HAVE( OWNER_TEMPLATE )
+#  define Owner(t)  ::gsl::owner<t>
+# else
+#  define Owner(t)  ::gsl::owner<t>::type
+# endif
+#endif
+
+//
+// GSL.assert: assertions
+//
+
+#if gsl_HAVE( TYPE_TRAITS )
+# define gsl_ELIDE_CONTRACT_( x )  static_assert(::std::is_constructible<bool, decltype( x )>::value, "argument of contract check must be convertible to bool")
+#else
+# define gsl_ELIDE_CONTRACT_( x )
+#endif
+
+#if defined( __CUDACC__ ) && defined( __CUDA_ARCH__ )
+# define  gsl_ASSUME( x )  gsl_ELIDE_CONTRACT_( x ) /* there is no assume intrinsic in CUDA device code */
+#elif gsl_COMPILER_MSVC_VERSION
+# define  gsl_ASSUME( x )  __assume( x )
+#elif gsl_COMPILER_GNUC_VERSION
+#  define gsl_ASSUME( x )  (( x ) ? static_cast<void>(0) : __builtin_unreachable())
+#elif defined(__has_builtin)
+# if __has_builtin(__builtin_unreachable)
+#  define gsl_ASSUME( x )  (( x ) ? static_cast<void>(0) : __builtin_unreachable())
+# endif
+#else
+# define  gsl_ASSUME( x )  gsl_ELIDE_CONTRACT_( x ) /* unknown compiler; cannot rely on assume intrinsic */
+#endif
+
+#if defined( gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER )
+#  define  gsl_CONTRACT_CHECK_( str, x )  ( ( x ) ? static_cast<void>(0) : ::gsl::fail_fast_assert_handler( #x, "GSL: " str, __FILE__, __LINE__ ) )
+#elif defined( __CUDACC__ ) && defined( __CUDA_ARCH__ )
+#  define  gsl_CONTRACT_CHECK_( str, x )  assert( ( x ) && str )
+#elif   defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
+#  define  gsl_CONTRACT_CHECK_( str, x )  ( ( x ) ? static_cast<void>(0) : ::gsl::detail::fail_fast_throw( "GSL: " str " at " __FILE__ ":" gsl_STRINGIFY(__LINE__) ) )
+#else // defined( gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES ) [default]
+#  define  gsl_CONTRACT_CHECK_( str, x )  ( ( x ) ? static_cast<void>(0) : ::gsl::detail::fail_fast_terminate() )
+#endif
+
+#if defined( gsl_CONFIG_CONTRACT_CHECKING_OFF ) || defined( gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF )
+# if defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME )
+#  define gsl_Expects( x )       gsl_ASSUME( x )
+# else // defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE ) [default]
+#  define gsl_Expects( x )       gsl_ELIDE_CONTRACT_( x )
+# endif
+#else
+# define  gsl_Expects( x )       gsl_CONTRACT_CHECK_( "Precondition failure", x )
+#endif
+#define   Expects( x )           gsl_Expects( x )
+
+#if !defined( gsl_CONFIG_CONTRACT_CHECKING_AUDIT ) || defined( gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF )
+# define  gsl_ExpectsAudit( x )  gsl_ELIDE_CONTRACT_( x )
+#else
+# define  gsl_ExpectsAudit( x )  gsl_CONTRACT_CHECK_( "Precondition failure (audit)", x )
+#endif
+
+#if defined( gsl_CONFIG_CONTRACT_CHECKING_OFF ) || defined( gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF )
+# if defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME )
+#  define gsl_Ensures( x )       gsl_ASSUME( x )
+# else // defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE ) [default]
+#  define gsl_Ensures( x )       gsl_ELIDE_CONTRACT_( x )
+# endif
+#else
+# define  gsl_Ensures( x )       gsl_CONTRACT_CHECK_( "Postcondition failure", x )
+#endif
+#define   Ensures( x )           gsl_Ensures( x )
+
+#if !defined( gsl_CONFIG_CONTRACT_CHECKING_AUDIT ) || defined( gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF )
+# define  gsl_EnsuresAudit( x )  gsl_ELIDE_CONTRACT_( x )
+#else
+# define  gsl_EnsuresAudit( x )  gsl_CONTRACT_CHECK_( "Postcondition failure (audit)", x )
+#endif
+
+#define gsl_STRINGIFY(  x )  gsl_STRINGIFY_( x )
+#define gsl_STRINGIFY_( x )  #x
+
+struct fail_fast : public std::logic_error
+{
+    explicit fail_fast( char const * message )
+    : std::logic_error( message ) {}
+};
+
+namespace detail {
+
+
+#if gsl_HAVE( EXCEPTIONS )
+gsl_NORETURN inline void fail_fast_throw( char const * message )
+{
+    throw fail_fast( message );
+}
+#endif // gsl_HAVE( EXCEPTIONS )
+gsl_NORETURN inline void fail_fast_terminate() gsl_noexcept
+{
+    std::terminate();
+}
+
+} // namespace detail
+
+// Should be defined by user
+gsl_api void fail_fast_assert_handler( char const * const expression, char const * const message, char const * const file, int line );
+
+#if   defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
+
+# if gsl_HAVE( EXCEPTIONS )
+gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use contract checking macros instead")
+gsl_constexpr14 inline
+void fail_fast_assert( bool cond, char const * const message )
+{
+    if ( !cond )
+        throw fail_fast( message );
+}
+# endif // gsl_HAVE( EXCEPTIONS )
+
+#elif defined( gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER )
+
+gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use contract checking macros instead")
+gsl_api gsl_constexpr14 inline
+void fail_fast_assert( bool cond, char const * const expression, char const * const message, char const * const file, int line )
+{
+    if ( !cond )
+        ::gsl::fail_fast_assert_handler( expression, message, file, line );
+}
+
+#else // defined( gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES ) [default]
+
+gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use contract checking macros instead")
+gsl_constexpr14 inline
+void fail_fast_assert( bool cond ) gsl_noexcept
+{
+    if ( !cond )
+        std::terminate();
+}
+
+#endif
+
+
+//
+// GSL.util: utilities
+//
+
+#if gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+
+// Add uncaught_exceptions for pre-2017 MSVC, GCC and Clang
+// Return unsigned char to save stack space, uncaught_exceptions can only increase by 1 in a scope
+
+namespace detail {
+
+gsl_api inline unsigned char to_uchar( unsigned x ) gsl_noexcept
+{
+    return static_cast<unsigned char>( x );
+}
+
+} // namespace detail
+
+namespace std11 {
+
+#if gsl_HAVE( UNCAUGHT_EXCEPTIONS )
+
+inline unsigned char uncaught_exceptions() gsl_noexcept
+{
+    return detail::to_uchar( std::uncaught_exceptions() );
+}
+
+#elif gsl_COMPILER_MSVC_VERSION
+
+extern "C" char * __cdecl _getptd();
+inline unsigned char uncaught_exceptions() gsl_noexcept
+{
+    return detail::to_uchar( *reinterpret_cast<unsigned*>(_getptd() + (sizeof(void*) == 8 ? 0x100 : 0x90) ) );
+}
+
+#elif gsl_COMPILER_CLANG_VERSION || gsl_COMPILER_GNUC_VERSION || gsl_COMPILER_APPLECLANG_VERSION
+
+extern "C" char * __cxa_get_globals();
+inline unsigned char uncaught_exceptions() gsl_noexcept
+{
+    return detail::to_uchar( *reinterpret_cast<unsigned*>(__cxa_get_globals() + sizeof(void*) ) );
+}
+#endif
+} // namespace std11
+#endif
+
+#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 110
+
+template< class F >
+class final_action
+{
+public:
+    explicit final_action( F action ) gsl_noexcept
+        : action_( std::move( action ) )
+        , invoke_( true )
+    {}
+
+    final_action( final_action && other ) gsl_noexcept
+        : action_( std::move( other.action_ ) )
+        , invoke_( other.invoke_ )
+    {
+        other.invoke_ = false;
+    }
+
+    gsl_SUPPRESS_MSGSL_WARNING(f.6)
+    virtual ~final_action() gsl_noexcept
+    {
+        if ( invoke_ )
+            action_();
+    }
+
+gsl_is_delete_access:
+    final_action( final_action const  & ) gsl_is_delete;
+    final_action & operator=( final_action const & ) gsl_is_delete;
+    final_action & operator=( final_action && ) gsl_is_delete;
+
+protected:
+    void dismiss() gsl_noexcept
+    {
+        invoke_ = false;
+    }
+
+private:
+    F action_;
+    bool invoke_;
+};
+
+template< class F >
+inline final_action<F> finally( F const & action ) gsl_noexcept
+{
+    return final_action<F>( action );
+}
+
+template< class F >
+inline final_action<F> finally( F && action ) gsl_noexcept
+{
+    return final_action<F>( std::forward<F>( action ) );
+}
+
+#if gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+
+template< class F >
+class final_action_return : public final_action<F>
+{
+public:
+    explicit final_action_return( F && action ) gsl_noexcept
+        : final_action<F>( std::move( action ) )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    final_action_return( final_action_return && other ) gsl_noexcept
+        : final_action<F>( std::move( other ) )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    ~final_action_return() override
+    {
+        if ( std11::uncaught_exceptions() != exception_count )
+            this->dismiss();
+    }
+
+gsl_is_delete_access:
+    final_action_return( final_action_return const & ) gsl_is_delete;
+    final_action_return & operator=( final_action_return const & ) gsl_is_delete;
+
+private:
+    unsigned char exception_count;
+};
+
+template< class F >
+inline final_action_return<F> on_return( F const & action ) gsl_noexcept
+{
+    return final_action_return<F>( action );
+}
+
+template< class F >
+inline final_action_return<F> on_return( F && action ) gsl_noexcept
+{
+    return final_action_return<F>( std::forward<F>( action ) );
+}
+
+template< class F >
+class final_action_error : public final_action<F>
+{
+public:
+    explicit final_action_error( F && action ) gsl_noexcept
+        : final_action<F>( std::move( action ) )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    final_action_error( final_action_error && other ) gsl_noexcept
+        : final_action<F>( std::move( other ) )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    ~final_action_error() override
+    {
+        if ( std11::uncaught_exceptions() == exception_count )
+            this->dismiss();
+    }
+
+gsl_is_delete_access:
+    final_action_error( final_action_error const & ) gsl_is_delete;
+    final_action_error & operator=( final_action_error const & ) gsl_is_delete;
+
+private:
+    unsigned char exception_count;
+};
+
+template< class F >
+inline final_action_error<F> on_error( F const & action ) gsl_noexcept
+{
+    return final_action_error<F>( action );
+}
+
+template< class F >
+inline final_action_error<F> on_error( F && action ) gsl_noexcept
+{
+    return final_action_error<F>( std::forward<F>( action ) );
+}
+
+#endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+
+#else // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 110
+
+class final_action
+{
+public:
+    typedef void (*Action)();
+
+    final_action( Action action )
+    : action_( action )
+    , invoke_( true )
+    {}
+
+    final_action( final_action const & other )
+        : action_( other.action_ )
+        , invoke_( other.invoke_ )
+    {
+        other.invoke_ = false;
+    }
+
+    virtual ~final_action()
+    {
+        if ( invoke_ )
+            action_();
+    }
+
+protected:
+    void dismiss()
+    {
+        invoke_ = false;
+    }
+
+private:
+    final_action & operator=( final_action const & );
+
+private:
+    Action action_;
+    mutable bool invoke_;
+};
+
+template< class F >
+inline final_action finally( F const & f )
+{
+    return final_action(( f ));
+}
+
+#if gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+
+class final_action_return : public final_action
+{
+public:
+    explicit final_action_return( Action action )
+        : final_action( action )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    ~final_action_return()
+    {
+        if ( std11::uncaught_exceptions() != exception_count )
+            this->dismiss();
+    }
+
+private:
+    final_action_return & operator=( final_action_return const & );
+
+private:
+    unsigned char exception_count;
+};
+
+template< class F >
+inline final_action_return on_return( F const & action )
+{
+    return final_action_return( action );
+}
+
+class final_action_error : public final_action
+{
+public:
+    explicit final_action_error( Action action )
+        : final_action( action )
+        , exception_count( std11::uncaught_exceptions() )
+    {}
+
+    ~final_action_error()
+    {
+        if ( std11::uncaught_exceptions() == exception_count )
+            this->dismiss();
+    }
+
+private:
+    final_action_error & operator=( final_action_error const & );
+
+private:
+    unsigned char exception_count;
+};
+
+template< class F >
+inline final_action_error on_error( F const & action )
+{
+    return final_action_error( action );
+}
+
+#endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+
+#endif // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION == 110
+
+#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
+
+template< class T, class U >
+gsl_api inline gsl_constexpr T narrow_cast( U && u ) gsl_noexcept
+{
+    return static_cast<T>( std::forward<U>( u ) );
+}
+
+#else
+
+template< class T, class U >
+gsl_api inline T narrow_cast( U u ) gsl_noexcept
+{
+    return static_cast<T>( u );
+}
+
+#endif // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
+
+struct narrowing_error : public std::exception {};
+
+#if gsl_HAVE( TYPE_TRAITS )
+
+namespace detail {
+
+    template< class T, class U >
+    struct is_same_signedness : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value>
+    {};
+
+# if defined( __NVCC__ )
+    // We do this to circumvent NVCC warnings about pointless unsigned comparisons with 0.
+    template< class T >
+    gsl_constexpr gsl_api bool is_negative( T value, std::true_type /*isSigned*/ ) gsl_noexcept
+    {
+        return value < T();
+    }
+    template< class T >
+    gsl_constexpr gsl_api bool is_negative( T /*value*/, std::false_type /*isUnsigned*/ ) gsl_noexcept
+    {
+        return false;
+    }
+    template< class T, class U >
+    gsl_constexpr gsl_api bool have_same_sign( T t, U u, std::true_type /*isSameSignedness*/ ) gsl_noexcept
+    {
+        return true;
+    }
+    template< class T, class U >
+    gsl_constexpr gsl_api bool have_same_sign( T t, U u, std::false_type /*isSameSignedness*/ ) gsl_noexcept
+    {
+        return detail::is_negative( t, std::is_signed<T>() ) == detail::is_negative( u, std::is_signed<U>() );
+    }
+# endif // defined( __NVCC__ )
+
+} // namespace detail
+
+#endif
+
+#if gsl_HAVE( EXCEPTIONS ) || !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION
+template< class T, class U >
+# if !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION && !defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
+gsl_api
+# endif // !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION && !defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
+inline T narrow( U u )
+{
+    T t = static_cast<T>( u );
+
+    if ( static_cast<U>( t ) != u )
+    {
+# if gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION || defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
+        throw narrowing_error();
+# else
+        std::terminate();
+# endif
+    }
+
+# if gsl_HAVE( TYPE_TRAITS )
+#  if defined( __NVCC__ )
+    if ( ! detail::have_same_sign( t, u, detail::is_same_signedness<T, U>() ) )
+#  else
+    gsl_SUPPRESS_MSVC_WARNING( 4127, "conditional expression is constant" )
+    if ( ! detail::is_same_signedness<T, U>::value && ( t < T() ) != ( u < U() ) )
+#  endif
+# else
+    // Don't assume T() works:
+    gsl_SUPPRESS_MSVC_WARNING( 4127, "conditional expression is constant" )
+    if ( ( t < 0 ) != ( u < 0 ) )
+# endif
+    {
+# if gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION || defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
+        throw narrowing_error();
+# else
+        std::terminate();
+# endif
+    }
+
+    return t;
+}
+#endif // gsl_HAVE( EXCEPTIONS ) || !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION
+
+template< class T, class U >
+gsl_api inline T narrow_failfast( U u )
+{
+    T t = static_cast<T>( u );
+
+    gsl_Expects( static_cast<U>( t ) == u );
+
+#if gsl_HAVE( TYPE_TRAITS )
+# if defined( __NVCC__ )
+    gsl_Expects( ::gsl::detail::have_same_sign( t, u, ::gsl::detail::is_same_signedness<T, U>() ) );
+# else
+    gsl_SUPPRESS_MSVC_WARNING( 4127, "conditional expression is constant" )
+    gsl_Expects( ( ::gsl::detail::is_same_signedness<T, U>::value || ( t < T() ) == ( u < U() ) ) );
+# endif
+#else
+    // Don't assume T() works:
+    gsl_SUPPRESS_MSVC_WARNING( 4127, "conditional expression is constant" )
+    gsl_Expects( ( t < 0 ) == ( u < 0 ) );
+#endif
+
+    return t;
+}
+
+
+//
+// at() - Bounds-checked way of accessing static arrays, std::array, std::vector.
+//
+
+template< class T, size_t N >
+gsl_api inline gsl_constexpr14 T & at( T(&arr)[N], size_t pos )
+{
+    gsl_Expects( pos < N );
+    return arr[pos];
+}
+
+template< class Container >
+inline gsl_constexpr14 typename Container::value_type & at( Container & cont, size_t pos )
+{
+    gsl_Expects( pos < cont.size() );
+    return cont[pos];
+}
+
+template< class Container >
+inline gsl_constexpr14 typename Container::value_type const & at( Container const & cont, size_t pos )
+{
+    gsl_Expects( pos < cont.size() );
+    return cont[pos];
+}
+
+#if gsl_HAVE( INITIALIZER_LIST )
+
+template< class T >
+inline const gsl_constexpr14 T at( std::initializer_list<T> cont, size_t pos )
+{
+    gsl_Expects( pos < cont.size() );
+    return *( cont.begin() + pos );
+}
+#endif
+
+template< class T >
+gsl_api inline gsl_constexpr14 T & at( span<T> s, size_t pos )
+{
+    return s[ pos ];
+}
+
+//
+// GSL.views: views
+//
+
+//
+// not_null<> - Wrap any indirection and enforce non-null.
+//
+
+template< class T >
+class not_null;
+
+namespace detail {
+
+// helper class to figure out the pointed-to type of a pointer
+#if gsl_CPP11_OR_GREATER
+template< class T, class E = void >
+struct element_type_helper
+{
+    // For types without a member element_type (this will handle raw pointers)
+    typedef typename std::remove_reference< decltype( *std::declval<T>() ) >::type type;
+};
+
+template< class T >
+struct element_type_helper< T, std17::void_t< typename T::element_type > >
+{
+    // For types with a member element_type
+    typedef typename T::element_type type;
+};
+#else
+// Pre-C++11, we cannot have decltype, so we cannot handle types without a member element_type
+template< class T, class E = void >
+struct element_type_helper
+{
+    typedef typename T::element_type type;
+};
+
+template< class T >
+struct element_type_helper< T* >
+{
+    typedef T type;
+};
+#endif
+
+template< class T >
+struct is_not_null_oracle : std11::false_type { };
+template< class T >
+struct is_not_null_oracle< not_null<T> > : std11::true_type { };
+
+template< class T, bool IsCopyable = true >
+struct not_null_data;
+#if gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS )
+template< class T >
+struct not_null_data< T, false >
+{
+    T ptr_;
+
+    gsl_constexpr14 not_null_data( T && _ptr ) gsl_noexcept
+    : ptr_( std::move( _ptr ) )
+    {
+    }
+    
+    gsl_constexpr14 not_null_data( not_null_data && other ) gsl_noexcept
+    : ptr_( std::move( other.ptr_ ) )
+    {
+    }
+    gsl_constexpr14 not_null_data & operator=( not_null_data && other ) gsl_noexcept
+    {
+        ptr_ = std::move( other.ptr_ );
+        return *this;
+    }
+
+gsl_is_delete_access:
+    not_null_data( not_null_data const & other ) gsl_is_delete;
+    not_null_data & operator=( not_null_data const & other ) gsl_is_delete;
+};
+#endif // gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS )
+template< class T >
+struct not_null_data< T, true >
+{
+    T ptr_;
+
+    gsl_constexpr14 not_null_data( T const & _ptr ) gsl_noexcept
+    : ptr_( _ptr )
+    {
+    }
+
+#if gsl_HAVE( RVALUE_REFERENCE )
+    gsl_constexpr14 not_null_data( T && _ptr ) gsl_noexcept
+    : ptr_( std::move( _ptr ) )
+    {
+    }
+    
+    gsl_constexpr14 not_null_data( not_null_data && other ) gsl_noexcept
+    : ptr_( std::move( other.ptr_ ) )
+    {
+    }
+    gsl_constexpr14 not_null_data & operator=( not_null_data && other ) gsl_noexcept
+    {
+        ptr_ = std::move( other.ptr_ );
+        return *this;
+    }
+#endif // gsl_HAVE( RVALUE_REFERENCE )
+
+    gsl_constexpr14 not_null_data( not_null_data const & other )
+    : ptr_( other.ptr_ )
+    {
+        gsl_Expects( ptr_ != gsl_nullptr );
+    }
+    gsl_constexpr14 not_null_data & operator=( not_null_data const & other )
+    {
+        gsl_Expects( other.ptr_ != gsl_nullptr );
+        ptr_ = other.ptr_;
+        return *this;
+    }
+};
+
+template< class T >
+struct is_copyable
+#if gsl_HAVE( TYPE_TRAITS )
+: std11::integral_constant< bool, std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value >
+#else
+: std11::true_type
+#endif
+{
+};
+#if gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( UNIQUE_PTR ) && gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 140 )
+// Type traits are buggy in VC++ 2013, so we explicitly declare `unique_ptr<>` non-copyable.
+template< class T, class Deleter >
+struct is_copyable< std::unique_ptr< T, Deleter > > : std11::false_type
+{
+};
+#endif
+
+} // namespace detail
+
+template< class T >
+class not_null
+{
+private:
+    detail::not_null_data< T, detail::is_copyable< T >::value > data_;
+
+    // need to access `not_null<U>::data_`
+    template< class U >
+    friend class not_null;
+
+public:
+    typedef typename detail::element_type_helper<T>::type element_type;
+
+#if gsl_HAVE( TYPE_TRAITS )
+    static_assert( std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr." );
+#endif
+
+#if gsl_CONFIG( NOT_NULL_EXPLICIT_CTOR )
+# if gsl_HAVE( RVALUE_REFERENCE )
+    template< class U
+    // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>, unique_ptr<X>>` tries to instantiate the copy constructor of `unique_ptr<>`, triggering an error.
+    // Note that Apple Clang's `__clang_major__` etc. are different from regular Clang.
+#  if gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
+        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
+        , typename std::enable_if< ( std::is_constructible<T, U>::value ), int >::type = 0
+#  endif
+    >
+    gsl_constexpr14 explicit not_null( U other )
+    : data_( T( std::move( other ) ) )
+    {
+        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    }
+# else // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
+    template< class U >
+    gsl_constexpr14 explicit not_null( U const& other )
+    : data_( T( other ) )
+    {
+        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    }
+# endif // gsl_HAVE( RVALUE_REFERENCE )
+#else // a.k.a. !gsl_CONFIG( NOT_NULL_EXPLICIT_CTOR )
+# if gsl_HAVE( RVALUE_REFERENCE )
+    // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>, unique_ptr<X>>` tries to instantiate the copy constructor of `unique_ptr<>`, triggering an error.
+    // Note that Apple Clang's `__clang_major__` etc. are different from regular Clang.
+#  if gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
+    template< class U
+        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
+        , typename std::enable_if< ( std::is_constructible<T, U>::value && !std::is_convertible<U, T>::value ), int >::type = 0
+    >
+    gsl_constexpr14 explicit not_null( U other )
+    : data_( T( std::move( other ) ) )
+    {
+        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    }
+
+    template< class U
+        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
+        , typename std::enable_if< ( std::is_convertible<U, T>::value ), int >::type = 0
+    >
+    gsl_constexpr14 not_null( U other )
+    : data_( T( std::move( other ) ) )
+    {
+        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    }
+#  else // a.k.a. !( gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
+    // If type_traits are not available, then we can't distinguish `is_convertible<>` and `is_constructible<>`, so we unconditionally permit implicit construction.
+    template< class U >
+    gsl_constexpr14 not_null( U other )
+    : data_( T( std::move( other ) ) )
+    {
+        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    }
+#  endif // gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
+# else // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
+    template< class U >
+    gsl_constexpr14 not_null( U const& other )
+    : data_( T( other ) )
+    {
+        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    }
+# endif // gsl_HAVE( RVALUE_REFERENCE )
+#endif // gsl_CONFIG( NOT_NULL_EXPLICIT_CTOR )
+
+# if gsl_HAVE( RVALUE_REFERENCE )
+    // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>, unique_ptr<X>>` tries to instantiate the copy constructor of `unique_ptr<>`, triggering an error.
+    // Note that Apple Clang's `__clang_major__` etc. are different from regular Clang.
+#  if gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
+    template< class U
+        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
+        , typename std::enable_if< ( std::is_constructible<T, U>::value && !std::is_convertible<U, T>::value ), int >::type = 0
+    >
+    gsl_constexpr14 explicit not_null( not_null<U> other )
+    : data_( T( std::move( other.data_.ptr_ ) ) )
+    {
+        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    }
+
+    template< class U
+        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
+        , typename std::enable_if< ( std::is_convertible<U, T>::value ), int >::type = 0
+    >
+    gsl_constexpr14 not_null( not_null<U> other )
+    : data_( T( std::move( other.data_.ptr_ ) ) )
+    {
+        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    }
+#  else // a.k.a. !( gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
+    // If type_traits are not available, then we can't distinguish `is_convertible<>` and `is_constructible<>`, so we unconditionally permit implicit construction.
+    template< class U >
+    gsl_constexpr14 not_null( not_null<U> other )
+    : data_( T( std::move( other.data_.ptr_ ) ) )
+    {
+        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    }
+    template< class U >
+    gsl_constexpr14 not_null<T>& operator=( not_null<U> other )
+    {
+        gsl_Expects( other.data_.ptr_ != gsl_nullptr );
+        data_.ptr_ = std::move( other.data_.ptr_ );
+        return *this;
+    }
+#  endif // gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
+# else // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
+    template< class U >
+    gsl_constexpr14 not_null( not_null<U> const& other )
+    : data_( T( other.data_.ptr_ ) )
+    {
+        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    }
+    template< class U >
+    gsl_constexpr14 not_null<T>& operator=( not_null<U> const & other )
+    {
+        gsl_Expects( other.data_.ptr_ != gsl_nullptr );
+        data_.ptr_ = other.data_.ptr_;
+        return *this;
+    }
+# endif // gsl_HAVE( RVALUE_REFERENCE )
+
+#if gsl_CONFIG( TRANSPARENT_NOT_NULL )
+    gsl_constexpr14 element_type *
+    get() const
+    {
+        gsl_Ensures( data_.ptr_ != gsl_nullptr );
+        return data_.ptr_.get();
+    }
+#else
+# if gsl_CONFIG( NOT_NULL_GET_BY_CONST_REF )
+    gsl_constexpr14 T const & get() const
+    {
+        gsl_Ensures( data_.ptr_ != gsl_nullptr );
+        return data_.ptr_;
+    }
+# else
+    gsl_constexpr14 T get() const
+    {
+        gsl_Ensures( data_.ptr_ != gsl_nullptr );
+        return data_.ptr_;
+    }
+# endif
+#endif
+
+    // We want an implicit conversion operator that can be used to convert from both lvalues (by
+    // const reference or by copy) and rvalues (by move). So it seems like we could define
+    //
+    //     template< class U >
+    //     operator U const &() const & { ... }
+    //     template< class U >
+    //     operator U &&() && { ... }
+    //
+    // However, having two conversion operators with different return types renders the assignment
+    // operator of the result type ambiguous:
+    //
+    //     not_null<std::unique_ptr<T>> p( ... );
+    //     std::unique_ptr<U> q;
+    //     q = std::move( p ); // ambiguous
+    //
+    // To avoid this ambiguity, we have both overloads of the conversion operator return `U`
+    // rather than `U const &` or `U &&`. This implies that converting an lvalue always induces
+    // a copy, which can cause unnecessary copies or even fail to compile in some situations:
+    //
+    //     not_null<std::shared_ptr<T>> sp( ... );
+    //     std::shared_ptr<U> const & rs = sp; // unnecessary copy
+    //     std::unique_ptr<U> const & ru = p; // error: cannot copy `unique_ptr<T>`
+    //
+    // However, these situations are rather unusual, and the following, more frequent situations
+    // remain unimpaired:
+    //
+    //     std::shared_ptr<U> vs = sp; // no extra copy
+    //     std::unique_ptr<U> vu = std::move( p );
+
+#if gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && gsl_HAVE( EXPLICIT )
+    // explicit conversion operator
+
+    template< class U
+        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
+        , typename std::enable_if< ( std::is_constructible<U, T const &>::value && !std::is_convertible<T, U>::value && !detail::is_not_null_oracle<U>::value ), int >::type = 0
+    >
+    gsl_constexpr14 explicit
+    operator U() const
+# if gsl_HAVE( FUNCTION_REF_QUALIFIER )
+    &
+# endif
+    {
+        gsl_Ensures( data_.ptr_ != gsl_nullptr );
+        return U( data_.ptr_ );
+    }
+# if gsl_HAVE( FUNCTION_REF_QUALIFIER )
+    template< class U
+        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
+        , typename std::enable_if< ( std::is_constructible<U, T>::value && !std::is_convertible<T, U>::value && !detail::is_not_null_oracle<U>::value ), int >::type = 0
+    >
+    gsl_constexpr14 explicit
+    operator U() &&
+    {
+        gsl_Ensures( data_.ptr_ != gsl_nullptr );
+        return U( std::move( data_.ptr_ ) );
+    }
+# endif
+
+    // implicit conversion operator
+    template< class U
+        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
+        , typename std::enable_if< ( std::is_constructible<U, T const &>::value && std::is_convertible<T, U>::value && !detail::is_not_null_oracle<U>::value ), int >::type = 0
+    >
+    gsl_constexpr14
+    operator U() const
+# if gsl_HAVE( FUNCTION_REF_QUALIFIER )
+    &
+# endif
+    {
+        gsl_Ensures( data_.ptr_ != gsl_nullptr );
+        return data_.ptr_;
+    }
+# if gsl_HAVE( FUNCTION_REF_QUALIFIER )
+    template< class U
+        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
+        , typename std::enable_if< ( std::is_convertible<T, U>::value && !detail::is_not_null_oracle<U>::value ), int >::type = 0
+    >
+    gsl_constexpr14
+    operator U() &&
+    {
+        gsl_Ensures( data_.ptr_ != gsl_nullptr );
+        return std::move( data_.ptr_ );
+    }
+# endif
+#else // a.k.a. #if !( gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && gsl_HAVE( EXPLICIT ) )
+    template< class U >
+    gsl_constexpr14
+    operator U() const
+    {
+        gsl_Ensures( data_.ptr_ != gsl_nullptr );
+        return data_.ptr_;
+    }
+#endif // gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && gsl_HAVE( EXPLICIT )
+
+    gsl_constexpr14 T const &
+    operator->() const
+    {
+        gsl_Ensures( data_.ptr_ != gsl_nullptr );
+        return data_.ptr_;
+    }
+
+    gsl_constexpr14 element_type &
+    operator*() const
+    {
+        gsl_Ensures( data_.ptr_ != gsl_nullptr );
+        return *data_.ptr_;
+    }
+
+#if gsl_HAVE( RVALUE_REFERENCE )
+    // Visual C++ 2013 doesn't generate default move constructors, so we declare them explicitly.
+    gsl_constexpr14 not_null( not_null && other ) gsl_noexcept
+    : data_( std::move( other.data_ ) )
+    {
+        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    }
+    gsl_constexpr14 not_null & operator=( not_null && other ) gsl_noexcept
+    {
+        gsl_Expects( other.data_.ptr_ != gsl_nullptr );
+        data_ = std::move( other.data_ );
+        return *this;
+    }
+#endif // gsl_HAVE( RVALUE_REFERENCE )
+
+#if gsl_HAVE( IS_DEFAULT )
+    gsl_constexpr14 not_null( not_null const & other ) = default;
+    gsl_constexpr14 not_null & operator=( not_null const & other ) = default;
+#endif
+
+gsl_is_delete_access:
+    not_null() gsl_is_delete;
+    // prevent compilation when initialized with a nullptr or literal 0:
+#if gsl_HAVE( NULLPTR )
+    not_null(             std::nullptr_t ) gsl_is_delete;
+    not_null & operator=( std::nullptr_t ) gsl_is_delete;
+#else
+    not_null(             int ) gsl_is_delete;
+    not_null & operator=( int ) gsl_is_delete;
+#endif
+
+    // unwanted operators...pointers only point to single objects!
+    not_null & operator++() gsl_is_delete;
+    not_null & operator--() gsl_is_delete;
+    not_null   operator++( int ) gsl_is_delete;
+    not_null   operator--( int ) gsl_is_delete;
+    not_null & operator+ ( size_t ) gsl_is_delete;
+    not_null & operator+=( size_t ) gsl_is_delete;
+    not_null & operator- ( size_t ) gsl_is_delete;
+    not_null & operator-=( size_t ) gsl_is_delete;
+    not_null & operator+=( std::ptrdiff_t ) gsl_is_delete;
+    not_null & operator-=( std::ptrdiff_t ) gsl_is_delete;
+    void       operator[]( std::ptrdiff_t ) const gsl_is_delete;
+};
+#if gsl_HAVE( DEDUCTION_GUIDES )
+template< class U >
+not_null( U ) -> not_null<U>;
+template< class U >
+not_null( not_null<U> ) -> not_null<U>;
+#endif
+
+#if gsl_HAVE( NULLPTR )
+void make_not_null( std::nullptr_t ) gsl_is_delete;
+#endif // gsl_HAVE( NULLPTR )
+#if gsl_HAVE( RVALUE_REFERENCE )
+template< class U >
+not_null<U> make_not_null( U u )
+{
+    return not_null<U>( std::move( u ) );
+}
+template< class U >
+not_null<U> make_not_null( not_null<U> u )
+{
+    return std::move( u );
+}
+#else // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
+template< class U >
+not_null<U> make_not_null( U const & u )
+{
+    return not_null<U>( u );
+}
+template< class U >
+not_null<U> make_not_null( not_null<U> const & u )
+{
+    return u;
+}
+#endif // gsl_HAVE( RVALUE_REFERENCE )
+
+
+// not_null with implicit constructor, allowing copy-initialization:
+
+template< class T >
+class not_null_ic : public not_null<T>
+{
+public:
+    template< class U
+        gsl_ENABLE_IF_(( std::is_constructible<T, U>::value ))
+    >
+    gsl_constexpr14
+#if gsl_HAVE( RVALUE_REFERENCE )
+    not_null_ic( U && u )
+    : not_null<T>( std::forward<U>( u ) )
+#else
+    not_null_ic( U const & u )
+    : not_null<T>( u )
+#endif
+    {}
+};
+
+// more not_null unwanted operators
+
+template< class T, class U >
+std::ptrdiff_t operator-( not_null<T> const &, not_null<U> const & ) gsl_is_delete;
+
+template< class T >
+not_null<T> operator-( not_null<T> const &, std::ptrdiff_t ) gsl_is_delete;
+
+template< class T >
+not_null<T> operator+( not_null<T> const &, std::ptrdiff_t ) gsl_is_delete;
+
+template< class T >
+not_null<T> operator+( std::ptrdiff_t, not_null<T> const & ) gsl_is_delete;
+
+// not_null comparisons
+
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() == std::declval<U const>() )
+operator==( not_null<T> const & l, not_null<U> const & r )
+{
+    return l.operator->() == r.operator->();
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() == std::declval<U const>() )
+operator==( not_null<T> const & l, U const & r )
+{
+    return l.operator->() == r;
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() == std::declval<U const>() )
+operator==( T const & l, not_null<U> const & r )
+{
+    return l == r.operator->();
+}
+
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() < std::declval<U const>() )
+operator<( not_null<T> const & l, not_null<U> const & r )
+{
+    return l.operator->() < r.operator->();
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() < std::declval<U const>() )
+operator<( not_null<T> const & l, U const & r )
+{
+    return l.operator->() < r;
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() < std::declval<U const>() )
+operator<( T const & l, not_null<U> const & r )
+{
+    return l < r.operator->();
+}
+
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() == std::declval<U const>() ) )
+operator!=( not_null<T> const & l, not_null<U> const & r )
+{
+    return !( l == r );
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() == std::declval<U const>() ) )
+operator!=( not_null<T> const & l, U const & r )
+{
+    return !( l == r );
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() == std::declval<U const>() ) )
+operator!=( T const & l, not_null<U> const & r )
+{
+    return !( l == r );
+}
+
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<U const>() < std::declval<T const>() ) )
+operator<=( not_null<T> const & l, not_null<U> const & r )
+{
+    return !( r < l );
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<U const>() < std::declval<T const>() ) )
+operator<=( not_null<T> const & l, U const & r )
+{
+    return !( r < l );
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<U const>() < std::declval<T const>() ) )
+operator<=( T const & l, not_null<U> const & r )
+{
+    return !( r < l );
+}
+
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<U const>() < std::declval<T const>() )
+operator>( not_null<T> const & l, not_null<U> const & r )
+{
+    return r < l;
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<U const>() < std::declval<T const>() )
+operator>( not_null<T> const & l, U const & r )
+{
+    return r < l;
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<U const>() < std::declval<T const>() )
+operator>( T const & l, not_null<U> const & r )
+{
+    return r < l;
+}
+
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() < std::declval<U const>() ) )
+operator>=( not_null<T> const & l, not_null<U> const & r )
+{
+    return !( l < r );
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() < std::declval<U const>() ) )
+operator>=( not_null<T> const & l, U const & r )
+{
+    return !( l < r );
+}
+template< class T, class U >
+inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() < std::declval<U const>() ) )
+operator>=( T const & l, not_null<U> const & r )
+{
+    return !( l < r );
+}
+
+// print not_null
+
+template< class CharType, class Traits, class T >
+std::basic_ostream< CharType, Traits > & operator<<( std::basic_ostream< CharType, Traits > & os, not_null<T> const & p )
+{
+    return os << p.operator->();
+}
+
+
+//
+// Byte-specific type.
+//
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+  enum class gsl_may_alias byte : unsigned char {};
+#else
+  struct gsl_may_alias byte { typedef unsigned char type; type v; };
+#endif
+
+template< class T >
+gsl_api inline gsl_constexpr byte to_byte( T v ) gsl_noexcept
+{
+#if    gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    return static_cast<byte>( v );
+#elif  gsl_HAVE( CONSTEXPR_11 )
+    return { static_cast<typename byte::type>( v ) };
+#else
+    byte b = { static_cast<typename byte::type>( v ) }; return b;
+#endif
+}
+
+template< class IntegerType  gsl_ENABLE_IF_(( std::is_integral<IntegerType>::value )) >
+gsl_api inline gsl_constexpr IntegerType to_integer( byte b ) gsl_noexcept
+{
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    return static_cast<typename std::underlying_type<byte>::type>( b );
+#else
+    return b.v;
+#endif
+}
+
+gsl_api inline gsl_constexpr unsigned char to_uchar( byte b ) gsl_noexcept
+{
+    return to_integer<unsigned char>( b );
+}
+
+gsl_api inline gsl_constexpr unsigned char to_uchar( int i ) gsl_noexcept
+{
+    return static_cast<unsigned char>( i );
+}
+
+template< class IntegerType  gsl_ENABLE_IF_(( std::is_integral<IntegerType>::value )) >
+gsl_api inline gsl_constexpr14 byte & operator<<=( byte & b, IntegerType shift ) gsl_noexcept
+{
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    return b = ::gsl::to_byte( ::gsl::to_uchar( b ) << shift );
+#else
+    b.v = ::gsl::to_uchar( b.v << shift ); return b;
+#endif
+}
+
+template< class IntegerType  gsl_ENABLE_IF_(( std::is_integral<IntegerType>::value )) >
+gsl_api inline gsl_constexpr byte operator<<( byte b, IntegerType shift ) gsl_noexcept
+{
+    return ::gsl::to_byte( ::gsl::to_uchar( b ) << shift );
+}
+
+template< class IntegerType  gsl_ENABLE_IF_(( std::is_integral<IntegerType>::value )) >
+gsl_api inline gsl_constexpr14 byte & operator>>=( byte & b, IntegerType shift ) gsl_noexcept
+{
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    return b = ::gsl::to_byte( ::gsl::to_uchar( b ) >> shift );
+#else
+    b.v = ::gsl::to_uchar( b.v >> shift ); return b;
+#endif
+}
+
+template< class IntegerType  gsl_ENABLE_IF_(( std::is_integral<IntegerType>::value )) >
+gsl_api inline gsl_constexpr byte operator>>( byte b, IntegerType shift ) gsl_noexcept
+{
+    return ::gsl::to_byte( ::gsl::to_uchar( b ) >> shift );
+}
+
+#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+gsl_DEFINE_ENUM_BITMASK_OPERATORS( byte )
+gsl_DEFINE_ENUM_RELATIONAL_OPERATORS( byte )
+#else // a.k.a. !gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+gsl_api inline gsl_constexpr bool operator==( byte l, byte r ) gsl_noexcept
+{
+    return l.v == r.v;
+}
+
+gsl_api inline gsl_constexpr bool operator!=( byte l, byte r ) gsl_noexcept
+{
+    return !( l == r );
+}
+
+gsl_api inline gsl_constexpr bool operator< ( byte l, byte r ) gsl_noexcept
+{
+    return l.v < r.v;
+}
+
+gsl_api inline gsl_constexpr bool operator<=( byte l, byte r ) gsl_noexcept
+{
+    return !( r < l );
+}
+
+gsl_api inline gsl_constexpr bool operator> ( byte l, byte r ) gsl_noexcept
+{
+    return ( r < l );
+}
+
+gsl_api inline gsl_constexpr bool operator>=( byte l, byte r ) gsl_noexcept
+{
+    return !( l < r );
+}
+
+gsl_api inline gsl_constexpr14 byte & operator|=( byte & l, byte r ) gsl_noexcept
+{
+    l.v |= r.v; return l;
+}
+
+gsl_api inline gsl_constexpr byte operator|( byte l, byte r ) gsl_noexcept
+{
+    return ::gsl::to_byte( l.v | r.v );
+}
+
+gsl_api inline gsl_constexpr14 byte & operator&=( byte & l, byte r ) gsl_noexcept
+{
+    l.v &= r.v; return l;
+}
+
+gsl_api inline gsl_constexpr byte operator&( byte l, byte r ) gsl_noexcept
+{
+    return ::gsl::to_byte( l.v & r.v );
+}
+
+gsl_api inline gsl_constexpr14 byte & operator^=( byte & l, byte r ) gsl_noexcept
+{
+    l.v ^= r.v; return l;
+}
+
+gsl_api inline gsl_constexpr byte operator^( byte l, byte r ) gsl_noexcept
+{
+    return ::gsl::to_byte( l.v ^ r.v );
+}
+
+gsl_api inline gsl_constexpr byte operator~( byte b ) gsl_noexcept
+{
+    return ::gsl::to_byte( ~b.v );
+}
+#endif // gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+
+#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
+
+// Tag to select span constructor taking a container:
+
+struct with_container_t { gsl_constexpr with_container_t() gsl_noexcept {} };
+const  gsl_constexpr   with_container_t with_container; // TODO: this can lead to ODR violations because the symbol will be defined in multiple translation units
+
+#endif
+
+//
+// span<> - A 1D view of contiguous T's, replace (*,len).
+//
+template< class T >
+class span
+{
+    template< class U > friend class span;
+
+public:
+    typedef gsl_CONFIG_SPAN_INDEX_TYPE index_type;
+
+    typedef T element_type;
+    typedef typename std11::remove_cv< T >::type value_type;
+
+    typedef T & reference;
+    typedef T * pointer;
+    typedef T const * const_pointer;
+    typedef T const & const_reference;
+
+    typedef pointer       iterator;
+    typedef const_pointer const_iterator;
+
+    typedef std::reverse_iterator< iterator >       reverse_iterator;
+    typedef std::reverse_iterator< const_iterator > const_reverse_iterator;
+
+    typedef typename std::iterator_traits< iterator >::difference_type difference_type;
+
+    // 26.7.3.2 Constructors, copy, and assignment [span.cons]
+
+    gsl_api gsl_constexpr14 span() gsl_noexcept
+        : first_( gsl_nullptr )
+        , last_ ( gsl_nullptr )
+    {
+    }
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
+
+#if gsl_HAVE( NULLPTR )
+    gsl_api gsl_constexpr14 span( std::nullptr_t, index_type size_in )
+        : first_( nullptr )
+        , last_ ( nullptr )
+    {
+        gsl_Expects( size_in == 0 );
+    }
+#endif
+
+#if gsl_HAVE( IS_DELETE )
+    gsl_DEPRECATED
+    gsl_api gsl_constexpr span( reference data_in )
+        : span( &data_in, 1 )
+    {}
+
+    gsl_api gsl_constexpr span( element_type && ) = delete;
+#endif
+
+#endif // deprecate
+
+    gsl_api gsl_constexpr14 span( pointer data_in, index_type size_in )
+        : first_( data_in )
+        , last_ ( data_in + size_in )
+    {
+        gsl_Expects( size_in == 0 || ( size_in > 0 && data_in != gsl_nullptr ) );
+    }
+
+    gsl_api gsl_constexpr14 span( pointer first_in, pointer last_in )
+        : first_( first_in )
+        , last_ ( last_in )
+    {
+        gsl_Expects( first_in <= last_in );
+    }
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
+
+    template< class U >
+    gsl_api gsl_constexpr14 span( U * data_in, index_type size_in )
+        : first_( data_in )
+        , last_ ( data_in + size_in )
+    {
+        gsl_Expects( size_in == 0 || ( size_in > 0 && data_in != gsl_nullptr ) );
+    }
+
+#endif // deprecate
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
+    template< class U, size_t N >
+    gsl_api gsl_constexpr span( U (&arr)[N] ) gsl_noexcept
+        : first_( gsl_ADDRESSOF( arr[0] ) )
+        , last_ ( gsl_ADDRESSOF( arr[0] ) + N )
+    {}
+#else
+    template< size_t N
+        gsl_ENABLE_IF_(( std::is_convertible<value_type(*)[], element_type(*)[] >::value ))
+    >
+    gsl_api gsl_constexpr span( element_type (&arr)[N] ) gsl_noexcept
+        : first_( gsl_ADDRESSOF( arr[0] ) )
+        , last_ ( gsl_ADDRESSOF( arr[0] ) + N )
+    {}
+#endif // deprecate
+
+#if gsl_HAVE( ARRAY )
+#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
+
+    template< class U, size_t N >
+    gsl_constexpr span( std::array< U, N > & arr )
+        : first_( arr.data() )
+        , last_ ( arr.data() + N )
+    {}
+
+    template< class U, size_t N >
+    gsl_constexpr span( std::array< U, N > const & arr )
+        : first_( arr.data() )
+        , last_ ( arr.data() + N )
+    {}
+
+#else
+
+    template< size_t N
+        gsl_ENABLE_IF_(( std::is_convertible<value_type(*)[], element_type(*)[] >::value ))
+    >
+    gsl_constexpr span( std::array< value_type, N > & arr )
+        : first_( arr.data() )
+        , last_ ( arr.data() + N )
+    {}
+
+    template< size_t N
+        gsl_ENABLE_IF_(( std::is_convertible<value_type(*)[], element_type(*)[] >::value ))
+    >
+    gsl_constexpr span( std::array< value_type, N > const & arr )
+        : first_( arr.data() )
+        , last_ ( arr.data() + N )
+    {}
+
+#endif // deprecate
+#endif // gsl_HAVE( ARRAY )
+
+#if gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+    template< class Container
+        gsl_ENABLE_IF_(( detail::is_compatible_container< Container, element_type >::value ))
+    >
+    gsl_constexpr span( Container & cont ) gsl_noexcept
+        : first_( std17::data( cont ) )
+        , last_ ( std17::data( cont ) + std17::size( cont ) )
+    {}
+
+    template< class Container
+        gsl_ENABLE_IF_((
+            std::is_const< element_type >::value
+            && detail::is_compatible_container< Container, element_type >::value
+        ))
+    >
+    gsl_constexpr span( Container const & cont ) gsl_noexcept
+        : first_( std17::data( cont ) )
+        , last_ ( std17::data( cont ) + std17::size( cont ) )
+    {}
+
+#elif gsl_HAVE( UNCONSTRAINED_SPAN_CONTAINER_CTOR )
+
+    template< class Container >
+    gsl_constexpr span( Container & cont )
+        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
+        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
+    {}
+
+    template< class Container >
+    gsl_constexpr span( Container const & cont )
+        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
+        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
+    {}
+
+#endif
+
+#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
+
+    template< class Container >
+    gsl_constexpr span( with_container_t, Container & cont ) gsl_noexcept
+        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
+        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
+    {}
+
+    template< class Container >
+    gsl_constexpr span( with_container_t, Container const & cont ) gsl_noexcept
+        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
+        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
+    {}
+
+#endif
+
+#if !gsl_DEPRECATE_TO_LEVEL( 4 )
+    // constructor taking shared_ptr deprecated since 0.29.0
+
+# if gsl_HAVE( SHARED_PTR )
+    gsl_DEPRECATED
+    gsl_constexpr span( shared_ptr<element_type> const & ptr )
+        : first_( ptr.get() )
+        , last_ ( ptr.get() ? ptr.get() + 1 : gsl_nullptr )
+    {}
+# endif
+
+    // constructors taking unique_ptr deprecated since 0.29.0
+
+# if gsl_HAVE( UNIQUE_PTR )
+#  if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+    template< class ArrayElementType = typename std::add_pointer<element_type>::type >
+#  else
+    template< class ArrayElementType >
+#  endif
+    gsl_DEPRECATED
+    gsl_constexpr span( unique_ptr<ArrayElementType> const & ptr, index_type count )
+        : first_( ptr.get() )
+        , last_ ( ptr.get() + count )
+    {}
+
+    gsl_DEPRECATED
+    gsl_constexpr span( unique_ptr<element_type> const & ptr )
+        : first_( ptr.get() )
+        , last_ ( ptr.get() ? ptr.get() + 1 : gsl_nullptr )
+    {}
+# endif
+
+#endif // deprecate shared_ptr, unique_ptr
+
+#if gsl_HAVE( IS_DEFAULT ) && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 430, 600)
+    gsl_constexpr span( span && ) gsl_noexcept = default;
+    gsl_constexpr span( span const & ) = default;
+#else
+    gsl_api gsl_constexpr span( span const & other )
+        : first_( other.begin() )
+        , last_ ( other.end() )
+    {}
+#endif
+
+#if gsl_HAVE( IS_DEFAULT )
+    gsl_constexpr14 span & operator=( span && ) gsl_noexcept = default;
+    gsl_constexpr14 span & operator=( span const & ) gsl_noexcept = default;
+#else
+    gsl_constexpr14 span & operator=( span other ) gsl_noexcept
+    {
+        first_ = other.first_;
+        last_ = other.last_;
+        return *this;
+    }
+#endif
+
+    template< class U
+        gsl_ENABLE_IF_(( std::is_convertible<U(*)[], element_type(*)[]>::value ))
+    >
+    gsl_api gsl_constexpr span( span<U> const & other )
+        : first_( other.begin() )
+        , last_ ( other.end() )
+    {}
+
+#if 0
+    // Converting from other span ?
+    template< class U > operator=();
+#endif
+
+    // 26.7.3.3 Subviews [span.sub]
+
+    gsl_api gsl_constexpr14 span first( index_type count ) const
+    {
+        gsl_Expects( std::size_t( count ) <= std::size_t( this->size() ) );
+        return span( this->data(), count );
+    }
+
+    gsl_api gsl_constexpr14 span last( index_type count ) const
+    {
+        gsl_Expects( std::size_t( count ) <= std::size_t( this->size() ) );
+        return span( this->data() + this->size() - count, count );
+    }
+
+    gsl_api gsl_constexpr14 span subspan( index_type offset ) const
+    {
+        gsl_Expects( std::size_t( offset ) <= std::size_t( this->size() ) );
+        return span( this->data() + offset, this->size() - offset );
+    }
+
+    gsl_api gsl_constexpr14 span subspan( index_type offset, index_type count ) const
+    {
+        gsl_Expects(
+            std::size_t( offset ) <= std::size_t( this->size() ) &&
+            std::size_t( count ) <= std::size_t( this->size() - offset ) );
+        return span( this->data() + offset, count );
+    }
+
+    // 26.7.3.4 Observers [span.obs]
+
+    gsl_api gsl_constexpr index_type size() const gsl_noexcept
+    {
+        return narrow_cast<index_type>( last_ - first_ );
+    }
+
+    gsl_api gsl_constexpr std::ptrdiff_t ssize() const gsl_noexcept
+    {
+        return narrow_cast<std::ptrdiff_t>( last_ - first_ );
+    }
+
+    gsl_api gsl_constexpr index_type size_bytes() const gsl_noexcept
+    {
+        return size() * narrow_cast<index_type>( sizeof( element_type ) );
+    }
+
+    gsl_api gsl_constexpr bool empty() const gsl_noexcept
+    {
+        return size() == 0;
+    }
+
+    // 26.7.3.5 Element access [span.elem]
+
+    gsl_api gsl_constexpr14 reference operator[]( index_type pos ) const
+    {
+        gsl_Expects( pos < size() );
+        return first_[ pos ];
+    }
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 6 )
+    gsl_DEPRECATED_MSG("use subscript indexing instead")
+    gsl_api gsl_constexpr14 reference operator()( index_type pos ) const
+    {
+        return (*this)[ pos ];
+    }
+
+    gsl_DEPRECATED_MSG("use subscript indexing instead")
+    gsl_api gsl_constexpr14 reference at( index_type pos ) const
+    {
+        return (*this)[ pos ];
+    }
+#endif // deprecate
+
+    gsl_api gsl_constexpr14 reference front() const
+    {
+        gsl_Expects( first_ != last_ );
+        return *first_;
+    }
+
+    gsl_api gsl_constexpr14 reference back() const
+    {
+        gsl_Expects( first_ != last_ );
+        return *(last_ - 1);
+    }
+
+    gsl_api gsl_constexpr pointer data() const gsl_noexcept
+    {
+        return first_;
+    }
+
+    // 26.7.3.6 Iterator support [span.iterators]
+
+    gsl_api gsl_constexpr iterator begin() const gsl_noexcept
+    {
+        return iterator( first_ );
+    }
+
+    gsl_api gsl_constexpr iterator end() const gsl_noexcept
+    {
+        return iterator( last_ );
+    }
+
+    gsl_api gsl_constexpr const_iterator cbegin() const gsl_noexcept
+    {
+#if gsl_CPP11_OR_GREATER
+        return { begin() };
+#else
+        return const_iterator( begin() );
+#endif
+    }
+
+    gsl_api gsl_constexpr const_iterator cend() const gsl_noexcept
+    {
+#if gsl_CPP11_OR_GREATER
+        return { end() };
+#else
+        return const_iterator( end() );
+#endif
+    }
+
+    gsl_constexpr17 reverse_iterator rbegin() const gsl_noexcept
+    {
+        return reverse_iterator( end() );
+    }
+
+    gsl_constexpr17 reverse_iterator rend() const gsl_noexcept
+    {
+        return reverse_iterator( begin() );
+    }
+
+    gsl_constexpr17 const_reverse_iterator crbegin() const gsl_noexcept
+    {
+        return const_reverse_iterator( cend() );
+    }
+
+    gsl_constexpr17 const_reverse_iterator crend() const gsl_noexcept
+    {
+        return const_reverse_iterator( cbegin() );
+    }
+
+    gsl_constexpr14 void swap( span & other ) gsl_noexcept
+    {
+        std::swap( first_, other.first_ );
+        std::swap( last_ , other.last_  );
+    }
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 3 )
+    // member length() deprecated since 0.29.0
+
+    gsl_DEPRECATED_MSG("use size() instead")
+    gsl_api gsl_constexpr index_type length() const gsl_noexcept
+    {
+        return size();
+    }
+
+    // member length_bytes() deprecated since 0.29.0
+
+    gsl_DEPRECATED_MSG("use size_bytes() instead")
+    gsl_api gsl_constexpr index_type length_bytes() const gsl_noexcept
+    {
+        return size_bytes();
+    }
+#endif
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 2 )
+    // member as_bytes(), as_writeable_bytes deprecated since 0.17.0
+
+    gsl_DEPRECATED_MSG("use free function gsl::as_bytes() instead")
+    gsl_api span< const byte > as_bytes() const gsl_noexcept
+    {
+        return span< const byte >( reinterpret_cast<const byte *>( data() ), size_bytes() ); // NOLINT
+    }
+
+    gsl_DEPRECATED_MSG("use free function gsl::as_writable_bytes() instead")
+    gsl_api span< byte > as_writeable_bytes() const gsl_noexcept
+    {
+        return span< byte >( reinterpret_cast<byte *>( data() ), size_bytes() ); // NOLINT
+    }
+
+#endif
+
+    template< class U >
+    gsl_api span< U > as_span() const
+    {
+        gsl_Expects( ( this->size_bytes() % sizeof(U) ) == 0 );
+        return span< U >( reinterpret_cast<U *>( this->data() ), this->size_bytes() / sizeof( U ) ); // NOLINT
+    }
+
+private:
+    pointer first_;
+    pointer last_;
+};
+
+// class template argument deduction guides:
+
+#if gsl_HAVE( DEDUCTION_GUIDES )   // gsl_CPP17_OR_GREATER
+
+template< class T, size_t N >
+span( T (&)[N] ) -> span<T /*, N*/>;
+
+template< class T, size_t N >
+span( std::array<T, N> & ) -> span<T /*, N*/>;
+
+template< class T, size_t N >
+span( std::array<T, N> const & ) -> span<const T /*, N*/>;
+
+template< class Container >
+span( Container& ) -> span<typename Container::value_type>;
+
+template< class Container >
+span( Container const & ) -> span<const typename Container::value_type>;
+
+#endif // gsl_HAVE( DEDUCTION_GUIDES )
+
+// 26.7.3.7 Comparison operators [span.comparison]
+
+#if gsl_CONFIG( ALLOWS_SPAN_COMPARISON )
+# if gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+
+template< class T, class U >
+gsl_SUPPRESS_MSGSL_WARNING(stl.1)
+inline gsl_constexpr bool operator==( span<T> const & l, span<U> const & r )
+{
+    return  l.size()  == r.size()
+        && (l.begin() == r.begin() || std::equal( l.begin(), l.end(), r.begin() ) );
+}
+
+template< class T, class U >
+gsl_SUPPRESS_MSGSL_WARNING(stl.1)
+inline gsl_constexpr bool operator< ( span<T> const & l, span<U> const & r )
+{
+    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
+}
+
+# else // a.k.a. !gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+
+template< class T >
+gsl_SUPPRESS_MSGSL_WARNING(stl.1)
+inline gsl_constexpr bool operator==( span<T> const & l, span<T> const & r )
+{
+    return  l.size()  == r.size()
+        && (l.begin() == r.begin() || std::equal( l.begin(), l.end(), r.begin() ) );
+}
+
+template< class T >
+gsl_SUPPRESS_MSGSL_WARNING(stl.1)
+inline gsl_constexpr bool operator< ( span<T> const & l, span<T> const & r )
+{
+    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
+}
+# endif // gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+
+template< class T, class U >
+inline gsl_constexpr bool operator!=( span<T> const & l, span<U> const & r )
+{
+    return !( l == r );
+}
+
+template< class T, class U >
+inline gsl_constexpr bool operator<=( span<T> const & l, span<U> const & r )
+{
+    return !( r < l );
+}
+
+template< class T, class U >
+inline gsl_constexpr bool operator> ( span<T> const & l, span<U> const & r )
+{
+    return ( r < l );
+}
+
+template< class T, class U >
+inline gsl_constexpr bool operator>=( span<T> const & l, span<U> const & r )
+{
+    return !( l < r );
+}
+#endif // gsl_CONFIG( ALLOWS_SPAN_COMPARISON )
+
+// span algorithms
+
+template< class T >
+gsl_api inline gsl_constexpr std::size_t size( span<T> const & spn )
+{
+    return static_cast<std::size_t>( spn.size() );
+}
+
+template< class T >
+gsl_api inline gsl_constexpr std::ptrdiff_t ssize( span<T> const & spn )
+{
+    return spn.ssize();
+}
+
+namespace detail {
+
+template< class II, class N, class OI >
+gsl_api gsl_constexpr14 inline OI copy_n( II first, N count, OI result )
+{
+    if ( count > 0 )
+    {
+        *result++ = *first;
+        for ( N i = 1; i < count; ++i )
+        {
+            *result++ = *++first;
+        }
+    }
+    return result;
+}
+}
+
+template< class T, class U >
+gsl_api gsl_constexpr14 inline void copy( span<T> src, span<U> dest )
+{
+#if gsl_CPP14_OR_GREATER // gsl_HAVE( TYPE_TRAITS ) (circumvent Travis clang 3.4)
+    static_assert( std::is_assignable<U &, T const &>::value, "Cannot assign elements of source span to elements of destination span" );
+#endif
+    gsl_Expects( dest.size() >= src.size() );
+    detail::copy_n( src.data(), src.size(), dest.data() );
+}
+
+// span creator functions (see ctors)
+
+template< class T >
+gsl_api inline span< const byte > as_bytes( span<T> spn ) gsl_noexcept
+{
+    return span< const byte >( reinterpret_cast<const byte *>( spn.data() ), spn.size_bytes() ); // NOLINT
+}
+
+template< class T>
+gsl_api inline span< byte > as_writable_bytes( span<T> spn ) gsl_noexcept
+{
+    return span< byte >( reinterpret_cast<byte *>( spn.data() ), spn.size_bytes() ); // NOLINT
+}
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 6 )
+template< class T>
+gsl_DEPRECATED_MSG("use as_writable_bytes() (different spelling) instead")
+gsl_api inline span< byte > as_writeable_bytes( span<T> spn ) gsl_noexcept
+{
+    return span< byte >( reinterpret_cast<byte *>( spn.data() ), spn.size_bytes() ); // NOLINT
+}
+#endif // deprecate
+
+#if gsl_FEATURE_TO_STD( MAKE_SPAN )
+
+template< class T >
+gsl_api inline gsl_constexpr span<T>
+make_span( T * ptr, typename span<T>::index_type count )
+{
+    return span<T>( ptr, count );
+}
+
+template< class T >
+gsl_api inline gsl_constexpr span<T>
+make_span( T * first, T * last )
+{
+    return span<T>( first, last );
+}
+
+template< class T, size_t N >
+gsl_api inline gsl_constexpr span<T>
+make_span( T (&arr)[N] )
+{
+    return span<T>( gsl_ADDRESSOF( arr[0] ), N );
+}
+
+#if gsl_HAVE( ARRAY )
+
+template< class T, size_t N >
+inline gsl_constexpr span<T>
+make_span( std::array<T,N> & arr )
+{
+    return span<T>( arr );
+}
+
+template< class T, size_t N >
+inline gsl_constexpr span<const T>
+make_span( std::array<T,N> const & arr )
+{
+    return span<const T>( arr );
+}
+#endif
+
+#if gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR ) && gsl_HAVE( AUTO )
+
+template< class Container, class EP = decltype( std17::data(std::declval<Container&>())) >
+inline gsl_constexpr auto
+make_span( Container & cont ) -> span< typename std::remove_pointer<EP>::type >
+{
+    return span< typename std::remove_pointer<EP>::type >( cont );
+}
+
+template< class Container, class EP = decltype( std17::data(std::declval<Container&>())) >
+inline gsl_constexpr auto
+make_span( Container const & cont ) -> span< const typename std::remove_pointer<EP>::type >
+{
+    return span< const typename std::remove_pointer<EP>::type >( cont );
+}
+
+#else
+
+template< class T >
+inline span<T>
+make_span( std::vector<T> & cont )
+{
+    return span<T>( with_container, cont );
+}
+
+template< class T >
+inline span<const T>
+make_span( std::vector<T> const & cont )
+{
+    return span<const T>( with_container, cont );
+}
+#endif
+
+#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
+
+template< class Container >
+inline gsl_constexpr span<typename Container::value_type>
+make_span( with_container_t, Container & cont ) gsl_noexcept
+{
+    return span< typename Container::value_type >( with_container, cont );
+}
+
+template< class Container >
+inline gsl_constexpr span<const typename Container::value_type>
+make_span( with_container_t, Container const & cont ) gsl_noexcept
+{
+    return span< const typename Container::value_type >( with_container, cont );
+}
+
+#endif // gsl_FEATURE_TO_STD( WITH_CONTAINER )
+
+#if !gsl_DEPRECATE_TO_LEVEL( 4 )
+template< class Ptr >
+gsl_DEPRECATED
+inline span<typename Ptr::element_type>
+make_span( Ptr & ptr )
+{
+    return span<typename Ptr::element_type>( ptr );
+}
+#endif // !gsl_DEPRECATE_TO_LEVEL( 4 )
+
+template< class Ptr >
+gsl_DEPRECATED
+inline span<typename Ptr::element_type>
+make_span( Ptr & ptr, typename span<typename Ptr::element_type>::index_type count )
+{
+    return span<typename Ptr::element_type>( ptr, count );
+}
+
+#endif // gsl_FEATURE_TO_STD( MAKE_SPAN )
+
+#if gsl_FEATURE_TO_STD( BYTE_SPAN )
+
+template< class T >
+gsl_api inline gsl_constexpr span<byte>
+byte_span( T & t ) gsl_noexcept
+{
+    return span<byte>( reinterpret_cast<byte *>( &t ), sizeof(T) );
+}
+
+template< class T >
+gsl_api inline gsl_constexpr span<const byte>
+byte_span( T const & t ) gsl_noexcept
+{
+    return span<const byte>( reinterpret_cast<byte const *>( &t ), sizeof(T) );
+}
+
+#endif // gsl_FEATURE_TO_STD( BYTE_SPAN )
+
+//
+// basic_string_span:
+//
+
+template< class T >
+class basic_string_span;
+
+namespace detail {
+
+template< class T >
+struct is_basic_string_span_oracle : std11::false_type {};
+
+template< class T >
+struct is_basic_string_span_oracle< basic_string_span<T> > : std11::true_type {};
+
+template< class T >
+struct is_basic_string_span : is_basic_string_span_oracle< typename std11::remove_cv<T>::type > {};
+
+template< class T >
+gsl_api inline gsl_constexpr14 std::size_t string_length( T * ptr, std::size_t max )
+{
+    if ( ptr == gsl_nullptr || max <= 0 )
+        return 0;
+
+    std::size_t len = 0;
+    while ( len < max && ptr[len] ) // NOLINT
+        ++len;
+
+    return len;
+}
+
+} // namespace detail
+
+//
+// basic_string_span<> - A view of contiguous characters, replace (*,len).
+//
+template< class T >
+class basic_string_span
+{
+public:
+    typedef T element_type;
+    typedef span<T> span_type;
+
+    typedef typename span_type::index_type index_type;
+    typedef typename span_type::difference_type difference_type;
+
+    typedef typename span_type::pointer pointer ;
+    typedef typename span_type::reference reference ;
+
+    typedef typename span_type::iterator iterator ;
+    typedef typename span_type::const_iterator const_iterator ;
+    typedef typename span_type::reverse_iterator reverse_iterator;
+    typedef typename span_type::const_reverse_iterator const_reverse_iterator;
+
+    // construction:
+
+#if gsl_HAVE( IS_DEFAULT )
+    gsl_constexpr basic_string_span() gsl_noexcept = default;
+#else
+    gsl_api gsl_constexpr basic_string_span() gsl_noexcept {}
+#endif
+
+#if gsl_HAVE( NULLPTR )
+    gsl_api gsl_constexpr basic_string_span( std::nullptr_t ) gsl_noexcept
+    : span_( nullptr, static_cast<index_type>( 0 ) )
+    {}
+#endif
+
+#ifdef __CUDACC_RELAXED_CONSTEXPR__
+    gsl_api
+#endif // __CUDACC_RELAXED_CONSTEXPR__
+    gsl_constexpr basic_string_span( pointer ptr )
+    : span_( remove_z( ptr, (std::numeric_limits<index_type>::max)() ) )
+    {}
+
+    gsl_api gsl_constexpr basic_string_span( pointer ptr, index_type count )
+    : span_( ptr, count )
+    {}
+
+    gsl_api gsl_constexpr basic_string_span( pointer firstElem, pointer lastElem )
+    : span_( firstElem, lastElem )
+    {}
+
+    template< std::size_t N >
+    gsl_api gsl_constexpr basic_string_span( element_type (&arr)[N] )
+    : span_( remove_z( gsl_ADDRESSOF( arr[0] ), N ) )
+    {}
+
+#if gsl_HAVE( ARRAY )
+
+    template< std::size_t N >
+    gsl_constexpr basic_string_span( std::array< typename std11::remove_const<element_type>::type, N> & arr )
+    : span_( remove_z( arr ) )
+    {}
+
+    template< std::size_t N >
+    gsl_constexpr basic_string_span( std::array< typename std11::remove_const<element_type>::type, N> const & arr )
+    : span_( remove_z( arr ) )
+    {}
+
+#endif
+
+#if gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+
+    // Exclude: array, [basic_string,] basic_string_span
+
+    template< class Container
+        gsl_ENABLE_IF_((
+            ! detail::is_std_array< Container >::value
+            && ! detail::is_basic_string_span< Container >::value
+            && std::is_convertible< typename Container::pointer, pointer >::value
+            && std::is_convertible< typename Container::pointer, decltype(std::declval<Container>().data()) >::value
+        ))
+    >
+    gsl_constexpr basic_string_span( Container & cont )
+    : span_( ( cont ) )
+    {}
+
+    // Exclude: array, [basic_string,] basic_string_span
+
+    template< class Container
+        gsl_ENABLE_IF_((
+            ! detail::is_std_array< Container >::value
+            && ! detail::is_basic_string_span< Container >::value
+            && std::is_convertible< typename Container::pointer, pointer >::value
+            && std::is_convertible< typename Container::pointer, decltype(std::declval<Container const &>().data()) >::value
+        ))
+    >
+    gsl_constexpr basic_string_span( Container const & cont )
+    : span_( ( cont ) )
+    {}
+
+#elif gsl_HAVE( UNCONSTRAINED_SPAN_CONTAINER_CTOR )
+
+    template< class Container >
+    gsl_constexpr basic_string_span( Container & cont )
+    : span_( cont )
+    {}
+
+    template< class Container >
+    gsl_constexpr basic_string_span( Container const & cont )
+    : span_( cont )
+    {}
+
+#else
+
+    template< class U >
+    gsl_api gsl_constexpr basic_string_span( span<U> const & rhs )
+    : span_( rhs )
+    {}
+
+#endif
+
+#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
+
+    template< class Container >
+    gsl_constexpr basic_string_span( with_container_t, Container & cont )
+    : span_( with_container, cont )
+    {}
+#endif
+
+#if gsl_HAVE( IS_DEFAULT )
+# if gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 440, 600 )
+    gsl_constexpr basic_string_span( basic_string_span const & rhs ) = default;
+
+    gsl_constexpr basic_string_span( basic_string_span && rhs ) = default;
+# else
+    gsl_constexpr basic_string_span( basic_string_span const & rhs ) gsl_noexcept = default;
+
+    gsl_constexpr basic_string_span( basic_string_span && rhs ) gsl_noexcept = default;
+# endif
+#endif
+
+    template< class U
+        gsl_ENABLE_IF_(( std::is_convertible<typename basic_string_span<U>::pointer, pointer>::value ))
+    >
+    gsl_api gsl_constexpr basic_string_span( basic_string_span<U> const & rhs )
+    : span_( reinterpret_cast<pointer>( rhs.data() ), rhs.length() ) // NOLINT
+    {}
+
+#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
+    template< class U
+        gsl_ENABLE_IF_(( std::is_convertible<typename basic_string_span<U>::pointer, pointer>::value ))
+    >
+    gsl_api gsl_constexpr basic_string_span( basic_string_span<U> && rhs )
+    : span_( reinterpret_cast<pointer>( rhs.data() ), rhs.length() ) // NOLINT
+    {}
+#endif
+
+    template< class CharTraits, class Allocator >
+    gsl_constexpr basic_string_span(
+        std::basic_string< typename std11::remove_const<element_type>::type, CharTraits, Allocator > & str )
+    : span_( gsl_ADDRESSOF( str[0] ), str.length() )
+    {}
+
+    template< class CharTraits, class Allocator >
+    gsl_constexpr basic_string_span(
+        std::basic_string< typename std11::remove_const<element_type>::type, CharTraits, Allocator > const & str )
+    : span_( gsl_ADDRESSOF( str[0] ), str.length() )
+    {}
+
+    // assignment:
+
+#if gsl_HAVE( IS_DEFAULT )
+    gsl_constexpr14 basic_string_span & operator=( basic_string_span const & rhs ) gsl_noexcept = default;
+
+    gsl_constexpr14 basic_string_span & operator=( basic_string_span && rhs ) gsl_noexcept = default;
+#endif
+
+    // sub span:
+
+    /*gsl_api*/ // currently disabled due to an apparent NVCC bug
+    gsl_constexpr14 basic_string_span first( index_type count ) const
+    {
+        return span_.first( count );
+    }
+
+    /*gsl_api*/ // currently disabled due to an apparent NVCC bug
+    gsl_constexpr14 basic_string_span last( index_type count ) const
+    {
+        return span_.last( count );
+    }
+
+    /*gsl_api*/ // currently disabled due to an apparent NVCC bug
+    gsl_constexpr14 basic_string_span subspan( index_type offset ) const
+    {
+        return span_.subspan( offset );
+    }
+
+    /*gsl_api*/ // currently disabled due to an apparent NVCC bug
+    gsl_constexpr14 basic_string_span subspan( index_type offset, index_type count ) const
+    {
+        return span_.subspan( offset, count );
+    }
+
+    // observers:
+
+    gsl_api gsl_constexpr index_type length() const gsl_noexcept
+    {
+        return span_.size();
+    }
+
+    gsl_api gsl_constexpr index_type size() const gsl_noexcept
+    {
+        return span_.size();
+    }
+
+    gsl_api gsl_constexpr index_type length_bytes() const gsl_noexcept
+    {
+        return span_.size_bytes();
+    }
+
+    gsl_api gsl_constexpr index_type size_bytes() const gsl_noexcept
+    {
+        return span_.size_bytes();
+    }
+
+    gsl_api gsl_constexpr bool empty() const gsl_noexcept
+    {
+        return size() == 0;
+    }
+
+    gsl_api gsl_constexpr14 reference operator[]( index_type idx ) const
+    {
+        return span_[idx];
+    }
+
+#if ! gsl_DEPRECATE_TO_LEVEL( 6 )
+    gsl_DEPRECATED_MSG("use subscript indexing instead")
+    gsl_api gsl_constexpr14 reference operator()( index_type idx ) const
+    {
+        return span_[idx];
+    }
+#endif // deprecate
+
+    gsl_api gsl_constexpr14 reference front() const
+    {
+        return span_.front();
+    }
+
+    gsl_api gsl_constexpr14 reference back() const
+    {
+        return span_.back();
+    }
+
+    gsl_api gsl_constexpr pointer data() const gsl_noexcept
+    {
+        return span_.data();
+    }
+
+    gsl_api gsl_constexpr iterator begin() const gsl_noexcept
+    {
+        return span_.begin();
+    }
+
+    gsl_api gsl_constexpr iterator end() const gsl_noexcept
+    {
+        return span_.end();
+    }
+
+    gsl_constexpr17 reverse_iterator rbegin() const gsl_noexcept
+    {
+        return span_.rbegin();
+    }
+
+    gsl_constexpr17 reverse_iterator rend() const gsl_noexcept
+    {
+        return span_.rend();
+    }
+
+    // const version not in p0123r2:
+
+    gsl_api gsl_constexpr const_iterator cbegin() const gsl_noexcept
+    {
+        return span_.cbegin();
+    }
+
+    gsl_api gsl_constexpr const_iterator cend() const gsl_noexcept
+    {
+        return span_.cend();
+    }
+
+    gsl_constexpr17 const_reverse_iterator crbegin() const gsl_noexcept
+    {
+        return span_.crbegin();
+    }
+
+    gsl_constexpr17 const_reverse_iterator crend() const gsl_noexcept
+    {
+        return span_.crend();
+    }
+
+private:
+    gsl_api static gsl_constexpr14 span_type remove_z( pointer const & sz, std::size_t max )
+    {
+        return span_type( sz, detail::string_length( sz, max ) );
+    }
+
+#if gsl_HAVE( ARRAY )
+    template< size_t N >
+    static gsl_constexpr14 span_type remove_z( std::array<typename std11::remove_const<element_type>::type, N> & arr )
+    {
+        return remove_z( gsl_ADDRESSOF( arr[0] ), narrow_cast< std::size_t >( N ) );
+    }
+
+    template< size_t N >
+    static gsl_constexpr14 span_type remove_z( std::array<typename std11::remove_const<element_type>::type, N> const & arr )
+    {
+        return remove_z( gsl_ADDRESSOF( arr[0] ), narrow_cast< std::size_t >( N ) );
+    }
+#endif
+
+private:
+    span_type span_;
+};
+
+// basic_string_span comparison functions:
+
+#if gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+
+template< class T, class U >
+gsl_SUPPRESS_MSGSL_WARNING(stl.1)
+inline gsl_constexpr14 bool operator==( basic_string_span<T> const & l, U const & u ) gsl_noexcept
+{
+    const basic_string_span< typename std11::add_const<T>::type > r( u );
+
+    return l.size() == r.size()
+        && std::equal( l.begin(), l.end(), r.begin() );
+}
+
+template< class T, class U >
+gsl_SUPPRESS_MSGSL_WARNING(stl.1)
+inline gsl_constexpr14 bool operator<( basic_string_span<T> const & l, U const & u ) gsl_noexcept
+{
+    const basic_string_span< typename std11::add_const<T>::type > r( u );
+
+    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
+}
+
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+
+template< class T, class U
+    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
+>
+gsl_SUPPRESS_MSGSL_WARNING(stl.1)
+inline gsl_constexpr14 bool operator==( U const & u, basic_string_span<T> const & r ) gsl_noexcept
+{
+    const basic_string_span< typename std11::add_const<T>::type > l( u );
+
+    return l.size() == r.size()
+        && std::equal( l.begin(), l.end(), r.begin() );
+}
+
+template< class T, class U
+    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
+>
+gsl_SUPPRESS_MSGSL_WARNING(stl.1)
+inline gsl_constexpr14 bool operator<( U const & u, basic_string_span<T> const & r ) gsl_noexcept
+{
+    const basic_string_span< typename std11::add_const<T>::type > l( u );
+
+    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
+}
+#endif
+
+#else //gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+
+template< class T >
+gsl_SUPPRESS_MSGSL_WARNING(stl.1)
+inline gsl_constexpr14 bool operator==( basic_string_span<T> const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return l.size() == r.size()
+        && std::equal( l.begin(), l.end(), r.begin() );
+}
+
+template< class T >
+gsl_SUPPRESS_MSGSL_WARNING(stl.1)
+inline gsl_constexpr14 bool operator<( basic_string_span<T> const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
+}
+
+#endif // gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+
+template< class T, class U >
+inline gsl_constexpr14 bool operator!=( basic_string_span<T> const & l, U const & r ) gsl_noexcept
+{
+    return !( l == r );
+}
+
+template< class T, class U >
+inline gsl_constexpr14 bool operator<=( basic_string_span<T> const & l, U const & r ) gsl_noexcept
+{
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) || ! gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+    return !( r < l );
+#else
+    basic_string_span< typename std11::add_const<T>::type > rr( r );
+    return !( rr < l );
+#endif
+}
+
+template< class T, class U >
+inline gsl_constexpr14 bool operator>( basic_string_span<T> const & l, U const & r ) gsl_noexcept
+{
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) || ! gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+    return ( r < l );
+#else
+    basic_string_span< typename std11::add_const<T>::type > rr( r );
+    return ( rr < l );
+#endif
+}
+
+template< class T, class U >
+inline gsl_constexpr14 bool operator>=( basic_string_span<T> const & l, U const & r ) gsl_noexcept
+{
+    return !( l < r );
+}
+
+#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+
+template< class T, class U
+    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
+>
+inline gsl_constexpr14 bool operator!=( U const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return !( l == r );
+}
+
+template< class T, class U
+    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
+>
+inline gsl_constexpr14 bool operator<=( U const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return !( r < l );
+}
+
+template< class T, class U
+    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
+>
+inline gsl_constexpr14 bool operator>( U const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return ( r < l );
+}
+
+template< class T, class U
+    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
+>
+inline gsl_constexpr14 bool operator>=( U const & l, basic_string_span<T> const & r ) gsl_noexcept
+{
+    return !( l < r );
+}
+
+#endif // gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+
+// convert basic_string_span to byte span:
+
+template< class T >
+gsl_api inline span< const byte > as_bytes( basic_string_span<T> spn ) gsl_noexcept
+{
+    return span< const byte >( reinterpret_cast<const byte *>( spn.data() ), spn.size_bytes() ); // NOLINT
+}
+
+//
+// String types:
+//
+
+typedef char * zstring;
+typedef const char * czstring;
+
+#if gsl_HAVE( WCHAR )
+typedef wchar_t * wzstring;
+typedef const wchar_t * cwzstring;
+#endif
+
+typedef basic_string_span< char > string_span;
+typedef basic_string_span< char const > cstring_span;
+
+#if gsl_HAVE( WCHAR )
+typedef basic_string_span< wchar_t > wstring_span;
+typedef basic_string_span< wchar_t const > cwstring_span;
+#endif
+
+// to_string() allow (explicit) conversions from string_span to string
+
+#if 0
+
+template< class T >
+inline std::basic_string< typename std::remove_const<T>::type > to_string( basic_string_span<T> spn )
+{
+     std::string( spn.data(), spn.length() );
+}
+
+#else
+
+inline std::string to_string( string_span const & spn )
+{
+    return std::string( spn.data(), spn.length() );
+}
+
+inline std::string to_string( cstring_span const & spn )
+{
+    return std::string( spn.data(), spn.length() );
+}
+
+#if gsl_HAVE( WCHAR )
+
+inline std::wstring to_string( wstring_span const & spn )
+{
+    return std::wstring( spn.data(), spn.length() );
+}
+
+inline std::wstring to_string( cwstring_span const & spn )
+{
+    return std::wstring( spn.data(), spn.length() );
+}
+
+#endif // gsl_HAVE( WCHAR )
+#endif // to_string()
+
+//
+// Stream output for string_span types
+//
+
+namespace detail {
+
+template< class Stream >
+void write_padding( Stream & os, std::streamsize n )
+{
+    for ( std::streamsize i = 0; i < n; ++i )
+        os.rdbuf()->sputc( os.fill() );
+}
+
+template< class Stream, class Span >
+Stream & write_to_stream( Stream & os, Span const & spn )
+{
+    typename Stream::sentry sentry( os );
+
+    if ( !os )
+        return os;
+
+    const std::streamsize length = narrow<std::streamsize>( spn.length() );
+
+    // Whether, and how, to pad
+    const bool pad = ( length < os.width() );
+    const bool left_pad = pad && ( os.flags() & std::ios_base::adjustfield ) == std::ios_base::right;
+
+    if ( left_pad )
+        write_padding( os, os.width() - length );
+
+    // Write span characters
+    os.rdbuf()->sputn( spn.begin(), length );
+
+    if ( pad && !left_pad )
+        write_padding( os, os.width() - length );
+
+    // Reset output stream width
+    os.width(0);
+
+    return os;
+}
+
+} // namespace detail
+
+template< typename Traits >
+std::basic_ostream< char, Traits > & operator<<( std::basic_ostream< char, Traits > & os, string_span const & spn )
+{
+    return detail::write_to_stream( os, spn );
+}
+
+template< typename Traits >
+std::basic_ostream< char, Traits > & operator<<( std::basic_ostream< char, Traits > & os, cstring_span const & spn )
+{
+    return detail::write_to_stream( os, spn );
+}
+
+#if gsl_HAVE( WCHAR )
+
+template< typename Traits >
+std::basic_ostream< wchar_t, Traits > & operator<<( std::basic_ostream< wchar_t, Traits > & os, wstring_span const & spn )
+{
+    return detail::write_to_stream( os, spn );
+}
+
+template< typename Traits >
+std::basic_ostream< wchar_t, Traits > & operator<<( std::basic_ostream< wchar_t, Traits > & os, cwstring_span const & spn )
+{
+    return detail::write_to_stream( os, spn );
+}
+
+#endif // gsl_HAVE( WCHAR )
+
+//
+// ensure_sentinel()
+//
+// Provides a way to obtain a span from a contiguous sequence
+// that ends with a (non-inclusive) sentinel value.
+//
+// Will fail-fast if sentinel cannot be found before max elements are examined.
+//
+namespace detail {
+
+template< class T, class SizeType, const T Sentinel >
+gsl_api static span<T> ensure_sentinel( T * seq, SizeType max = (std::numeric_limits<SizeType>::max)() )
+{
+    typedef T * pointer;
+
+    gsl_SUPPRESS_MSVC_WARNING( 26429, "f.23: symbol 'cur' is never tested for nullness, it can be marked as not_null" )
+    pointer cur = seq;
+
+    while ( static_cast<SizeType>( cur - seq ) < max && *cur != Sentinel )
+        ++cur;
+
+    gsl_Expects( *cur == Sentinel );
+
+    return span<T>( seq, narrow_cast< typename span<T>::index_type >( cur - seq ) );
+}
+} // namespace detail
+
+//
+// ensure_z - creates a string_span for a czstring or cwzstring.
+// Will fail fast if a null-terminator cannot be found before
+// the limit of size_type.
+//
+
+template< class T >
+gsl_api inline span<T> ensure_z( T * const & sz, size_t max = (std::numeric_limits<size_t>::max)() )
+{
+    return detail::ensure_sentinel<T, size_t, 0>( sz, max );
+}
+
+template< class T, size_t N >
+gsl_api inline span<T> ensure_z( T (&sz)[N] )
+{
+    return ::gsl::ensure_z( gsl_ADDRESSOF( sz[0] ), N );
+}
+
+# if gsl_HAVE( TYPE_TRAITS )
+
+template< class Container >
+inline span< typename std::remove_pointer<typename Container::pointer>::type >
+ensure_z( Container & cont )
+{
+    return ::gsl::ensure_z( cont.data(), cont.length() );
+}
+# endif
+
+//
+// basic_zstring_span<> - A view of contiguous null-terminated characters, replace (*,len).
+//
+
+template <typename T>
+class basic_zstring_span
+{
+public:
+    typedef T element_type;
+    typedef span<T> span_type;
+
+    typedef typename span_type::index_type index_type;
+    typedef typename span_type::difference_type difference_type;
+
+    typedef element_type * czstring_type;
+    typedef basic_string_span<element_type> string_span_type;
+
+    gsl_api gsl_constexpr14 basic_zstring_span( span_type s )
+        : span_( s )
+    {
+        // expects a zero-terminated span
+        gsl_Expects( s[s.size() - 1] == '\0');
+    }
+
+#if gsl_HAVE( IS_DEFAULT )
+    gsl_constexpr basic_zstring_span( basic_zstring_span const & other ) = default;
+    gsl_constexpr basic_zstring_span( basic_zstring_span &&      other ) = default;
+    gsl_constexpr14 basic_zstring_span & operator=( basic_zstring_span const & other ) = default;
+    gsl_constexpr14 basic_zstring_span & operator=( basic_zstring_span &&      other ) = default;
+#else
+    gsl_api gsl_constexpr basic_zstring_span( basic_zstring_span const & other) : span_ ( other.span_ ) {}
+    gsl_api gsl_constexpr basic_zstring_span & operator=( basic_zstring_span const & other ) { span_ = other.span_; return *this; }
+#endif
+
+    gsl_api gsl_constexpr bool empty() const gsl_noexcept
+    {
+        return span_.size() == 0;
+    }
+
+    gsl_api gsl_constexpr string_span_type as_string_span() const gsl_noexcept
+    {
+        return string_span_type( span_.data(), span_.size() > 1 ? span_.size() - 1 : 0 );
+    }
+
+    /*gsl_api*/ // currently disabled due to an apparent NVCC bug
+    gsl_constexpr string_span_type ensure_z() const
+    {
+        return ::gsl::ensure_z(span_.data(), span_.size());
+    }
+
+    gsl_api gsl_constexpr czstring_type assume_z() const gsl_noexcept
+    {
+        return span_.data();
+    }
+
+private:
+    span_type span_;
+};
+
+//
+// zString types:
+//
+
+typedef basic_zstring_span< char > zstring_span;
+typedef basic_zstring_span< char const > czstring_span;
+
+#if gsl_HAVE( WCHAR )
+typedef basic_zstring_span< wchar_t > wzstring_span;
+typedef basic_zstring_span< wchar_t const > cwzstring_span;
+#endif
+
+} // namespace gsl
+
+#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
+
+namespace std {
+
+template<>
+struct hash< ::gsl::byte >
+{
+public:
+    gsl_constexpr std::size_t operator()( ::gsl::byte v ) const gsl_noexcept
+    {
+        return ::gsl::to_integer<std::size_t>( v );
+    }
+};
+
+} // namespace std
+
+#endif
+
+#if gsl_FEATURE_GSL_LITE_NAMESPACE
+
+// gsl_lite namespace:
+
+// gsl-lite currently keeps all symbols in the namespace `gsl`. The `gsl_lite` namespace contains all the symbols in the
+// `gsl` namespace, plus some extensions that are not specified in the Core Guidelines.
+//
+// Going forward, we want to support coexistence of gsl-lite with M-GSL, so we want to encourage using the `gsl_lite`
+// namespace when consuming gsl-lite. Typical use in library code would be:
+//
+//     #include <gsl-lite/gsl-lite.hpp> // instead of <gsl/gsl-lite.hpp>
+//
+//     namespace foo {
+//         namespace gsl = ::gsl_lite; // convenience alias
+//         double mean(gsl::span<double const> elements) {
+//             gsl_Expects(!elements.empty()); // instead of Expects()
+//             ...
+//         }
+//     } // namespace foo
+//
+// In a future version, the new <gsl-lite/gsl-lite.hpp> header will only define the `gsl_lite` namespace and no
+// unprefixed `Expects()` and `Ensures()` macros to avoid collision with M-GSL. To ensure backward compatibility, the
+// old header <gsl/gsl-lite.hpp> will keep defining the `gsl` namespace and the `Expects()` and `Ensures()` macros.
+
+namespace gsl_lite
+{
+
+namespace std11 = ::gsl::std11;
+namespace std14 = ::gsl::std14;
+namespace std17 = ::gsl::std17;
+namespace std20 = ::gsl::std20;
+
+using namespace std11;
+using namespace std14;
+using namespace std17;
+using namespace std20;
+
+#if gsl_HAVE( SHARED_PTR )
+using std::unique_ptr;
+using std::shared_ptr;
+using std::make_shared;
+#endif
+
+using ::gsl::index;
+
+// Integer type for dimensions.
+typedef gsl_CONFIG_INDEX_TYPE dim;
+
+// Integer type for array strides.
+typedef gsl_CONFIG_INDEX_TYPE stride;
+
+// Integer type for pointer, iterator, or index differences.
+typedef gsl_CONFIG_INDEX_TYPE diff;
+
+#if  gsl_HAVE( ALIAS_TEMPLATE )
+using ::gsl::owner;
+#endif
+
+using ::gsl::fail_fast;
+
+using ::gsl::finally;
+#if gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+using ::gsl::on_return;
+using ::gsl::on_error;
+#endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+
+using ::gsl::narrow_cast;
+using ::gsl::narrowing_error;
+using ::gsl::narrow;
+using ::gsl::narrow_failfast;
+
+
+using ::gsl::at;
+
+using ::gsl::not_null;
+using ::gsl::make_not_null;
+
+using ::gsl::byte;
+
+using ::gsl::with_container_t;
+using ::gsl::with_container;
+
+using ::gsl::span;
+using ::gsl::make_span;
+using ::gsl::byte_span;
+using ::gsl::copy;
+using ::gsl::as_bytes;
+using ::gsl::as_writable_bytes;
+#if ! gsl_DEPRECATE_TO_LEVEL( 6 )
+using ::gsl::as_writeable_bytes;
+#endif
+
+using ::gsl::basic_string_span;
+using ::gsl::string_span;
+using ::gsl::cstring_span;
+
+using ::gsl::basic_zstring_span;
+using ::gsl::zstring_span;
+using ::gsl::czstring_span;
+
+using ::gsl::zstring;
+using ::gsl::czstring;
+
+#if gsl_HAVE( WCHAR )
+using ::gsl::wzstring;
+using ::gsl::cwzstring;
+
+using ::gsl::wzstring_span;
+using ::gsl::cwzstring_span;
+#endif // gsl_HAVE( WCHAR )
+
+} // namespace gsl_lite
+
+#endif // gsl_FEATURE_GSL_LITE_NAMESPACE
+
+gsl_RESTORE_MSVC_WARNINGS()
+
+#endif // GSL_GSL_LITE_HPP_INCLUDED
+
+// end of file
diff --git a/modules/cpu/src/runtime/io_utils.h b/modules/cpu/src/runtime/io_utils.h
index 3918c1a3fe..836cd8e73c 100644
--- a/modules/cpu/src/runtime/io_utils.h
+++ b/modules/cpu/src/runtime/io_utils.h
@@ -1,7 +1,7 @@
 #pragma once
 #include <filesystem>
 #include <fstream>
-#include <gsl/gsl-lite.hpp>
+#include "gsl-lite.hpp"
 #include <vector>
 
 inline std::vector<uint8_t> read_stream(std::istream &stream) {
diff --git a/modules/cpu/src/runtime/method_table_impl.h b/modules/cpu/src/runtime/method_table_impl.h
index 1c55881c58..aa183d80ba 100644
--- a/modules/cpu/src/runtime/method_table_impl.h
+++ b/modules/cpu/src/runtime/method_table_impl.h
@@ -64,7 +64,7 @@ inline bool bool_binary_logical_and(bool x, bool y) { return x && y; }
 inline bool bool_binary_logical_or(bool x, bool y) { return x || y; }
 inline bool bool_binary_logical_xor(bool x, bool y) { return x ^ y; }
 
-static nncase_mt_t nncase_mt = {fabsf,
+[[maybe_unused]] static nncase_mt_t nncase_mt = {fabsf,
                                 acosf,
                                 acoshf,
                                 asinf,
@@ -118,7 +118,7 @@ static nncase_mt_t nncase_mt = {fabsf,
 
 inline void *rt_malloc(size_t size) { return (void *)new uint8_t[size](); }
 
-static runtime_util_mt runtime_util = {
+[[maybe_unused]] static runtime_util_mt runtime_util = {
     printf,
     rt_malloc,
     free,
@@ -128,7 +128,7 @@ static runtime_util_mt runtime_util = {
     memcpy,
     memset};
 
-static hardware_context_mt hw_ctx_mt = {
+[[maybe_unused]] static hardware_context_mt hw_ctx_mt = {
     hardware_context::lock_block,   hardware_context::mark_block_visit,
     hardware_context::unlock_block, hardware_context::wait_block_sync,
     hardware_context::lock_all,     hardware_context::mark_all_visit,
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 2b4d7e3a8f..8f6065ddfd 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -47,7 +47,7 @@ cpu_runtime_module &cpu_runtime_function::module() const noexcept {
 
 result<void> cpu_runtime_function::initialize_core(
     NNCASE_UNUSED runtime_function_init_context &context) noexcept {
-
+    text_ = module().text_physical().subspan(context.header().entrypoint, context.header().text_size);
     // try_(context.read_section(".desc", [this](auto sr, size_t) ->
     // result<void> {
     //     auto header = sr.template read<desc_header>();
@@ -111,7 +111,7 @@ result<void> cpu_runtime_function::initialize_core(
 result<value_t>
 cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
                                   NNCASE_UNUSED value_t return_value) noexcept {
-    try_var(id, module().find_id_by_function(this));
+    // try_var(id, module().find_id_by_function(this));
 
     uint8_t **buffers = new uint8_t *[parameters.size()];
     // input buffer
@@ -121,9 +121,8 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
         buffers[i] = (uint8_t *)(input_span.data());
     }
 
-    auto elfloader_ = elfloader{(char *)module().text_physical().data()};
-    elfloader_.invoke_elf(id, buffers, &nncase_mt, nullptr,
-                          (const uint8_t *)module().rdata_physical().data());
+    auto elfloader_ = elfloader{(char *)text_.data()};
+    elfloader_.invoke_elf(&hw_ctx_mt, &runtime_util, &nncase_mt, buffers);
 
     delete[] buffers;
 
diff --git a/modules/cpu/src/runtime/runtime_function.h b/modules/cpu/src/runtime/runtime_function.h
index 74b24e0319..9bee025935 100644
--- a/modules/cpu/src/runtime/runtime_function.h
+++ b/modules/cpu/src/runtime/runtime_function.h
@@ -32,6 +32,7 @@ class cpu_runtime_function : public runtime_function {
                                 value_t return_value) noexcept override;
 
   private:
+    gsl::span<const gsl::byte> text_;
     // std::vector<uint32_t> input_ranks_;
     // std::vector<std::vector<uint32_t>> input_shapes_;
     // std::vector<std::vector<uint32_t>> input_strides_;
diff --git a/modules/cpu/src/runtime/runtime_types.h b/modules/cpu/src/runtime/runtime_types.h
deleted file mode 100644
index 0fa69d7913..0000000000
--- a/modules/cpu/src/runtime/runtime_types.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#pragma once
-#include <nncase/runtime/small_vector.hpp>
-
-using dims_t = itlib::small_vector<size_t, 8>;
-using strides_t = itlib::small_vector<size_t, 8>;
-using axes_t = itlib::small_vector<int64_t, 8>;
-
-enum class unary_op_t : uint8_t {
-    abs = 0,
-    acos = 1,
-    acosh = 2,
-    asin = 3,
-    asinh = 4,
-    ceil = 5,
-    cos = 6,
-    cosh = 7,
-    exp = 8,
-    floor = 9,
-    log = 10,
-    neg = 11,
-    round = 12,
-    rsqrt = 13,
-    sin = 14,
-    sinh = 15,
-    sign = 16,
-    sqrt = 17,
-    square = 18,
-    tanh = 19,
-    bitwise_not = 20,
-    logical_not = 21,
-    swish = 22
-};
-
-enum class binary_op_t : uint8_t {
-    add = 0,
-    sub = 1,
-    mul = 2,
-    div = 3,
-    mod = 4,
-    min = 5,
-    max = 6,
-    pow = 7,
-    bitwise_and = 8,
-    bitwise_or = 9,
-    bitwise_xor = 10,
-    logical_and = 11,
-    logical_or = 12,
-    logical_xor = 13,
-    left_shift = 14,
-    right_shift = 15,
-    idenity_a = 16,
-};
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/runtime_utils.h b/modules/cpu/src/runtime/runtime_utils.h
index 73d4698e73..70b62857e3 100644
--- a/modules/cpu/src/runtime/runtime_utils.h
+++ b/modules/cpu/src/runtime/runtime_utils.h
@@ -1,10 +1,10 @@
 #pragma once
 
-#include "runtime_types.h"
 #include <array>
+#include <cassert>
 #include <cmath>
 #include <cstddef>
-#include <gsl/gsl-lite.hpp>
+#include "gsl-lite.hpp"
 #include <iostream>
 #include <linux/limits.h>
 #include <numeric>
@@ -28,7 +28,7 @@ inline void join_thread(pthread_t &pt)
     pthread_join(pt, NULL);
 }
 
-inline void rt_assert(bool condition, char *message)
+inline void rt_assert([[maybe_unused]] bool condition, [[maybe_unused]] char *message)
 {
     assert(condition && message);
 }
diff --git a/modules/cpu/src/runtime/thread_pool.cpp b/modules/cpu/src/runtime/thread_pool.cpp
index 69de596cbd..c73a47b6ed 100644
--- a/modules/cpu/src/runtime/thread_pool.cpp
+++ b/modules/cpu/src/runtime/thread_pool.cpp
@@ -1,4 +1,5 @@
 #include "thread_pool.h"
+#include <stdexcept>
 
 using namespace nncase::runtime::cpu::thread_pool;
 
diff --git a/src/Native/src/test_cli.cpp b/src/Native/src/test_cli.cpp
index ea375f4f35..1dd265f39a 100644
--- a/src/Native/src/test_cli.cpp
+++ b/src/Native/src/test_cli.cpp
@@ -79,7 +79,7 @@ result<void> run_core(const std::string &kmodel_path,
 
         if (i == (loop_count - 1)) {
             if (entry->parameters_size() == (bins.size() - 1)) {
-                auto output_bin = *bins.end();
+                auto output_bin = bins.back();
                 std::ofstream output_stream(output_bin, std::ios::binary);
                 if (ret.is_a<tensor>()) {
                     try_(write_tensor_buffer(ret, output_stream));
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 8f3d87e106..8cf79e60f7 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -38,11 +38,17 @@ public async Task TestCpuUnary()
     {
         var shape = new[] { 1, 384, 2048 };
         var input = new Var("input", new TensorType(DataTypes.Float32, shape));
-        var main = new Function("main", IR.F.Math.Unary(UnaryOp.Asin, input), new[] { input });
+        var main = new Function("main", IR.F.Math.Unary(UnaryOp.Neg, input), new[] { input });
         var module = new IR.IRModule(main);
         await Compile(module);
 
-        // Testing.RunKModel(File.ReadAllBytes(Path.Join(Dumpper.Directory, "test.kmodel")), Dumpper.Directory, new[] { input_tensor });
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
+        using (var fs = Dumpper.OpenFile("input_0.bin"))
+        {
+            fs.Write(input_tensor.BytesBuffer);
+        }
+
+        Testing.RunKModel(File.ReadAllBytes(Path.Join(Dumpper.Directory, "test.kmodel")), Dumpper.Directory, new[] { input_tensor });
     }
 
     [Fact]

From 8a9b033be760a55d46162562f2f68e2da86df182 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 13 Sep 2023 19:14:26 +0800
Subject: [PATCH 172/308] refactor method table

---
 .../CodeGen/CSourceBuiltn.cs                  | 135 ++++++++---------
 .../cpu/src/runtime/cmodel/include/binary.h   |  56 +++----
 .../src/runtime/cmodel/include/layernorm.h    |   8 +-
 .../cpu/src/runtime/cmodel/include/matmul.h   |  12 +-
 .../runtime/cmodel/include/runtime_utils.h    |  19 ++-
 .../cpu/src/runtime/cmodel/include/softmax.h  |  12 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h |  20 +--
 .../cpu/src/runtime/cmodel/include/tensor.h   |  10 +-
 .../cpu/src/runtime/cmodel/include/unary.h    |  48 +++---
 .../cmodel/tests/decoder_layer/main.cpp       | 132 ++++++++---------
 .../src/runtime/cmodel/tests/embed/main.cpp   | 140 +++++++++---------
 .../src/runtime/cmodel/tests/head/main.cpp    | 132 ++++++++---------
 .../src/runtime/cmodel/tests/norm/main.cpp    | 132 ++++++++---------
 .../src/runtime/cmodel/tests/unary/main.cpp   | 132 ++++++++---------
 14 files changed, 494 insertions(+), 494 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index ff51290c96..b0c4871591 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -214,6 +214,7 @@ cpu_cmodel STATIC
 if(CMAKE_BUILD_TYPE STREQUAL ""Release"")
   add_compile_options(-O1)
 endif()
+add_compile_options(-fPIE)
 add_link_options(
   -no-pie
   -nostartfiles
@@ -270,8 +271,8 @@ public static string MakeMain(TIR.PrimFunction primFunction)
 
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
             nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {{global_hardware_init(hw_ctx_impl);
-    runtime_util = *rt_util_mt;
-    nncase_mt = *nncase_mt_impl;
+    runtime_util = rt_util_mt;
+    nncase_mt = nncase_mt_impl;
 
     {init_tensors}
 
@@ -280,71 +281,71 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
     pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
-    runtime_util.create_thread(t_0_0, NULL, f_0_0);
-    runtime_util.create_thread(t_0_1, NULL, f_0_1);
-    runtime_util.create_thread(t_0_2, NULL, f_0_2);
-    runtime_util.create_thread(t_0_3, NULL, f_0_3);
-    runtime_util.create_thread(t_1_0, NULL, f_1_0);
-    runtime_util.create_thread(t_1_1, NULL, f_1_1);
-    runtime_util.create_thread(t_1_2, NULL, f_1_2);
-    runtime_util.create_thread(t_1_3, NULL, f_1_3);
-    runtime_util.create_thread(t_2_0, NULL, f_2_0);
-    runtime_util.create_thread(t_2_1, NULL, f_2_1);
-    runtime_util.create_thread(t_2_2, NULL, f_2_2);
-    runtime_util.create_thread(t_2_3, NULL, f_2_3);
-    runtime_util.create_thread(t_3_0, NULL, f_3_0);
-    runtime_util.create_thread(t_3_1, NULL, f_3_1);
-    runtime_util.create_thread(t_3_2, NULL, f_3_2);
-    runtime_util.create_thread(t_3_3, NULL, f_3_3);
-    runtime_util.create_thread(t_4_0, NULL, f_4_0);
-    runtime_util.create_thread(t_4_1, NULL, f_4_1);
-    runtime_util.create_thread(t_4_2, NULL, f_4_2);
-    runtime_util.create_thread(t_4_3, NULL, f_4_3);
-    runtime_util.create_thread(t_5_0, NULL, f_5_0);
-    runtime_util.create_thread(t_5_1, NULL, f_5_1);
-    runtime_util.create_thread(t_5_2, NULL, f_5_2);
-    runtime_util.create_thread(t_5_3, NULL, f_5_3);
-    runtime_util.create_thread(t_6_0, NULL, f_6_0);
-    runtime_util.create_thread(t_6_1, NULL, f_6_1);
-    runtime_util.create_thread(t_6_2, NULL, f_6_2);
-    runtime_util.create_thread(t_6_3, NULL, f_6_3);
-    runtime_util.create_thread(t_7_0, NULL, f_7_0);
-    runtime_util.create_thread(t_7_1, NULL, f_7_1);
-    runtime_util.create_thread(t_7_2, NULL, f_7_2);
-    runtime_util.create_thread(t_7_3, NULL, f_7_3);
-
-    runtime_util.join_thread(t_0_0);
-    runtime_util.join_thread(t_0_1);
-    runtime_util.join_thread(t_0_2);
-    runtime_util.join_thread(t_0_3);
-    runtime_util.join_thread(t_1_0);
-    runtime_util.join_thread(t_1_1);
-    runtime_util.join_thread(t_1_2);
-    runtime_util.join_thread(t_1_3);
-    runtime_util.join_thread(t_2_0);
-    runtime_util.join_thread(t_2_1);
-    runtime_util.join_thread(t_2_2);
-    runtime_util.join_thread(t_2_3);
-    runtime_util.join_thread(t_3_0);
-    runtime_util.join_thread(t_3_1);
-    runtime_util.join_thread(t_3_2);
-    runtime_util.join_thread(t_3_3);
-    runtime_util.join_thread(t_4_0);
-    runtime_util.join_thread(t_4_1);
-    runtime_util.join_thread(t_4_2);
-    runtime_util.join_thread(t_4_3);
-    runtime_util.join_thread(t_5_0);
-    runtime_util.join_thread(t_5_1);
-    runtime_util.join_thread(t_5_2);
-    runtime_util.join_thread(t_5_3);
-    runtime_util.join_thread(t_6_0);
-    runtime_util.join_thread(t_6_1);
-    runtime_util.join_thread(t_6_2);
-    runtime_util.join_thread(t_6_3);
-    runtime_util.join_thread(t_7_0);
-    runtime_util.join_thread(t_7_1);
-    runtime_util.join_thread(t_7_2);
-    runtime_util.join_thread(t_7_3);
+    runtime_util->create_thread(t_0_0, NULL, f_0_0);
+    runtime_util->create_thread(t_0_1, NULL, f_0_1);
+    runtime_util->create_thread(t_0_2, NULL, f_0_2);
+    runtime_util->create_thread(t_0_3, NULL, f_0_3);
+    runtime_util->create_thread(t_1_0, NULL, f_1_0);
+    runtime_util->create_thread(t_1_1, NULL, f_1_1);
+    runtime_util->create_thread(t_1_2, NULL, f_1_2);
+    runtime_util->create_thread(t_1_3, NULL, f_1_3);
+    runtime_util->create_thread(t_2_0, NULL, f_2_0);
+    runtime_util->create_thread(t_2_1, NULL, f_2_1);
+    runtime_util->create_thread(t_2_2, NULL, f_2_2);
+    runtime_util->create_thread(t_2_3, NULL, f_2_3);
+    runtime_util->create_thread(t_3_0, NULL, f_3_0);
+    runtime_util->create_thread(t_3_1, NULL, f_3_1);
+    runtime_util->create_thread(t_3_2, NULL, f_3_2);
+    runtime_util->create_thread(t_3_3, NULL, f_3_3);
+    runtime_util->create_thread(t_4_0, NULL, f_4_0);
+    runtime_util->create_thread(t_4_1, NULL, f_4_1);
+    runtime_util->create_thread(t_4_2, NULL, f_4_2);
+    runtime_util->create_thread(t_4_3, NULL, f_4_3);
+    runtime_util->create_thread(t_5_0, NULL, f_5_0);
+    runtime_util->create_thread(t_5_1, NULL, f_5_1);
+    runtime_util->create_thread(t_5_2, NULL, f_5_2);
+    runtime_util->create_thread(t_5_3, NULL, f_5_3);
+    runtime_util->create_thread(t_6_0, NULL, f_6_0);
+    runtime_util->create_thread(t_6_1, NULL, f_6_1);
+    runtime_util->create_thread(t_6_2, NULL, f_6_2);
+    runtime_util->create_thread(t_6_3, NULL, f_6_3);
+    runtime_util->create_thread(t_7_0, NULL, f_7_0);
+    runtime_util->create_thread(t_7_1, NULL, f_7_1);
+    runtime_util->create_thread(t_7_2, NULL, f_7_2);
+    runtime_util->create_thread(t_7_3, NULL, f_7_3);
+
+    runtime_util->join_thread(t_0_0);
+    runtime_util->join_thread(t_0_1);
+    runtime_util->join_thread(t_0_2);
+    runtime_util->join_thread(t_0_3);
+    runtime_util->join_thread(t_1_0);
+    runtime_util->join_thread(t_1_1);
+    runtime_util->join_thread(t_1_2);
+    runtime_util->join_thread(t_1_3);
+    runtime_util->join_thread(t_2_0);
+    runtime_util->join_thread(t_2_1);
+    runtime_util->join_thread(t_2_2);
+    runtime_util->join_thread(t_2_3);
+    runtime_util->join_thread(t_3_0);
+    runtime_util->join_thread(t_3_1);
+    runtime_util->join_thread(t_3_2);
+    runtime_util->join_thread(t_3_3);
+    runtime_util->join_thread(t_4_0);
+    runtime_util->join_thread(t_4_1);
+    runtime_util->join_thread(t_4_2);
+    runtime_util->join_thread(t_4_3);
+    runtime_util->join_thread(t_5_0);
+    runtime_util->join_thread(t_5_1);
+    runtime_util->join_thread(t_5_2);
+    runtime_util->join_thread(t_5_3);
+    runtime_util->join_thread(t_6_0);
+    runtime_util->join_thread(t_6_1);
+    runtime_util->join_thread(t_6_2);
+    runtime_util->join_thread(t_6_3);
+    runtime_util->join_thread(t_7_0);
+    runtime_util->join_thread(t_7_1);
+    runtime_util->join_thread(t_7_2);
+    runtime_util->join_thread(t_7_3);
 }}";
     }
 
diff --git a/modules/cpu/src/runtime/cmodel/include/binary.h b/modules/cpu/src/runtime/cmodel/include/binary.h
index 348741cac9..5193c039a7 100644
--- a/modules/cpu/src/runtime/cmodel/include/binary.h
+++ b/modules/cpu/src/runtime/cmodel/include/binary.h
@@ -60,16 +60,16 @@ void binary_impl(binary_op_t op, const T *lhs, const T *rhs, T *output,
     // TODO: only support float for now
     if (std::is_same_v<T, float>) {
         switch (op) {
-            BINARY_IMPL_OP(add, nncase_mt.float_binary_add);
-            BINARY_IMPL_OP(sub, nncase_mt.float_binary_sub);
-            BINARY_IMPL_OP(mul, nncase_mt.float_binary_mul);
-            BINARY_IMPL_OP(div, nncase_mt.float_binary_div);
+            BINARY_IMPL_OP(add, nncase_mt->float_binary_add);
+            BINARY_IMPL_OP(sub, nncase_mt->float_binary_sub);
+            BINARY_IMPL_OP(mul, nncase_mt->float_binary_mul);
+            BINARY_IMPL_OP(div, nncase_mt->float_binary_div);
             BINARY_IMPL_OP(idenity_a,
                            [](T a, [[maybe_unused]] T b) { return a; });
-            BINARY_IMPL_OP(min, nncase_mt.float_binary_min);
-            BINARY_IMPL_OP(max, nncase_mt.float_binary_max);
-            BINARY_IMPL_OP(pow, nncase_mt.float_binary_pow);
-            BINARY_IMPL_OP(mod, nncase_mt.float_binary_mod);
+            BINARY_IMPL_OP(min, nncase_mt->float_binary_min);
+            BINARY_IMPL_OP(max, nncase_mt->float_binary_max);
+            BINARY_IMPL_OP(pow, nncase_mt->float_binary_pow);
+            BINARY_IMPL_OP(mod, nncase_mt->float_binary_mod);
             // BINARY_IMPL_OP(logical_and,
             //                [](T a, T b) { return static_cast<T>(a && b); });
             // BINARY_IMPL_OP(logical_or,
@@ -77,20 +77,20 @@ void binary_impl(binary_op_t op, const T *lhs, const T *rhs, T *output,
             // BINARY_IMPL_OP(logical_xor,
             //                [](T a, T b) { return static_cast<T>(a ^ b); });
         default:
-            runtime_util.rt_assert(false, (char *)"Unsupported Binary Op!");
+            runtime_util->rt_assert(false, (char *)"Unsupported Binary Op!");
         }
     } else if (std::is_same_v<T, int32_t>) {
         switch (op) {
-            BINARY_IMPL_OP(add, nncase_mt.int32_binary_add);
-            BINARY_IMPL_OP(sub, nncase_mt.int32_binary_sub);
-            BINARY_IMPL_OP(mul, nncase_mt.int32_binary_mul);
-            BINARY_IMPL_OP(div, nncase_mt.int32_binary_div);
+            BINARY_IMPL_OP(add, nncase_mt->int32_binary_add);
+            BINARY_IMPL_OP(sub, nncase_mt->int32_binary_sub);
+            BINARY_IMPL_OP(mul, nncase_mt->int32_binary_mul);
+            BINARY_IMPL_OP(div, nncase_mt->int32_binary_div);
             BINARY_IMPL_OP(idenity_a,
                            [](T a, [[maybe_unused]] T b) { return a; });
-            BINARY_IMPL_OP(min, nncase_mt.int32_binary_min);
-            BINARY_IMPL_OP(max, nncase_mt.int32_binary_max);
-            BINARY_IMPL_OP(pow, nncase_mt.int32_binary_pow);
-            BINARY_IMPL_OP(mod, nncase_mt.int32_binary_mod);
+            BINARY_IMPL_OP(min, nncase_mt->int32_binary_min);
+            BINARY_IMPL_OP(max, nncase_mt->int32_binary_max);
+            BINARY_IMPL_OP(pow, nncase_mt->int32_binary_pow);
+            BINARY_IMPL_OP(mod, nncase_mt->int32_binary_mod);
             // BINARY_IMPL_OP(logical_and,
             //                [](T a, T b) { return static_cast<T>(a && b); });
             // BINARY_IMPL_OP(logical_or,
@@ -98,20 +98,20 @@ void binary_impl(binary_op_t op, const T *lhs, const T *rhs, T *output,
             // BINARY_IMPL_OP(logical_xor,
             //                [](T a, T b) { return static_cast<T>(a ^ b); });
         default:
-            runtime_util.rt_assert(false, (char *)"Unsupported Binary Op!");
+            runtime_util->rt_assert(false, (char *)"Unsupported Binary Op!");
         }
     } else if (std::is_same_v<T, int64_t>) {
         switch (op) {
-            BINARY_IMPL_OP(add, nncase_mt.int64_binary_add);
-            BINARY_IMPL_OP(sub, nncase_mt.int64_binary_sub);
-            BINARY_IMPL_OP(mul, nncase_mt.int64_binary_mul);
-            BINARY_IMPL_OP(div, nncase_mt.int64_binary_div);
+            BINARY_IMPL_OP(add, nncase_mt->int64_binary_add);
+            BINARY_IMPL_OP(sub, nncase_mt->int64_binary_sub);
+            BINARY_IMPL_OP(mul, nncase_mt->int64_binary_mul);
+            BINARY_IMPL_OP(div, nncase_mt->int64_binary_div);
             BINARY_IMPL_OP(idenity_a,
                            [](T a, [[maybe_unused]] T b) { return a; });
-            BINARY_IMPL_OP(min, nncase_mt.int64_binary_min);
-            BINARY_IMPL_OP(max, nncase_mt.int64_binary_max);
-            BINARY_IMPL_OP(pow, nncase_mt.int64_binary_pow);
-            BINARY_IMPL_OP(mod, nncase_mt.int64_binary_mod);
+            BINARY_IMPL_OP(min, nncase_mt->int64_binary_min);
+            BINARY_IMPL_OP(max, nncase_mt->int64_binary_max);
+            BINARY_IMPL_OP(pow, nncase_mt->int64_binary_pow);
+            BINARY_IMPL_OP(mod, nncase_mt->int64_binary_mod);
             // BINARY_IMPL_OP(logical_and,
             //                [](T a, T b) { return static_cast<T>(a && b); });
             // BINARY_IMPL_OP(logical_or,
@@ -119,10 +119,10 @@ void binary_impl(binary_op_t op, const T *lhs, const T *rhs, T *output,
             // BINARY_IMPL_OP(logical_xor,
             //                [](T a, T b) { return static_cast<T>(a ^ b); });
         default:
-            runtime_util.rt_assert(false, (char *)"Unsupported Binary Op!");
+            runtime_util->rt_assert(false, (char *)"Unsupported Binary Op!");
         }
     } else {
-        runtime_util.rt_assert(false, (char *)"Unsupported Binary Type!");
+        runtime_util->rt_assert(false, (char *)"Unsupported Binary Type!");
     }
 }
 
diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index 80ac9522fe..8ccb233c6d 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -1,7 +1,7 @@
 #include "runtime_utils.h"
 #include <apply.h>
 #include <cmath>
-#ifdef __riscv_vector
+#ifdef __riscv_vector_
 #include <riscv_vector.h>
 #endif
 
@@ -27,7 +27,7 @@ void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *output,
         if (rms_norm) {
             mean = 0;
         }
-        auto sigma = nncase_mt.float_unary_sqrt(sum_sqr[o_offset] / norm_size -
+        auto sigma = nncase_mt->float_unary_sqrt(sum_sqr[o_offset] / norm_size -
                                                 mean * mean + eps);
 
         auto input_offset = offset(input_stride, input_index);
@@ -61,7 +61,7 @@ void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *output,
     // }
 }
 
-#ifdef __riscv_vector
+#ifdef __riscv_vector_
 template <typename T>
 void layernorm_rvv_impl(const T *input, const T *sum, T *sum_sqr, T *gamma,
                         T *beta, gsl::span<const size_t> input_shape,
@@ -145,7 +145,7 @@ void layernorm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
                strides_t output_strides, strides_t sum_strides,
                strides_t gamma_strides, T eps, int32_t axis, int32_t norm_size,
                bool rms_norm = false) {
-#ifdef __riscv_vector
+#ifdef __riscv_vector_
     return layernorm_rvv_impl(
         input, sum, sum_sqr, gamma, beta,
         gsl::make_span(input_dims).template as_span<const size_t>(),
diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
index 4707583a54..b3445dc963 100644
--- a/modules/cpu/src/runtime/cmodel/include/matmul.h
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -12,8 +12,8 @@ void matmul_unit_impl(const T *input_a, const T *input_b, T *output,
     int32_t b_cols = static_cast<int32_t>(in_b_shape[1]);
 
     for (int32_t oy = 0; oy < a_rows; oy++) {
-        T *values = (T *)runtime_util.malloc(sizeof(T) * b_cols);
-        // runtime_util.memset(values, 0, sizeof(T) * b_cols);
+        T *values = (T *)runtime_util->malloc(sizeof(T) * b_cols);
+        // runtime_util->memset(values, 0, sizeof(T) * b_cols);
         for (int32_t i = 0; i < a_cols; i++) {
             for (int32_t ox = 0; ox < b_cols; ox++) {
                 const auto a = input_a[oy * a_cols + i];
@@ -21,8 +21,8 @@ void matmul_unit_impl(const T *input_a, const T *input_b, T *output,
                 values[ox] += a * b;
             }
         }
-        runtime_util.memcpy(output + oy * b_cols, values, sizeof(T) * b_cols);
-        runtime_util.free(values);
+        runtime_util->memcpy(output + oy * b_cols, values, sizeof(T) * b_cols);
+        runtime_util->free(values);
     }
 }
 
@@ -99,7 +99,7 @@ void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                 T *out_ptr = output + n * new_out_stride[0] +
                              c * new_out_stride[1] + h * new_out_stride[2];
                 for (size_t m = 0; m < new_a_shape[3]; m++) {
-                    T *values = (T*)runtime_util.malloc(new_b_shape[4] * sizeof(T));
+                    T *values = (T*)runtime_util->malloc(new_b_shape[4] * sizeof(T));
                     for (size_t k = 0; k < new_a_shape[4]; k++) {
                         for (size_t n = 0; n < new_b_shape[4]; n++) {
                             values[n] += in_a_ptr[m * new_a_stride[3] +
@@ -112,7 +112,7 @@ void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                         out_ptr[m * new_out_stride[3] + n * new_out_stride[4]] =
                             values[n];
                     }
-                    runtime_util.free(values);
+                    runtime_util->free(values);
                 }
             }
         }
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index 5d32f27413..f210a2df0e 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -7,14 +7,14 @@
 
 using namespace nncase::runtime::cpu;
 
-static nncase_mt_t nncase_mt;
-static runtime_util_mt runtime_util;
+static nncase_mt_t *nncase_mt;
+static runtime_util_mt *runtime_util;
 
 void print_vec(itlib::small_vector<size_t, 8> vec) {
     for (const size_t v : vec) {
-        runtime_util.printf("%zu, ", v);
+        runtime_util->printf("%zu, ", v);
     }
-    runtime_util.printf("\n");
+    runtime_util->printf("\n");
 }
 
 template <class TShape> inline size_t compute_size(const TShape &shape) {
@@ -57,7 +57,7 @@ inline strides_t get_default_strides(dims_t shape) {
 template <class offset_type, class S>
 inline offset_type element_offset(const S &strides, const S &index) noexcept {
     offset_type size = 0;
-    for (auto i = 0; i < strides.size(); i++) {
+    for (auto i = 0; i < (int)strides.size(); i++) {
         size += strides[i] * index[i];
     }
     return size;
@@ -69,7 +69,7 @@ inline size_t offset(gsl::span<const size_t> strides,
     if (strides.size() == 0 || index.size() == 0) {
         return 0;
     }
-    runtime_util.rt_assert(strides.size() == index.size(),
+    runtime_util->rt_assert(strides.size() == index.size(),
                            (char *)"strides and index must have the same rank");
     return element_offset<size_t>(strides, index);
 }
@@ -147,11 +147,10 @@ template <typename T> double dot(const T *v1, const T *v2, size_t size) {
 
 template <typename T> double cosine(const T *v1, const T *v2, size_t size) {
     for (size_t i = 0; i < 10; i++) {
-        runtime_util.printf("%f, %f\n", (float)v1[i], (float)v2[i]);
-        ;
+        runtime_util->printf("%f, %f\n", (float)v1[i], (float)v2[i]);
     }
-    return dot(v1, v2, size) / ((nncase_mt.float_unary_sqrt(dot(v1, v1, size)) *
-                                 nncase_mt.float_unary_sqrt(dot(v2, v2, size))));
+    return dot(v1, v2, size) / ((nncase_mt->float_unary_sqrt(dot(v1, v1, size)) *
+                                 nncase_mt->float_unary_sqrt(dot(v2, v2, size))));
 }
 
 inline dims_t get_reduced_offset(gsl::span<const size_t> in_offset,
diff --git a/modules/cpu/src/runtime/cmodel/include/softmax.h b/modules/cpu/src/runtime/cmodel/include/softmax.h
index f672b0f05c..d01366479e 100644
--- a/modules/cpu/src/runtime/cmodel/include/softmax.h
+++ b/modules/cpu/src/runtime/cmodel/include/softmax.h
@@ -33,7 +33,7 @@ void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
     auto reduced_shape = get_reduced_shape(in_shape, axes, true);
     auto reduced_strides = get_default_strides(reduced_shape);
     auto reduced_size = compute_size(reduced_shape);
-    auto tmp = (T *)runtime_util.malloc(reduced_size * sizeof(T));
+    auto tmp = (T *)runtime_util->malloc(reduced_size * sizeof(T));
     for (size_t i = 0; i < reduced_size; i++) {
         tmp[i] = std::numeric_limits<T>().lowest();
     }
@@ -73,9 +73,9 @@ void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
         const auto out_index = get_reduced_offset(index, axes, true);
         auto out_idx = offset(reduced_strides, out_index);
         if (std::is_same_v<T, float>) {
-            output[in_idx] = nncase_mt.float_unary_exp(in);
+            output[in_idx] = nncase_mt->float_unary_exp(in);
         } else {
-            runtime_util.rt_assert(false,
+            runtime_util->rt_assert(false,
                                    (char *)"Not supported Type in softmax!");
         }
 
@@ -93,15 +93,15 @@ void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
         out /= in;
         if (needLog) {
             if (std::is_same_v<T, float>) {
-                out = nncase_mt.float_unary_log(out);
+                out = nncase_mt->float_unary_log(out);
             } else {
-                runtime_util.rt_assert(
+                runtime_util->rt_assert(
                     false, (char *)"Not supported Type in softmax!");
             }
         }
     }));
 
-    runtime_util.free(tmp);
+    runtime_util->free(tmp);
 }
 } // namespace
 void softmax(const float *input, float *output,
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 9c871b18e8..c1cbdcde12 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -68,7 +68,7 @@ void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest,
 
 template <class T, loc_t DestLoc, loc_t SrcLoc>
 void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
-    runtime_util.rt_assert(
+    runtime_util->rt_assert(
         dest.dimension() == src.dimension(),
         (char *)"Dest and Src dimension mismatch in __tensor_copy_sync");
     apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
@@ -290,7 +290,7 @@ void tdma_load_broadcast_async([[maybe_unused]] tensor<T, Dest> &dest,
                                [[maybe_unused]] tensor<T, Src> &src,
                                [[maybe_unused]] thread_context &ctx) {
     // throw std::system_error(std::make_error_code(std::errc::not_supported));
-    runtime_util.rt_assert(false, (char *)"not_supported");
+    runtime_util->rt_assert(false, (char *)"not_supported");
 }
 
 template <class T>
@@ -302,11 +302,11 @@ void reduce_async_visit_func1(int visited, thread_context &ctx,
     new_dims.insert(new_dims.begin(), BLOCKS * CORES);
     if (visited == 1) {
         if (global_hardware_ctx.global_var != nullptr) {
-            runtime_util.rt_assert(false,
+            runtime_util->rt_assert(false,
                                    (char *)"the global var has been used!");
         }
         gather_span =
-            (T *)runtime_util.malloc(sizeof(T) * compute_size(new_dims));
+            (T *)runtime_util->malloc(sizeof(T) * compute_size(new_dims));
         global_hardware_ctx.global_var = gather_span;
     }
     dims_t begin(new_dims.size(), 0);
@@ -353,7 +353,7 @@ void tdma_reduce_async(tensor<T, loc_t::local> &src,
 
     {
         __tdma_all_sync_apply_macro(reduce_async_visit_func2, ([]() -> void {
-                                        runtime_util.free(global_hardware_ctx.global_var);
+                                        runtime_util->free(global_hardware_ctx.global_var);
                                         global_hardware_ctx.global_var =
                                             nullptr;
                                     }),
@@ -375,11 +375,11 @@ void all_reduce_async_visit_func1(int visited, thread_context &ctx,
     new_dims.insert(new_dims.begin(), BLOCKS * CORES);
     if (visited == 1) {
         if (global_hardware_ctx.global_var != nullptr) {
-            runtime_util.rt_assert(false,
+            runtime_util->rt_assert(false,
                                    (char *)"the global var has been used!");
         }
         gather_span =
-            (T *)runtime_util.malloc(sizeof(T) * compute_size(new_dims));
+            (T *)runtime_util->malloc(sizeof(T) * compute_size(new_dims));
         global_hardware_ctx.global_var = (void *)gather_span;
     }
     dims_t begin(new_dims.size(), 0);
@@ -412,11 +412,11 @@ void all_reduce_async_visit_func2_all(int visit, tensor<T, ALoc> &src,
                                      compute_size(new_dims)),
                       new_dims);
         reduced_span =
-            (T *)runtime_util.malloc(sizeof(T) * compute_size(reduced_shape));
+            (T *)runtime_util->malloc(sizeof(T) * compute_size(reduced_shape));
         tensor<T> reduced_tensor = tensor<T>(reduced_shape);
         reduce(gather_tensor, reduced_tensor, reduce_op, (T)0, dims_t({0}),
                false);
-        runtime_util.free(gather_span);
+        runtime_util->free(gather_span);
         global_hardware_ctx.global_var = reduced_span;
     } else {
         tensor<T> reduced_tensor =
@@ -428,7 +428,7 @@ void all_reduce_async_visit_func2_all(int visit, tensor<T, ALoc> &src,
 }
 
 template <class T, loc_t ALoc, loc_t BLoc>
-void all_reduce_async_visit_func2_by_block(int visit, tensor<T, ALoc> &src,
+void all_reduce_async_visit_func2_by_block([[maybe_unused]] int visit, tensor<T, ALoc> &src,
                                            tensor<T, BLoc> &dest,
                                            reduce_op_t reduce_op) {
     auto new_dims = dims_t(src.dimension());
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index f52a63ab43..1c57de32b4 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -24,7 +24,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
           strides_(get_default_strides(dims_)),
           size_(compute_size(dims_)) {
         parent_ = nullptr;
-        auto ptr = (T *)runtime_util.malloc(size_ * sizeof(T));
+        auto ptr = (T *)runtime_util->malloc(size_ * sizeof(T));
         data_ = gsl::make_span(ptr, size_);
     }
 
@@ -35,7 +35,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
           strides_(get_default_strides(dims_)),
           size_(compute_size(dims_)) {
         if (size_ != data_.size()) {
-            runtime_util.rt_assert(false, (char*)"Invalid tensor size");
+            runtime_util->rt_assert(false, (char*)"Invalid tensor size");
         }
     }
 
@@ -46,7 +46,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
           strides_(strides),
           size_(compute_size(dims_, strides_)) {
         if (size_ != data_.size()) {
-            runtime_util.rt_assert(false, (char*)"Invalid tensor size");
+            runtime_util->rt_assert(false, (char*)"Invalid tensor size");
         }
     }
 
@@ -69,7 +69,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
 
     ~tensor() {
         if (parent_ == nullptr) {
-            runtime_util.free(data_.data());
+            runtime_util->free(data_.data());
         }
     }
 
@@ -83,7 +83,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
         auto subspan_offset = offset(strides_, begins);
         data_ = parent->data_.subspan(subspan_offset);
         if (data_.size() < size_) {
-            runtime_util.rt_assert(false, (char*)"Invalid tensor size");
+            runtime_util->rt_assert(false, (char*)"Invalid tensor size");
         }
     }
 
diff --git a/modules/cpu/src/runtime/cmodel/include/unary.h b/modules/cpu/src/runtime/cmodel/include/unary.h
index 9d2b33c0f0..23a92be28e 100644
--- a/modules/cpu/src/runtime/cmodel/include/unary.h
+++ b/modules/cpu/src/runtime/cmodel/include/unary.h
@@ -44,35 +44,35 @@ void unary_impl(unary_op_t op, const T *input, T *output,
                 gsl::span<const size_t> out_strides) noexcept {
     if (std::is_same_v<T, float>) {
         switch (op) {
-            UNARY_IMPL_OP(abs, nncase_mt.float_unary_abs);
-            UNARY_IMPL_OP(acos, nncase_mt.float_unary_cos);
-            UNARY_IMPL_OP(acosh, nncase_mt.float_unary_cosh);
-            UNARY_IMPL_OP(asin, nncase_mt.float_unary_asin);
-            UNARY_IMPL_OP(asinh, nncase_mt.float_unary_asinh);
-            UNARY_IMPL_OP(ceil, nncase_mt.float_unary_ceil);
-            UNARY_IMPL_OP(cos, nncase_mt.float_unary_cos);
-            UNARY_IMPL_OP(cosh, nncase_mt.float_unary_cosh);
-            UNARY_IMPL_OP(exp, nncase_mt.float_unary_exp);
-            UNARY_IMPL_OP(floor, nncase_mt.float_unary_floor);
-            UNARY_IMPL_OP(log, nncase_mt.float_unary_log);
-            UNARY_IMPL_OP(logical_not, nncase_mt.float_unary_logical_not);
-            UNARY_IMPL_OP(neg, nncase_mt.float_unary_neg);
-            UNARY_IMPL_OP(round, nncase_mt.float_unary_round);
-            UNARY_IMPL_OP(rsqrt, nncase_mt.float_unary_rsqrt);
-            UNARY_IMPL_OP(sign, nncase_mt.float_unary_sign);
-            UNARY_IMPL_OP(sin, nncase_mt.float_unary_sin);
-            UNARY_IMPL_OP(sinh, nncase_mt.float_unary_sinh);
-            UNARY_IMPL_OP(sqrt, nncase_mt.float_unary_sqrt);
-            UNARY_IMPL_OP(square, nncase_mt.float_unary_square);
-            UNARY_IMPL_OP(tanh, nncase_mt.float_unary_tanh);
+            UNARY_IMPL_OP(abs, nncase_mt->float_unary_abs);
+            UNARY_IMPL_OP(acos, nncase_mt->float_unary_cos);
+            UNARY_IMPL_OP(acosh, nncase_mt->float_unary_cosh);
+            UNARY_IMPL_OP(asin, nncase_mt->float_unary_asin);
+            UNARY_IMPL_OP(asinh, nncase_mt->float_unary_asinh);
+            UNARY_IMPL_OP(ceil, nncase_mt->float_unary_ceil);
+            UNARY_IMPL_OP(cos, nncase_mt->float_unary_cos);
+            UNARY_IMPL_OP(cosh, nncase_mt->float_unary_cosh);
+            UNARY_IMPL_OP(exp, nncase_mt->float_unary_exp);
+            UNARY_IMPL_OP(floor, nncase_mt->float_unary_floor);
+            UNARY_IMPL_OP(log, nncase_mt->float_unary_log);
+            UNARY_IMPL_OP(logical_not, nncase_mt->float_unary_logical_not);
+            UNARY_IMPL_OP(neg, nncase_mt->float_unary_neg);
+            UNARY_IMPL_OP(round, nncase_mt->float_unary_round);
+            UNARY_IMPL_OP(rsqrt, nncase_mt->float_unary_rsqrt);
+            UNARY_IMPL_OP(sign, nncase_mt->float_unary_sign);
+            UNARY_IMPL_OP(sin, nncase_mt->float_unary_sin);
+            UNARY_IMPL_OP(sinh, nncase_mt->float_unary_sinh);
+            UNARY_IMPL_OP(sqrt, nncase_mt->float_unary_sqrt);
+            UNARY_IMPL_OP(square, nncase_mt->float_unary_square);
+            UNARY_IMPL_OP(tanh, nncase_mt->float_unary_tanh);
             UNARY_IMPL_OP(swish, [](float x) {
-                return x / (1 + nncase_mt.float_unary_exp(-x));
+                return x / (1 + nncase_mt->float_unary_exp(-x));
             });
         default:
-            runtime_util.rt_assert(false, (char *)"Unsupported Unary Op!");
+            runtime_util->rt_assert(false, (char *)"Unsupported Unary Op!");
         }
     } else {
-        runtime_util.rt_assert(false, (char *)"Unsupported Unary Type!");
+        runtime_util->rt_assert(false, (char *)"Unsupported Unary Type!");
     }
 } // namespace
 
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
index 62744a89f6..ce3eddb25d 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
@@ -91,8 +91,8 @@ DEFINE_BFUNC(7)
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
             nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
-    runtime_util = *rt_util_mt;
-    nncase_mt = *nncase_mt_impl;
+    runtime_util = rt_util_mt;
+    nncase_mt = nncase_mt_impl;
 
     MALLOC_IMM(15, ImmOutputs[0], float, (1 * 384 * 8192),
                dims_t({1, 384, 8192}))
@@ -272,71 +272,71 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
     pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
-    runtime_util.create_thread(t_0_0, NULL, f_0_0);
-    runtime_util.create_thread(t_0_1, NULL, f_0_1);
-    runtime_util.create_thread(t_0_2, NULL, f_0_2);
-    runtime_util.create_thread(t_0_3, NULL, f_0_3);
-    runtime_util.create_thread(t_1_0, NULL, f_1_0);
-    runtime_util.create_thread(t_1_1, NULL, f_1_1);
-    runtime_util.create_thread(t_1_2, NULL, f_1_2);
-    runtime_util.create_thread(t_1_3, NULL, f_1_3);
-    runtime_util.create_thread(t_2_0, NULL, f_2_0);
-    runtime_util.create_thread(t_2_1, NULL, f_2_1);
-    runtime_util.create_thread(t_2_2, NULL, f_2_2);
-    runtime_util.create_thread(t_2_3, NULL, f_2_3);
-    runtime_util.create_thread(t_3_0, NULL, f_3_0);
-    runtime_util.create_thread(t_3_1, NULL, f_3_1);
-    runtime_util.create_thread(t_3_2, NULL, f_3_2);
-    runtime_util.create_thread(t_3_3, NULL, f_3_3);
-    runtime_util.create_thread(t_4_0, NULL, f_4_0);
-    runtime_util.create_thread(t_4_1, NULL, f_4_1);
-    runtime_util.create_thread(t_4_2, NULL, f_4_2);
-    runtime_util.create_thread(t_4_3, NULL, f_4_3);
-    runtime_util.create_thread(t_5_0, NULL, f_5_0);
-    runtime_util.create_thread(t_5_1, NULL, f_5_1);
-    runtime_util.create_thread(t_5_2, NULL, f_5_2);
-    runtime_util.create_thread(t_5_3, NULL, f_5_3);
-    runtime_util.create_thread(t_6_0, NULL, f_6_0);
-    runtime_util.create_thread(t_6_1, NULL, f_6_1);
-    runtime_util.create_thread(t_6_2, NULL, f_6_2);
-    runtime_util.create_thread(t_6_3, NULL, f_6_3);
-    runtime_util.create_thread(t_7_0, NULL, f_7_0);
-    runtime_util.create_thread(t_7_1, NULL, f_7_1);
-    runtime_util.create_thread(t_7_2, NULL, f_7_2);
-    runtime_util.create_thread(t_7_3, NULL, f_7_3);
+    runtime_util->create_thread(t_0_0, NULL, f_0_0);
+    runtime_util->create_thread(t_0_1, NULL, f_0_1);
+    runtime_util->create_thread(t_0_2, NULL, f_0_2);
+    runtime_util->create_thread(t_0_3, NULL, f_0_3);
+    runtime_util->create_thread(t_1_0, NULL, f_1_0);
+    runtime_util->create_thread(t_1_1, NULL, f_1_1);
+    runtime_util->create_thread(t_1_2, NULL, f_1_2);
+    runtime_util->create_thread(t_1_3, NULL, f_1_3);
+    runtime_util->create_thread(t_2_0, NULL, f_2_0);
+    runtime_util->create_thread(t_2_1, NULL, f_2_1);
+    runtime_util->create_thread(t_2_2, NULL, f_2_2);
+    runtime_util->create_thread(t_2_3, NULL, f_2_3);
+    runtime_util->create_thread(t_3_0, NULL, f_3_0);
+    runtime_util->create_thread(t_3_1, NULL, f_3_1);
+    runtime_util->create_thread(t_3_2, NULL, f_3_2);
+    runtime_util->create_thread(t_3_3, NULL, f_3_3);
+    runtime_util->create_thread(t_4_0, NULL, f_4_0);
+    runtime_util->create_thread(t_4_1, NULL, f_4_1);
+    runtime_util->create_thread(t_4_2, NULL, f_4_2);
+    runtime_util->create_thread(t_4_3, NULL, f_4_3);
+    runtime_util->create_thread(t_5_0, NULL, f_5_0);
+    runtime_util->create_thread(t_5_1, NULL, f_5_1);
+    runtime_util->create_thread(t_5_2, NULL, f_5_2);
+    runtime_util->create_thread(t_5_3, NULL, f_5_3);
+    runtime_util->create_thread(t_6_0, NULL, f_6_0);
+    runtime_util->create_thread(t_6_1, NULL, f_6_1);
+    runtime_util->create_thread(t_6_2, NULL, f_6_2);
+    runtime_util->create_thread(t_6_3, NULL, f_6_3);
+    runtime_util->create_thread(t_7_0, NULL, f_7_0);
+    runtime_util->create_thread(t_7_1, NULL, f_7_1);
+    runtime_util->create_thread(t_7_2, NULL, f_7_2);
+    runtime_util->create_thread(t_7_3, NULL, f_7_3);
 
-    runtime_util.join_thread(t_0_0);
-    runtime_util.join_thread(t_0_1);
-    runtime_util.join_thread(t_0_2);
-    runtime_util.join_thread(t_0_3);
-    runtime_util.join_thread(t_1_0);
-    runtime_util.join_thread(t_1_1);
-    runtime_util.join_thread(t_1_2);
-    runtime_util.join_thread(t_1_3);
-    runtime_util.join_thread(t_2_0);
-    runtime_util.join_thread(t_2_1);
-    runtime_util.join_thread(t_2_2);
-    runtime_util.join_thread(t_2_3);
-    runtime_util.join_thread(t_3_0);
-    runtime_util.join_thread(t_3_1);
-    runtime_util.join_thread(t_3_2);
-    runtime_util.join_thread(t_3_3);
-    runtime_util.join_thread(t_4_0);
-    runtime_util.join_thread(t_4_1);
-    runtime_util.join_thread(t_4_2);
-    runtime_util.join_thread(t_4_3);
-    runtime_util.join_thread(t_5_0);
-    runtime_util.join_thread(t_5_1);
-    runtime_util.join_thread(t_5_2);
-    runtime_util.join_thread(t_5_3);
-    runtime_util.join_thread(t_6_0);
-    runtime_util.join_thread(t_6_1);
-    runtime_util.join_thread(t_6_2);
-    runtime_util.join_thread(t_6_3);
-    runtime_util.join_thread(t_7_0);
-    runtime_util.join_thread(t_7_1);
-    runtime_util.join_thread(t_7_2);
-    runtime_util.join_thread(t_7_3);
+    runtime_util->join_thread(t_0_0);
+    runtime_util->join_thread(t_0_1);
+    runtime_util->join_thread(t_0_2);
+    runtime_util->join_thread(t_0_3);
+    runtime_util->join_thread(t_1_0);
+    runtime_util->join_thread(t_1_1);
+    runtime_util->join_thread(t_1_2);
+    runtime_util->join_thread(t_1_3);
+    runtime_util->join_thread(t_2_0);
+    runtime_util->join_thread(t_2_1);
+    runtime_util->join_thread(t_2_2);
+    runtime_util->join_thread(t_2_3);
+    runtime_util->join_thread(t_3_0);
+    runtime_util->join_thread(t_3_1);
+    runtime_util->join_thread(t_3_2);
+    runtime_util->join_thread(t_3_3);
+    runtime_util->join_thread(t_4_0);
+    runtime_util->join_thread(t_4_1);
+    runtime_util->join_thread(t_4_2);
+    runtime_util->join_thread(t_4_3);
+    runtime_util->join_thread(t_5_0);
+    runtime_util->join_thread(t_5_1);
+    runtime_util->join_thread(t_5_2);
+    runtime_util->join_thread(t_5_3);
+    runtime_util->join_thread(t_6_0);
+    runtime_util->join_thread(t_6_1);
+    runtime_util->join_thread(t_6_2);
+    runtime_util->join_thread(t_6_3);
+    runtime_util->join_thread(t_7_0);
+    runtime_util->join_thread(t_7_1);
+    runtime_util->join_thread(t_7_2);
+    runtime_util->join_thread(t_7_3);
 
     CLEAR_SHARED(0);
     CLEAR_SHARED(1);
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp b/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
index 98a85bec6c..d127978464 100644
--- a/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
@@ -30,94 +30,94 @@ DEFINE_BFUNC(7)
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt, nncase_mt_t *nncase_mt_impl,
             uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
-    runtime_util = *rt_util_mt;
-    nncase_mt = *nncase_mt_impl;
+    runtime_util = rt_util_mt;
+    nncase_mt = nncase_mt_impl;
 
     auto Position_ids_ = tensor<int64_t, loc_t::device>(
         gsl::make_span((int64_t *)inputs[0], 384), {1, 384});
-    runtime_util.printf("1\n");
+    runtime_util->printf("1\n");
 
     auto GatherData_ = tensor<float, loc_t::device>(
         gsl::make_span((float *)inputs[1], 384 * 8192), {384, 8192});
 
-    runtime_util.printf("2\n");
+    runtime_util->printf("2\n");
     auto Output_ = tensor<float, loc_t::device>(
         gsl::make_span((float *)inputs[2], 384 * 8192), {1, 384, 8192});
 
-    runtime_util.printf("3\n");
+    runtime_util->printf("3\n");
     Position_ids = &Position_ids_;
     GatherData = &GatherData_;
     Output = &Output_;
-    runtime_util.printf("%d\n", Position_ids->data().size());
+    runtime_util->printf("%d\n", Position_ids->data().size());
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
     pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
     pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
-    runtime_util.create_thread(t_0_0, NULL, f_0_0);
-    runtime_util.create_thread(t_0_1, NULL, f_0_1);
-    runtime_util.create_thread(t_0_2, NULL, f_0_2);
-    runtime_util.create_thread(t_0_3, NULL, f_0_3);
-    runtime_util.create_thread(t_1_0, NULL, f_1_0);
-    runtime_util.create_thread(t_1_1, NULL, f_1_1);
-    runtime_util.create_thread(t_1_2, NULL, f_1_2);
-    runtime_util.create_thread(t_1_3, NULL, f_1_3);
-    runtime_util.create_thread(t_2_0, NULL, f_2_0);
-    runtime_util.create_thread(t_2_1, NULL, f_2_1);
-    runtime_util.create_thread(t_2_2, NULL, f_2_2);
-    runtime_util.create_thread(t_2_3, NULL, f_2_3);
-    runtime_util.create_thread(t_3_0, NULL, f_3_0);
-    runtime_util.create_thread(t_3_1, NULL, f_3_1);
-    runtime_util.create_thread(t_3_2, NULL, f_3_2);
-    runtime_util.create_thread(t_3_3, NULL, f_3_3);
-    runtime_util.create_thread(t_4_0, NULL, f_4_0);
-    runtime_util.create_thread(t_4_1, NULL, f_4_1);
-    runtime_util.create_thread(t_4_2, NULL, f_4_2);
-    runtime_util.create_thread(t_4_3, NULL, f_4_3);
-    runtime_util.create_thread(t_5_0, NULL, f_5_0);
-    runtime_util.create_thread(t_5_1, NULL, f_5_1);
-    runtime_util.create_thread(t_5_2, NULL, f_5_2);
-    runtime_util.create_thread(t_5_3, NULL, f_5_3);
-    runtime_util.create_thread(t_6_0, NULL, f_6_0);
-    runtime_util.create_thread(t_6_1, NULL, f_6_1);
-    runtime_util.create_thread(t_6_2, NULL, f_6_2);
-    runtime_util.create_thread(t_6_3, NULL, f_6_3);
-    runtime_util.create_thread(t_7_0, NULL, f_7_0);
-    runtime_util.create_thread(t_7_1, NULL, f_7_1);
-    runtime_util.create_thread(t_7_2, NULL, f_7_2);
-    runtime_util.create_thread(t_7_3, NULL, f_7_3);
+    runtime_util->create_thread(t_0_0, NULL, f_0_0);
+    runtime_util->create_thread(t_0_1, NULL, f_0_1);
+    runtime_util->create_thread(t_0_2, NULL, f_0_2);
+    runtime_util->create_thread(t_0_3, NULL, f_0_3);
+    runtime_util->create_thread(t_1_0, NULL, f_1_0);
+    runtime_util->create_thread(t_1_1, NULL, f_1_1);
+    runtime_util->create_thread(t_1_2, NULL, f_1_2);
+    runtime_util->create_thread(t_1_3, NULL, f_1_3);
+    runtime_util->create_thread(t_2_0, NULL, f_2_0);
+    runtime_util->create_thread(t_2_1, NULL, f_2_1);
+    runtime_util->create_thread(t_2_2, NULL, f_2_2);
+    runtime_util->create_thread(t_2_3, NULL, f_2_3);
+    runtime_util->create_thread(t_3_0, NULL, f_3_0);
+    runtime_util->create_thread(t_3_1, NULL, f_3_1);
+    runtime_util->create_thread(t_3_2, NULL, f_3_2);
+    runtime_util->create_thread(t_3_3, NULL, f_3_3);
+    runtime_util->create_thread(t_4_0, NULL, f_4_0);
+    runtime_util->create_thread(t_4_1, NULL, f_4_1);
+    runtime_util->create_thread(t_4_2, NULL, f_4_2);
+    runtime_util->create_thread(t_4_3, NULL, f_4_3);
+    runtime_util->create_thread(t_5_0, NULL, f_5_0);
+    runtime_util->create_thread(t_5_1, NULL, f_5_1);
+    runtime_util->create_thread(t_5_2, NULL, f_5_2);
+    runtime_util->create_thread(t_5_3, NULL, f_5_3);
+    runtime_util->create_thread(t_6_0, NULL, f_6_0);
+    runtime_util->create_thread(t_6_1, NULL, f_6_1);
+    runtime_util->create_thread(t_6_2, NULL, f_6_2);
+    runtime_util->create_thread(t_6_3, NULL, f_6_3);
+    runtime_util->create_thread(t_7_0, NULL, f_7_0);
+    runtime_util->create_thread(t_7_1, NULL, f_7_1);
+    runtime_util->create_thread(t_7_2, NULL, f_7_2);
+    runtime_util->create_thread(t_7_3, NULL, f_7_3);
 
-    runtime_util.join_thread(t_0_0);
-    runtime_util.join_thread(t_0_1);
-    runtime_util.join_thread(t_0_2);
-    runtime_util.join_thread(t_0_3);
-    runtime_util.join_thread(t_1_0);
-    runtime_util.join_thread(t_1_1);
-    runtime_util.join_thread(t_1_2);
-    runtime_util.join_thread(t_1_3);
-    runtime_util.join_thread(t_2_0);
-    runtime_util.join_thread(t_2_1);
-    runtime_util.join_thread(t_2_2);
-    runtime_util.join_thread(t_2_3);
-    runtime_util.join_thread(t_3_0);
-    runtime_util.join_thread(t_3_1);
-    runtime_util.join_thread(t_3_2);
-    runtime_util.join_thread(t_3_3);
-    runtime_util.join_thread(t_4_0);
-    runtime_util.join_thread(t_4_1);
-    runtime_util.join_thread(t_4_2);
-    runtime_util.join_thread(t_4_3);
-    runtime_util.join_thread(t_5_0);
-    runtime_util.join_thread(t_5_1);
-    runtime_util.join_thread(t_5_2);
-    runtime_util.join_thread(t_5_3);
-    runtime_util.join_thread(t_6_0);
-    runtime_util.join_thread(t_6_1);
-    runtime_util.join_thread(t_6_2);
-    runtime_util.join_thread(t_6_3);
-    runtime_util.join_thread(t_7_0);
-    runtime_util.join_thread(t_7_1);
-    runtime_util.join_thread(t_7_2);
-    runtime_util.join_thread(t_7_3);
+    runtime_util->join_thread(t_0_0);
+    runtime_util->join_thread(t_0_1);
+    runtime_util->join_thread(t_0_2);
+    runtime_util->join_thread(t_0_3);
+    runtime_util->join_thread(t_1_0);
+    runtime_util->join_thread(t_1_1);
+    runtime_util->join_thread(t_1_2);
+    runtime_util->join_thread(t_1_3);
+    runtime_util->join_thread(t_2_0);
+    runtime_util->join_thread(t_2_1);
+    runtime_util->join_thread(t_2_2);
+    runtime_util->join_thread(t_2_3);
+    runtime_util->join_thread(t_3_0);
+    runtime_util->join_thread(t_3_1);
+    runtime_util->join_thread(t_3_2);
+    runtime_util->join_thread(t_3_3);
+    runtime_util->join_thread(t_4_0);
+    runtime_util->join_thread(t_4_1);
+    runtime_util->join_thread(t_4_2);
+    runtime_util->join_thread(t_4_3);
+    runtime_util->join_thread(t_5_0);
+    runtime_util->join_thread(t_5_1);
+    runtime_util->join_thread(t_5_2);
+    runtime_util->join_thread(t_5_3);
+    runtime_util->join_thread(t_6_0);
+    runtime_util->join_thread(t_6_1);
+    runtime_util->join_thread(t_6_2);
+    runtime_util->join_thread(t_6_3);
+    runtime_util->join_thread(t_7_0);
+    runtime_util->join_thread(t_7_1);
+    runtime_util->join_thread(t_7_2);
+    runtime_util->join_thread(t_7_3);
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
index 89c5e3106d..cd2d73d5d5 100644
--- a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
@@ -33,8 +33,8 @@ DEFINE_BFUNC(7)
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
             nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
-    runtime_util = *rt_util_mt;
-    nncase_mt = *nncase_mt_impl;
+    runtime_util = rt_util_mt;
+    nncase_mt = nncase_mt_impl;
 
     MALLOC_SHARED(0, output, dims_t({1, 48, 32000}));
     MALLOC_SHARED(1, output, dims_t({1, 48, 32000}));
@@ -62,69 +62,69 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
     pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
-    runtime_util.create_thread(t_0_0, NULL, f_0_0);
-    runtime_util.create_thread(t_0_1, NULL, f_0_1);
-    runtime_util.create_thread(t_0_2, NULL, f_0_2);
-    runtime_util.create_thread(t_0_3, NULL, f_0_3);
-    runtime_util.create_thread(t_1_0, NULL, f_1_0);
-    runtime_util.create_thread(t_1_1, NULL, f_1_1);
-    runtime_util.create_thread(t_1_2, NULL, f_1_2);
-    runtime_util.create_thread(t_1_3, NULL, f_1_3);
-    runtime_util.create_thread(t_2_0, NULL, f_2_0);
-    runtime_util.create_thread(t_2_1, NULL, f_2_1);
-    runtime_util.create_thread(t_2_2, NULL, f_2_2);
-    runtime_util.create_thread(t_2_3, NULL, f_2_3);
-    runtime_util.create_thread(t_3_0, NULL, f_3_0);
-    runtime_util.create_thread(t_3_1, NULL, f_3_1);
-    runtime_util.create_thread(t_3_2, NULL, f_3_2);
-    runtime_util.create_thread(t_3_3, NULL, f_3_3);
-    runtime_util.create_thread(t_4_0, NULL, f_4_0);
-    runtime_util.create_thread(t_4_1, NULL, f_4_1);
-    runtime_util.create_thread(t_4_2, NULL, f_4_2);
-    runtime_util.create_thread(t_4_3, NULL, f_4_3);
-    runtime_util.create_thread(t_5_0, NULL, f_5_0);
-    runtime_util.create_thread(t_5_1, NULL, f_5_1);
-    runtime_util.create_thread(t_5_2, NULL, f_5_2);
-    runtime_util.create_thread(t_5_3, NULL, f_5_3);
-    runtime_util.create_thread(t_6_0, NULL, f_6_0);
-    runtime_util.create_thread(t_6_1, NULL, f_6_1);
-    runtime_util.create_thread(t_6_2, NULL, f_6_2);
-    runtime_util.create_thread(t_6_3, NULL, f_6_3);
-    runtime_util.create_thread(t_7_0, NULL, f_7_0);
-    runtime_util.create_thread(t_7_1, NULL, f_7_1);
-    runtime_util.create_thread(t_7_2, NULL, f_7_2);
-    runtime_util.create_thread(t_7_3, NULL, f_7_3);
+    runtime_util->create_thread(t_0_0, NULL, f_0_0);
+    runtime_util->create_thread(t_0_1, NULL, f_0_1);
+    runtime_util->create_thread(t_0_2, NULL, f_0_2);
+    runtime_util->create_thread(t_0_3, NULL, f_0_3);
+    runtime_util->create_thread(t_1_0, NULL, f_1_0);
+    runtime_util->create_thread(t_1_1, NULL, f_1_1);
+    runtime_util->create_thread(t_1_2, NULL, f_1_2);
+    runtime_util->create_thread(t_1_3, NULL, f_1_3);
+    runtime_util->create_thread(t_2_0, NULL, f_2_0);
+    runtime_util->create_thread(t_2_1, NULL, f_2_1);
+    runtime_util->create_thread(t_2_2, NULL, f_2_2);
+    runtime_util->create_thread(t_2_3, NULL, f_2_3);
+    runtime_util->create_thread(t_3_0, NULL, f_3_0);
+    runtime_util->create_thread(t_3_1, NULL, f_3_1);
+    runtime_util->create_thread(t_3_2, NULL, f_3_2);
+    runtime_util->create_thread(t_3_3, NULL, f_3_3);
+    runtime_util->create_thread(t_4_0, NULL, f_4_0);
+    runtime_util->create_thread(t_4_1, NULL, f_4_1);
+    runtime_util->create_thread(t_4_2, NULL, f_4_2);
+    runtime_util->create_thread(t_4_3, NULL, f_4_3);
+    runtime_util->create_thread(t_5_0, NULL, f_5_0);
+    runtime_util->create_thread(t_5_1, NULL, f_5_1);
+    runtime_util->create_thread(t_5_2, NULL, f_5_2);
+    runtime_util->create_thread(t_5_3, NULL, f_5_3);
+    runtime_util->create_thread(t_6_0, NULL, f_6_0);
+    runtime_util->create_thread(t_6_1, NULL, f_6_1);
+    runtime_util->create_thread(t_6_2, NULL, f_6_2);
+    runtime_util->create_thread(t_6_3, NULL, f_6_3);
+    runtime_util->create_thread(t_7_0, NULL, f_7_0);
+    runtime_util->create_thread(t_7_1, NULL, f_7_1);
+    runtime_util->create_thread(t_7_2, NULL, f_7_2);
+    runtime_util->create_thread(t_7_3, NULL, f_7_3);
 
-    runtime_util.join_thread(t_0_0);
-    runtime_util.join_thread(t_0_1);
-    runtime_util.join_thread(t_0_2);
-    runtime_util.join_thread(t_0_3);
-    runtime_util.join_thread(t_1_0);
-    runtime_util.join_thread(t_1_1);
-    runtime_util.join_thread(t_1_2);
-    runtime_util.join_thread(t_1_3);
-    runtime_util.join_thread(t_2_0);
-    runtime_util.join_thread(t_2_1);
-    runtime_util.join_thread(t_2_2);
-    runtime_util.join_thread(t_2_3);
-    runtime_util.join_thread(t_3_0);
-    runtime_util.join_thread(t_3_1);
-    runtime_util.join_thread(t_3_2);
-    runtime_util.join_thread(t_3_3);
-    runtime_util.join_thread(t_4_0);
-    runtime_util.join_thread(t_4_1);
-    runtime_util.join_thread(t_4_2);
-    runtime_util.join_thread(t_4_3);
-    runtime_util.join_thread(t_5_0);
-    runtime_util.join_thread(t_5_1);
-    runtime_util.join_thread(t_5_2);
-    runtime_util.join_thread(t_5_3);
-    runtime_util.join_thread(t_6_0);
-    runtime_util.join_thread(t_6_1);
-    runtime_util.join_thread(t_6_2);
-    runtime_util.join_thread(t_6_3);
-    runtime_util.join_thread(t_7_0);
-    runtime_util.join_thread(t_7_1);
-    runtime_util.join_thread(t_7_2);
-    runtime_util.join_thread(t_7_3);
+    runtime_util->join_thread(t_0_0);
+    runtime_util->join_thread(t_0_1);
+    runtime_util->join_thread(t_0_2);
+    runtime_util->join_thread(t_0_3);
+    runtime_util->join_thread(t_1_0);
+    runtime_util->join_thread(t_1_1);
+    runtime_util->join_thread(t_1_2);
+    runtime_util->join_thread(t_1_3);
+    runtime_util->join_thread(t_2_0);
+    runtime_util->join_thread(t_2_1);
+    runtime_util->join_thread(t_2_2);
+    runtime_util->join_thread(t_2_3);
+    runtime_util->join_thread(t_3_0);
+    runtime_util->join_thread(t_3_1);
+    runtime_util->join_thread(t_3_2);
+    runtime_util->join_thread(t_3_3);
+    runtime_util->join_thread(t_4_0);
+    runtime_util->join_thread(t_4_1);
+    runtime_util->join_thread(t_4_2);
+    runtime_util->join_thread(t_4_3);
+    runtime_util->join_thread(t_5_0);
+    runtime_util->join_thread(t_5_1);
+    runtime_util->join_thread(t_5_2);
+    runtime_util->join_thread(t_5_3);
+    runtime_util->join_thread(t_6_0);
+    runtime_util->join_thread(t_6_1);
+    runtime_util->join_thread(t_6_2);
+    runtime_util->join_thread(t_6_3);
+    runtime_util->join_thread(t_7_0);
+    runtime_util->join_thread(t_7_1);
+    runtime_util->join_thread(t_7_2);
+    runtime_util->join_thread(t_7_3);
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp b/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
index 7f2469b710..8f5faebbe3 100644
--- a/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
@@ -28,8 +28,8 @@ DEFINE_BFUNC(7)
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
             nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
-    runtime_util = *rt_util_mt;
-    nncase_mt = *nncase_mt_impl;
+    runtime_util = rt_util_mt;
+    nncase_mt = nncase_mt_impl;
 
     auto input0 = tensor<float, loc_t::device>(
         gsl::make_span((float *)inputs[0], 384 * 8192), {1, 384, 8192});
@@ -44,69 +44,69 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
     pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
-    runtime_util.create_thread(t_0_0, NULL, f_0_0);
-    runtime_util.create_thread(t_0_1, NULL, f_0_1);
-    runtime_util.create_thread(t_0_2, NULL, f_0_2);
-    runtime_util.create_thread(t_0_3, NULL, f_0_3);
-    runtime_util.create_thread(t_1_0, NULL, f_1_0);
-    runtime_util.create_thread(t_1_1, NULL, f_1_1);
-    runtime_util.create_thread(t_1_2, NULL, f_1_2);
-    runtime_util.create_thread(t_1_3, NULL, f_1_3);
-    runtime_util.create_thread(t_2_0, NULL, f_2_0);
-    runtime_util.create_thread(t_2_1, NULL, f_2_1);
-    runtime_util.create_thread(t_2_2, NULL, f_2_2);
-    runtime_util.create_thread(t_2_3, NULL, f_2_3);
-    runtime_util.create_thread(t_3_0, NULL, f_3_0);
-    runtime_util.create_thread(t_3_1, NULL, f_3_1);
-    runtime_util.create_thread(t_3_2, NULL, f_3_2);
-    runtime_util.create_thread(t_3_3, NULL, f_3_3);
-    runtime_util.create_thread(t_4_0, NULL, f_4_0);
-    runtime_util.create_thread(t_4_1, NULL, f_4_1);
-    runtime_util.create_thread(t_4_2, NULL, f_4_2);
-    runtime_util.create_thread(t_4_3, NULL, f_4_3);
-    runtime_util.create_thread(t_5_0, NULL, f_5_0);
-    runtime_util.create_thread(t_5_1, NULL, f_5_1);
-    runtime_util.create_thread(t_5_2, NULL, f_5_2);
-    runtime_util.create_thread(t_5_3, NULL, f_5_3);
-    runtime_util.create_thread(t_6_0, NULL, f_6_0);
-    runtime_util.create_thread(t_6_1, NULL, f_6_1);
-    runtime_util.create_thread(t_6_2, NULL, f_6_2);
-    runtime_util.create_thread(t_6_3, NULL, f_6_3);
-    runtime_util.create_thread(t_7_0, NULL, f_7_0);
-    runtime_util.create_thread(t_7_1, NULL, f_7_1);
-    runtime_util.create_thread(t_7_2, NULL, f_7_2);
-    runtime_util.create_thread(t_7_3, NULL, f_7_3);
+    runtime_util->create_thread(t_0_0, NULL, f_0_0);
+    runtime_util->create_thread(t_0_1, NULL, f_0_1);
+    runtime_util->create_thread(t_0_2, NULL, f_0_2);
+    runtime_util->create_thread(t_0_3, NULL, f_0_3);
+    runtime_util->create_thread(t_1_0, NULL, f_1_0);
+    runtime_util->create_thread(t_1_1, NULL, f_1_1);
+    runtime_util->create_thread(t_1_2, NULL, f_1_2);
+    runtime_util->create_thread(t_1_3, NULL, f_1_3);
+    runtime_util->create_thread(t_2_0, NULL, f_2_0);
+    runtime_util->create_thread(t_2_1, NULL, f_2_1);
+    runtime_util->create_thread(t_2_2, NULL, f_2_2);
+    runtime_util->create_thread(t_2_3, NULL, f_2_3);
+    runtime_util->create_thread(t_3_0, NULL, f_3_0);
+    runtime_util->create_thread(t_3_1, NULL, f_3_1);
+    runtime_util->create_thread(t_3_2, NULL, f_3_2);
+    runtime_util->create_thread(t_3_3, NULL, f_3_3);
+    runtime_util->create_thread(t_4_0, NULL, f_4_0);
+    runtime_util->create_thread(t_4_1, NULL, f_4_1);
+    runtime_util->create_thread(t_4_2, NULL, f_4_2);
+    runtime_util->create_thread(t_4_3, NULL, f_4_3);
+    runtime_util->create_thread(t_5_0, NULL, f_5_0);
+    runtime_util->create_thread(t_5_1, NULL, f_5_1);
+    runtime_util->create_thread(t_5_2, NULL, f_5_2);
+    runtime_util->create_thread(t_5_3, NULL, f_5_3);
+    runtime_util->create_thread(t_6_0, NULL, f_6_0);
+    runtime_util->create_thread(t_6_1, NULL, f_6_1);
+    runtime_util->create_thread(t_6_2, NULL, f_6_2);
+    runtime_util->create_thread(t_6_3, NULL, f_6_3);
+    runtime_util->create_thread(t_7_0, NULL, f_7_0);
+    runtime_util->create_thread(t_7_1, NULL, f_7_1);
+    runtime_util->create_thread(t_7_2, NULL, f_7_2);
+    runtime_util->create_thread(t_7_3, NULL, f_7_3);
 
-    runtime_util.join_thread(t_0_0);
-    runtime_util.join_thread(t_0_1);
-    runtime_util.join_thread(t_0_2);
-    runtime_util.join_thread(t_0_3);
-    runtime_util.join_thread(t_1_0);
-    runtime_util.join_thread(t_1_1);
-    runtime_util.join_thread(t_1_2);
-    runtime_util.join_thread(t_1_3);
-    runtime_util.join_thread(t_2_0);
-    runtime_util.join_thread(t_2_1);
-    runtime_util.join_thread(t_2_2);
-    runtime_util.join_thread(t_2_3);
-    runtime_util.join_thread(t_3_0);
-    runtime_util.join_thread(t_3_1);
-    runtime_util.join_thread(t_3_2);
-    runtime_util.join_thread(t_3_3);
-    runtime_util.join_thread(t_4_0);
-    runtime_util.join_thread(t_4_1);
-    runtime_util.join_thread(t_4_2);
-    runtime_util.join_thread(t_4_3);
-    runtime_util.join_thread(t_5_0);
-    runtime_util.join_thread(t_5_1);
-    runtime_util.join_thread(t_5_2);
-    runtime_util.join_thread(t_5_3);
-    runtime_util.join_thread(t_6_0);
-    runtime_util.join_thread(t_6_1);
-    runtime_util.join_thread(t_6_2);
-    runtime_util.join_thread(t_6_3);
-    runtime_util.join_thread(t_7_0);
-    runtime_util.join_thread(t_7_1);
-    runtime_util.join_thread(t_7_2);
-    runtime_util.join_thread(t_7_3);
+    runtime_util->join_thread(t_0_0);
+    runtime_util->join_thread(t_0_1);
+    runtime_util->join_thread(t_0_2);
+    runtime_util->join_thread(t_0_3);
+    runtime_util->join_thread(t_1_0);
+    runtime_util->join_thread(t_1_1);
+    runtime_util->join_thread(t_1_2);
+    runtime_util->join_thread(t_1_3);
+    runtime_util->join_thread(t_2_0);
+    runtime_util->join_thread(t_2_1);
+    runtime_util->join_thread(t_2_2);
+    runtime_util->join_thread(t_2_3);
+    runtime_util->join_thread(t_3_0);
+    runtime_util->join_thread(t_3_1);
+    runtime_util->join_thread(t_3_2);
+    runtime_util->join_thread(t_3_3);
+    runtime_util->join_thread(t_4_0);
+    runtime_util->join_thread(t_4_1);
+    runtime_util->join_thread(t_4_2);
+    runtime_util->join_thread(t_4_3);
+    runtime_util->join_thread(t_5_0);
+    runtime_util->join_thread(t_5_1);
+    runtime_util->join_thread(t_5_2);
+    runtime_util->join_thread(t_5_3);
+    runtime_util->join_thread(t_6_0);
+    runtime_util->join_thread(t_6_1);
+    runtime_util->join_thread(t_6_2);
+    runtime_util->join_thread(t_6_3);
+    runtime_util->join_thread(t_7_0);
+    runtime_util->join_thread(t_7_1);
+    runtime_util->join_thread(t_7_2);
+    runtime_util->join_thread(t_7_3);
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp b/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp
index cc62abe23f..720aec388c 100755
--- a/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp
@@ -28,8 +28,8 @@ DEFINE_BFUNC(7)
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
             nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
-    runtime_util = *rt_util_mt;
-    nncase_mt = *nncase_mt_impl;
+    runtime_util = rt_util_mt;
+    nncase_mt = nncase_mt_impl;
 
     auto buffer_0_ = tensor<float, loc_t::device>(
         gsl::make_span((float *)inputs[0], 786432), {1, 384, 2048});
@@ -43,69 +43,69 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
     pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
     pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
 
-    runtime_util.create_thread(t_0_0, NULL, f_0_0);
-    runtime_util.create_thread(t_0_1, NULL, f_0_1);
-    runtime_util.create_thread(t_0_2, NULL, f_0_2);
-    runtime_util.create_thread(t_0_3, NULL, f_0_3);
-    runtime_util.create_thread(t_1_0, NULL, f_1_0);
-    runtime_util.create_thread(t_1_1, NULL, f_1_1);
-    runtime_util.create_thread(t_1_2, NULL, f_1_2);
-    runtime_util.create_thread(t_1_3, NULL, f_1_3);
-    runtime_util.create_thread(t_2_0, NULL, f_2_0);
-    runtime_util.create_thread(t_2_1, NULL, f_2_1);
-    runtime_util.create_thread(t_2_2, NULL, f_2_2);
-    runtime_util.create_thread(t_2_3, NULL, f_2_3);
-    runtime_util.create_thread(t_3_0, NULL, f_3_0);
-    runtime_util.create_thread(t_3_1, NULL, f_3_1);
-    runtime_util.create_thread(t_3_2, NULL, f_3_2);
-    runtime_util.create_thread(t_3_3, NULL, f_3_3);
-    runtime_util.create_thread(t_4_0, NULL, f_4_0);
-    runtime_util.create_thread(t_4_1, NULL, f_4_1);
-    runtime_util.create_thread(t_4_2, NULL, f_4_2);
-    runtime_util.create_thread(t_4_3, NULL, f_4_3);
-    runtime_util.create_thread(t_5_0, NULL, f_5_0);
-    runtime_util.create_thread(t_5_1, NULL, f_5_1);
-    runtime_util.create_thread(t_5_2, NULL, f_5_2);
-    runtime_util.create_thread(t_5_3, NULL, f_5_3);
-    runtime_util.create_thread(t_6_0, NULL, f_6_0);
-    runtime_util.create_thread(t_6_1, NULL, f_6_1);
-    runtime_util.create_thread(t_6_2, NULL, f_6_2);
-    runtime_util.create_thread(t_6_3, NULL, f_6_3);
-    runtime_util.create_thread(t_7_0, NULL, f_7_0);
-    runtime_util.create_thread(t_7_1, NULL, f_7_1);
-    runtime_util.create_thread(t_7_2, NULL, f_7_2);
-    runtime_util.create_thread(t_7_3, NULL, f_7_3);
+    runtime_util->create_thread(t_0_0, NULL, f_0_0);
+    runtime_util->create_thread(t_0_1, NULL, f_0_1);
+    runtime_util->create_thread(t_0_2, NULL, f_0_2);
+    runtime_util->create_thread(t_0_3, NULL, f_0_3);
+    runtime_util->create_thread(t_1_0, NULL, f_1_0);
+    runtime_util->create_thread(t_1_1, NULL, f_1_1);
+    runtime_util->create_thread(t_1_2, NULL, f_1_2);
+    runtime_util->create_thread(t_1_3, NULL, f_1_3);
+    runtime_util->create_thread(t_2_0, NULL, f_2_0);
+    runtime_util->create_thread(t_2_1, NULL, f_2_1);
+    runtime_util->create_thread(t_2_2, NULL, f_2_2);
+    runtime_util->create_thread(t_2_3, NULL, f_2_3);
+    runtime_util->create_thread(t_3_0, NULL, f_3_0);
+    runtime_util->create_thread(t_3_1, NULL, f_3_1);
+    runtime_util->create_thread(t_3_2, NULL, f_3_2);
+    runtime_util->create_thread(t_3_3, NULL, f_3_3);
+    runtime_util->create_thread(t_4_0, NULL, f_4_0);
+    runtime_util->create_thread(t_4_1, NULL, f_4_1);
+    runtime_util->create_thread(t_4_2, NULL, f_4_2);
+    runtime_util->create_thread(t_4_3, NULL, f_4_3);
+    runtime_util->create_thread(t_5_0, NULL, f_5_0);
+    runtime_util->create_thread(t_5_1, NULL, f_5_1);
+    runtime_util->create_thread(t_5_2, NULL, f_5_2);
+    runtime_util->create_thread(t_5_3, NULL, f_5_3);
+    runtime_util->create_thread(t_6_0, NULL, f_6_0);
+    runtime_util->create_thread(t_6_1, NULL, f_6_1);
+    runtime_util->create_thread(t_6_2, NULL, f_6_2);
+    runtime_util->create_thread(t_6_3, NULL, f_6_3);
+    runtime_util->create_thread(t_7_0, NULL, f_7_0);
+    runtime_util->create_thread(t_7_1, NULL, f_7_1);
+    runtime_util->create_thread(t_7_2, NULL, f_7_2);
+    runtime_util->create_thread(t_7_3, NULL, f_7_3);
 
-    runtime_util.join_thread(t_0_0);
-    runtime_util.join_thread(t_0_1);
-    runtime_util.join_thread(t_0_2);
-    runtime_util.join_thread(t_0_3);
-    runtime_util.join_thread(t_1_0);
-    runtime_util.join_thread(t_1_1);
-    runtime_util.join_thread(t_1_2);
-    runtime_util.join_thread(t_1_3);
-    runtime_util.join_thread(t_2_0);
-    runtime_util.join_thread(t_2_1);
-    runtime_util.join_thread(t_2_2);
-    runtime_util.join_thread(t_2_3);
-    runtime_util.join_thread(t_3_0);
-    runtime_util.join_thread(t_3_1);
-    runtime_util.join_thread(t_3_2);
-    runtime_util.join_thread(t_3_3);
-    runtime_util.join_thread(t_4_0);
-    runtime_util.join_thread(t_4_1);
-    runtime_util.join_thread(t_4_2);
-    runtime_util.join_thread(t_4_3);
-    runtime_util.join_thread(t_5_0);
-    runtime_util.join_thread(t_5_1);
-    runtime_util.join_thread(t_5_2);
-    runtime_util.join_thread(t_5_3);
-    runtime_util.join_thread(t_6_0);
-    runtime_util.join_thread(t_6_1);
-    runtime_util.join_thread(t_6_2);
-    runtime_util.join_thread(t_6_3);
-    runtime_util.join_thread(t_7_0);
-    runtime_util.join_thread(t_7_1);
-    runtime_util.join_thread(t_7_2);
-    runtime_util.join_thread(t_7_3);
+    runtime_util->join_thread(t_0_0);
+    runtime_util->join_thread(t_0_1);
+    runtime_util->join_thread(t_0_2);
+    runtime_util->join_thread(t_0_3);
+    runtime_util->join_thread(t_1_0);
+    runtime_util->join_thread(t_1_1);
+    runtime_util->join_thread(t_1_2);
+    runtime_util->join_thread(t_1_3);
+    runtime_util->join_thread(t_2_0);
+    runtime_util->join_thread(t_2_1);
+    runtime_util->join_thread(t_2_2);
+    runtime_util->join_thread(t_2_3);
+    runtime_util->join_thread(t_3_0);
+    runtime_util->join_thread(t_3_1);
+    runtime_util->join_thread(t_3_2);
+    runtime_util->join_thread(t_3_3);
+    runtime_util->join_thread(t_4_0);
+    runtime_util->join_thread(t_4_1);
+    runtime_util->join_thread(t_4_2);
+    runtime_util->join_thread(t_4_3);
+    runtime_util->join_thread(t_5_0);
+    runtime_util->join_thread(t_5_1);
+    runtime_util->join_thread(t_5_2);
+    runtime_util->join_thread(t_5_3);
+    runtime_util->join_thread(t_6_0);
+    runtime_util->join_thread(t_6_1);
+    runtime_util->join_thread(t_6_2);
+    runtime_util->join_thread(t_6_3);
+    runtime_util->join_thread(t_7_0);
+    runtime_util->join_thread(t_7_1);
+    runtime_util->join_thread(t_7_2);
+    runtime_util->join_thread(t_7_3);
 }
\ No newline at end of file

From 842119bcf4b49d274445c8aeb52cd4ca1f41a341 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 14 Sep 2023 11:16:13 +0800
Subject: [PATCH 173/308] fix cpu test

---
 modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs | 6 +++---
 modules/cpu/src/runtime/CMakeLists.txt              | 7 ++++---
 modules/cpu/src/runtime/shared_memory.h             | 1 +
 3 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index b0c4871591..48aef1e29c 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -193,8 +193,7 @@ public static string CMakeDef(string name, [CallerFilePath] string? callerFilePa
 
 add_library(
   cpu_cmodel STATIC
-  {solutionPath}/modules/cpu/src/runtime/cmodel/src/dummy.cpp
-  {solutionPath}/modules/cpu/src/runtime/hardware_context.cpp)
+  {solutionPath}/modules/cpu/src/runtime/cmodel/src/dummy.cpp)
 
 set(CMAKE_CXX_STANDARD 20)
 
@@ -270,9 +269,10 @@ public static string MakeMain(TIR.PrimFunction primFunction)
 DEFINE_BFUNC(7)
 
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {{global_hardware_init(hw_ctx_impl);
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {{
     runtime_util = rt_util_mt;
     nncase_mt = nncase_mt_impl;
+    global_hardware_init(hw_ctx_impl);
 
     {init_tensors}
 
diff --git a/modules/cpu/src/runtime/CMakeLists.txt b/modules/cpu/src/runtime/CMakeLists.txt
index aba9f8da01..f0e8511e39 100644
--- a/modules/cpu/src/runtime/CMakeLists.txt
+++ b/modules/cpu/src/runtime/CMakeLists.txt
@@ -11,13 +11,14 @@ set(SRCS runtime_module.cpp
          elfreloc_amd64.cpp
          elfreloc_i386.cpp
          elfreloc_riscv64.cpp
-         hardware_context.cpp)
+         hardware_context.cpp
+         shared_memory.cpp)
 
 if (BUILDING_RUNTIME)
     if (ENABLE_CPU_RUNTIME)
         add_library(runtime_cpu OBJECT ${SRCS})
-        target_link_libraries(runtime_cpu PUBLIC nncaseruntime cpu_cmodel pthread)
-        set_target_properties(runtime_cpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
+        target_link_libraries(runtime_cpu PUBLIC nncaseruntime pthread rt stdc++)
+        # set_target_properties(runtime_cpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
         install(TARGETS runtime_cpu EXPORT nncaseruntimeTargets)
     endif()
 else()
diff --git a/modules/cpu/src/runtime/shared_memory.h b/modules/cpu/src/runtime/shared_memory.h
index b1eab116aa..6663d8e675 100644
--- a/modules/cpu/src/runtime/shared_memory.h
+++ b/modules/cpu/src/runtime/shared_memory.h
@@ -15,6 +15,7 @@
 #pragma once
 #include <filesystem>
 #include <nncase/runtime/cpu/compiler_defs.h>
+#include "gsl-lite.hpp"
 
 #ifdef WIN32
 #include <Windows.h>

From 40f6ad8053d631ef29beb720e8f523b27204c276 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 14 Sep 2023 11:20:03 +0800
Subject: [PATCH 174/308] refactor auto distributed

---
 .../CodeGen/CSourceConvertVisitor.cs          |   3 +
 .../CodeGen/CSourceExtensions.cs              |   2 +-
 .../Evaluator/XPU/Binary.cs                   |   1 -
 .../Evaluator/XPU/BlockMMA.cs                 |  12 --
 .../Evaluator/XPU/Matmul.cs                   |   1 +
 .../Evaluator/XPU/XPUModule.cs                |   1 -
 modules/Nncase.Modules.CPU/IR/XPU/Binary.cs   |   2 +-
 modules/Nncase.Modules.CPU/IR/XPU/BlockMMA.cs |  15 --
 .../Nncase.Modules.CPU.csproj                 |   1 +
 .../Passes/Tile/SingleCPUFusionConverter.cs   | 139 +++++++++++++++---
 src/Nncase.Core/CostModel/Cost.cs             |  14 ++
 src/Nncase.Core/DistributedType.cs            |   2 +-
 src/Nncase.Core/DistributedUtilities.cs       |   5 +
 src/Nncase.Core/IR/Math/Binary.cs             |   4 +-
 src/Nncase.Core/IR/Math/MatMul.cs             |   4 +-
 src/Nncase.Core/IR/Math/Unary.cs              |   2 +-
 src/Nncase.Core/IR/NN/LayerNorm.cs            |   6 +-
 src/Nncase.Core/IR/Op.cs                      |  20 ++-
 src/Nncase.Core/IR/Tensors/Concat.cs          |   4 +-
 src/Nncase.Core/IR/Tensors/Functional.cs      |  14 +-
 src/Nncase.Core/IR/Tensors/Gather.cs          |  10 +-
 src/Nncase.Core/IR/Tensors/Slice.cs           |   2 +-
 src/Nncase.Core/IR/Tensors/UnSqueeze.cs       |   2 +-
 src/Nncase.Core/IR/TypePattern.cs             |   1 +
 .../Passes/EGraphExtractExtensions.cs         |   2 +-
 src/Nncase.Evaluator/Math/Binary.cs           |   2 +-
 src/Nncase.Evaluator/Math/MatMul.cs           | 136 +++++++++--------
 src/Nncase.Evaluator/NN/LayerNorm.cs          |  72 ++++++++-
 .../Tensors/BoxingEvaluator.cs                |  44 +++++-
 src/Nncase.Evaluator/Tensors/Concat.cs        | 109 ++++++++++----
 src/Nncase.Evaluator/Tensors/Gather.cs        |  75 +++++++---
 src/Nncase.Evaluator/Tensors/Slice.cs         |  21 ++-
 src/Nncase.Evaluator/Tensors/UnSqueeze.cs     |  35 ++++-
 src/Nncase.Importer/Onnx/Concat.cs            |   2 +-
 src/Nncase.Importer/Onnx/Gather.cs            |   2 +-
 .../Rules/Neutral/CombineQuantize.cs          |   8 +-
 .../Rules/Neutral/CombineTranspose.cs         |   7 +-
 src/Nncase.Passes/Rules/Neutral/FocusFull.cs  |   9 +-
 .../Rules/Neutral/FoldGatherReshape.cs        |   8 +-
 .../Distributed/UnitTestDistTypeInfer.cs      | 105 +++++++++++++
 .../Evaluator/UnitTestEvaluatorTensors.cs     |   4 +-
 src/Nncase.Tests/Match/UnitTestEGraphMatch.cs |  10 +-
 src/Nncase.Tests/Rewrite/RewriteBase.cs       |   2 +-
 .../Rules/ShapeBucket/ShapeBucketTest.cs      |   2 +-
 .../Targets/UnitTestCPUTargetTiling.cs        | 123 +++++++++++-----
 45 files changed, 780 insertions(+), 265 deletions(-)
 delete mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/BlockMMA.cs
 delete mode 100644 modules/Nncase.Modules.CPU/IR/XPU/BlockMMA.cs
 create mode 100644 src/Nncase.Tests/Distributed/UnitTestDistTypeInfer.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index c2bc888555..40b0d2b414 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -250,6 +250,9 @@ protected override CSymbol VisitCall(Call expr)
                 case IR.XPU.Binary binary:
                     IndentScope.Writer.Write($"binary({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, binary_op_t::{binary.BinaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
                     break;
+                case IR.XPU.Matmul matmul:
+                    IndentScope.Writer.Write($"matmul({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name})");
+                    break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
             }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index 88547f5fc9..01f0744962 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -38,7 +38,7 @@ public static string ToC(this PrimType primType) =>
 
     public static string ToC(this MemoryLocation location) => location switch
     {
-        MemoryLocation.Output or MemoryLocation.Input => "loc_t::device",
+        MemoryLocation.Output or MemoryLocation.Input or MemoryLocation.Rdata => "loc_t::device",
         MemoryLocation.L2Data => "loc_t::shared",
         MemoryLocation.L1Data => "loc_t::local",
         _ => throw new NotSupportedException(location.ToString()),
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Binary.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Binary.cs
index b8fa9f2206..36fa13389d 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Binary.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Binary.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
-
 using Nncase.IR;
 using Nncase.IR.XPU;
 
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/BlockMMA.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/BlockMMA.cs
deleted file mode 100644
index 09fc41aa34..0000000000
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/BlockMMA.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.IR.XPU;
-
-namespace Nncase.Evaluator.XPU;
-
-public sealed class BlockMMAEvaluator : ITypeInferencer<BlockMMA>
-{
-    public IRType Visit(ITypeInferenceContext context, BlockMMA target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Matmul.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Matmul.cs
index 631fc4fe3c..5da9e21761 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Matmul.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Matmul.cs
@@ -3,6 +3,7 @@
 
 using Nncase.IR;
 using Nncase.IR.XPU;
+
 namespace Nncase.Evaluator.XPU;
 
 public sealed class MatmulEvaluator : ITypeInferencer<Matmul>
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 941167e411..57fc797d20 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -18,6 +18,5 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<UnaryEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<BinaryEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<MatmulEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<BlockMMAEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs b/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs
index b616ba8d16..40e6f55312 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs
@@ -6,7 +6,7 @@ namespace Nncase.IR.XPU;
 public sealed partial class Binary : XPUKernelOp
 {
     public static readonly ParameterInfo Lhs = new(typeof(Binary), 0, "input");
-    
+
     public static readonly ParameterInfo Rhs = new(typeof(Binary), 1, "input");
 
     public static readonly ParameterInfo Output = new(typeof(Binary), 2, "output");
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/BlockMMA.cs b/modules/Nncase.Modules.CPU/IR/XPU/BlockMMA.cs
deleted file mode 100644
index c69a5077e7..0000000000
--- a/modules/Nncase.Modules.CPU/IR/XPU/BlockMMA.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-namespace Nncase.IR.XPU;
-
-
-public sealed partial class BlockMMA : XPUKernelOp
-{
-    public static readonly ParameterInfo Lhs = new(typeof(BlockMMA), 0, "input");
-
-    public static readonly ParameterInfo Rhs = new(typeof(BlockMMA), 1, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(BlockMMA), 2, "output");
-
-}
diff --git a/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj b/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj
index 60eb18e05d..edfe0f068e 100644
--- a/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj
+++ b/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj
@@ -6,6 +6,7 @@
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+    <LangVersion>11.0</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 3fd776a997..d8a2157f2b 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -41,10 +41,36 @@ public TIR.PrimFunction Convert(Fusion fusion)
     {
         // 1. convert to distribute graph
         var distConverter = new DistributeConvertVisitor(TileOptions);
-        var candidatebodys = distConverter.Convert(fusion.Body);
+        var candidatebodys = distConverter.Convert(fusion.Body, out var stagesMap);
         var graph = new EGraph();
         var bodyEclasses = candidatebodys.Select(graph.Add).ToArray();
-        _ = bodyEclasses.Skip(1).Select(cls => graph.Union(bodyEclasses[0], cls)).ToArray(); // must keep this.
+        foreach (var (b, i) in candidatebodys.Select((b, i) => (b, i)))
+        {
+            DumpScope.Current.DumpDotIR(b, "body_" + i.ToString(), "Distribute");
+        }
+
+        // 2. union stages
+        foreach (var ((_, equivals), i) in stagesMap.Select((k, i) => (k, i)))
+        {
+            foreach (var (b, j) in equivals.Select((b, j) => (b, j)))
+            {
+                DumpScope.Current.DumpDotIR(b, $"eq_{i}_{j}", "Distribute");
+            }
+
+            var equivalEclasses = equivals.Select(graph.Add).ToArray();
+
+            foreach (var cls in equivalEclasses.Skip(1))
+            {
+                graph.Union(equivalEclasses[0], cls);
+            }
+        }
+
+        // 3. union final body
+        foreach (var cls in bodyEclasses.Skip(1))
+        {
+            graph.Union(bodyEclasses[0], cls);
+        }
+
         graph.Rebuild();
         var body = graph.Extract(bodyEclasses[0], null);
         var newFusion = fusion.With(body: body);
@@ -62,18 +88,22 @@ public TIR.PrimFunction Convert(Fusion fusion)
 
     private sealed class DistributeConvertVisitor : ExprVisitor<IReadOnlyList<Expr>, Unit>
     {
+        private readonly Dictionary<Expr, List<Expr>> _stagesMap;
+
         public DistributeConvertVisitor(TileOptions tileOptions)
         {
             TileOptions = tileOptions;
             Placement = new Placement(Placement.DeviceKind.CPU, tileOptions.Hierarchy, "bt");
+            _stagesMap = new Dictionary<Expr, List<Expr>>(ReferenceEqualityComparer.Instance);
         }
 
         public TileOptions TileOptions { get; }
 
         public Placement Placement { get; }
 
-        public IReadOnlyList<Expr> Convert(Expr body)
+        public IReadOnlyList<Expr> Convert(Expr body, out IReadOnlyDictionary<Expr, List<Expr>> stagesMap)
         {
+            stagesMap = _stagesMap;
             return Visit(body).Select(newbody => IR.F.Tensors.Boxing(newbody, body.CheckedType)).ToArray();
         }
 
@@ -82,31 +112,98 @@ protected override IReadOnlyList<Expr> DefaultVisitLeaf(Expr expr)
             return new[] { expr };
         }
 
+        protected override IReadOnlyList<Expr> VisitLeafTuple(Tuple expr)
+        {
+            return expr.Fields.ToArray().Select(Visit).CartesianProduct().Select(e => new IR.Tuple(e.ToArray())).ToArray();
+        }
+
         protected override IReadOnlyList<Expr> VisitLeafVar(Var expr)
         {
-            var type = (TensorType)expr.TypeAnnotation;
-            return DistributedUtilities.GetLeafCandidateNDSBPs(type, Placement).
-                Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistributedType(type, ndsbp, Placement))).
-                ToArray();
+            return Array.Empty<Expr>();
         }
 
         protected override IReadOnlyList<Expr> VisitLeafConst(Const expr)
         {
-            return DistributedUtilities.GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, Placement)
-                .Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, Placement))).
-                ToArray();
+            return Array.Empty<Expr>();
         }
 
         protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
         {
-            return expr.Arguments.ToArray().
-                Select(arg => ExprMemo[arg]).
-                CartesianProduct<Expr>().
+            if (expr.Target is not Op op)
+            {
+                throw new NotSupportedException("not support auto distributed call function");
+            }
+
+            var equivalArgs = op.Parameters.
+                Select(param => (param.ParameterKind, expr.Arguments[param.Index]) switch
+                {
+                    (ParameterKind.Input, Expr e) when e is Const or Var => DistributedUtilities.GetLeafCandidateBoxings(e, Placement),
+                    (ParameterKind.Attribute, Expr e) when e is Const or Var => new[] { e },
+                    (_, Expr arg) => ExprMemo[arg],
+                }).ToArray();
+            var equivalCalls = equivalArgs.
+                CartesianProduct().
                 Select(args => args.ToArray()).
-                Select(args => new Call(expr.Target, args)).
-                Where(c => c.InferenceType()).
-                ToArray();
+                Select(args => BuildEqualityCalls(op, args)).
+                SelectMany(i => i).
+                Select(c => (c.InferenceType(), c)).ToArray();
+
+            if (equivalCalls.Any(t => t.Item1))
+            {
+                return equivalCalls.Where(t => t.Item1).Select(t => t.c).ToArray();
+            }
+
+            var boxingArgs = new List<IReadOnlyList<Expr>>();
+            foreach (var (info, newArgs) in op.Parameters.Zip(equivalArgs))
+            {
+                var oldArg = expr.Arguments[info.Index];
+                if (!_stagesMap.TryGetValue(oldArg, out var equivals))
+                {
+                    equivals = new List<Expr>();
+                    _stagesMap.Add(oldArg, equivals);
+                }
+
+                equivals.AddRange(newArgs);
+                var tensorType = (TensorType)oldArg.CheckedType;
+                boxingArgs.Add(info.ParameterKind switch
+                {
+                    ParameterKind.Input => DistributedUtilities.GetLeafCandidateNDSBPs(tensorType, Placement).Select(ndsbp => IR.F.Tensors.Boxing(newArgs[0], new DistributedType(tensorType, ndsbp, Placement))).ToList(),
+                    ParameterKind.Attribute => new Expr[] { newArgs[0] },
+                    _ => throw new ArgumentOutOfRangeException(info.ParameterKind.ToString()),
+                });
+            }
+
+            equivalCalls = boxingArgs.CartesianProduct().
+                Select(Enumerable.ToArray<Expr>).
+                Select(args => BuildEqualityCalls(op, args)).
+                SelectMany(i => i).
+                Select(c => (c.InferenceType(), c)).ToArray();
+
+            if (!equivalCalls.Any(t => t.Item1))
+            {
+                throw new InvalidOperationException("after boxing still invalid!");
+            }
+
+            return equivalCalls.Where(t => t.Item1).Select(t => t.c).ToArray();
+        }
+
+        private IEnumerable<Call> BuildEqualityCalls(Op target, Expr[] args)
+        {
+            if (!target.Parameters.Where(p => p.ParameterKind == ParameterKind.Input).All(p => IsDistributed(args[p.Index].CheckedType)))
+            {
+                throw new InvalidDataException();
+            }
+
+            IEnumerable<Call> calls = new[] { new Call(target, args) };
+            return calls;
         }
+
+        private bool IsDistributed(IRType type) => type switch
+        {
+            DistributedType => true,
+            TupleType t => t.All(IsDistributed),
+            _ => false,
+        };
     }
 
     private sealed class ConvertVisitor : ExprVisitor<Unit, Unit>
@@ -305,7 +402,7 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
             return buffer;
         }
 
-        private (TensorType, MemoryLocation) GetTypeAndLocation(IRType type)
+        private Tuple<TensorType, MemoryLocation> GetTypeAndLocation(IRType type)
         {
             MemoryLocation location = MemoryLocation.Data;
             if (type is DistributedType distTensorType)
@@ -323,10 +420,14 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
             TensorType tensorType;
             if (type is DistributedType distTensor)
             {
-                if (!DistributedUtilities.IsDistributable(distTensor.TensorType, distTensor.NdSbp.ToArray(), distTensor.Placement, out tensorType))
+                if (!DistributedUtilities.IsDistributable(distTensor.TensorType, distTensor.NdSbp.ToArray(), distTensor.Placement, out var tType))
                 {
                     throw new NotSupportedException();
                 }
+                else
+                {
+                    tensorType = tType;
+                }
             }
             else if (type is TensorType ttype)
             {
@@ -337,7 +438,7 @@ private TIR.Buffer TryAllocateBuffer(Expr expr)
                 throw new NotSupportedException();
             }
 
-            return (tensorType, location);
+            return new Tuple<TensorType, MemoryLocation>(tensorType, location);
         }
     }
 }
diff --git a/src/Nncase.Core/CostModel/Cost.cs b/src/Nncase.Core/CostModel/Cost.cs
index b09193ccb9..257b575f01 100644
--- a/src/Nncase.Core/CostModel/Cost.cs
+++ b/src/Nncase.Core/CostModel/Cost.cs
@@ -198,6 +198,20 @@ public static Cost Sum<TSource, TSelector>(this in SpanSelectEnumerable<TSource,
 
 public static class CostUtility
 {
+    public static UInt128 GetRingReduceCommunicate(DistributedType distributedType, int[] axes)
+    {
+        var ttype = DistributedUtilities.GetDividedTensorType(distributedType, out _);
+        var splits = axes.Where(i => distributedType.NdSbp[i] is SBPSplit);
+        if (!splits.Any())
+        {
+            return 0;
+        }
+
+        var p = (UInt128)splits.Select(i => distributedType.Placement.Hierarchy[i]).Aggregate(1, (acc, i) => acc * i);
+        var v = GetMemoryAccess(distributedType.TensorType);
+        return (p - 1) * (v / p);
+    }
+
     public static UInt128 GetMemoryAccess(IRType type)
     {
         return type switch
diff --git a/src/Nncase.Core/DistributedType.cs b/src/Nncase.Core/DistributedType.cs
index d113fec72b..782bbd77a8 100644
--- a/src/Nncase.Core/DistributedType.cs
+++ b/src/Nncase.Core/DistributedType.cs
@@ -97,5 +97,5 @@ public DistributedType(TensorType tensorType, IRArray<SBP> ndsbp, Placement plac
 
     public Placement Placement { get; }
 
-    public override string ToString() => $"{TensorType} ({string.Join(',', NdSbp)}) {Placement}";
+    public override string ToString() => $"{TensorType}, ({string.Join(',', NdSbp)}), {Placement}";
 }
diff --git a/src/Nncase.Core/DistributedUtilities.cs b/src/Nncase.Core/DistributedUtilities.cs
index 6787e8c588..6520d13023 100644
--- a/src/Nncase.Core/DistributedUtilities.cs
+++ b/src/Nncase.Core/DistributedUtilities.cs
@@ -33,6 +33,11 @@ public static IReadOnlyList<IRArray<SBP>> GetLeafCandidateNDSBPs(TensorType tens
            ToArray();
     }
 
+    public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement placement)
+    {
+        return GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).ToArray();
+    }
+
     public static bool IsDistributable(TensorType tensorType, ReadOnlySpan<SBP> ndsbp, Placement placement, [MaybeNullWhen(false)] out TensorType distType)
     {
         distType = null;
diff --git a/src/Nncase.Core/IR/Math/Binary.cs b/src/Nncase.Core/IR/Math/Binary.cs
index ead10ff710..f61f8a8704 100644
--- a/src/Nncase.Core/IR/Math/Binary.cs
+++ b/src/Nncase.Core/IR/Math/Binary.cs
@@ -20,12 +20,12 @@ public sealed partial class Binary : Op
     /// <summary>
     /// Gets lhs.
     /// </summary>
-    public static readonly ParameterInfo Lhs = new(typeof(Binary), 0, "lhs");
+    public static readonly ParameterInfo Lhs = new(typeof(Binary), 0, "lhs", ParameterKind.Input);
 
     /// <summary>
     /// Gets rhs.
     /// </summary>
-    public static readonly ParameterInfo Rhs = new(typeof(Binary), 1, "rhs");
+    public static readonly ParameterInfo Rhs = new(typeof(Binary), 1, "rhs", ParameterKind.Input);
 
     public BinaryOp BinaryOp { get; }
 
diff --git a/src/Nncase.Core/IR/Math/MatMul.cs b/src/Nncase.Core/IR/Math/MatMul.cs
index 51d5615f1f..fc74e211e1 100644
--- a/src/Nncase.Core/IR/Math/MatMul.cs
+++ b/src/Nncase.Core/IR/Math/MatMul.cs
@@ -20,10 +20,10 @@ public sealed partial class MatMul : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Lhs = new(typeof(MatMul), 0, "lhs");
+    public static readonly ParameterInfo Lhs = new(typeof(MatMul), 0, "lhs", ParameterKind.Input);
 
     /// <summary>
     /// Gets Other.
     /// </summary>
-    public static readonly ParameterInfo Rhs = new(typeof(MatMul), 1, "rhs");
+    public static readonly ParameterInfo Rhs = new(typeof(MatMul), 1, "rhs", ParameterKind.Input);
 }
diff --git a/src/Nncase.Core/IR/Math/Unary.cs b/src/Nncase.Core/IR/Math/Unary.cs
index 820572437e..20d6b3fb03 100644
--- a/src/Nncase.Core/IR/Math/Unary.cs
+++ b/src/Nncase.Core/IR/Math/Unary.cs
@@ -20,7 +20,7 @@ public sealed partial class Unary : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Unary), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Unary), 0, "input", ParameterKind.Input);
 
     public UnaryOp UnaryOp { get; }
 
diff --git a/src/Nncase.Core/IR/NN/LayerNorm.cs b/src/Nncase.Core/IR/NN/LayerNorm.cs
index bbeeb7dec9..33436fe50c 100644
--- a/src/Nncase.Core/IR/NN/LayerNorm.cs
+++ b/src/Nncase.Core/IR/NN/LayerNorm.cs
@@ -21,17 +21,17 @@ public sealed partial class LayerNorm : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(LayerNorm), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(LayerNorm), 0, "input", ParameterKind.Input);
 
     /// <summary>
     /// Gets scale.
     /// </summary>
-    public static readonly ParameterInfo Scale = new(typeof(LayerNorm), 1, "scale");
+    public static readonly ParameterInfo Scale = new(typeof(LayerNorm), 1, "scale", ParameterKind.Input);
 
     /// <summary>
     /// Gets bias.
     /// </summary>
-    public static readonly ParameterInfo Bias = new(typeof(LayerNorm), 2, "bias");
+    public static readonly ParameterInfo Bias = new(typeof(LayerNorm), 2, "bias", ParameterKind.Input);
 
     public int Axis { get; }
 
diff --git a/src/Nncase.Core/IR/Op.cs b/src/Nncase.Core/IR/Op.cs
index 8a478d530c..2af2e39fd3 100644
--- a/src/Nncase.Core/IR/Op.cs
+++ b/src/Nncase.Core/IR/Op.cs
@@ -12,6 +12,12 @@
 
 namespace Nncase.IR;
 
+public enum ParameterKind : int
+{
+    Input,
+    Attribute,
+}
+
 /// <summary>
 /// Parameter information.
 /// </summary>
@@ -24,11 +30,13 @@ public sealed class ParameterInfo
     /// <param name="ownerType">this op type.</param>
     /// <param name="index">param index.</param>
     /// <param name="name">param name.</param>
-    public ParameterInfo(Type ownerType, int index, string name)
+    /// <param name="parameterKind">kind.</param>
+    public ParameterInfo(Type ownerType, int index, string name, ParameterKind parameterKind = ParameterKind.Attribute)
     {
         OwnerType = ownerType;
         Index = index;
         Name = name;
+        ParameterKind = parameterKind;
     }
 
     /// <summary>
@@ -39,8 +47,9 @@ public ParameterInfo(Type ownerType, int index, string name)
     /// <param name="index">param index.</param>
     /// <param name="name">param name.</param>
     /// <param name="pattern">the param condition.</param>
-    public ParameterInfo(Type ownerType, int index, string name, TypePattern pattern)
-        : this(ownerType, index, name)
+    /// <param name="parameterKind">kind.</param>
+    public ParameterInfo(Type ownerType, int index, string name, TypePattern pattern, ParameterKind parameterKind = ParameterKind.Attribute)
+        : this(ownerType, index, name, parameterKind)
     {
         Pattern = pattern;
     }
@@ -60,6 +69,11 @@ public ParameterInfo(Type ownerType, int index, string name, TypePattern pattern
     /// </summary>
     public string Name { get; }
 
+    /// <summary>
+    /// Gets parameter kind.
+    /// </summary>
+    public ParameterKind ParameterKind { get; }
+
     /// <summary>
     /// Gets this paramter's type condition.
     /// </summary>
diff --git a/src/Nncase.Core/IR/Tensors/Concat.cs b/src/Nncase.Core/IR/Tensors/Concat.cs
index 88a22e4376..3578d66fce 100644
--- a/src/Nncase.Core/IR/Tensors/Concat.cs
+++ b/src/Nncase.Core/IR/Tensors/Concat.cs
@@ -20,10 +20,10 @@ public sealed partial class Concat : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Concat), 0, "inputs");
+    public static readonly ParameterInfo Input = new(typeof(Concat), 0, "inputs", ParameterKind.Input);
 
     /// <summary>
     /// Gets axis.
     /// </summary>
-    public static readonly ParameterInfo Axis = new(typeof(Concat), 1, "axis");
+    public int Axis { get; }
 }
diff --git a/src/Nncase.Core/IR/Tensors/Functional.cs b/src/Nncase.Core/IR/Tensors/Functional.cs
index f54b037f79..ab3924488a 100644
--- a/src/Nncase.Core/IR/Tensors/Functional.cs
+++ b/src/Nncase.Core/IR/Tensors/Functional.cs
@@ -70,10 +70,16 @@ public static Call Bitcast(PrimType type, Expr input, PrimType newType, Expr sha
     public static Call Cast(Expr input, DataType newType, CastMode castMode = CastMode.KDefault) =>
         new Call(new Cast(newType, castMode), input);
 
-    public static Call Boxing(Expr input, IRType type) =>
-        new Call(new Boxing(type), input);
+    public static Call Boxing(Expr input, IRType type) {
+        if (input.CheckedType == type)
+        {
+            throw new NotSupportedException();
+        }
+
+        return new Call(new Boxing(type), input);
+    }
 
-    public static Call Concat(Expr input, Expr axis) => new Call(new Concat(), input, axis);
+    public static Call Concat(Expr input, int axis) => new Call(new Concat(axis), input);
 
     public static Call ConstantOfShape(Expr shape, Expr value) => new Call(new ConstantOfShape(), shape, value);
 
@@ -92,7 +98,7 @@ public static Call Expand(Expr input, Expr shape)
 
     public static Call Flatten(Expr input, Expr axis) => new Call(new Flatten(), input, axis);
 
-    public static Call Gather(Expr input, Expr axis, Expr index) => new Call(new Gather(), input, axis, index);
+    public static Call Gather(Expr input, int axis, Expr index) => new Call(new Gather(axis), input, index);
 
     public static Call GatherElements(Expr input, Expr axis, Expr indices) =>
         new Call(new GatherElements(), input, axis, indices);
diff --git a/src/Nncase.Core/IR/Tensors/Gather.cs b/src/Nncase.Core/IR/Tensors/Gather.cs
index a498d38984..5ac52f4888 100644
--- a/src/Nncase.Core/IR/Tensors/Gather.cs
+++ b/src/Nncase.Core/IR/Tensors/Gather.cs
@@ -22,15 +22,15 @@ public sealed partial class Gather : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Gather), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Gather), 0, "input", ParameterKind.Input);
 
     /// <summary>
-    /// Gets axis.
+    /// Gets index.
     /// </summary>
-    public static readonly ParameterInfo Axis = new(typeof(Gather), 1, "axis", IsIntegralScalar());
+    public static readonly ParameterInfo Index = new(typeof(Gather), 1, "index", IsIntegral(), ParameterKind.Input);
 
     /// <summary>
-    /// Gets index.
+    /// Gets axis.
     /// </summary>
-    public static readonly ParameterInfo Index = new(typeof(Gather), 2, "index", IsIntegral());
+    public int Axis { get; }
 }
diff --git a/src/Nncase.Core/IR/Tensors/Slice.cs b/src/Nncase.Core/IR/Tensors/Slice.cs
index bc58e51ee8..05963ad7f7 100644
--- a/src/Nncase.Core/IR/Tensors/Slice.cs
+++ b/src/Nncase.Core/IR/Tensors/Slice.cs
@@ -21,7 +21,7 @@ public sealed partial class Slice : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Slice), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Slice), 0, "input", ParameterKind.Input);
 
     /// <summary>
     /// Gets begins.
diff --git a/src/Nncase.Core/IR/Tensors/UnSqueeze.cs b/src/Nncase.Core/IR/Tensors/UnSqueeze.cs
index cbc2574fc3..6ce9247d24 100644
--- a/src/Nncase.Core/IR/Tensors/UnSqueeze.cs
+++ b/src/Nncase.Core/IR/Tensors/UnSqueeze.cs
@@ -23,7 +23,7 @@ public sealed partial class Unsqueeze : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Unsqueeze), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Unsqueeze), 0, "input", ParameterKind.Input);
 
     /// <summary>
     /// Gets dimension.
diff --git a/src/Nncase.Core/IR/TypePattern.cs b/src/Nncase.Core/IR/TypePattern.cs
index 6eea450f5c..3b4116d032 100644
--- a/src/Nncase.Core/IR/TypePattern.cs
+++ b/src/Nncase.Core/IR/TypePattern.cs
@@ -187,6 +187,7 @@ public static TypePattern HasRank(Func<int, bool> cond, string reason) => HasSha
       x => x switch
       {
           TensorType ttype => DataTypes.IsIntegral(ttype.DType),
+          DistributedType distributedType => DataTypes.IsIntegral(distributedType.TensorType.DType),
           _ => false,
       },
       "IsIntegral");
diff --git a/src/Nncase.EGraph/Passes/EGraphExtractExtensions.cs b/src/Nncase.EGraph/Passes/EGraphExtractExtensions.cs
index bbafcac29c..d522b3b6a4 100644
--- a/src/Nncase.EGraph/Passes/EGraphExtractExtensions.cs
+++ b/src/Nncase.EGraph/Passes/EGraphExtractExtensions.cs
@@ -29,7 +29,7 @@ public static class EGraphExtractExtensions
     /// <returns>Extracted root expression.</returns>
     public static Expr Extract(this IEGraph eGraph, EClass root, Evaluator.IBaseFuncCostEvaluator? basefunc_cost_evaluator)
     {
-        // 1. set the all expr checked shape
+        // 1. set enode expr with more accuracy type.
         foreach (var eclass in eGraph.Classes)
         {
             foreach (var nodes in eclass.Nodes)
diff --git a/src/Nncase.Evaluator/Math/Binary.cs b/src/Nncase.Evaluator/Math/Binary.cs
index 2d994a40c5..61d3fd06dc 100755
--- a/src/Nncase.Evaluator/Math/Binary.cs
+++ b/src/Nncase.Evaluator/Math/Binary.cs
@@ -62,7 +62,7 @@ public IRType Visit(ITypeInferenceContext context, Binary target)
         {
             (TensorType a, TensorType b) => Visit(target, a, b),
             (DistributedType a, DistributedType b) => Visit(target, a, b),
-            _ => new InvalidType("invalid binary type"),
+            _ => new InvalidType($"{lhs} {rhs}"),
         };
     }
 
diff --git a/src/Nncase.Evaluator/Math/MatMul.cs b/src/Nncase.Evaluator/Math/MatMul.cs
index 1c295c0382..dbf72cf73d 100644
--- a/src/Nncase.Evaluator/Math/MatMul.cs
+++ b/src/Nncase.Evaluator/Math/MatMul.cs
@@ -19,69 +19,9 @@ namespace Nncase.Evaluator.Math;
 /// </summary>
 public class MatMulEvaluator : IEvaluator<MatMul>, ITypeInferencer<MatMul>, ICostEvaluator<MatMul>, IShapeEvaluator<MatMul>, IMetricEvaluator<MatMul>
 {
-    /// <inheritdoc/>
-    public IValue Visit(IEvaluateContext context, MatMul matMul)
-    {
-        var input = context.GetOrtArgumentValue(matMul, MatMul.Lhs);
-        var other = context.GetOrtArgumentValue(matMul, MatMul.Rhs);
-        return OrtKI.MatMul(input, other).ToValue();
-    }
-
-    /// <inheritdoc/>
-    public IRType Visit(ITypeInferenceContext context, MatMul target)
-    {
-        var lhs = context.CheckArgumentType<IRType>(target, MatMul.Lhs);
-        var rhs = context.CheckArgumentType<IRType>(target, MatMul.Rhs);
-        return (lhs, rhs) switch
-        {
-            (DistributedType a, DistributedType b) => Visit(a, b),
-            (TensorType a, TensorType b) => Visit(a, b),
-            _ => new InvalidType(string.Empty),
-        };
-    }
-
-    /// <inheritdoc/>
-    public Cost Visit(ICostEvaluateContext context, MatMul target)
-    {
-        var lhs = context.GetArgumentType<TensorType>(target, MatMul.Lhs);
-        var rhs = context.GetArgumentType<TensorType>(target, MatMul.Rhs);
-        var outputType = context.GetReturnType<TensorType>();
-
-        uint macPerElement = lhs.Shape[^1].IsFixed ? (uint)lhs.Shape[^1].FixedValue : 1U;
-        return new()
-        {
-            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(lhs) + CostUtility.GetMemoryAccess(rhs),
-            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(outputType),
-            [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(outputType, macPerElement),
-        };
-    }
-
-    public Metric Visit(IMetricEvaluateContext context, MatMul target)
+    public static IRType VisitDistributedType(DistributedType a, DistributedType b)
     {
-        var lhs = context.GetArgumentType<TensorType>(target, MatMul.Lhs);
-        var rhs = context.GetArgumentType<TensorType>(target, MatMul.Rhs);
-        var outputType = context.GetReturnType<TensorType>();
-        var k = (UInt128)lhs.Shape[^1].FixedValue;
-        var m = MetricUtility.GetFLOPs(lhs) / k;
-        var n = MetricUtility.GetFLOPs(rhs) / k;
-        return new()
-        {
-            [MetricFactorNames.OffChipMemoryTraffic] = CostUtility.GetMemoryAccess(lhs) + CostUtility.GetMemoryAccess(rhs) + CostUtility.GetMemoryAccess(outputType),
-            [MetricFactorNames.FLOPs] = m * n * ((2 * k) - 1),
-            [MetricFactorNames.Parallel] = 4,
-        };
-    }
-
-    public Expr Visit(IShapeEvaluateContext context, MatMul target)
-    {
-        var lhs = context.GetArgumentShape(target, MatMul.Lhs);
-        var rhs = context.GetArgumentShape(target, MatMul.Rhs);
-        return Cast(IR.F.ShapeExpr.MatMulShape(lhs, rhs), DataTypes.Int32);
-    }
-
-    private IRType Visit(DistributedType a, DistributedType b)
-    {
-        if (Visit(a.TensorType, b.TensorType) is not TensorType outType)
+        if (VisitTensorType(a.TensorType, b.TensorType) is not TensorType outType)
         {
             return new InvalidType(string.Empty);
         }
@@ -143,7 +83,7 @@ private IRType Visit(DistributedType a, DistributedType b)
         return new DistributedType(outType, ndsbp, a.Placement);
     }
 
-    private IRType Visit(TensorType lhs, TensorType rhs)
+    public static IRType VisitTensorType(TensorType lhs, TensorType rhs)
     {
         if (lhs.Shape.IsUnranked || rhs.Shape.IsUnranked)
         {
@@ -182,4 +122,74 @@ private IRType Visit(TensorType lhs, TensorType rhs)
         var end = new[] { lhs.Shape[^2], rhs.Shape[^1] };
         return new TensorType(lhs.DType, front.Concat(end).ToArray());
     }
+
+    /// <inheritdoc/>
+    public IValue Visit(IEvaluateContext context, MatMul matMul)
+    {
+        var input = context.GetOrtArgumentValue(matMul, MatMul.Lhs);
+        var other = context.GetOrtArgumentValue(matMul, MatMul.Rhs);
+        return OrtKI.MatMul(input, other).ToValue();
+    }
+
+    /// <inheritdoc/>
+    public IRType Visit(ITypeInferenceContext context, MatMul target)
+    {
+        var lhs = context.CheckArgumentType<IRType>(target, MatMul.Lhs);
+        var rhs = context.CheckArgumentType<IRType>(target, MatMul.Rhs);
+        return (lhs, rhs) switch
+        {
+            (DistributedType a, DistributedType b) => VisitDistributedType(a, b),
+            (TensorType a, TensorType b) => VisitTensorType(a, b),
+            _ => new InvalidType(string.Empty),
+        };
+    }
+
+    /// <inheritdoc/>
+    public Cost Visit(ICostEvaluateContext context, MatMul target)
+    {
+        var lhs = context.GetArgumentType<IRType>(target, MatMul.Lhs);
+        var rhs = context.GetArgumentType<IRType>(target, MatMul.Rhs);
+        var outputType = context.GetReturnType<IRType>();
+
+        uint macPerElement = 1;
+        if (lhs is TensorType { Shape: Shape lhsShape })
+        {
+            macPerElement = lhsShape[^1].IsFixed ? (uint)lhsShape[^1].FixedValue : 1U;
+        }
+        else if (lhs is DistributedType distributedType)
+        {
+            var lhsType = DistributedUtilities.GetDividedTensorType(distributedType, out var _);
+            macPerElement = lhsType.Shape[^1].IsFixed ? (uint)lhsType.Shape[^1].FixedValue : 1U;
+        }
+
+        return new()
+        {
+            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(lhs) + CostUtility.GetMemoryAccess(rhs),
+            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(outputType),
+            [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(outputType, macPerElement),
+        };
+    }
+
+    public Metric Visit(IMetricEvaluateContext context, MatMul target)
+    {
+        var lhs = context.GetArgumentType<TensorType>(target, MatMul.Lhs);
+        var rhs = context.GetArgumentType<TensorType>(target, MatMul.Rhs);
+        var outputType = context.GetReturnType<TensorType>();
+        var k = (UInt128)lhs.Shape[^1].FixedValue;
+        var m = MetricUtility.GetFLOPs(lhs) / k;
+        var n = MetricUtility.GetFLOPs(rhs) / k;
+        return new()
+        {
+            [MetricFactorNames.OffChipMemoryTraffic] = CostUtility.GetMemoryAccess(lhs) + CostUtility.GetMemoryAccess(rhs) + CostUtility.GetMemoryAccess(outputType),
+            [MetricFactorNames.FLOPs] = m * n * ((2 * k) - 1),
+            [MetricFactorNames.Parallel] = 4,
+        };
+    }
+
+    public Expr Visit(IShapeEvaluateContext context, MatMul target)
+    {
+        var lhs = context.GetArgumentShape(target, MatMul.Lhs);
+        var rhs = context.GetArgumentShape(target, MatMul.Rhs);
+        return Cast(IR.F.ShapeExpr.MatMulShape(lhs, rhs), DataTypes.Int32);
+    }
 }
diff --git a/src/Nncase.Evaluator/NN/LayerNorm.cs b/src/Nncase.Evaluator/NN/LayerNorm.cs
index 653692f5d0..ee48e31a82 100644
--- a/src/Nncase.Evaluator/NN/LayerNorm.cs
+++ b/src/Nncase.Evaluator/NN/LayerNorm.cs
@@ -29,20 +29,45 @@ public IValue Visit(IEvaluateContext context, LayerNorm layerNorm)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, LayerNorm target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, LayerNorm.Input);
-        return Visit(input);
+        var input = context.CheckArgumentType<IRType>(target, LayerNorm.Input);
+        var scale = context.CheckArgumentType<IRType>(target, LayerNorm.Scale);
+        var bias = context.CheckArgumentType<IRType>(target, LayerNorm.Bias);
+
+        return (input, scale, bias) switch
+        {
+            (DistributedType a, DistributedType b, DistributedType c) => Visit(a, b, c, target.Axis),
+            (TensorType a, TensorType, TensorType) => Visit(a),
+            _ => new InvalidType(input.GetType().ToString()),
+        };
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, LayerNorm target)
     {
-        var inputType = context.GetArgumentType<TensorType>(target, LayerNorm.Input);
-        var returnType = context.GetReturnType<TensorType>();
-        return new()
+        var inputType = context.GetArgumentType<IRType>(target, LayerNorm.Input);
+        var returnType = context.GetReturnType<IRType>();
+        switch (inputType, returnType)
         {
-            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType),
-            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(returnType),
-        };
+            case (TensorType, TensorType):
+                return new()
+                {
+                    [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType),
+                    [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(returnType),
+                };
+
+            case (DistributedType, DistributedType):
+                var scaleType = context.GetArgumentType<DistributedType>(target, LayerNorm.Scale);
+                var biasType = context.GetArgumentType<DistributedType>(target, LayerNorm.Bias);
+                var ring = CostUtility.GetRingReduceCommunicate(scaleType, new[] { 0, 1 }) + CostUtility.GetRingReduceCommunicate(biasType, new[] { 0, 1 });
+                return new()
+                {
+                    [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType) + ring,
+                    [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(inputType, 1),
+                    [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(returnType) + ring,
+                };
+            default:
+                throw new NotSupportedException();
+        }
     }
 
     public Metric Visit(IMetricEvaluateContext context, LayerNorm target)
@@ -70,6 +95,37 @@ private IRType Visit(TensorType input)
         return input;
     }
 
+    private IRType Visit(DistributedType input, DistributedType scale, DistributedType bias, int raxis)
+    {
+        var invalid = new InvalidType($"{input}, {scale}, {bias} not support");
+        if (input.Placement != scale.Placement || scale.Placement != bias.Placement)
+        {
+            return invalid;
+        }
+
+        var ndsbp = new SBP[input.Placement.Rank];
+
+        for (int i = 0; i < input.Placement.Rank; i++)
+        {
+            switch (input.NdSbp[i], scale.NdSbp[i], bias.NdSbp[i])
+            {
+                case (SBPSplit { Axis: int ix }, SBPSplit { Axis: int sx }, SBPSplit { Axis: int bx }) when ix >= raxis && sx == (ix - raxis) && bx == sx:
+                    ndsbp[i] = SBP.S(ix);
+                    break;
+                case (SBPSplit { Axis: int ix }, SBPBroadCast, SBPBroadCast) when ix < raxis:
+                    ndsbp[i] = SBP.S(ix);
+                    break;
+                case (SBPBroadCast, SBPBroadCast, SBPBroadCast):
+                    ndsbp[i] = SBP.B;
+                    break;
+                default:
+                    return invalid;
+            }
+        }
+
+        return new DistributedType(input.TensorType, ndsbp, input.Placement);
+    }
+
 #if true
     private Tensor LayerNormImpl(Tensor input, Tensor scale, Tensor bias, int axis, float epsilon, bool useMean = true)
     {
diff --git a/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs b/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
index 491bf4979f..5dadb47739 100644
--- a/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
+++ b/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
@@ -1,6 +1,6 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
+#pragma warning disable SA1010, SA1008
 using System;
 using System.Linq;
 using Nncase.CostModel;
@@ -39,8 +39,48 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
                     [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(tensorType),
                 };
                 break;
+            case (DistributedType { Placement: { Rank: 1 } } din, DistributedType { Placement: { Rank: 2 } } dout):
+                {
+                    // shared tensor broadcast to local.
+                    var a = DistributedUtilities.GetDividedTensorType(din, out _);
+                    var b = DistributedUtilities.GetDividedTensorType(dout, out _);
+                    cost = new Cost()
+                    {
+                        [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(a),
+                        [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(b),
+                    };
+                }
+
+                break;
+            case (DistributedType { NdSbp: [(SBPSplit or SBPBroadCast), SBPPartialSum], Placement.Rank: 2 } din,
+                  DistributedType { NdSbp: [(SBPSplit or SBPBroadCast), SBPBroadCast], Placement.Rank: 2 }):
+                {
+                    // reduce scater and broadcast (ring reduce)
+                    _ = DistributedUtilities.GetDividedTensorType(din, out _);
+                    var v = (int)CostUtility.GetMemoryAccess(din.TensorType);
+                    var comm = (din.Placement.Hierarchy[1] - 1) * (v / din.Placement.Hierarchy[1]) * 2; // reduce-scatter + gather
+                    cost = new Cost()
+                    {
+                        [CostFactorNames.MemoryLoad] = (UInt128)comm,
+                        [CostFactorNames.MemoryStore] = (UInt128)comm,
+                    };
+                }
+
+                break;
+            case (DistributedType a, DistributedType b) when a.Placement == b.Placement && a.NdSbp != b.NdSbp:
+                {
+                    cost = new Cost()
+                    {
+                        [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(a) + CostUtility.GetMemoryAccess(b),
+                        [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(a.TensorType),
+                    };
+                }
+
+                break;
+            case (DistributedType a, DistributedType b) when a == b:
+                throw new InvalidOperationException($"the boxing inType == outType");
             default:
-                throw new ArgumentOutOfRangeException(nameof(context));
+                throw new NotSupportedException($"{inType} {returnType}");
         }
 
         return cost;
diff --git a/src/Nncase.Evaluator/Tensors/Concat.cs b/src/Nncase.Evaluator/Tensors/Concat.cs
index 994e76de22..b382899ca4 100644
--- a/src/Nncase.Evaluator/Tensors/Concat.cs
+++ b/src/Nncase.Evaluator/Tensors/Concat.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using NetFabric.Hyperlinq;
 using Nncase.CostModel;
@@ -25,7 +26,7 @@ public class ConcatEvaluator : IEvaluator<Concat>, ITypeInferencer<Concat>, ICos
     public IValue Visit(IEvaluateContext context, Concat cat)
     {
         var inputs = context.GetArgumentValueAsTensors(cat, Concat.Input);
-        var axis = context.GetArgumentValueAsScalar<int>(cat, Concat.Axis);
+        var axis = cat.Axis;
         return OrtKI.Concat(inputs.Select(t => t.ToOrtTensor()).ToArray(), axis).ToValue();
     }
 
@@ -33,14 +34,13 @@ public IValue Visit(IEvaluateContext context, Concat cat)
     public IRType Visit(ITypeInferenceContext context, Concat target)
     {
         var inputs = context.CheckArgumentType<TupleType>(target, Concat.Input);
-        var axis = context.CheckArgumentType<TensorType>(target, Concat.Axis);
-        return Visit(context, target, inputs, axis);
+        return Visit(inputs, target.Axis);
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Concat target)
     {
-        var ret = context.GetReturnType<TensorType>();
+        var ret = context.GetReturnType<IRType>();
         return new()
         {
             [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(ret),
@@ -52,8 +52,7 @@ public Cost Visit(ICostEvaluateContext context, Concat target)
     public Expr Visit(IShapeEvaluateContext context, Concat target)
     {
         var inShape = context.GetArgumentShape(target, Concat.Input);
-        var axis = context.GetArgument(target, Concat.Axis);
-        var axisV = ShapeExprUtility.Positive(axis, inShape[0]);
+        var axisV = ShapeExprUtility.Positive(target.Axis, inShape[0]);
         var inShapes = ((IR.Tuple)inShape).Fields.ToArray().Select(x => Cast(x, DataTypes.Int32)).ToArray();
         var dim = inShapes.ToArray().Aggregate((Expr)0, (sum, shape) => sum + shape[axisV]);
         var outShape = ShapeExprUtility.Replace(inShapes[0], axisV, dim);
@@ -68,17 +67,18 @@ public Expr Visit(IShapeEvaluateContext context, Concat target)
         DataType? allDType = null;
         foreach (var (i, input) in Enumerable.Range(0, inputs.Count).Select(i => (i, inputs[i])))
         {
-            var type = input as TensorType;
-            if (type is null)
+            TensorType type;
+            if (input is TensorType a)
             {
-                if (input is InvalidType)
-                {
-                    return input;
-                }
-                else
-                {
-                    return new InvalidType($"The ConCat Item[{i}] Must Be TensorType But Get {input.GetType().Name}");
-                }
+                type = a;
+            }
+            else if (input is DistributedType { TensorType: TensorType b })
+            {
+                type = b;
+            }
+            else
+            {
+                return new InvalidType($"The ConCat Item[{i}] Must Have TensorType But Get {input}");
             }
 
             if (type.Shape.IsUnranked)
@@ -103,7 +103,14 @@ public Expr Visit(IShapeEvaluateContext context, Concat target)
         return null;
     }
 
-    private IRType Visit(ITypeInferenceContext context, Concat target, TupleType inputs, TensorType axis)
+    private TensorType GetTensorType(IRType input) => input switch
+    {
+        TensorType t => t,
+        DistributedType d => d.TensorType,
+        _ => throw new InvalidCastException(),
+    };
+
+    private IRType Visit(TupleType inputs, int axis)
     {
         var result = CheckType(inputs);
         if (result != null)
@@ -111,15 +118,15 @@ private IRType Visit(ITypeInferenceContext context, Concat target, TupleType inp
             return result;
         }
 
-        var sameRank = inputs.All(input => ((TensorType)input).Shape.Rank == ((TensorType)inputs[0]).Shape.Rank);
+        var sameRank = inputs.All(input => GetTensorType(input).Shape.Rank == GetTensorType(inputs[0]).Shape.Rank);
         if (!sameRank)
         {
             return new InvalidType("Inputs of concat should be same rank");
         }
 
-        var input0 = (TensorType)inputs[0];
+        var input0 = GetTensorType(inputs[0]);
         InvalidType? invalidType = null;
-        var axisV = ((TensorConst)context.GetArgument(target, Concat.Axis)).Value.ToScalar<int>();
+        var axisV = axis;
         var axisValue = Util.PositiveIndex(axisV, input0.Shape.Rank);
         var shapeValue = Enumerable.Range(0, input0.Shape.Rank).Select(i =>
         {
@@ -134,18 +141,18 @@ private IRType Visit(ITypeInferenceContext context, Concat target, TupleType inp
                 var allAxisDimIsSame = true;
                 foreach (var inType in inputs.Fields)
                 {
-                    if (((TensorType)inType).Shape.IsUnranked)
+                    if (GetTensorType(inType).Shape.IsUnranked)
                     {
                         continue;
                     }
 
-                    var d = ((TensorType)inType).Shape[i];
+                    var d = GetTensorType(inType).Shape[i];
                     if (d.IsUnknown)
                     {
                         return Dimension.Unknown;
                     }
 
-                    if (d.FixedValue != ((TensorType)inputs[0]).Shape[i])
+                    if (d.FixedValue != GetTensorType(inputs[0]).Shape[i])
                     {
                         allAxisDimIsSame = false;
                     }
@@ -153,7 +160,7 @@ private IRType Visit(ITypeInferenceContext context, Concat target, TupleType inp
 
                 if (allAxisDimIsSame)
                 {
-                    return ((TensorType)inputs[0]).Shape[i];
+                    return GetTensorType(inputs[0]).Shape[i];
                 }
                 else
                 {
@@ -163,7 +170,55 @@ private IRType Visit(ITypeInferenceContext context, Concat target, TupleType inp
             }
         });
         var shape = new Shape(shapeValue);
-        return (invalidType as IRType) ?? new TensorType(input0.DType, shape);
+        if (invalidType is InvalidType invalid)
+        {
+            return invalid;
+        }
+
+        var tensorType = new TensorType(input0.DType, shape);
+
+        if (inputs[0] is not DistributedType distributedType)
+        {
+            return tensorType;
+        }
+
+        if (inputs.OfType<DistributedType>().Select(d => d.Placement).ToHashSet().Count != 1)
+        {
+            return new InvalidType("the inputs have different placement");
+        }
+
+        var ndsbp = new SBP[distributedType.Placement.Rank];
+
+        for (int i = 0; i < distributedType.Placement.Rank; i++)
+        {
+            var sbps = inputs.OfType<DistributedType>().Select(d => d.NdSbp[i]).ToArray();
+            if (sbps.Any(sbp => sbp is SBPSplit { Axis: int x } && x == axis))
+            {
+                return new InvalidType("not support distribute on concat axis");
+            }
+
+            if (sbps.Any(sbp => sbp is SBPPartialSum))
+            {
+                return new InvalidType("not support distribute with partialsum");
+            }
+
+            if (sbps.OfType<SBPSplit>().ToHashSet() is HashSet<SBPSplit> set)
+            {
+                switch (set.Count)
+                {
+                    case 0:
+                        ndsbp[i] = SBP.B;
+                        break;
+                    case 1:
+                        ndsbp[i] = set.First();
+                        break;
+                    default:
+                        return new InvalidType("not support distribute with different axis");
+                }
+            }
+        }
+
+        return new DistributedType(tensorType, ndsbp, distributedType.Placement);
     }
 
     // axis: if one of inputs shape[axis] is unknown
@@ -173,12 +228,12 @@ private Dimension AxisDim(TupleType inputs, int axisValue)
     {
         var allAxisDimIsFixed = inputs.Fields.Aggregate(
             true,
-            (prod, next) => prod && ((TensorType)next).Shape[axisValue].IsFixed);
+            (prod, next) => prod && (next switch { TensorType t => t, DistributedType d => d.TensorType, _ => throw new NotSupportedException() }).Shape[axisValue].IsFixed);
         if (allAxisDimIsFixed)
         {
             return inputs.Fields.Aggregate(
                 0,
-                (prod, next) => prod + ((TensorType)next).Shape[axisValue].FixedValue);
+                (prod, next) => prod + (next switch { TensorType t => t, DistributedType d => d.TensorType, _ => throw new NotSupportedException() }).Shape[axisValue].FixedValue);
         }
         else
         {
diff --git a/src/Nncase.Evaluator/Tensors/Gather.cs b/src/Nncase.Evaluator/Tensors/Gather.cs
index acfd7ec9b5..aa9e5bec65 100644
--- a/src/Nncase.Evaluator/Tensors/Gather.cs
+++ b/src/Nncase.Evaluator/Tensors/Gather.cs
@@ -23,7 +23,7 @@ public class GatherEvaluator : IEvaluator<Gather>, ITypeInferencer<Gather>, ICos
     public IValue Visit(IEvaluateContext context, Gather gather)
     {
         var input = context.GetOrtArgumentValue(gather, Gather.Input);
-        var axis = context.GetArgumentValueAsScalar<int>(gather, Gather.Axis);
+        var axis = gather.Axis;
         var index = context.GetOrtArgumentValue(gather, Gather.Index);
         return OrtKI.Gather(input, index, axis).ToValue();
     }
@@ -31,29 +31,35 @@ public IValue Visit(IEvaluateContext context, Gather gather)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Gather target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Gather.Input);
-        var axis = context.CheckArgumentType<TensorType>(target, Gather.Axis);
-        var index = context.CheckArgumentType<TensorType>(target, Gather.Index);
-        return Visit(context, target, input, axis, index);
+        var input = context.CheckArgumentType<IRType>(target, Gather.Input);
+        var index = context.CheckArgumentType<IRType>(target, Gather.Index);
+
+        return (input, index) switch
+        {
+            (TensorType a, TensorType b) => Visit(a, target.Axis, b),
+            (DistributedType a, DistributedType b) => Visit(a, target.Axis, b),
+            _ => new InvalidType($"{input}, {index}"),
+        };
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Gather target)
     {
-        var ret_type = context.GetReturnType<TensorType>();
+        var inputType = context.GetArgumentType<IRType>(target, Gather.Input);
+        var indexType = context.GetArgumentType<IRType>(target, Gather.Index);
+        var retType = context.GetReturnType<IRType>();
         return new()
         {
-            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(ret_type.DType),
-            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(ret_type.DType),
-            [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(ret_type.DType, 1),
+            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType) + CostUtility.GetMemoryAccess(indexType),
+            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(retType),
+            [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(retType),
         };
     }
 
     public Expr Visit(IShapeEvaluateContext context, Gather target)
     {
-        var axis = context.GetArgument(target, Gather.Axis);
         var inShape = context.GetArgumentShape(target, Gather.Input);
-        axis = ShapeExprUtility.Positive(Cast(axis, DataTypes.Int32), inShape);
+        var axis = ShapeExprUtility.Positive(target.Axis, inShape);
         var indexShape = context.GetArgumentShape(target, Gather.Index);
         var outShape = ShapeExprUtility.ReplaceList(inShape, axis, indexShape);
         return outShape;
@@ -68,26 +74,53 @@ public Metric Visit(IMetricEvaluateContext context, Gather target)
         };
     }
 
-    private IRType Visit(ITypeInferenceContext context, Gather target, TensorType input, TensorType axis, TensorType index)
+    private IRType Visit(TensorType input, int axis, TensorType index)
     {
         if (input.Shape.IsUnranked)
         {
             return input;
         }
 
-        if (context.GetArgument(target, Gather.Axis) is TensorConst axisValue)
+        axis = axis < 0 ? axis + input.Shape.Rank : axis;
+
+        // input_shape[:axis] + index_shape + input_shape[axis + 1:]
+        var inShape = input.Shape.ToArray();
+        var newShape = inShape[..axis].Concat(index.Shape).Concat(inShape[(axis + 1)..]).ToArray();
+        return new TensorType(input.DType, newShape);
+    }
+
+    private IRType Visit(DistributedType input, int axis, DistributedType index)
+    {
+        var invalid = new InvalidType(input.ToString() + " " + index.ToString());
+        if (Visit(input.TensorType, axis, index.TensorType) is not TensorType tensorType)
         {
-            var axisV = axisValue.Value.ToScalar<int>();
-            axisV = axisV < 0 ? axisV + input.Shape.Rank : axisV;
+            return invalid;
+        }
 
-            // input_shape[:axis] + index_shape + input_shape[axis + 1:]
-            var inShape = input.Shape.ToArray();
-            var newShape = inShape[..axisV].Concat(index.Shape).Concat(inShape[(axisV + 1)..]).ToArray();
-            return new TensorType(input.DType, newShape);
+        if (input.Placement != index.Placement)
+        {
+            return invalid;
         }
-        else
+
+        var ndsbp = new SBP[input.Placement.Rank];
+
+        for (int i = 0; i < input.Placement.Rank; i++)
         {
-            return new InvalidType("Gather axis must be constant");
+            switch (input.NdSbp[i], index.NdSbp[i])
+            {
+                case (SBPSplit { Axis: int ix }, _) when ix == axis:
+                    return new InvalidType($"the input can't split on {axis}");
+                case (SBPBroadCast, SBPSplit { Axis: int ix }):
+                    ndsbp[i] = SBP.S(ix);
+                    break;
+                case (SBPSplit { Axis: int ix }, SBPBroadCast):
+                    ndsbp[i] = SBP.S(ix - axis + index.TensorType.Shape.Rank - 1);
+                    break;
+                default:
+                    return invalid;
+            }
         }
+
+        return new DistributedType(tensorType, ndsbp, input.Placement);
     }
 }
diff --git a/src/Nncase.Evaluator/Tensors/Slice.cs b/src/Nncase.Evaluator/Tensors/Slice.cs
index 219894f0da..5cc2c2b310 100644
--- a/src/Nncase.Evaluator/Tensors/Slice.cs
+++ b/src/Nncase.Evaluator/Tensors/Slice.cs
@@ -41,18 +41,23 @@ public IValue Visit(IEvaluateContext context, Slice sl)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Slice target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Slice.Input);
+        var input = context.CheckArgumentType<IRType>(target, Slice.Input);
         context.CheckArgumentType<TensorType>(target, Slice.Begins);
         context.CheckArgumentType<TensorType>(target, Slice.Ends);
         context.CheckArgumentType<TensorType>(target, Slice.Axes);
         context.CheckArgumentType<TensorType>(target, Slice.Strides);
-        return Visit(context, target, input);
+        return input switch
+        {
+            TensorType t => Visit(context, target, t),
+            DistributedType d => Visit(context, target, d),
+            _ => new InvalidType(input.GetType().Name),
+        };
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Slice target)
     {
-        var outputType = context.GetReturnType<TensorType>();
+        var outputType = context.GetReturnType<IRType>();
 
         return new()
         {
@@ -227,4 +232,14 @@ end is TensorConst ends_con &&
 
         return input with { Shape = outShape };
     }
+
+    private IRType Visit(ITypeInferenceContext context, Slice target, DistributedType input)
+    {
+        if (Visit(context, target, input.TensorType) is not TensorType tensorType)
+        {
+            return new InvalidType("not support input tensor type infer");
+        }
+
+        return new DistributedType(tensorType, input.NdSbp, input.Placement);
+    }
 }
diff --git a/src/Nncase.Evaluator/Tensors/UnSqueeze.cs b/src/Nncase.Evaluator/Tensors/UnSqueeze.cs
index b8c937c44a..0370d54ae5 100644
--- a/src/Nncase.Evaluator/Tensors/UnSqueeze.cs
+++ b/src/Nncase.Evaluator/Tensors/UnSqueeze.cs
@@ -27,9 +27,18 @@ public IValue Visit(IEvaluateContext context, Unsqueeze unSqueeze)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Unsqueeze target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Unsqueeze.Input);
+        var input = context.CheckArgumentType<IRType>(target, Unsqueeze.Input);
         _ = context.CheckArgumentType<TensorType>(target, Unsqueeze.Dim);
-        return Visit(context, target, input);
+        if (input is TensorType tensorType)
+        {
+            return Visit(context, target, tensorType);
+        }
+        else if (input is DistributedType distributedType)
+        {
+            return Visit(context, target, distributedType);
+        }
+
+        return new InvalidType(input.GetType().Name);
     }
 
     /// <inheritdoc/>
@@ -101,4 +110,26 @@ private IRType Visit(ITypeInferenceContext context, Unsqueeze target, TensorType
 
         return input with { Shape = new Shape(Enumerable.Repeat(Dimension.Unknown, input.Shape.Rank + 1)) };
     }
+
+    private IRType Visit(ITypeInferenceContext context, Unsqueeze target, DistributedType input)
+    {
+        var tensorType = (TensorType)Visit(context, target, input.TensorType);
+
+        var ndsbp = new SBP[input.NdSbp.Count];
+
+        if (context.GetArgument(target, Unsqueeze.Dim) is TensorConst tdims)
+        {
+            var dimsValue = tdims.Value.Cast<int>();
+            for (int i = 0; i < input.NdSbp.Count; i++)
+            {
+                ndsbp[i] = input.NdSbp[i] switch
+                {
+                    SBPSplit { Axis: int axis } => SBP.S(axis + dimsValue.Select(i => i <= axis).Count(b => b)),
+                    SBP sbp => sbp,
+                };
+            }
+        }
+
+        return new DistributedType(tensorType, ndsbp, input.Placement);
+    }
 }
diff --git a/src/Nncase.Importer/Onnx/Concat.cs b/src/Nncase.Importer/Onnx/Concat.cs
index 5f0e471652..433036c7be 100644
--- a/src/Nncase.Importer/Onnx/Concat.cs
+++ b/src/Nncase.Importer/Onnx/Concat.cs
@@ -14,7 +14,7 @@ private Expr VisitConcat(NodeProto op)
         {
             var inputs = Enumerable.Range(0, op.Input.Count).Select(x => GetInputExpr(op, x)).ToArray();
             var axis = GetIntAttribute(op, "axis");
-            return F.Tensors.Concat(new Tuple(inputs), axis);
+            return F.Tensors.Concat(new Tuple(inputs), (int)axis);
         }
     }
 }
diff --git a/src/Nncase.Importer/Onnx/Gather.cs b/src/Nncase.Importer/Onnx/Gather.cs
index eb03f835f6..ae47bb396d 100644
--- a/src/Nncase.Importer/Onnx/Gather.cs
+++ b/src/Nncase.Importer/Onnx/Gather.cs
@@ -14,7 +14,7 @@ private Expr VisitGather(in NodeProto op)
         {
             var (input, indices) = GetInputExprs(op, 0, 1);
             var axis = GetIntAttribute(op, "axis", 0);
-            return F.Tensors.Gather(input, axis, indices);
+            return F.Tensors.Gather(input, (int)axis, indices);
         }
     }
 }
diff --git a/src/Nncase.Passes/Rules/Neutral/CombineQuantize.cs b/src/Nncase.Passes/Rules/Neutral/CombineQuantize.cs
index c065fe65c7..ec134106e7 100644
--- a/src/Nncase.Passes/Rules/Neutral/CombineQuantize.cs
+++ b/src/Nncase.Passes/Rules/Neutral/CombineQuantize.cs
@@ -34,12 +34,14 @@ public sealed partial class CombineQuantizeConcat : RewriteRule<Pattern>
       "quantize",
       _ => true,
       IsConcat(
-        IsTuple(IsVArgsRepeat("tupleInputs", () => IsWildcard())),
-        IsWildcard("axis")),
+        "concat",
+        _ => true,
+        IsTuple(IsVArgsRepeat("tupleInputs", () => IsWildcard()))),
       IsWildcard("quantParam"));
 
-    private Expr? GetReplace(Quantize quantize, IReadOnlyList<Expr> tupleInputs, Expr axis, Expr quantParam, RunPassContext options)
+    private Expr? GetReplace(Quantize quantize, IReadOnlyList<Expr> tupleInputs, IR.Tensors.Concat concat, Expr quantParam, RunPassContext options)
     {
+        int axis = concat.Axis;
         var userAnalysis = options.GetAnalysis<IExprUserAnalysisResult>();
 
         // see UnitTestCombineQuantize.TestCombineQuantizeConcatNegative
diff --git a/src/Nncase.Passes/Rules/Neutral/CombineTranspose.cs b/src/Nncase.Passes/Rules/Neutral/CombineTranspose.cs
index dbe323c1ee..c1435250b7 100644
--- a/src/Nncase.Passes/Rules/Neutral/CombineTranspose.cs
+++ b/src/Nncase.Passes/Rules/Neutral/CombineTranspose.cs
@@ -194,6 +194,7 @@ public sealed partial class CombineTransposeConcat : IRewriteRule
     public IPattern Pattern { get; } = IsConcat(
                "concat",
                "concatCall",
+               _ => true,
                PatternMatch.Utility.IsTuple(null, IsVArgsRepeat("tupleInputs", exprs =>
                {
                    var patterns = new Pattern[exprs.Length];
@@ -203,11 +204,11 @@ public sealed partial class CombineTransposeConcat : IRewriteRule
                    }
 
                    return patterns;
-               })),
-               IsTensorConst("axis"));
+               })));
 
-    private Expr? GetReplace(Expr concat, Call concatCall, IReadOnlyList<Expr> tupleInputs, int axis, IMatchResult matchResult)
+    private Expr? GetReplace(IR.Tensors.Concat concat, Call concatCall, IReadOnlyList<Expr> tupleInputs, IMatchResult matchResult)
     {
+        int axis = concat.Axis;
         var inputs = Enumerable.Range(0, tupleInputs.Count).Select(i => (Expr)matchResult[$"input_{i}"]);
         var perms = new HashSet<Tensor<int>>(Enumerable.Range(0, tupleInputs.Count).Select(i => ((TensorConst)matchResult[$"perm_{i}"]).Value.Cast<int>(CastMode.KDefault)));
 
diff --git a/src/Nncase.Passes/Rules/Neutral/FocusFull.cs b/src/Nncase.Passes/Rules/Neutral/FocusFull.cs
index 3aa0e6b227..5c8b749140 100644
--- a/src/Nncase.Passes/Rules/Neutral/FocusFull.cs
+++ b/src/Nncase.Passes/Rules/Neutral/FocusFull.cs
@@ -20,18 +20,19 @@ public sealed partial class FocusFull : RewriteRule<Pattern>
 
     /// <inheritdoc />
     public override Pattern Pattern { get; } = IsConcat(
-      null,
+      "concat",
       "concatCall",
+      _ => true,
       PatternMatch.Utility.IsTuple("tp", new[] {
         IsSlice(Input, IsTensorConst("begin0"), IsTensorConst("end0"), IsTensorConst("axes0"), IsTensorConst("stride0")),
         IsSlice(Input, IsTensorConst("begin1"), IsTensorConst("end1"), IsTensorConst("axes1"), IsTensorConst("stride1")),
         IsSlice(Input, IsTensorConst("begin2"), IsTensorConst("end2"), IsTensorConst("axes2"), IsTensorConst("stride2")),
         IsSlice(Input, IsTensorConst("begin3"), IsTensorConst("end3"), IsTensorConst("axes3"), IsTensorConst("stride3")),
-      }),
-      IsTensorConst("axis"));
+      }));
 
-    private Expr? GetReplace(Call concatCall, Expr input, int[] begin0, long[] end0, int[] axes0, int[] stride0, int[] begin1, long[] end1, int[] axes1, int[] stride1, int[] begin2, long[] end2, int[] axes2, int[] stride2, int[] begin3, long[] end3, int[] axes3, int[] stride3, int axis)
+    private Expr? GetReplace(IR.Tensors.Concat concat, Call concatCall, Expr input, int[] begin0, long[] end0, int[] axes0, int[] stride0, int[] begin1, long[] end1, int[] axes1, int[] stride1, int[] begin2, long[] end2, int[] axes2, int[] stride2, int[] begin3, long[] end3, int[] axes3, int[] stride3)
     {
+        int axis = concat.Axis;
         var inputShape = input.CheckedShape.ToValueArray();
         if (inputShape[0] != 1)
         {
diff --git a/src/Nncase.Passes/Rules/Neutral/FoldGatherReshape.cs b/src/Nncase.Passes/Rules/Neutral/FoldGatherReshape.cs
index f0b23530f0..4500a41674 100644
--- a/src/Nncase.Passes/Rules/Neutral/FoldGatherReshape.cs
+++ b/src/Nncase.Passes/Rules/Neutral/FoldGatherReshape.cs
@@ -15,10 +15,14 @@ public sealed partial class FoldGatherReshape : RewriteRule<Pattern>
 {
     // Reshape(Gather(Shape, 0, 0), new[] { 0 }) -> GetItem(Shape, 0)
     public override Pattern Pattern => IsGather(
-        IsReshape(IsWildcard("input"), IsTensorConst("newShape")), IsTensorConst("axis"), IsTensorConst("index"));
+        "gather",
+        _ => true,
+        IsReshape(IsWildcard("input"), IsTensorConst("newShape")),
+        IsTensorConst("index"));
 
-    private Expr? GetReplace(Expr input, int[] newShape, int axis, int index)
+    private Expr? GetReplace(Expr input, int[] newShape, IR.Tensors.Gather gather, int index)
     {
+        int axis = gather.Axis;
         if (newShape.SequenceEqual(new[] { 1 }) && axis == 1)
         {
             return input[index];
diff --git a/src/Nncase.Tests/Distributed/UnitTestDistTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestDistTypeInfer.cs
new file mode 100644
index 0000000000..2d07b70bbe
--- /dev/null
+++ b/src/Nncase.Tests/Distributed/UnitTestDistTypeInfer.cs
@@ -0,0 +1,105 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.IO;
+using System.Linq;
+using Nncase;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.IR.Math;
+using Xunit;
+
+namespace Nncase.Tests.DistributedTest;
+
+[TestFixture.AutoSetupTestMethod(InitSession = true)]
+public sealed class UnitTestDistTypeInfer : TestClassBase
+{
+    public static TheoryData<UnaryOp, DistributedType, DistributedType> InferUnaryData => new() {
+        { UnaryOp.Exp,
+          new(new(DataTypes.Float32, new[] { 48, 32 }), new[] { SBP.B, SBP.B }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
+          new(new(DataTypes.Float32, new[] { 48, 32 }), new[] { SBP.B, SBP.B }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt"))
+        },
+    };
+
+    [Theory]
+    [MemberData(nameof(InferUnaryData))]
+    public void TestInferUnary(UnaryOp unaryOp, DistributedType inputType, DistributedType outputType)
+    {
+        var input = new Var(inputType);
+        var unary = IR.F.Math.Unary(unaryOp, input);
+        CompilerServices.InferenceType(unary);
+        Assert.Equal(outputType, unary.CheckedType);
+    }
+
+    [Theory]
+    [ClassData(typeof(InferMatmulData))]
+    public void TestInferMatmul(DistributedType lhsType, DistributedType rhsType, IRType outType)
+    {
+        var lhs = new Var(lhsType);
+        var rhs = new Var(rhsType);
+        var matmul = IR.F.Math.MatMul(lhs, rhs);
+        CompilerServices.InferenceType(matmul);
+        if (outType is InvalidType && matmul.CheckedType is InvalidType)
+        {
+        }
+        else
+        {
+            Assert.Equal(outType, matmul.CheckedType);
+        }
+    }
+
+    [Fact]
+    public void TestInferMatmulProduct()
+    {
+        var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+        var lhsShape = new[] { 1, 64, 384, 8192 };
+        var rhsShape = new[] { 1, 64, 8192, 384 };
+        var lhsType = new TensorType(DataTypes.Float32, lhsShape);
+        var rhsType = new TensorType(DataTypes.Float32, rhsShape);
+        var candiateArgs = new[] {
+            DistributedUtilities.GetLeafCandidateNDSBPs(lhsType, placement).Select(ndsbp => new DistributedType(lhsType, ndsbp, placement)),
+            DistributedUtilities.GetLeafCandidateNDSBPs(rhsType, placement).Select(ndsbp => new DistributedType(rhsType, ndsbp, placement)),
+            }.
+            CartesianProduct().
+            Select(argTypes => argTypes.Select(type => new Var(type)).ToArray());
+
+        int count = 0;
+        using (var f = Dumpper.OpenFile("types.txt"))
+        {
+            using var wr = new StreamWriter(f);
+            foreach (var args in candiateArgs)
+            {
+                var matmul = IR.F.Math.MatMul(args[0], args[1]);
+                matmul.InferenceType();
+                if (matmul.CheckedType is not InvalidType)
+                {
+                    count++;
+                }
+
+                wr.WriteLine($"{args[0].CheckedType} {args[1].CheckedType} => {matmul.CheckedType}");
+            }
+        }
+
+        Assert.Equal(64, count);
+    }
+}
+
+internal sealed class InferMatmulData : TheoryData<DistributedType, DistributedType, IRType>
+{
+    public InferMatmulData()
+    {
+        var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+        var lhs = new[] { 1, 64, 384, 8192 };
+        var rhs = new[] { 1, 64, 8192, 384 };
+        var o = new[] { 1, 64, 384, 384 };
+
+        Add(
+            new(new(DataTypes.Float32, lhs), new[] { SBP.S(1), SBP.S(2) }, placement),
+            new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(1), SBP.B }, placement),
+            new DistributedType(new(DataTypes.Float32, o), new[] { SBP.S(1), SBP.S(2) }, placement));
+        Add(
+            new(new(DataTypes.Float32, lhs), new[] { SBP.S(1), SBP.S(3) }, placement),
+            new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(1), SBP.S(2) }, placement),
+            new DistributedType(new(DataTypes.Float32, o), new SBP[] { SBP.S(1), SBP.P }, placement));
+    }
+}
diff --git a/src/Nncase.Tests/Evaluator/UnitTestEvaluatorTensors.cs b/src/Nncase.Tests/Evaluator/UnitTestEvaluatorTensors.cs
index 63cb7507a4..4d56cde01b 100644
--- a/src/Nncase.Tests/Evaluator/UnitTestEvaluatorTensors.cs
+++ b/src/Nncase.Tests/Evaluator/UnitTestEvaluatorTensors.cs
@@ -112,7 +112,7 @@ public void TestConcat3()
         for (long i = 0; i < shape.Length; i++)
         {
             var expect = OrtKI.Concat(new OrtKISharp.Tensor[] { inputA, inputB }, i);
-            var expr = IR.F.Tensors.Concat(new Tuple(inputA.ToTensor(), inputB.ToTensor()), i);
+            var expr = IR.F.Tensors.Concat(new Tuple(inputA.ToTensor(), inputB.ToTensor()), (int)i);
             CompilerServices.InferenceType(expr);
             Assert.Equal(expect, expr.Evaluate().AsTensor().ToOrtTensor());
         }
@@ -624,7 +624,7 @@ public void TestGather()
         long batchDims = 0L;
         var expect = OrtKI.Gather(input.ToOrtTensor(), indices.ToOrtTensor(), batchDims);
 
-        var expr = IR.F.Tensors.Gather(input, batchDims, indices);
+        var expr = IR.F.Tensors.Gather(input, (int)batchDims, indices);
         CompilerServices.InferenceType(expr);
         Assert.Equal(expect, expr.Evaluate().AsTensor().ToOrtTensor());
     }
diff --git a/src/Nncase.Tests/Match/UnitTestEGraphMatch.cs b/src/Nncase.Tests/Match/UnitTestEGraphMatch.cs
index af32681a6d..f9e1691387 100644
--- a/src/Nncase.Tests/Match/UnitTestEGraphMatch.cs
+++ b/src/Nncase.Tests/Match/UnitTestEGraphMatch.cs
@@ -113,7 +113,7 @@ public void TestMatchVArgs()
         Expr expr = Concat(tuple, 0);
         CompilerServices.InferenceType(expr);
 
-        var vpat = IsConcat(IsTuple("tp"), IsConst(0));
+        var vpat = IsConcat(0, IsTuple("tp"));
 
         Assert.True(CompilerServices.TryEMatchRoot(expr, vpat, out var eMatches));
         Assert.Single(eMatches);
@@ -122,13 +122,11 @@ public void TestMatchVArgs()
     [Fact]
     public void TestMatchVArgsTwice()
     {
-        ConstPattern wcaxis = IsConst();
-
         var tuple_lhs = new IR.Tuple(1, new Var(), 3);
         var tuple_rhs = new IR.Tuple(4, 5, 6);
         Expr expr = Concat(tuple_lhs, 0) + Concat(tuple_rhs, 1);
 
-        var vpat = IsConcat(IsTuple("tp"), wcaxis);
+        var vpat = IsConcat(_ => true, IsTuple("tp"));
 
         Assert.True(CompilerServices.TryEMatchRoot(expr, vpat, out var eMatches));
         Assert.Equal(2, eMatches.Count);
@@ -151,9 +149,8 @@ public void TestMatchVArgsRecursion()
 
         var wc = IsWildcard("wc");
         var wcperm = IsWildcard("perm");
-        var wcaxis = IsWildcard("axis");
 
-        var pattern = IsConcat(IsTuple(IsVArgsRepeat("wcvargs", () => IsTranspose(IsWildcard(), wcperm))), wcaxis);
+        var pattern = IsConcat(_ => true, IsTuple(IsVArgsRepeat("wcvargs", () => IsTranspose(IsWildcard(), wcperm))));
 
         Assert.True(CompilerServices.TryEMatchRoot(expr, pattern, out var results));
         Assert.Single(results);
@@ -163,7 +160,6 @@ public void TestMatchVArgsRecursion()
         Assert.Equal(((Call)wcvargs[1]).Arguments[0], y);
         Assert.Equal(((Call)wcvargs[2]).Arguments[0], z);
         Assert.Equal(result[wcperm], perm);
-        Assert.Equal(result[wcaxis], (Const)0);
     }
 
     [Fact]
diff --git a/src/Nncase.Tests/Rewrite/RewriteBase.cs b/src/Nncase.Tests/Rewrite/RewriteBase.cs
index 3fd4de87fe..5426c7290e 100644
--- a/src/Nncase.Tests/Rewrite/RewriteBase.cs
+++ b/src/Nncase.Tests/Rewrite/RewriteBase.cs
@@ -2072,7 +2072,7 @@ public Function PreExpr
             var input = new Tensor<int>(new[] { 0, 1, 2, 3 }, shape);
             var indices = new Tensor<long>(new[] { 0L, 0L, 1L, 1L }, shape);
             long batchDims = 0L;
-            var expr = IR.F.Tensors.Gather(input, batchDims, indices);
+            var expr = IR.F.Tensors.Gather(input, (int)batchDims, indices);
             return new Function(expr, new Var[] { _input });
         }
     }
diff --git a/src/Nncase.Tests/Rules/ShapeBucket/ShapeBucketTest.cs b/src/Nncase.Tests/Rules/ShapeBucket/ShapeBucketTest.cs
index 5518962c89..97e256a4ee 100644
--- a/src/Nncase.Tests/Rules/ShapeBucket/ShapeBucketTest.cs
+++ b/src/Nncase.Tests/Rules/ShapeBucket/ShapeBucketTest.cs
@@ -232,7 +232,7 @@ public void TestMatMulReshape()
         var lhs = MakeVar(input);
         var add = Add(lhs, new[] { 1f });
         var rhs = Reshape(add, Concat(
-            new IR.Tuple(Reshape(Gather(ShapeOf(add), 0L, 0L), new[] { 1L }), new[] { 3L }, new[] { 24L }, new[] { 24L }), 0));
+            new IR.Tuple(Reshape(Gather(ShapeOf(add), 0, 0L), new[] { 1L }), new[] { 3L }, new[] { 24L }, new[] { 24L }), 0));
 
         var lhsVar = new Var("lhs", new TensorType(input.ElementType, input.Shape));
         var rhsVar = new Var("rhs", new TensorType(input.ElementType, input.Shape));
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 8cf79e60f7..a0da152c6b 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -33,63 +33,112 @@ public UnitTestCPUTargetTiling()
 #endif
     }
 
-    [Fact]
-    public async Task TestCpuUnary()
+    [Theory]
+
+    // [ClassData(typeof(TilingCaseMHA))]
+    [ClassData(typeof(TilingCaseBinaryMul))]
+    [ClassData(typeof(TilingCaseUnary))]
+    [ClassData(typeof(TilingCaseMatmulUnary))]
+    public async Task TestCpuFunction(Function main)
     {
-        var shape = new[] { 1, 384, 2048 };
-        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
-        var main = new Function("main", IR.F.Math.Unary(UnaryOp.Neg, input), new[] { input });
         var module = new IR.IRModule(main);
-        await Compile(module);
+        using (var _ = new Diagnostics.DumpScope(main.Name, CompileOptions.DumpFlags))
+        {
+            await Compile(module);
+        }
+    }
+
+    private async Task Compile(IRModule module)
+    {
+        var compiler = CompileSession.Compiler;
+        compiler.ImportIRModule(module);
+        await compiler.CompileAsync();
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile("test.kmodel"))
+        {
+            compiler.Gencode(fs);
+        }
+    }
+}
 
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
-        using (var fs = Dumpper.OpenFile("input_0.bin"))
+internal sealed class TilingCaseMHA : TheoryData<Function>
+{
+    public TilingCaseMHA()
+    {
+        var hid_in = new Var("hidden_in", new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 }));
+        var pos_ids = new Var("position_ids", new TensorType(DataTypes.Int64, new[] { 1, 384 }));
+
+        Fusion fusion;
         {
-            fs.Write(input_tensor.BytesBuffer);
+            var scale = IR.F.Tensors.ConstantOfShape(new[] { 8192 }, 1.0f).Evaluate().AsTensor();
+            var bias = IR.F.Tensors.ConstantOfShape(new[] { 8192 }, 0.0f).Evaluate().AsTensor();
+            var weights = IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 64, 8192, 128 }).Evaluate().AsTensor();
+            var gdata = IR.F.Random.Normal(DataTypes.Float32, new[] { 384, 128 }).Evaluate().AsTensor();
+
+            var fin = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 }));
+            var fin2 = new Var("input2", new TensorType(DataTypes.Int64, new[] { 1, 384 }));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.LayerNorm(2, 1e-6f, false)), fin, scale, bias);
+            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Unsqueeze()), v0, new[] { 0 });
+            var v2 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), v1, weights);
+            var v3 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Slice()), v2, new[] { 64 }, new[] { 128 }, new[] { 3 }, new[] { 1 });
+            var v4 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Unary(UnaryOp.Neg)), v3);
+            var v5 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Slice()), v2, new[] { 0 }, new[] { 64 }, new[] { 3 }, new[] { 1 });
+            var v6 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Concat(3)), new IR.Tuple(v4, v5));
+
+            var v7 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Gather(0)), gdata, fin2);
+            var v8 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Unsqueeze()), v7, new[] { 0 });
+
+            var v9 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Binary(BinaryOp.Mul)), v2, v8);
+            var v10 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Binary(BinaryOp.Mul)), v6, v8);
+            var v11 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Binary(BinaryOp.Add)), v9, v10);
+
+            fusion = new Fusion("cpu", v11, fin, fin2);
         }
 
-        Testing.RunKModel(File.ReadAllBytes(Path.Join(Dumpper.Directory, "test.kmodel")), Dumpper.Directory, new[] { input_tensor });
+        var main = new Function("mha_qk", new Call(fusion, hid_in, pos_ids), new[] { hid_in, pos_ids });
+        Add(main);
     }
+}
 
-    [Fact]
-    public async Task TestCpuBinary()
+internal sealed class TilingCaseBinaryMul : TheoryData<Function>
+{
+    public TilingCaseBinaryMul()
     {
         var lhsShape = new[] { 1, 64, 384, 128 };
         var lhs = new Var("lhs", new TensorType(DataTypes.Float32, lhsShape));
         var rhsShape = new[] { 1, 1, 384, 128 };
         var rhs = new Var("lhs", new TensorType(DataTypes.Float32, rhsShape));
-        var main = new Function("main", lhs * rhs, new[] { lhs, rhs });
-        var module = new IR.IRModule(main);
-        await Compile(module);
+        var main = new Function("binary_mul", lhs * rhs, new[] { lhs, rhs });
+        Add(main);
     }
+}
 
-    [Fact]
-    public async Task TestCpuMatMul()
+internal sealed class TilingCaseUnary : TheoryData<Function>
+{
+    public TilingCaseUnary()
     {
-        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, new[] { 1, 1, 384, 8192 }));
-        var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, new[] { 1, 64, 8192, 128 });
-
-        var main = new Function("main", IR.F.Tensors.MatMul(lhs, rhs), new[] { lhs });
-        var module = new IR.IRModule(main);
-        await Compile(module);
-
-        // var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 3, 4 }).Evaluate().AsTensor();
-        // using (var fs = Dumpper.OpenFile("input_0.bin"))
-        // {
-        //     fs.Write(input_tensor.BytesBuffer);
-        // }
-
-        // Testing.RunKModel(File.ReadAllBytes(Path.Join(Dumpper.Directory, "test.kmodel")), Dumpper.Directory, new[] { input_tensor });
+        var shape = new[] { 1, 384, 2048 };
+        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
+        var main = new Function("unary", IR.F.Math.Unary(UnaryOp.Asin, input), new[] { input });
+        Add(main);
     }
+}
 
-    private async Task Compile(IRModule module)
+internal sealed class TilingCaseMatmulUnary : TheoryData<Function>
+{
+    public TilingCaseMatmulUnary()
     {
-        var compiler = CompileSession.Compiler;
-        compiler.ImportIRModule(module);
-        await compiler.CompileAsync();
-        using (var fs = Dumpper.OpenFile("test.kmodel"))
+        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }));
+        var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, new[] { 1, 64, 8192, 128 }).Evaluate().AsTensor().Cast<float>();
+        Fusion fusion;
         {
-            compiler.Gencode(fs);
+            var fin = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), fin, rhs);
+            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Unary(UnaryOp.Neg)), v0);
+            fusion = new Fusion("cpu", v1, fin);
         }
+
+        var main = new Function("matmul_unary", new Call(fusion, lhs), new[] { lhs });
+        Add(main);
     }
 }
+

From 5a0ea7f4c8f8f1a9cda715524815e3b9bf7c4591 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 14 Sep 2023 14:39:02 +0800
Subject: [PATCH 175/308] update cpu test

---
 .../Targets/UnitTestCPUTargetTiling.cs        | 107 +++++++++++++++---
 1 file changed, 93 insertions(+), 14 deletions(-)

diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index a0da152c6b..5fbeac88bc 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -36,15 +36,19 @@ public UnitTestCPUTargetTiling()
     [Theory]
 
     // [ClassData(typeof(TilingCaseMHA))]
-    [ClassData(typeof(TilingCaseBinaryMul))]
-    [ClassData(typeof(TilingCaseUnary))]
-    [ClassData(typeof(TilingCaseMatmulUnary))]
-    public async Task TestCpuFunction(Function main)
+    // [ClassData(typeof(TilingCaseBinaryMul))]
+    // [ClassData(typeof(TilingCaseUnary))]
+    [ClassData(typeof(TilingCaseMatmul))]
+    // [ClassData(typeof(TilingCaseMatmulUnary))]
+    public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
         using (var _ = new Diagnostics.DumpScope(main.Name, CompileOptions.DumpFlags))
         {
             await Compile(module);
+            var output = Testing.RunKModel(File.ReadAllBytes(Path.Join(Diagnostics.DumpScope.Current.Directory, "test.kmodel")), Diagnostics.DumpScope.Current.Directory, inputs);
+            var cos = Tests.Comparator.CosSimilarity(output, Value.FromTensor(inputs[^1]))[0];
+            Assert.True(cos > 0.999);
         }
     }
 
@@ -99,7 +103,7 @@ public TilingCaseMHA()
     }
 }
 
-internal sealed class TilingCaseBinaryMul : TheoryData<Function>
+internal sealed class TilingCaseBinaryMul : TheoryData<Function, Tensor[]>
 {
     public TilingCaseBinaryMul()
     {
@@ -108,37 +112,112 @@ public TilingCaseBinaryMul()
         var rhsShape = new[] { 1, 1, 384, 128 };
         var rhs = new Var("lhs", new TensorType(DataTypes.Float32, rhsShape));
         var main = new Function("binary_mul", lhs * rhs, new[] { lhs, rhs });
-        Add(main);
+
+        var lhs_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, lhsShape).Evaluate().AsTensor();
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
+        {
+            fs.Write(lhs_tensor.BytesBuffer);
+        }
+
+        var rhs_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, rhsShape).Evaluate().AsTensor();
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_1.bin"))
+        {
+            fs.Write(rhs_tensor.BytesBuffer);
+        }
+
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { lhs, Value.FromTensor(lhs_tensor) },
+            { rhs, Value.FromTensor(rhs_tensor) },
+        };
+        var output = main.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { lhs_tensor, rhs_tensor, output });
     }
 }
 
-internal sealed class TilingCaseUnary : TheoryData<Function>
+internal sealed class TilingCaseUnary : TheoryData<Function, Tensor[]>
 {
     public TilingCaseUnary()
     {
         var shape = new[] { 1, 384, 2048 };
         var input = new Var("input", new TensorType(DataTypes.Float32, shape));
         var main = new Function("unary", IR.F.Math.Unary(UnaryOp.Asin, input), new[] { input });
-        Add(main);
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
+        {
+            fs.Write(input_tensor.BytesBuffer);
+        }
+
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { input, Value.FromTensor(input_tensor) },
+        };
+        var output = main.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
     }
 }
 
-internal sealed class TilingCaseMatmulUnary : TheoryData<Function>
+internal sealed class TilingCaseMatmul : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseMatmul()
+    {
+        var lhsShape = new[] { 1, 64, 384, 8192 };
+        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, lhsShape));
+        var rhsShape = new[] { 1, 64, 8192, 128 };
+        var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, rhsShape).Evaluate().AsTensor().Cast<float>();
+
+        var main = new Function("matmul", IR.F.Math.MatMul(lhs, rhs), new[] { lhs });
+
+        var lhs_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, lhsShape).Evaluate().AsTensor();
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
+        {
+            fs.Write(lhs_tensor.BytesBuffer);
+        }
+
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { lhs, Value.FromTensor(lhs_tensor) },
+        };
+        var output = main.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { lhs_tensor, output });
+    }
+}
+
+internal sealed class TilingCaseMatmulUnary : TheoryData<Function, Tensor[]>
 {
     public TilingCaseMatmulUnary()
     {
-        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }));
-        var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, new[] { 1, 64, 8192, 128 }).Evaluate().AsTensor().Cast<float>();
+        var lhsShape = new[] { 1, 64, 384, 8192 };
+        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, lhsShape));
+        var rhsShape = new[] { 1, 64, 8192, 128 };
+        var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, rhsShape).Evaluate().AsTensor().Cast<float>();
         Fusion fusion;
+        Var fin;
         {
-            var fin = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }));
+            fin = new Var("input", new TensorType(DataTypes.Float32, lhsShape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), fin, rhs);
             var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Unary(UnaryOp.Neg)), v0);
             fusion = new Fusion("cpu", v1, fin);
         }
 
         var main = new Function("matmul_unary", new Call(fusion, lhs), new[] { lhs });
-        Add(main);
+
+        var lhs_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, lhsShape).Evaluate().AsTensor();
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
+        {
+            fs.Write(lhs_tensor.BytesBuffer);
+        }
+
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin, Value.FromTensor(lhs_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { lhs_tensor, output });
     }
 }
-

From b83da364e3de3e8bfd90db229f3fcd35710ca053 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 14 Sep 2023 15:33:59 +0800
Subject: [PATCH 176/308] fix rdata

---
 .../CodeGen/CSourceBuiltn.cs                  | 39 +++++++++++-------
 .../CodeGen/CSourceConvertVisitor.cs          | 11 ++++-
 .../CodeGen/FunctionBuilder.cs                |  5 +--
 .../CodeGen/FunctionCSource.cs                |  3 +-
 .../CodeGen/LinkableFunction.cs               |  4 +-
 .../CodeGen/LinkableModule.cs                 |  5 +--
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  5 ---
 .../Passes/Tile/SingleCPUFusionConverter.cs   | 40 ++++++++-----------
 8 files changed, 57 insertions(+), 55 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index 48aef1e29c..2de798157a 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -9,6 +9,10 @@ namespace Nncase.CodeGen.CPU;
 public static class CSourceBuiltn
 {
 #if MULTI_CORE_CPU
+    public const string KernelHeader = @"#include ""thread_context.h""
+using namespace shared;
+";
+
     public static string ClusterDef()
     {
         return @"#pragma once
@@ -227,20 +231,26 @@ cpu_cmodel STATIC
 ";
     }
 
-    public const string KernelHeader = @"#include ""thread_context.h""
-using namespace shared;
-";
+    public static string MakeKernel(string kernelImpl)
+    {
+        return KernelHeader + kernelImpl;
+    }
 
-    public static string MakeMain(TIR.PrimFunction primFunction)
+    public static string MakeMain(TIR.PrimFunction primFunction, IEnumerable<TIR.Buffer> rdataBuffers)
     {
-        string device_tensors = string.Join('\n', primFunction.Parameters.AsValueEnumerable().Select(b => $"static tensor<{b.ElemType.ToC()},{b.MemSpan.Location.ToC()}> *{b.Name};").ToArray());
+        string device_tensors = string.Join('\n', primFunction.Parameters.ToArray().Concat(rdataBuffers).Select(b => $"static tensor<{b.ElemType.ToC()},{b.MemSpan.Location.ToC()}> *{b.Name};").ToArray());
 
-        string init_tensors = string.Join('\n', primFunction.Parameters.ToArray().Select((b, i) =>
+        string init_tensors = string.Join("\n", primFunction.Parameters.ToArray().Select((b, i) =>
+        {
+            var size = TensorUtilities.GetSize(b.CheckedShape.ToValueArray(), TensorUtilities.GetStrides(b.CheckedShape.ToValueArray()), 1);
+            return $@"    auto {b.Name}_ = tensor<{b.ElemType.ToC()}, {b.MemSpan.Location.ToC()}>(gsl::make_span(({b.ElemType.ToC()}*)inputs[{i}], {size}), {{{string.Join(',', b.CheckedShape)}}});
+    {b.Name} = &{b.Name}_;";
+        }).Concat(rdataBuffers.Select(b =>
         {
             var size = TensorUtilities.GetSize(b.CheckedShape.ToValueArray(), TensorUtilities.GetStrides(b.CheckedShape.ToValueArray()), 1);
-            return $@"auto {b.Name}_ = tensor<{b.ElemType.ToC()}, {b.MemSpan.Location.ToC()}>(gsl::make_span(({b.ElemType.ToC()}*)inputs[{i}], {size}), {{{string.Join(',', b.CheckedShape)}}});
+            return $@"    auto {b.Name}_ = tensor<{b.ElemType.ToC()}, {b.MemSpan.Location.ToC()}>(gsl::make_span(({b.ElemType.ToC()}*)(rdata + {((IR.TensorConst)b.MemSpan.Start).Value.ToScalar<ulong>()}), {size}), {{{string.Join(',', b.CheckedShape)}}});
     {b.Name} = &{b.Name}_;";
-        }));
+        })));
 
         return @$"#include ""cluster_def.h""
 #include <runtime_utils.h>
@@ -269,12 +279,12 @@ public static string MakeMain(TIR.PrimFunction primFunction)
 DEFINE_BFUNC(7)
 
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {{
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs, uint8_t *rdata) {{
     runtime_util = rt_util_mt;
     nncase_mt = nncase_mt_impl;
     global_hardware_init(hw_ctx_impl);
 
-    {init_tensors}
+{init_tensors}
 
     pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
     pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
@@ -349,12 +359,13 @@ void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
 }}";
     }
 
-    public static string MakeShared()
+    public static string MakeShared(string shareds)
     {
-        return @"#include <tdma.h>
+        return @$"#include <tdma.h>
 
-namespace shared {
-} // namespace shared";
+namespace shared {{
+{shareds}
+}} // namespace shared";
     }
 
 #else
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 40b0d2b414..a4c007ad6d 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -130,7 +130,11 @@ public FunctionCSource GetFunctionCSource()
             _sharedWriter.Write(_exprMemo[b]);
             _sharedWriter.WriteLine(";");
         });
-        return new(_sharedBuilder.ToString(), _kernelBuilder.ToString());
+
+        return new(
+            CSourceBuiltn.MakeMain(VisitEntry, _exprMemo.Keys.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location == MemoryLocation.Rdata)),
+            CSourceBuiltn.MakeShared(_sharedBuilder.ToString()),
+            CSourceBuiltn.MakeKernel(_kernelBuilder.ToString()));
     }
 
     /// <inheritdoc/>
@@ -350,6 +354,11 @@ private void DeclBuffer(TIR.Buffer buffer)
 
         var symbol = Visit(buffer);
 
+        if (buffer.MemSpan.Location == MemoryLocation.Rdata)
+        {
+            return;
+        }
+
         IndentScope.Writer.IndWrite($"{symbol.Type} {symbol.Name}({{{string.Join(',', buffer.Dimensions.AsValueEnumerable().Select(Visit).Select(s => s.Name).ToArray())}}});\n");
     }
 }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
index 078e0b5175..d1f55bc233 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
@@ -70,9 +70,6 @@ public unsafe LinkableFunction Build(TIR.PrimFunction function)
         visitor.Visit(function);
         var functionCSource = visitor.GetFunctionCSource();
 
-        // 2. write the desc
-        var descContent = new MemoryStream();
-
         // 3. write the rdata
         foreach (var (@const, range) in function.SchedResult.Rdatas)
         {
@@ -87,7 +84,7 @@ public unsafe LinkableFunction Build(TIR.PrimFunction function)
             _rdataWriter.Write(bytes);
         }
 
-        return new LinkableFunction(_id, descContent.ToArray(), function, functionCSource);
+        return new LinkableFunction(_id, function, functionCSource);
     }
 
     public void Dispose()
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
index e2df1f8015..bc49aec1e7 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
@@ -16,9 +16,10 @@
 namespace Nncase.CodeGen;
 
 #if MULTI_CORE_CPU
-internal sealed record FunctionCSource(string Shared, string Kernel)
+internal sealed record FunctionCSource(string Main, string Shared, string Kernel)
 {
 }
+
 #else
 internal sealed class FunctionCSource
 {
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
index 5d3e3aa0fc..d1934086f2 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
@@ -8,15 +8,13 @@ namespace Nncase.CodeGen.CPU;
 
 internal sealed class LinkableFunction : ILinkableFunction
 {
-    public LinkableFunction(uint id, byte[] descContents, TIR.PrimFunction sourceFunction, FunctionCSource funcCSource)
+    public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, FunctionCSource funcCSource)
     {
         Id = id;
         SourceFunction = sourceFunction;
         PrimFunction = sourceFunction;
         FunctionCSource = funcCSource;
         Text = Array.Empty<byte>();
-
-        // new LinkedSection(descContents, ".desc", 0, 8, (uint)descContents.Length)
         Sections = Array.Empty<ILinkedSection>();
     }
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index 089c0330fd..c6121cba2b 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -53,7 +53,7 @@ public ILinkedModule Link(ILinkContext linkContext)
                 {
                     using (var writer = new StreamWriter(fs))
                     {
-                        writer.Write(CSourceBuiltn.MakeMain(func.PrimFunction));
+                        writer.Write(func.FunctionCSource.Main);
                     }
                 }
 
@@ -61,7 +61,7 @@ public ILinkedModule Link(ILinkContext linkContext)
                 {
                     using (var writer = new StreamWriter(fs))
                     {
-                        writer.Write(CSourceBuiltn.MakeShared());
+                        writer.Write(func.FunctionCSource.Shared);
                     }
                 }
 
@@ -69,7 +69,6 @@ public ILinkedModule Link(ILinkContext linkContext)
                 {
                     using (var writer = new StreamWriter(fs))
                     {
-                        writer.Write(CSourceBuiltn.KernelHeader);
                         writer.Write(func.FunctionCSource.Kernel);
                     }
                 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 3f76e7cae2..05944af695 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -36,9 +36,4 @@ public static Call Matmul(Expr lhs, Expr rhs, Expr output)
     {
         return new Call(new Matmul(), lhs, rhs, output);
     }
-
-    public static Call BlockMMA(Expr lhs, Expr rhs, Expr output)
-    {
-        return new Call(new Matmul(), lhs, rhs, output);
-    }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index d8a2157f2b..e8e9100d3a 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -44,19 +44,18 @@ public TIR.PrimFunction Convert(Fusion fusion)
         var candidatebodys = distConverter.Convert(fusion.Body, out var stagesMap);
         var graph = new EGraph();
         var bodyEclasses = candidatebodys.Select(graph.Add).ToArray();
-        foreach (var (b, i) in candidatebodys.Select((b, i) => (b, i)))
-        {
-            DumpScope.Current.DumpDotIR(b, "body_" + i.ToString(), "Distribute");
-        }
 
+        // foreach (var (b, i) in candidatebodys.Select((b, i) => (b, i)))
+        // {
+        //     DumpScope.Current.DumpDotIR(b, "body_" + i.ToString(), "Distribute");
+        // }
         // 2. union stages
         foreach (var ((_, equivals), i) in stagesMap.Select((k, i) => (k, i)))
         {
-            foreach (var (b, j) in equivals.Select((b, j) => (b, j)))
-            {
-                DumpScope.Current.DumpDotIR(b, $"eq_{i}_{j}", "Distribute");
-            }
-
+            // foreach (var (b, j) in equivals.Select((b, j) => (b, j)))
+            // {
+            //     DumpScope.Current.DumpDotIR(b, $"eq_{i}_{j}", "Distribute");
+            // }
             var equivalEclasses = equivals.Select(graph.Add).ToArray();
 
             foreach (var cls in equivalEclasses.Skip(1))
@@ -229,8 +228,8 @@ protected override Unit DefaultVisitLeaf(Expr expr)
 
         protected override Unit VisitLeafCall(Call expr)
         {
-            var arguments = expr.Arguments.AsValueEnumerable().Select(TryAllocateBuffer).ToArray();
-            var ret = TryAllocateBuffer(expr);
+            var arguments = expr.Arguments.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray();
+            var ret = AllocOrGetBuffer(expr);
             switch (expr.Target)
             {
                 case CPUKernelOp kernelOp:
@@ -266,13 +265,13 @@ private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call
             {
                 case (TensorType tensorType, DistributedType distTensorType):
                     {
-                        _mainBody.Add(T.Block(nameof(Boxing)).Body(IR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSbp, distTensorType.Placement)).Build());
+                        _mainBody.Add(IR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSbp, distTensorType.Placement));
                     }
 
                     break;
                 case (DistributedType distTensorType, TensorType tensorType):
                     {
-                        _mainBody.Add(T.Block(nameof(Boxing)).Body(IR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSbp, distTensorType.Placement)).Build());
+                        _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSbp, distTensorType.Placement));
                     }
 
                     break;
@@ -284,24 +283,17 @@ private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
             var input = arguments[IR.Math.Unary.Input.Index];
-            _mainBody.Add(T.Block(nameof(IR.Math.Unary)).Body(IR.F.XPU.Unary(unary.UnaryOp, input, ret)).Build());
+            _mainBody.Add(IR.F.XPU.Unary(unary.UnaryOp, input, ret));
         }
 
         private void GenerateBinary(Binary binary, Buffer[] arguments, Buffer ret)
         {
-            _mainBody.Add(T.Block(nameof(IR.Math.Unary)).Body(IR.F.XPU.Binary(binary.BinaryOp, arguments[0], arguments[1], ret)).Build());
+            _mainBody.Add(IR.F.XPU.Binary(binary.BinaryOp, arguments[0], arguments[1], ret));
         }
 
         private void GenerateMatmul(MatMul matmul, Buffer[] arguments, Buffer ret)
         {
-            if (ret.MemSpan.Location == MemoryLocation.L2Data)
-            {
-                _mainBody.Add(T.Block(nameof(XPU.BlockMMA)).Body(IR.F.XPU.Matmul(arguments[0], arguments[1], ret)).Build());
-            }
-            else
-            {
-                _mainBody.Add(T.Block(nameof(XPU.Matmul)).Body(IR.F.XPU.Matmul(arguments[0], arguments[1], ret)).Build());
-            }
+            _mainBody.Add(IR.F.XPU.Matmul(arguments[0], arguments[1], ret));
         }
 
 #if false
@@ -370,7 +362,7 @@ private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffe
         }
 #endif
 
-        private TIR.Buffer TryAllocateBuffer(Expr expr)
+        private TIR.Buffer AllocOrGetBuffer(Expr expr)
         {
             var name = $"buffer_{_buffersMap.Keys.Count}";
             if (!_buffersMap.TryGetValue(expr, out var buffer))

From 58403fe2eaa6605e55f707c34667577b02a1a720 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 14 Sep 2023 17:59:04 +0800
Subject: [PATCH 177/308] update cpu test with rdata

---
 modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs       | 8 ++++----
 modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs     | 2 +-
 .../Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs   | 8 +++-----
 modules/cpu/src/runtime/CMakeLists.txt                    | 2 +-
 modules/cpu/src/runtime/elfloader.cpp                     | 4 ++--
 modules/cpu/src/runtime/elfloader.h                       | 4 ++--
 modules/cpu/src/runtime/runtime_function.cpp              | 7 +++++--
 modules/cpu/src/runtime/runtime_function.h                | 1 +
 src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs       | 6 +++---
 9 files changed, 22 insertions(+), 20 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index 2de798157a..130f432953 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -224,16 +224,16 @@ cpu_cmodel STATIC
   -fPIC
   -fno-stack-protector
   -static
-  -Wl,-e,_Z6_startPN6nncase7runtime3cpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPh
+  -Wl,-e,_Z6_startPN6nncase7runtime3cpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPhS8_
 )
 add_executable({name} ""main.cpp"")
 target_link_libraries({name} cpu_cmodel)
 ";
     }
 
-    public static string MakeKernel(string kernelImpl)
+    public static string MakeKernel(string ctype, string kernelImpl)
     {
-        return KernelHeader + kernelImpl;
+        return KernelHeader + ctype + kernelImpl;
     }
 
     public static string MakeMain(TIR.PrimFunction primFunction, IEnumerable<TIR.Buffer> rdataBuffers)
@@ -257,7 +257,7 @@ public static string MakeMain(TIR.PrimFunction primFunction, IEnumerable<TIR.Buf
 
 #define DEFINE_TFUNC(b, t)                                                     \
     void *f_##b##_##t(void *arg) {{                                             \
-        block##b::thread##t::{primFunction.Name}({string.Join(',', primFunction.Parameters.AsValueEnumerable().Select(b => '*' + b.Name).ToArray())});               \
+        block##b::thread##t::{primFunction.Name}({string.Join(',', primFunction.Parameters.AsValueEnumerable().Select(b => '*' + b.Name).ToArray().Concat(rdataBuffers.Select(b => '*' + b.Name)).ToArray())});               \
         return arg;                                                            \
     }}
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
index e6c368629b..398ac8e444 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
@@ -134,7 +134,7 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
-            return $"-c \"cd {sourcePath} && mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Debug && cmake --build .\"";
+            return $"-c \"cd {sourcePath} && mkdir -p build && cd build && rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Debug && cmake --build .\"";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
         {
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index a4c007ad6d..e8a074643c 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -131,10 +131,11 @@ public FunctionCSource GetFunctionCSource()
             _sharedWriter.WriteLine(";");
         });
 
+        var ctype = $"void {VisitEntry.Name}({string.Join(", ", VisitEntry.Parameters.AsValueEnumerable().Select(Visit).Select(s => $"{s.Type} &{s.Name}").ToArray().Concat(_exprMemo.Keys.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location == MemoryLocation.Rdata).Select(Visit).Select(s => $" {s.Type} &{s.Name}").ToArray()))})";
         return new(
             CSourceBuiltn.MakeMain(VisitEntry, _exprMemo.Keys.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location == MemoryLocation.Rdata)),
             CSourceBuiltn.MakeShared(_sharedBuilder.ToString()),
-            CSourceBuiltn.MakeKernel(_kernelBuilder.ToString()));
+            CSourceBuiltn.MakeKernel(ctype, _kernelBuilder.ToString()));
     }
 
     /// <inheritdoc/>
@@ -152,13 +153,10 @@ protected override CSymbol VisitPrimFunction(PrimFunction expr)
 
         var ctype = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(Visit).Select(s => $"{s.Type} &{s.Name}").ToArray())})";
 
-        _sharedWriter.WriteLine(ctype + ";");
-        _sharedWriter.WriteLine();
-
         using (var scope = new IndentScope(_kernelBuilder))
         {
             // 1. Function signature
-            IndentScope.Writer.IndWrite($"{ctype} {{\n");
+            IndentScope.Writer.IndWrite($"{{\n");
 
             // 2. Function body
             using (_ = new IndentScope())
diff --git a/modules/cpu/src/runtime/CMakeLists.txt b/modules/cpu/src/runtime/CMakeLists.txt
index f0e8511e39..28c1c570b0 100644
--- a/modules/cpu/src/runtime/CMakeLists.txt
+++ b/modules/cpu/src/runtime/CMakeLists.txt
@@ -17,7 +17,7 @@ set(SRCS runtime_module.cpp
 if (BUILDING_RUNTIME)
     if (ENABLE_CPU_RUNTIME)
         add_library(runtime_cpu OBJECT ${SRCS})
-        target_link_libraries(runtime_cpu PUBLIC nncaseruntime pthread rt stdc++)
+        target_link_libraries(runtime_cpu PUBLIC nncaseruntime pthread rt)
         # set_target_properties(runtime_cpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
         install(TARGETS runtime_cpu EXPORT nncaseruntimeTargets)
     endif()
diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/cpu/src/runtime/elfloader.cpp
index 84e00a6922..97badbec43 100644
--- a/modules/cpu/src/runtime/elfloader.cpp
+++ b/modules/cpu/src/runtime/elfloader.cpp
@@ -6,7 +6,7 @@ using namespace nncase::runtime;
 using namespace nncase::runtime::cpu;
 
 int elfloader::invoke_elf(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs, uint8_t *rdata) {
 
     check(el_init(&ctx_), "initialising");
 
@@ -33,7 +33,7 @@ int elfloader::invoke_elf(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_
     // printf("Binary entrypoint is %" PRIxPTR "; invoking %p\n",
     //        (uintptr_t)ctx_.ehdr.e_entry, (void *)epaddr);
 
-    ep(hw_ctx_impl, rt_util_mt, nncase_mt_impl, inputs);
+    ep(hw_ctx_impl, rt_util_mt, nncase_mt_impl, inputs, rdata);
 
     free(ptr_);
 
diff --git a/modules/cpu/src/runtime/elfloader.h b/modules/cpu/src/runtime/elfloader.h
index f37fbf6c74..ac81c18ea8 100644
--- a/modules/cpu/src/runtime/elfloader.h
+++ b/modules/cpu/src/runtime/elfloader.h
@@ -15,7 +15,7 @@
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
 typedef void (*entrypoint_t)(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs);
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs, uint8_t *rdata);
 
 class elfloader {
   public:
@@ -51,7 +51,7 @@ class elfloader {
     }
 
     int invoke_elf(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs);
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs, uint8_t *rdata);
 
   private:
     void *ptr_;
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/cpu/src/runtime/runtime_function.cpp
index 8f6065ddfd..5f1da9edb6 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/cpu/src/runtime/runtime_function.cpp
@@ -47,7 +47,9 @@ cpu_runtime_module &cpu_runtime_function::module() const noexcept {
 
 result<void> cpu_runtime_function::initialize_core(
     NNCASE_UNUSED runtime_function_init_context &context) noexcept {
-    text_ = module().text_physical().subspan(context.header().entrypoint, context.header().text_size);
+    text_ = module().text_physical().subspan(context.header().entrypoint,
+                                             context.header().text_size);
+    rdata_ = module().rdata_physical();
     // try_(context.read_section(".desc", [this](auto sr, size_t) ->
     // result<void> {
     //     auto header = sr.template read<desc_header>();
@@ -122,7 +124,8 @@ cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
     }
 
     auto elfloader_ = elfloader{(char *)text_.data()};
-    elfloader_.invoke_elf(&hw_ctx_mt, &runtime_util, &nncase_mt, buffers);
+    elfloader_.invoke_elf(&hw_ctx_mt, &runtime_util, &nncase_mt, buffers,
+                          (uint8_t *)rdata_.data());
 
     delete[] buffers;
 
diff --git a/modules/cpu/src/runtime/runtime_function.h b/modules/cpu/src/runtime/runtime_function.h
index 9bee025935..ffaab9c605 100644
--- a/modules/cpu/src/runtime/runtime_function.h
+++ b/modules/cpu/src/runtime/runtime_function.h
@@ -33,6 +33,7 @@ class cpu_runtime_function : public runtime_function {
 
   private:
     gsl::span<const gsl::byte> text_;
+    gsl::span<const gsl::byte> rdata_;
     // std::vector<uint32_t> input_ranks_;
     // std::vector<std::vector<uint32_t>> input_shapes_;
     // std::vector<std::vector<uint32_t>> input_strides_;
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 5fbeac88bc..2d058fefb9 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -36,10 +36,10 @@ public UnitTestCPUTargetTiling()
     [Theory]
 
     // [ClassData(typeof(TilingCaseMHA))]
-    // [ClassData(typeof(TilingCaseBinaryMul))]
-    // [ClassData(typeof(TilingCaseUnary))]
+    [ClassData(typeof(TilingCaseBinaryMul))]
+    [ClassData(typeof(TilingCaseUnary))]
     [ClassData(typeof(TilingCaseMatmul))]
-    // [ClassData(typeof(TilingCaseMatmulUnary))]
+    [ClassData(typeof(TilingCaseMatmulUnary))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);

From e4e3c14051946d5d71d931c6e728003ba7fc7fcb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 15 Sep 2023 10:43:13 +0800
Subject: [PATCH 178/308] fix typeinfer

---
 src/Nncase.Evaluator/Math/MatMul.cs |  4 ++++
 src/Nncase.Evaluator/Math/Unary.cs  | 18 +++++++++++++++---
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/src/Nncase.Evaluator/Math/MatMul.cs b/src/Nncase.Evaluator/Math/MatMul.cs
index dbf72cf73d..3d9a774501 100644
--- a/src/Nncase.Evaluator/Math/MatMul.cs
+++ b/src/Nncase.Evaluator/Math/MatMul.cs
@@ -46,6 +46,10 @@ public static IRType VisitDistributedType(DistributedType a, DistributedType b)
                     {
                         ndsbp[i] = SBP.P;
                     }
+                    else if ((ax == (aRank - 1) && bx != (bRank - 2)) || (ax != (aRank - 1) && bx == (bRank - 2)))
+                    {
+                        return invalid;
+                    }
                     else
                     {
                         if (ax == bx)
diff --git a/src/Nncase.Evaluator/Math/Unary.cs b/src/Nncase.Evaluator/Math/Unary.cs
index 7e7b682226..874a2c5bdb 100644
--- a/src/Nncase.Evaluator/Math/Unary.cs
+++ b/src/Nncase.Evaluator/Math/Unary.cs
@@ -69,7 +69,7 @@ public IRType Visit(ITypeInferenceContext context, Unary target)
         return inputType switch
         {
             TensorType tensorType => Visit(tensorType),
-            DistributedType distTensorType => Visit(distTensorType),
+            DistributedType distTensorType => Visit(distTensorType, target.UnaryOp),
             _ => new InvalidType($"Not support {inputType.GetType().Name}"),
         };
     }
@@ -122,9 +122,21 @@ public Expr Visit(IShapeEvaluateContext context, Unary target)
         return context.GetArgumentShape(target, Unary.Input);
     }
 
-    private IRType Visit(DistributedType distTensorType)
+    private IRType Visit(DistributedType inType, UnaryOp unaryOp)
     {
-        return distTensorType;
+        var invalid = new InvalidType(inType.ToString());
+        var ndsbp = new SBP[inType.Placement.Rank];
+        for (int i = 0; i < inType.Placement.Rank; i++)
+        {
+            if (inType.NdSbp[i] is SBPPartialSum && unaryOp != UnaryOp.Neg)
+            {
+                return invalid;
+            }
+
+            ndsbp[i] = inType.NdSbp[i];
+        }
+
+        return new DistributedType(inType.TensorType, ndsbp, inType.Placement);
     }
 
     private int Compute_int(int input, UnaryOp op) => op switch

From 503a896f564509f5aa9c25ee91eac1d03a41987b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 15 Sep 2023 14:19:25 +0800
Subject: [PATCH 179/308] add XPU Op layernorm

---
 .../Evaluator/XPU/LayerNorm.cs                | 12 +++++
 .../Evaluator/XPU/XPUModule.cs                |  2 +
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  5 ++
 .../Nncase.Modules.CPU/IR/XPU/LayerNorm.cs    | 23 +++++++++
 .../Passes/Tile/SingleCPUFusionConverter.cs   |  9 ++++
 .../Targets/UnitTestCPUTargetTiling.cs        | 50 +++++++++++++++++--
 6 files changed, 98 insertions(+), 3 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/LayerNorm.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/LayerNorm.cs

diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/LayerNorm.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/LayerNorm.cs
new file mode 100644
index 0000000000..825844bae8
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/LayerNorm.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class LayerNormEvaluator : ITypeInferencer<LayerNorm>
+{
+    public IRType Visit(ITypeInferenceContext context, LayerNorm target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 57fc797d20..0d12ee17bb 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using DryIoc;
+using Nncase.Evaluator.NN;
 using Nncase.Hosting;
 
 namespace Nncase.Evaluator.XPU;
@@ -18,5 +19,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<UnaryEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<BinaryEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<MatmulEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<LayerNormEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 05944af695..7df63582bb 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -36,4 +36,9 @@ public static Call Matmul(Expr lhs, Expr rhs, Expr output)
     {
         return new Call(new Matmul(), lhs, rhs, output);
     }
+
+    public static Call LayerNorm(int axis, float eps, bool useMean, Expr input, Expr scale, Expr bias, Expr output, DistributedType distributedType)
+    {
+        return new Call(new LayerNorm(axis, eps, useMean, distributedType), input, scale, bias, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/LayerNorm.cs b/modules/Nncase.Modules.CPU/IR/XPU/LayerNorm.cs
new file mode 100644
index 0000000000..2074880d48
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/LayerNorm.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class LayerNorm : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(LayerNorm), 0, "input");
+
+    public static readonly ParameterInfo Scale = new(typeof(LayerNorm), 1, "scale");
+
+    public static readonly ParameterInfo Bias = new(typeof(LayerNorm), 2, "bias");
+
+    public static readonly ParameterInfo Output = new(typeof(LayerNorm), 3, "output");
+
+    public int Axis { get; }
+
+    public float Epsilon { get; }
+
+    public bool UseMean { get; }
+
+    public DistributedType DistType { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index e8e9100d3a..c9bcb0222c 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -11,6 +11,7 @@
 using Nncase.IR.CPU;
 using Nncase.IR.F;
 using Nncase.IR.Math;
+using Nncase.IR.NN;
 using Nncase.IR.Tensors;
 using Nncase.Passes.Mutators;
 using Nncase.PatternMatch;
@@ -244,6 +245,9 @@ protected override Unit VisitLeafCall(Call expr)
                         case MatMul matmul:
                             GenerateMatmul(matmul, arguments, ret);
                             break;
+                        case LayerNorm layernorm:
+                            GenerateLayerNorm(layernorm, arguments, ret, (DistributedType)expr.Arguments[0].CheckedType);
+                            break;
                         default:
                             throw new NotSupportedException();
                     }
@@ -296,6 +300,11 @@ private void GenerateMatmul(MatMul matmul, Buffer[] arguments, Buffer ret)
             _mainBody.Add(IR.F.XPU.Matmul(arguments[0], arguments[1], ret));
         }
 
+        private void GenerateLayerNorm(LayerNorm layerNorm, Buffer[] arguments, Buffer ret, DistributedType distributedType)
+        {
+            _mainBody.Add(IR.F.XPU.LayerNorm(layerNorm.Axis, layerNorm.Epsilon, layerNorm.UseMean, arguments[0], arguments[1], arguments[2], ret, distributedType));
+        }
+
 #if false
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 2d058fefb9..0d6f73807c 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -40,6 +40,7 @@ public UnitTestCPUTargetTiling()
     [ClassData(typeof(TilingCaseUnary))]
     [ClassData(typeof(TilingCaseMatmul))]
     [ClassData(typeof(TilingCaseMatmulUnary))]
+    // [ClassData(typeof(TilingCaseLayerNorm))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -169,7 +170,15 @@ public TilingCaseMatmul()
         var rhsShape = new[] { 1, 64, 8192, 128 };
         var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, rhsShape).Evaluate().AsTensor().Cast<float>();
 
-        var main = new Function("matmul", IR.F.Math.MatMul(lhs, rhs), new[] { lhs });
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, lhsShape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), fin, rhs);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("matmul", new Call(fusion, lhs), new[] { lhs });
 
         var lhs_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, lhsShape).Evaluate().AsTensor();
         using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
@@ -179,9 +188,9 @@ public TilingCaseMatmul()
 
         var feedDict = new Dictionary<Var, IValue>
         {
-            { lhs, Value.FromTensor(lhs_tensor) },
+            { fin, Value.FromTensor(lhs_tensor) },
         };
-        var output = main.Body.Evaluate(feedDict).AsTensor();
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
 
         Add(main, new[] { lhs_tensor, output });
     }
@@ -221,3 +230,38 @@ public TilingCaseMatmulUnary()
         Add(main, new[] { lhs_tensor, output });
     }
 }
+
+internal sealed class TilingCaseLayerNorm : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseLayerNorm()
+    {
+        var shape = new[] { 1, 384, 8192 };
+        int axis = 2;
+        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
+        var scale = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { shape[2] }).Evaluate().AsTensor();
+        var bias = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 3, new[] { shape[2] }).Evaluate().AsTensor();
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, shape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.LayerNorm(axis, 1e-5f, false)), fin, scale, bias);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+        var main = new Function("layernorm", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
+        {
+            fs.Write(input_tensor.BytesBuffer);
+        }
+
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}

From 4fc1e3578397e3332d99eebbae11d5e51fa7124b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 15 Sep 2023 16:04:52 +0800
Subject: [PATCH 180/308] update layernorm cost

---
 src/Nncase.Evaluator/NN/LayerNorm.cs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/Nncase.Evaluator/NN/LayerNorm.cs b/src/Nncase.Evaluator/NN/LayerNorm.cs
index ee48e31a82..4021791e73 100644
--- a/src/Nncase.Evaluator/NN/LayerNorm.cs
+++ b/src/Nncase.Evaluator/NN/LayerNorm.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
+using System.Linq;
 using Nncase.CostModel;
 using Nncase.IR;
 using Nncase.IR.NN;
@@ -55,14 +56,15 @@ public Cost Visit(ICostEvaluateContext context, LayerNorm target)
                     [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(returnType),
                 };
 
-            case (DistributedType, DistributedType):
+            case (DistributedType inputDistributedType, DistributedType):
                 var scaleType = context.GetArgumentType<DistributedType>(target, LayerNorm.Scale);
                 var biasType = context.GetArgumentType<DistributedType>(target, LayerNorm.Bias);
                 var ring = CostUtility.GetRingReduceCommunicate(scaleType, new[] { 0, 1 }) + CostUtility.GetRingReduceCommunicate(biasType, new[] { 0, 1 });
+                var reCompute = inputDistributedType.NdSbp.Select((sbp, i) => sbp is SBPSplit ? 1 : inputDistributedType.Placement.Hierarchy[i]).ToArray().Aggregate(1, (acc, rep) => acc * rep);
                 return new()
                 {
                     [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType) + ring,
-                    [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(inputType, 1),
+                    [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(inputType, 1) * (UInt128)reCompute,
                     [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(returnType) + ring,
                 };
             default:

From c2b6a99bbf99cb432aef764a454d0a55632a1f2e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 15 Sep 2023 16:07:03 +0800
Subject: [PATCH 181/308] fix cost evaluator

---
 src/Nncase.Core/CostModel/Cost.cs             |  6 +-
 src/Nncase.Core/DistributedType.cs            | 20 +-----
 src/Nncase.Core/DistributedUtilities.cs       | 62 ++++++++++++++-----
 src/Nncase.Core/TensorUtilities.cs            |  7 ++-
 src/Nncase.Evaluator/Math/MatMul.cs           |  2 +-
 src/Nncase.Evaluator/Math/Unary.cs            |  8 +--
 .../Tensors/{BoxingEvaluator.cs => Boxing.cs} | 14 ++---
 .../Core/UnitTestTensorUtilities.cs           | 32 ++++++----
 .../Distributed/UnitTestDistTypeInfer.cs      | 22 +++++--
 .../UnitTestDistributedUtilities.cs           | 30 +++++++++
 10 files changed, 139 insertions(+), 64 deletions(-)
 rename src/Nncase.Evaluator/Tensors/{BoxingEvaluator.cs => Boxing.cs} (88%)
 create mode 100644 src/Nncase.Tests/Distributed/UnitTestDistributedUtilities.cs

diff --git a/src/Nncase.Core/CostModel/Cost.cs b/src/Nncase.Core/CostModel/Cost.cs
index 257b575f01..e4c2d814a3 100644
--- a/src/Nncase.Core/CostModel/Cost.cs
+++ b/src/Nncase.Core/CostModel/Cost.cs
@@ -200,7 +200,7 @@ public static class CostUtility
 {
     public static UInt128 GetRingReduceCommunicate(DistributedType distributedType, int[] axes)
     {
-        var ttype = DistributedUtilities.GetDividedTensorType(distributedType, out _);
+        var ttype = DistributedUtilities.GetDividedTensorType(distributedType);
         var splits = axes.Where(i => distributedType.NdSbp[i] is SBPSplit);
         if (!splits.Any())
         {
@@ -218,7 +218,7 @@ public static UInt128 GetMemoryAccess(IRType type)
         {
             TensorType t => (UInt128)(t.Shape.Aggregate(1D, (acc, x) => acc * (x.IsFixed ? x.FixedValue : 1)) * t.DType.SizeInBytes),
             TupleType t => t.Fields.Sum(GetMemoryAccess),
-            DistributedType t => (UInt128)((float)GetMemoryAccess(DistributedUtilities.GetDividedTensorType(t, out var scale)) * scale),
+            DistributedType t => GetMemoryAccess(DistributedUtilities.GetDividedTensorType(t)),
             _ => 0,
         };
     }
@@ -244,7 +244,7 @@ public static UInt128 GetCPUCycles(IRType type, double cyclesPerElement = 1)
         {
             TensorType t => (UInt128)(t.Shape.Aggregate(1D, (acc, x) => acc * (x.IsFixed ? x.FixedValue : 1)) * cyclesPerElement),
             TupleType t => t.Fields.Sum(GetMemoryAccess),
-            DistributedType t => GetCPUCycles(DistributedUtilities.GetDividedTensorType(t, out _)),
+            DistributedType t => GetCPUCycles(DistributedUtilities.GetDividedTensorType(t)),
             _ => 0,
         };
     }
diff --git a/src/Nncase.Core/DistributedType.cs b/src/Nncase.Core/DistributedType.cs
index 782bbd77a8..02c34ae934 100644
--- a/src/Nncase.Core/DistributedType.cs
+++ b/src/Nncase.Core/DistributedType.cs
@@ -77,25 +77,7 @@ public enum DeviceKind : uint
     public override string ToString() => $"@{Kind} [{string.Join(',', Hierarchy.Zip(Name).Select(t => t.First.ToString() + '@' + t.Second.ToString()))}]";
 }
 
-public sealed record DistributedType : IRType
+public sealed record DistributedType(TensorType TensorType, IRArray<SBP> NdSbp, Placement Placement) : IRType
 {
-    public DistributedType(TensorType tensorType, IRArray<SBP> ndsbp, Placement placement)
-    {
-        if (placement.Hierarchy.Count != ndsbp.Count)
-        {
-            throw new ArgumentException("spb dimension != placement rank!");
-        }
-
-        TensorType = tensorType;
-        NdSbp = ndsbp;
-        Placement = placement;
-    }
-
-    public TensorType TensorType { get; }
-
-    public IRArray<SBP> NdSbp { get; }
-
-    public Placement Placement { get; }
-
     public override string ToString() => $"{TensorType}, ({string.Join(',', NdSbp)}), {Placement}";
 }
diff --git a/src/Nncase.Core/DistributedUtilities.cs b/src/Nncase.Core/DistributedUtilities.cs
index 6520d13023..84a4d83180 100644
--- a/src/Nncase.Core/DistributedUtilities.cs
+++ b/src/Nncase.Core/DistributedUtilities.cs
@@ -38,6 +38,26 @@ public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement p
         return GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).ToArray();
     }
 
+    public static IReadOnlyList<Expr> GetBroadCastBoxings(Expr expr)
+    {
+        var getNonPartialNDSbps = (IRArray<SBP> ndsbp) => new IRArray<SBP>(ndsbp.Select(sbp => sbp is SBPPartialSum ? SBP.B : sbp).ToArray());
+
+        if (expr is IR.Tuple tuple)
+        {
+            throw new NotSupportedException("current not support!");
+        }
+
+        var type = (DistributedType)expr.CheckedType;
+        var ndsbp = getNonPartialNDSbps(type.NdSbp);
+
+        if (ndsbp != type.NdSbp)
+        {
+            return new[] { IR.F.Tensors.Boxing(expr, type with { NdSbp = ndsbp }) };
+        }
+
+        return Array.Empty<Expr>();
+    }
+
     public static bool IsDistributable(TensorType tensorType, ReadOnlySpan<SBP> ndsbp, Placement placement, [MaybeNullWhen(false)] out TensorType distType)
     {
         distType = null;
@@ -74,23 +94,37 @@ public static bool IsDivisible(int input, int divisor)
         return false;
     }
 
-    public static TensorType GetDividedTensorType(DistributedType distTensorType, out float notContiguousScale)
+    public static float GetDividedTensorEfficiency(DistributedType distributedType, int burstLength)
     {
-        var shape = distTensorType.TensorType.Shape.ToValueArray();
-        var tiles = distTensorType.TensorType.Shape.ToValueArray();
-        foreach (var (s, i) in distTensorType.NdSbp.OfType<SBPSplit>().Select((s, i) => (s, i)))
-        {
-            tiles[s.Axis] /= distTensorType.Placement.Hierarchy[i];
-        }
-
-        var isIsContiguous = Enumerable.Range(0, tiles.Length).
+        var (tiles, shape) = GetDividedTile(distributedType);
+        return Enumerable.Range(0, tiles.Count).
                   Select(i => tiles[i].Ranges(0, shape[i])).
                   CartesianProduct().
-                  Select(rgs => TensorUtilities.IsContiguousSlice(shape, rgs.ToArray()));
-        var allTiles = isIsContiguous.Count();
-        int notContiguous = isIsContiguous.Count(b => b == false);
-        notContiguousScale = ((float)notContiguous / allTiles) + 1.0f;
+                  Select(rgs =>
+                  {
+                      var slice = rgs.ToArray();
+                      var iscontiguous = TensorUtilities.IsContiguousSlice(shape.ToArray(), slice, out var contiguousStart);
+                      var size = TensorUtilities.GetProduct(tiles.ToArray(), contiguousStart) * distributedType.TensorType.DType.SizeInBytes;
+                      var (div, rem) = Math.DivRem(size, burstLength);
+                      return ((div * 1.0f) + ((float)rem / burstLength)) / (div + 1);
+                  }).Average();
+    }
+
+    public static TensorType GetDividedTensorType(DistributedType distributedType)
+    {
+        var (tiles, _) = GetDividedTile(distributedType);
+        return distributedType.TensorType with { Shape = new Shape(tiles) };
+    }
+
+    private static (IReadOnlyList<int> Tile, IReadOnlyList<int> Shape) GetDividedTile(DistributedType distributedType)
+    {
+        var shape = distributedType.TensorType.Shape.ToValueArray();
+        var tiles = distributedType.TensorType.Shape.ToValueArray();
+        foreach (var (s, i) in distributedType.NdSbp.OfType<SBPSplit>().Select((s, i) => (s, i)))
+        {
+            tiles[s.Axis] /= distributedType.Placement.Hierarchy[i];
+        }
 
-        return distTensorType.TensorType with { Shape = tiles };
+        return (tiles, shape);
     }
 }
diff --git a/src/Nncase.Core/TensorUtilities.cs b/src/Nncase.Core/TensorUtilities.cs
index 717274e0d3..79f658aefa 100644
--- a/src/Nncase.Core/TensorUtilities.cs
+++ b/src/Nncase.Core/TensorUtilities.cs
@@ -323,10 +323,11 @@ public static bool IsContiguous(ReadOnlySpan<int> dimensions, ReadOnlySpan<int>
     /// <summary>
     /// check the dimensions selected range is contiguous.
     /// </summary>
-    public static bool IsContiguousSlice(ReadOnlySpan<int> dimensions, ReadOnlySpan<System.Range> slices)
+    public static bool IsContiguousSlice(ReadOnlySpan<int> dimensions, ReadOnlySpan<System.Range> slices, out int contiguousStart)
     {
         if (dimensions.Length != slices.Length)
         {
+            contiguousStart = slices.Length - 1;
             return false;
         }
 
@@ -366,13 +367,17 @@ public static bool IsContiguousSlice(ReadOnlySpan<int> dimensions, ReadOnlySpan<
             };
             if (status == SliceStatus.IsInvalid)
             {
+                contiguousStart = i + 1;
                 return false;
             }
         }
 
+        contiguousStart = 0;
         return true;
     }
 
+    public static bool IsContiguousSlice(ReadOnlySpan<int> dimensions, ReadOnlySpan<System.Range> slices) => IsContiguousSlice(dimensions, slices, out _);
+
     public static long[] ToLongs(this ReadOnlySpan<int> ints)
     {
         var longs = new long[ints.Length];
diff --git a/src/Nncase.Evaluator/Math/MatMul.cs b/src/Nncase.Evaluator/Math/MatMul.cs
index 3d9a774501..5294229bec 100644
--- a/src/Nncase.Evaluator/Math/MatMul.cs
+++ b/src/Nncase.Evaluator/Math/MatMul.cs
@@ -162,7 +162,7 @@ public Cost Visit(ICostEvaluateContext context, MatMul target)
         }
         else if (lhs is DistributedType distributedType)
         {
-            var lhsType = DistributedUtilities.GetDividedTensorType(distributedType, out var _);
+            var lhsType = DistributedUtilities.GetDividedTensorType(distributedType);
             macPerElement = lhsType.Shape[^1].IsFixed ? (uint)lhsType.Shape[^1].FixedValue : 1U;
         }
 
diff --git a/src/Nncase.Evaluator/Math/Unary.cs b/src/Nncase.Evaluator/Math/Unary.cs
index 874a2c5bdb..678fd0c673 100644
--- a/src/Nncase.Evaluator/Math/Unary.cs
+++ b/src/Nncase.Evaluator/Math/Unary.cs
@@ -181,13 +181,13 @@ private IRType Visit(TensorType input)
 
     private Cost Visit(DistributedType inType, DistributedType outType, Unary target)
     {
-        var inPartType = DistributedUtilities.GetDividedTensorType(inType, out float inScale);
-        var outPartType = DistributedUtilities.GetDividedTensorType(outType, out float outScale);
+        var inPartType = DistributedUtilities.GetDividedTensorType(inType);
+        var outPartType = DistributedUtilities.GetDividedTensorType(outType);
         return new()
         {
-            [CostFactorNames.MemoryLoad] = (UInt128)((float)CostUtility.GetMemoryAccess(inPartType) * inScale),
+            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inPartType),
             [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(outPartType, CostUtility.GetCPUCyclesOfUnary(target.UnaryOp)),
-            [CostFactorNames.MemoryStore] = (UInt128)((float)CostUtility.GetMemoryAccess(outPartType) * outScale),
+            [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(outPartType),
         };
     }
 
diff --git a/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs b/src/Nncase.Evaluator/Tensors/Boxing.cs
similarity index 88%
rename from src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
rename to src/Nncase.Evaluator/Tensors/Boxing.cs
index 5dadb47739..d09a52c16a 100644
--- a/src/Nncase.Evaluator/Tensors/BoxingEvaluator.cs
+++ b/src/Nncase.Evaluator/Tensors/Boxing.cs
@@ -11,6 +11,8 @@ namespace Nncase.Evaluator.Tensors;
 
 public sealed class BoxingEvaluator : ITypeInferencer<Boxing>, ICostEvaluator<Boxing>
 {
+    private const int _burstLength = 256;
+
     public IRType Visit(ITypeInferenceContext context, Boxing target)
     {
         return target.NewType;
@@ -24,26 +26,24 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
         switch (inType, returnType)
         {
             case (TensorType tensorType, DistributedType distTensorType):
-                var partedOutType = DistributedUtilities.GetDividedTensorType(distTensorType, out _);
                 cost = new Cost()
                 {
                     [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(tensorType),
-                    [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(partedOutType),
+                    [CostFactorNames.MemoryStore] = (UInt128)((float)CostUtility.GetMemoryAccess(distTensorType) / DistributedUtilities.GetDividedTensorEfficiency(distTensorType, _burstLength)),
                 };
                 break;
             case (DistributedType distTensorType, TensorType tensorType):
-                var partedInType = DistributedUtilities.GetDividedTensorType(distTensorType, out _);
                 cost = new Cost()
                 {
-                    [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(partedInType),
+                    [CostFactorNames.MemoryLoad] = (UInt128)((float)CostUtility.GetMemoryAccess(distTensorType) / DistributedUtilities.GetDividedTensorEfficiency(distTensorType, _burstLength)),
                     [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(tensorType),
                 };
                 break;
             case (DistributedType { Placement: { Rank: 1 } } din, DistributedType { Placement: { Rank: 2 } } dout):
                 {
                     // shared tensor broadcast to local.
-                    var a = DistributedUtilities.GetDividedTensorType(din, out _);
-                    var b = DistributedUtilities.GetDividedTensorType(dout, out _);
+                    var a = DistributedUtilities.GetDividedTensorType(din);
+                    var b = DistributedUtilities.GetDividedTensorType(dout);
                     cost = new Cost()
                     {
                         [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(a),
@@ -56,7 +56,7 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
                   DistributedType { NdSbp: [(SBPSplit or SBPBroadCast), SBPBroadCast], Placement.Rank: 2 }):
                 {
                     // reduce scater and broadcast (ring reduce)
-                    _ = DistributedUtilities.GetDividedTensorType(din, out _);
+                    _ = DistributedUtilities.GetDividedTensorType(din);
                     var v = (int)CostUtility.GetMemoryAccess(din.TensorType);
                     var comm = (din.Placement.Hierarchy[1] - 1) * (v / din.Placement.Hierarchy[1]) * 2; // reduce-scatter + gather
                     cost = new Cost()
diff --git a/src/Nncase.Tests/Core/UnitTestTensorUtilities.cs b/src/Nncase.Tests/Core/UnitTestTensorUtilities.cs
index d07f20bd78..649e23127f 100644
--- a/src/Nncase.Tests/Core/UnitTestTensorUtilities.cs
+++ b/src/Nncase.Tests/Core/UnitTestTensorUtilities.cs
@@ -54,48 +54,58 @@ public sealed class UnitTestTensorUtilities
     public void TestIsContiguousSlice()
     {
         var dim1 = new[] { 1, 512, 14, 14 };
-
+        int start;
         Assert.True(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..512, 0..14, 0..14 }));
+          new[] { 0..1, 0..512, 0..14, 0..14 }, out start));
+        Assert.Equal(0, start);
 
         Assert.True(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..1, 0..1, 0..14 }));
+          new[] { 0..1, 0..1, 0..1, 0..14 }, out start));
+        Assert.Equal(0, start);
 
         Assert.True(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..1, 0..1, 7..14 }));
+          new[] { 0..1, 0..1, 0..1, 7..14 }, out start));
+        Assert.Equal(0, start);
 
         Assert.True(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..1, 7..14, 0..14 }));
+          new[] { 0..1, 0..1, 7..14, 0..14 }, out start));
+        Assert.Equal(0, start);
 
         Assert.False(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..512, 0..7, 0..14 }));
+          new[] { 0..1, 0..512, 0..7, 0..14 }, out start));
+        Assert.Equal(2, start);
 
         Assert.False(TensorUtilities.IsContiguousSlice(
             dim1,
-            new[] { 0..1, 0..512, 0..7, 0..14, 0..1 }));
+            new[] { 0..1, 0..512, 0..7, 0..14, 0..1 }, out start));
+        Assert.Equal(4, start);
 
         Assert.False(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 10..512, 0..1, 0..1 }));
+          new[] { 0..1, 10..512, 0..1, 0..1 }, out start));
+        Assert.Equal(2, start);
 
         Assert.False(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..512, 0..7, 0..1 }));
+          new[] { 0..1, 0..512, 0..7, 0..1 }, out start));
+        Assert.Equal(3, start);
 
         var dim2 = new[] { 1, 512, 1, 196 };
 
         Assert.True(TensorUtilities.IsContiguousSlice(
               dim2,
-              new[] { 0..1, 0..128, 0..1, 0..196 }));
+              new[] { 0..1, 0..128, 0..1, 0..196 }, out start));
+        Assert.Equal(0, start);
 
         Assert.True(TensorUtilities.IsContiguousSlice(
               dim2,
-              new[] { 0..1, 0..1, 0..1, 10..15 }));
+              new[] { 0..1, 0..1, 0..1, 10..15 }, out start));
+        Assert.Equal(0, start);
     }
 
     // long GetProduct(ReadOnlySpan<int> dimensions, int startIndex = 0)
diff --git a/src/Nncase.Tests/Distributed/UnitTestDistTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestDistTypeInfer.cs
index 2d07b70bbe..d3759fcec4 100644
--- a/src/Nncase.Tests/Distributed/UnitTestDistTypeInfer.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestDistTypeInfer.cs
@@ -14,21 +14,31 @@ namespace Nncase.Tests.DistributedTest;
 [TestFixture.AutoSetupTestMethod(InitSession = true)]
 public sealed class UnitTestDistTypeInfer : TestClassBase
 {
-    public static TheoryData<UnaryOp, DistributedType, DistributedType> InferUnaryData => new() {
+    public static TheoryData<UnaryOp, DistributedType, IRType> InferUnaryData => new() {
         { UnaryOp.Exp,
           new(new(DataTypes.Float32, new[] { 48, 32 }), new[] { SBP.B, SBP.B }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
-          new(new(DataTypes.Float32, new[] { 48, 32 }), new[] { SBP.B, SBP.B }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt"))
+          new DistributedType(new(DataTypes.Float32, new[] { 48, 32 }), new[] { SBP.B, SBP.B }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt"))
+        },
+        { UnaryOp.Exp,
+          new(new(DataTypes.Float32, new[] { 384, 128 }), new SBP[] { SBP.S(0), SBP.P }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
+          new InvalidType(string.Empty)
         },
     };
 
     [Theory]
     [MemberData(nameof(InferUnaryData))]
-    public void TestInferUnary(UnaryOp unaryOp, DistributedType inputType, DistributedType outputType)
+    public void TestInferUnary(UnaryOp unaryOp, DistributedType inputType, IRType outType)
     {
         var input = new Var(inputType);
         var unary = IR.F.Math.Unary(unaryOp, input);
         CompilerServices.InferenceType(unary);
-        Assert.Equal(outputType, unary.CheckedType);
+        if (outType is InvalidType && unary.CheckedType is InvalidType)
+        {
+        }
+        else
+        {
+            Assert.Equal(outType, unary.CheckedType);
+        }
     }
 
     [Theory]
@@ -93,6 +103,10 @@ public InferMatmulData()
         var rhs = new[] { 1, 64, 8192, 384 };
         var o = new[] { 1, 64, 384, 384 };
 
+        Add(
+            new(new(DataTypes.Float32, new[] { 1, 1, 384, 8192 }), new[] { SBP.S(2), SBP.S(2) }, placement),
+            new(new(DataTypes.Float32, new[] { 1, 64, 8192, 128 }), new SBP[] { SBP.S(2), SBP.S(2) }, placement),
+            new InvalidType(string.Empty));
         Add(
             new(new(DataTypes.Float32, lhs), new[] { SBP.S(1), SBP.S(2) }, placement),
             new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(1), SBP.B }, placement),
diff --git a/src/Nncase.Tests/Distributed/UnitTestDistributedUtilities.cs b/src/Nncase.Tests/Distributed/UnitTestDistributedUtilities.cs
new file mode 100644
index 0000000000..ada1622e22
--- /dev/null
+++ b/src/Nncase.Tests/Distributed/UnitTestDistributedUtilities.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Linq;
+using NetFabric.Hyperlinq;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Xunit;
+
+namespace Nncase.Tests.DistributedTest;
+
+public sealed class UnitTestDistributedUtilities
+{
+    [Fact]
+    public void TestEffiecicy()
+    {
+        var burst = 256;
+        var type1 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(1), SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt"));
+        var eff1 = DistributedUtilities.GetDividedTensorEfficiency(type1, burst);
+
+        var type2 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(1), SBP.S(3) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt"));
+        var eff2 = DistributedUtilities.GetDividedTensorEfficiency(type2, burst);
+
+        var type3 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(3), SBP.S(3) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt"));
+        var eff3 = DistributedUtilities.GetDividedTensorEfficiency(type3, burst);
+        Assert.True(eff1 > eff2);
+        Assert.True(eff2 > eff3);
+    }
+}

From 5fb198239f8b28385ceb1357d47eb5958938e17c Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 15 Sep 2023 19:56:12 +0800
Subject: [PATCH 182/308] fix layernorm

---
 .../CodeGen/CSourceConvertVisitor.cs          | 47 ++++++++++++
 modules/cpu/src/runtime/cmodel/include/tdma.h | 72 +++++++++----------
 2 files changed, 81 insertions(+), 38 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index e8a074643c..98fd150094 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -11,6 +11,7 @@
 using System.Reactive;
 using System.Runtime.InteropServices;
 using System.Text;
+using DryIoc.ImTools;
 using NetFabric.Hyperlinq;
 using Nncase.IR;
 using Nncase.Runtime;
@@ -161,6 +162,7 @@ protected override CSymbol VisitPrimFunction(PrimFunction expr)
             // 2. Function body
             using (_ = new IndentScope())
             {
+                IndentScope.Writer.IndWrite($"thread_context ctx(bid, tid);\n");
                 Visit(expr.Body);
             }
 
@@ -254,6 +256,51 @@ protected override CSymbol VisitCall(Call expr)
                     break;
                 case IR.XPU.Matmul matmul:
                     IndentScope.Writer.Write($"matmul({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name})");
+                    break;
+                case IR.XPU.LayerNorm layernorm:
+                    using (_ = new IndentScope())
+                    {
+                        IndentScope.Writer.IndWrite($"{{\n");
+
+                        var dividedType = DistributedUtilities.GetDividedTensorType(layernorm.DistType);
+                        var sbpOnAxis = layernorm.DistType.NdSbp.Where(sbp => sbp is SBPSplit s && s.Axis >= layernorm.Axis).ToArray();
+                        switch (sbpOnAxis.Length)
+                        {
+                            case 0:
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
+                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
+                                IndentScope.Writer.IndWrite($"layernorm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({layernorm.Epsilon}), {layernorm.Axis}, {layernorm.DistType.TensorType.Shape[layernorm.Axis]}, {(!layernorm.UseMean).ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)});\n");
+                                break;
+                            case 1:
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
+                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
+                                if (sbpOnAxis[0] == layernorm.DistType.NdSbp[1])
+                                {
+                                    IndentScope.Writer.IndWrite($"tdma_reduce_async(sum, sum, reduce_op_t::sum, ctx);\n");
+                                    IndentScope.Writer.IndWrite($"tdma_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, ctx);\n");
+                                }
+                                else
+                                {
+                                    IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum, sum, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
+                                    IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
+                                }
+
+                                IndentScope.Writer.IndWrite($"layernorm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({layernorm.Epsilon}), {layernorm.Axis}, {layernorm.DistType.TensorType.Shape[layernorm.Axis]}, {(!layernorm.UseMean).ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)});\n"); break;
+                            case 2:
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
+                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
+                                IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum, sum, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
+                                IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
+                                IndentScope.Writer.IndWrite($"layernorm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({layernorm.Epsilon}), {layernorm.Axis}, {layernorm.DistType.TensorType.Shape[layernorm.Axis]}, {(!layernorm.UseMean).ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)});\n");
+                                break;
+                        }
+
+                        IndentScope.Writer.IndWrite("}\n");
+                    }
+
                     break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index c1cbdcde12..b50ec37a04 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -352,12 +352,12 @@ void tdma_reduce_async(tensor<T, loc_t::local> &src,
                                  ctx, src, dest)}
 
     {
-        __tdma_all_sync_apply_macro(reduce_async_visit_func2, ([]() -> void {
-                                        runtime_util->free(global_hardware_ctx.global_var);
-                                        global_hardware_ctx.global_var =
-                                            nullptr;
-                                    }),
-                                    ctx, src, dest, reduce_op)
+        __tdma_all_sync_apply_macro(
+            reduce_async_visit_func2, ([]() -> void {
+                runtime_util->free(global_hardware_ctx.global_var);
+                global_hardware_ctx.global_var = nullptr;
+            }),
+            ctx, src, dest, reduce_op)
     }
 }
 
@@ -395,10 +395,11 @@ void all_reduce_async_visit_func1(int visited, thread_context &ctx,
 }
 
 template <class T, loc_t ALoc, loc_t BLoc>
-void all_reduce_async_visit_func2_all(int visit, tensor<T, ALoc> &src,
+void all_reduce_async_visit_func2_all(int visit,
+                                      [[maybe_unused]] thread_context ctx,
+                                      tensor<T, ALoc> &src,
                                       tensor<T, BLoc> &dest,
                                       reduce_op_t reduce_op) {
-
     T *gather_span = nullptr;
     T *reduced_span = nullptr;
     auto new_dims = dims_t(src.dimension());
@@ -406,29 +407,30 @@ void all_reduce_async_visit_func2_all(int visit, tensor<T, ALoc> &src,
     auto reduced_shape = get_reduced_shape(new_dims, dims_t({0}), false);
 
     if (visit == 1) {
-        gather_span = global_hardware_ctx.global_var;
-        tensor<T> gather_tensor =
-            tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
-                                     compute_size(new_dims)),
-                      new_dims);
+        gather_span = (T *)global_hardware_ctx.global_var;
+        tensor<T> gather_tensor = tensor<T>(
+            gsl::make_span(gather_span, compute_size(new_dims)), new_dims);
         reduced_span =
             (T *)runtime_util->malloc(sizeof(T) * compute_size(reduced_shape));
-        tensor<T> reduced_tensor = tensor<T>(reduced_shape);
+        tensor<T> reduced_tensor =
+            tensor<T>(gsl::make_span(reduced_span, compute_size(reduced_shape)),
+                      reduced_shape);
         reduce(gather_tensor, reduced_tensor, reduce_op, (T)0, dims_t({0}),
                false);
         runtime_util->free(gather_span);
         global_hardware_ctx.global_var = reduced_span;
-    } else {
-        tensor<T> reduced_tensor =
-            tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
-                                     compute_size(reduced_shape)),
-                      reduced_shape);
-        __tensor_copy_sync(std::move(dest), std::move(reduced_tensor));
     }
+    tensor<T> reduced_tensor =
+        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
+                                 compute_size(reduced_shape)),
+                  reduced_shape);
+    __tensor_copy_sync(std::move(dest), std::move(reduced_tensor));
 }
 
 template <class T, loc_t ALoc, loc_t BLoc>
-void all_reduce_async_visit_func2_by_block([[maybe_unused]] int visit, tensor<T, ALoc> &src,
+void all_reduce_async_visit_func2_by_block([[maybe_unused]] int visit,
+                                           [[maybe_unused]] thread_context ctx,
+                                           tensor<T, ALoc> &src,
                                            tensor<T, BLoc> &dest,
                                            reduce_op_t reduce_op) {
     auto new_dims = dims_t(src.dimension());
@@ -468,31 +470,25 @@ void tdma_all_reduce_async(tensor<T, ALoc> &src, tensor<T, BLoc> &dest,
                            reduce_op_t reduce_op, reduce_strategy_t strategy,
                            thread_context &ctx) {
     {
-        __tdma_all_sync_apply_macro(
-            all_reduce_async_visit_func1, []() -> void {}, ctx, src)
+        __tdma_all_sync_apply_macro(all_reduce_async_visit_func1,
+                                    ([]() -> void {}), ctx, src)
     }
     switch (strategy) {
     case reduce_strategy_t::all: {
         __tdma_all_sync_apply_macro(
-            all_reduce_async_visit_func2_all,
-            []() -> void {
-                auto reduced_tensor =
-                    static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-                delete reduced_tensor;
+            all_reduce_async_visit_func2_all, ([]() -> void {
+                runtime_util->free(global_hardware_ctx.global_var);
                 global_hardware_ctx.global_var = nullptr;
-            },
-            src, dest, reduce_op);
+            }),
+            ctx, src, dest, reduce_op);
     } break;
     case reduce_strategy_t::by_block: {
-        __tdma_all_sync_apply(
-            all_reduce_async_visit_func2_by_block,
-            []() -> void {
-                auto reduced_tensor =
-                    static_cast<tensor<T> *>(global_hardware_ctx.global_var);
-                delete reduced_tensor;
+        __tdma_all_sync_apply_macro(
+            all_reduce_async_visit_func2_by_block, ([]() -> void {
+                runtime_util->free(global_hardware_ctx.global_var);
                 global_hardware_ctx.global_var = nullptr;
-            },
-            src, dest, reduce_op);
+            }),
+            ctx, src, dest, reduce_op);
     } break;
     default:
         break;

From 038fdd460c720bd52878e2b27e4508ae0972b3d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 18 Sep 2023 12:14:54 +0800
Subject: [PATCH 183/308] add partial resplit

---
 .../CodeGen/CSourceConvertVisitor.cs          |   2 +-
 .../Passes/Tile/SingleCPUFusionConverter.cs   |  39 +++++--
 src/Nncase.Core/CostModel/Cost.cs             |  18 +---
 ...utedUtilities.cs => DistributedUtility.cs} |  35 ++++--
 src/Nncase.Evaluator/Math/MatMul.cs           |   2 +-
 src/Nncase.Evaluator/Math/Unary.cs            |   4 +-
 src/Nncase.Evaluator/NN/LayerNorm.cs          |  16 ++-
 src/Nncase.Evaluator/Tensors/Boxing.cs        | 102 ++++++++++++------
 ...TestDistTensor.cs => UnitTestConstruct.cs} |   4 +-
 src/Nncase.Tests/Distributed/UnitTestCost.cs  |  42 ++++++++
 ...tDistTypeInfer.cs => UnitTestTypeInfer.cs} |   6 +-
 ...butedUtilities.cs => UnitTestUtilities.cs} |   8 +-
 12 files changed, 197 insertions(+), 81 deletions(-)
 rename src/Nncase.Core/{DistributedUtilities.cs => DistributedUtility.cs} (76%)
 rename src/Nncase.Tests/Distributed/{UnitTestDistTensor.cs => UnitTestConstruct.cs} (95%)
 create mode 100644 src/Nncase.Tests/Distributed/UnitTestCost.cs
 rename src/Nncase.Tests/Distributed/{UnitTestDistTypeInfer.cs => UnitTestTypeInfer.cs} (92%)
 rename src/Nncase.Tests/Distributed/{UnitTestDistributedUtilities.cs => UnitTestUtilities.cs} (78%)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 98fd150094..ad4625738e 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -262,7 +262,7 @@ protected override CSymbol VisitCall(Call expr)
                     {
                         IndentScope.Writer.IndWrite($"{{\n");
 
-                        var dividedType = DistributedUtilities.GetDividedTensorType(layernorm.DistType);
+                        var dividedType = DistributedUtility.GetDividedTensorType(layernorm.DistType);
                         var sbpOnAxis = layernorm.DistType.NdSbp.Where(sbp => sbp is SBPSplit s && s.Axis >= layernorm.Axis).ToArray();
                         switch (sbpOnAxis.Length)
                         {
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index c9bcb0222c..89647dcbd2 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -137,7 +137,7 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
             var equivalArgs = op.Parameters.
                 Select(param => (param.ParameterKind, expr.Arguments[param.Index]) switch
                 {
-                    (ParameterKind.Input, Expr e) when e is Const or Var => DistributedUtilities.GetLeafCandidateBoxings(e, Placement),
+                    (ParameterKind.Input, Expr e) when e is Const or Var => DistributedUtility.GetLeafCandidateBoxings(e, Placement),
                     (ParameterKind.Attribute, Expr e) when e is Const or Var => new[] { e },
                     (_, Expr arg) => ExprMemo[arg],
                 }).ToArray();
@@ -146,11 +146,11 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
                 Select(args => args.ToArray()).
                 Select(args => BuildEqualityCalls(op, args)).
                 SelectMany(i => i).
-                Select(c => (c.InferenceType(), c)).ToArray();
+                ToArray();
 
-            if (equivalCalls.Any(t => t.Item1))
+            if (equivalCalls.Any(t => t.Valid))
             {
-                return equivalCalls.Where(t => t.Item1).Select(t => t.c).ToArray();
+                return equivalCalls.Where(t => t.Valid).Select(t => t.Call).ToArray();
             }
 
             var boxingArgs = new List<IReadOnlyList<Expr>>();
@@ -167,7 +167,7 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
                 var tensorType = (TensorType)oldArg.CheckedType;
                 boxingArgs.Add(info.ParameterKind switch
                 {
-                    ParameterKind.Input => DistributedUtilities.GetLeafCandidateNDSBPs(tensorType, Placement).Select(ndsbp => IR.F.Tensors.Boxing(newArgs[0], new DistributedType(tensorType, ndsbp, Placement))).ToList(),
+                    ParameterKind.Input => DistributedUtility.GetLeafCandidateNDSBPs(tensorType, Placement).Select(ndsbp => IR.F.Tensors.Boxing(newArgs[0], new DistributedType(tensorType, ndsbp, Placement))).ToList(),
                     ParameterKind.Attribute => new Expr[] { newArgs[0] },
                     _ => throw new ArgumentOutOfRangeException(info.ParameterKind.ToString()),
                 });
@@ -177,24 +177,41 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
                 Select(Enumerable.ToArray<Expr>).
                 Select(args => BuildEqualityCalls(op, args)).
                 SelectMany(i => i).
-                Select(c => (c.InferenceType(), c)).ToArray();
+                ToArray();
 
-            if (!equivalCalls.Any(t => t.Item1))
+            if (!equivalCalls.Any(t => t.Valid))
             {
                 throw new InvalidOperationException("after boxing still invalid!");
             }
 
-            return equivalCalls.Where(t => t.Item1).Select(t => t.c).ToArray();
+            return equivalCalls.Where(t => t.Valid).Select(t => t.Call).ToArray();
         }
 
-        private IEnumerable<Call> BuildEqualityCalls(Op target, Expr[] args)
+        private IEnumerable<(bool Valid, Call Call)> BuildEqualityCalls(Op target, Expr[] args)
         {
             if (!target.Parameters.Where(p => p.ParameterKind == ParameterKind.Input).All(p => IsDistributed(args[p.Index].CheckedType)))
             {
                 throw new InvalidDataException();
             }
 
-            IEnumerable<Call> calls = new[] { new Call(target, args) };
+            var calls = new List<(bool, Call)>();
+            var call = new Call(target, args);
+            var valid = call.InferenceType();
+            calls.Add((valid, call));
+            if (!valid)
+            {
+                var broadcastArgs = args.Select(DistributedUtility.GetPartialCandidateBoxings).ToArray();
+
+                if (broadcastArgs.All(bargs => bargs.Count >= 0))
+                {
+                    calls.AddRange(broadcastArgs.Select((bargs, i) => bargs.Any() ? bargs : bargs.Concat(new[] { args[i] })).
+                        CartesianProduct().
+                        Select(bargs => bargs.ToArray()).
+                        Select(bargs => new Call(target, bargs)).
+                        Select(c => (c.InferenceType(), c)));
+                }
+            }
+
             return calls;
         }
 
@@ -421,7 +438,7 @@ private Tuple<TensorType, MemoryLocation> GetTypeAndLocation(IRType type)
             TensorType tensorType;
             if (type is DistributedType distTensor)
             {
-                if (!DistributedUtilities.IsDistributable(distTensor.TensorType, distTensor.NdSbp.ToArray(), distTensor.Placement, out var tType))
+                if (!DistributedUtility.IsDistributable(distTensor.TensorType, distTensor.NdSbp.ToArray(), distTensor.Placement, out var tType))
                 {
                     throw new NotSupportedException();
                 }
diff --git a/src/Nncase.Core/CostModel/Cost.cs b/src/Nncase.Core/CostModel/Cost.cs
index e4c2d814a3..4146bb5a86 100644
--- a/src/Nncase.Core/CostModel/Cost.cs
+++ b/src/Nncase.Core/CostModel/Cost.cs
@@ -198,27 +198,13 @@ public static Cost Sum<TSource, TSelector>(this in SpanSelectEnumerable<TSource,
 
 public static class CostUtility
 {
-    public static UInt128 GetRingReduceCommunicate(DistributedType distributedType, int[] axes)
-    {
-        var ttype = DistributedUtilities.GetDividedTensorType(distributedType);
-        var splits = axes.Where(i => distributedType.NdSbp[i] is SBPSplit);
-        if (!splits.Any())
-        {
-            return 0;
-        }
-
-        var p = (UInt128)splits.Select(i => distributedType.Placement.Hierarchy[i]).Aggregate(1, (acc, i) => acc * i);
-        var v = GetMemoryAccess(distributedType.TensorType);
-        return (p - 1) * (v / p);
-    }
-
     public static UInt128 GetMemoryAccess(IRType type)
     {
         return type switch
         {
             TensorType t => (UInt128)(t.Shape.Aggregate(1D, (acc, x) => acc * (x.IsFixed ? x.FixedValue : 1)) * t.DType.SizeInBytes),
             TupleType t => t.Fields.Sum(GetMemoryAccess),
-            DistributedType t => GetMemoryAccess(DistributedUtilities.GetDividedTensorType(t)),
+            DistributedType t => GetMemoryAccess(DistributedUtility.GetDividedTensorType(t)),
             _ => 0,
         };
     }
@@ -244,7 +230,7 @@ public static UInt128 GetCPUCycles(IRType type, double cyclesPerElement = 1)
         {
             TensorType t => (UInt128)(t.Shape.Aggregate(1D, (acc, x) => acc * (x.IsFixed ? x.FixedValue : 1)) * cyclesPerElement),
             TupleType t => t.Fields.Sum(GetMemoryAccess),
-            DistributedType t => GetCPUCycles(DistributedUtilities.GetDividedTensorType(t)),
+            DistributedType t => GetCPUCycles(DistributedUtility.GetDividedTensorType(t)),
             _ => 0,
         };
     }
diff --git a/src/Nncase.Core/DistributedUtilities.cs b/src/Nncase.Core/DistributedUtility.cs
similarity index 76%
rename from src/Nncase.Core/DistributedUtilities.cs
rename to src/Nncase.Core/DistributedUtility.cs
index 84a4d83180..e5e204be61 100644
--- a/src/Nncase.Core/DistributedUtilities.cs
+++ b/src/Nncase.Core/DistributedUtility.cs
@@ -6,7 +6,7 @@
 
 namespace Nncase;
 
-public static class DistributedUtilities
+public static class DistributedUtility
 {
     public static IReadOnlyList<IRArray<SBP>> GetLeafCandidateNDSBPs(TensorType tensorType, Placement placement)
     {
@@ -38,24 +38,41 @@ public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement p
         return GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).ToArray();
     }
 
-    public static IReadOnlyList<Expr> GetBroadCastBoxings(Expr expr)
+    /// <summary>
+    /// when input expression sbp is partial, get the new candidate boxings.
+    /// </summary>
+    /// <param name="expr">input expression.</param>
+    /// <returns>the boxings.</returns>
+    /// <exception cref="NotSupportedException">when expr is tuple.</exception>
+    public static IReadOnlyList<Expr> GetPartialCandidateBoxings(Expr expr)
     {
-        var getNonPartialNDSbps = (IRArray<SBP> ndsbp) => new IRArray<SBP>(ndsbp.Select(sbp => sbp is SBPPartialSum ? SBP.B : sbp).ToArray());
-
         if (expr is IR.Tuple tuple)
         {
             throw new NotSupportedException("current not support!");
         }
 
         var type = (DistributedType)expr.CheckedType;
-        var ndsbp = getNonPartialNDSbps(type.NdSbp);
-
-        if (ndsbp != type.NdSbp)
+        var tensorType = type.TensorType;
+        var candidateNdsbps = new List<SBP>[type.Placement.Rank];
+        for (int i = 0; i < type.Placement.Rank; i++)
         {
-            return new[] { IR.F.Tensors.Boxing(expr, type with { NdSbp = ndsbp }) };
+            candidateNdsbps[i] = new List<SBP>();
+            if (type.NdSbp[i] is SBPPartialSum)
+            {
+                candidateNdsbps[i].Add(SBP.B);
+                for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
+                {
+                    if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && IsDivisible(s, type.Placement.Hierarchy[i]))
+                    {
+                        candidateNdsbps[i].Add(SBP.S(axis));
+                    }
+                }
+            }
         }
 
-        return Array.Empty<Expr>();
+        return candidateNdsbps.CartesianProduct().
+            Select(ndsbp => new DistributedType(tensorType, new IRArray<SBP>(ndsbp), type.Placement)).
+            Select(disttype => IR.F.Tensors.Boxing(expr, disttype)).ToArray();
     }
 
     public static bool IsDistributable(TensorType tensorType, ReadOnlySpan<SBP> ndsbp, Placement placement, [MaybeNullWhen(false)] out TensorType distType)
diff --git a/src/Nncase.Evaluator/Math/MatMul.cs b/src/Nncase.Evaluator/Math/MatMul.cs
index 5294229bec..8ee68b4263 100644
--- a/src/Nncase.Evaluator/Math/MatMul.cs
+++ b/src/Nncase.Evaluator/Math/MatMul.cs
@@ -162,7 +162,7 @@ public Cost Visit(ICostEvaluateContext context, MatMul target)
         }
         else if (lhs is DistributedType distributedType)
         {
-            var lhsType = DistributedUtilities.GetDividedTensorType(distributedType);
+            var lhsType = DistributedUtility.GetDividedTensorType(distributedType);
             macPerElement = lhsType.Shape[^1].IsFixed ? (uint)lhsType.Shape[^1].FixedValue : 1U;
         }
 
diff --git a/src/Nncase.Evaluator/Math/Unary.cs b/src/Nncase.Evaluator/Math/Unary.cs
index 678fd0c673..d3d5cc5c36 100644
--- a/src/Nncase.Evaluator/Math/Unary.cs
+++ b/src/Nncase.Evaluator/Math/Unary.cs
@@ -181,8 +181,8 @@ private IRType Visit(TensorType input)
 
     private Cost Visit(DistributedType inType, DistributedType outType, Unary target)
     {
-        var inPartType = DistributedUtilities.GetDividedTensorType(inType);
-        var outPartType = DistributedUtilities.GetDividedTensorType(outType);
+        var inPartType = DistributedUtility.GetDividedTensorType(inType);
+        var outPartType = DistributedUtility.GetDividedTensorType(outType);
         return new()
         {
             [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inPartType),
diff --git a/src/Nncase.Evaluator/NN/LayerNorm.cs b/src/Nncase.Evaluator/NN/LayerNorm.cs
index 4021791e73..be36263787 100644
--- a/src/Nncase.Evaluator/NN/LayerNorm.cs
+++ b/src/Nncase.Evaluator/NN/LayerNorm.cs
@@ -59,7 +59,7 @@ public Cost Visit(ICostEvaluateContext context, LayerNorm target)
             case (DistributedType inputDistributedType, DistributedType):
                 var scaleType = context.GetArgumentType<DistributedType>(target, LayerNorm.Scale);
                 var biasType = context.GetArgumentType<DistributedType>(target, LayerNorm.Bias);
-                var ring = CostUtility.GetRingReduceCommunicate(scaleType, new[] { 0, 1 }) + CostUtility.GetRingReduceCommunicate(biasType, new[] { 0, 1 });
+                var ring = GetRingReduceCommunicate(scaleType, new[] { 0, 1 }) + GetRingReduceCommunicate(biasType, new[] { 0, 1 });
                 var reCompute = inputDistributedType.NdSbp.Select((sbp, i) => sbp is SBPSplit ? 1 : inputDistributedType.Placement.Hierarchy[i]).ToArray().Aggregate(1, (acc, rep) => acc * rep);
                 return new()
                 {
@@ -128,6 +128,20 @@ private IRType Visit(DistributedType input, DistributedType scale, DistributedTy
         return new DistributedType(input.TensorType, ndsbp, input.Placement);
     }
 
+    private UInt128 GetRingReduceCommunicate(DistributedType distributedType, int[] axes)
+    {
+        var ttype = DistributedUtility.GetDividedTensorType(distributedType);
+        var splits = axes.Where(i => distributedType.NdSbp[i] is SBPSplit);
+        if (!splits.Any())
+        {
+            return 0;
+        }
+
+        var p = (UInt128)splits.Select(i => distributedType.Placement.Hierarchy[i]).Aggregate(1, (acc, i) => acc * i);
+        var v = CostUtility.GetMemoryAccess(distributedType.TensorType);
+        return (p - 1) * (v / p);
+    }
+
 #if true
     private Tensor LayerNormImpl(Tensor input, Tensor scale, Tensor bias, int axis, float epsilon, bool useMean = true)
     {
diff --git a/src/Nncase.Evaluator/Tensors/Boxing.cs b/src/Nncase.Evaluator/Tensors/Boxing.cs
index d09a52c16a..e8b7453d02 100644
--- a/src/Nncase.Evaluator/Tensors/Boxing.cs
+++ b/src/Nncase.Evaluator/Tensors/Boxing.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 #pragma warning disable SA1010, SA1008
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Nncase.CostModel;
 using Nncase.IR;
@@ -22,58 +23,97 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
     {
         var inType = context.GetArgumentType<IRType>(target, Boxing.Input);
         var returnType = context.GetReturnType<IRType>();
-        Cost cost;
+        var cost = new Cost() { [CostFactorNames.MemoryLoad] = 0, [CostFactorNames.MemoryStore] = 0 };
         switch (inType, returnType)
         {
             case (TensorType tensorType, DistributedType distTensorType):
                 cost = new Cost()
                 {
                     [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(tensorType),
-                    [CostFactorNames.MemoryStore] = (UInt128)((float)CostUtility.GetMemoryAccess(distTensorType) / DistributedUtilities.GetDividedTensorEfficiency(distTensorType, _burstLength)),
+                    [CostFactorNames.MemoryStore] = (UInt128)((float)CostUtility.GetMemoryAccess(distTensorType) / DistributedUtility.GetDividedTensorEfficiency(distTensorType, _burstLength)),
                 };
                 break;
             case (DistributedType distTensorType, TensorType tensorType):
                 cost = new Cost()
                 {
-                    [CostFactorNames.MemoryLoad] = (UInt128)((float)CostUtility.GetMemoryAccess(distTensorType) / DistributedUtilities.GetDividedTensorEfficiency(distTensorType, _burstLength)),
+                    [CostFactorNames.MemoryLoad] = (UInt128)((float)CostUtility.GetMemoryAccess(distTensorType) / DistributedUtility.GetDividedTensorEfficiency(distTensorType, _burstLength)),
                     [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(tensorType),
                 };
                 break;
-            case (DistributedType { Placement: { Rank: 1 } } din, DistributedType { Placement: { Rank: 2 } } dout):
+
+            case (DistributedType a, DistributedType b) when a.Placement == b.Placement && a.NdSbp != b.NdSbp:
                 {
-                    // shared tensor broadcast to local.
-                    var a = DistributedUtilities.GetDividedTensorType(din);
-                    var b = DistributedUtilities.GetDividedTensorType(dout);
-                    cost = new Cost()
+                    var fullLoadStore = new Cost()
                     {
-                        [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(a),
-                        [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(b),
+                        [CostFactorNames.MemoryStore] = (UInt128)((float)CostUtility.GetMemoryAccess(a) / DistributedUtility.GetDividedTensorEfficiency(a, _burstLength)),
+                        [CostFactorNames.MemoryLoad] = (UInt128)((float)CostUtility.GetMemoryAccess(b) / DistributedUtility.GetDividedTensorEfficiency(b, _burstLength)),
                     };
-                }
 
-                break;
-            case (DistributedType { NdSbp: [(SBPSplit or SBPBroadCast), SBPPartialSum], Placement.Rank: 2 } din,
-                  DistributedType { NdSbp: [(SBPSplit or SBPBroadCast), SBPBroadCast], Placement.Rank: 2 }):
-                {
-                    // reduce scater and broadcast (ring reduce)
-                    _ = DistributedUtilities.GetDividedTensorType(din);
-                    var v = (int)CostUtility.GetMemoryAccess(din.TensorType);
-                    var comm = (din.Placement.Hierarchy[1] - 1) * (v / din.Placement.Hierarchy[1]) * 2; // reduce-scatter + gather
-                    cost = new Cost()
+                    float scatterPart = 1;
+                    float gatherPart = 1;
+                    for (int i = 0; i < a.Placement.Rank; i++)
                     {
-                        [CostFactorNames.MemoryLoad] = (UInt128)comm,
-                        [CostFactorNames.MemoryStore] = (UInt128)comm,
-                    };
-                }
+                        switch (a.NdSbp[i], b.NdSbp[i])
+                        {
+                            case (SBPSplit { Axis: int ax }, SBP sbpout):
+                                switch (sbpout)
+                                {
+                                    case SBPSplit { Axis: int bx }:
+                                        if (ax != bx)
+                                        {
+                                            // when split different axis, need global load store.
+                                            return fullLoadStore;
+                                        }
 
-                break;
-            case (DistributedType a, DistributedType b) when a.Placement == b.Placement && a.NdSbp != b.NdSbp:
-                {
-                    cost = new Cost()
+                                        break;
+                                    case SBPBroadCast:
+                                        scatterPart *= a.Placement.Hierarchy[i];
+                                        gatherPart *= a.Placement.Hierarchy[i];
+                                        break;
+                                    default:
+                                        throw new NotSupportedException("split to partial");
+                                }
+
+                                break;
+                            case (SBPBroadCast, SBPBroadCast or SBPSplit):
+                                // no cost.
+                                break;
+                            case (SBPPartialSum, SBP sbpout):
+                                switch (sbpout)
+                                {
+                                    case SBPPartialSum:
+                                        break;
+                                    case SBPBroadCast or SBPSplit:
+                                        gatherPart *= a.Placement.Hierarchy[i];
+                                        if (i == 0)
+                                        {
+                                            scatterPart *= a.Placement.Hierarchy[i];
+                                        }
+
+                                        break;
+                                }
+
+                                break;
+                            default:
+                                throw new NotSupportedException($"{a} to {b}");
+                        }
+                    }
+
+                    if (gatherPart > 1f)
                     {
-                        [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(a) + CostUtility.GetMemoryAccess(b),
-                        [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(a.TensorType),
-                    };
+                        cost += new Cost()
+                        {
+                            [CostFactorNames.MemoryStore] = (UInt128)((gatherPart - 1) * (float)CostUtility.GetMemoryAccess(DistributedUtility.GetDividedTensorType(a)) / gatherPart),
+                        };
+                    }
+
+                    if (scatterPart > 1f)
+                    {
+                        cost += new Cost()
+                        {
+                            [CostFactorNames.MemoryLoad] = (UInt128)((scatterPart - 1) * (float)CostUtility.GetMemoryAccess(DistributedUtility.GetDividedTensorType(b)) / scatterPart),
+                        };
+                    }
                 }
 
                 break;
diff --git a/src/Nncase.Tests/Distributed/UnitTestDistTensor.cs b/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
similarity index 95%
rename from src/Nncase.Tests/Distributed/UnitTestDistTensor.cs
rename to src/Nncase.Tests/Distributed/UnitTestConstruct.cs
index e04b2ae252..0ceefa4f5a 100644
--- a/src/Nncase.Tests/Distributed/UnitTestDistTensor.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
@@ -15,7 +15,7 @@
 namespace Nncase.Tests.DistributedTest;
 
 [TestFixture.AutoSetupTestMethod(InitSession = true)]
-public sealed class UnitTestDistTensor : TestClassBase
+public sealed class UnitTestConstruct : TestClassBase
 {
     [Fact]
     public void TestCreate()
@@ -61,7 +61,7 @@ public void TestGetLeafCandidateNDSBPs()
         Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
         var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
         var input = new Var(ttype);
-        var set = new HashSet<DistributedType>(DistributedUtilities.GetLeafCandidateNDSBPs(ttype, placement).Select(ndsbp => new DistributedType(ttype, ndsbp, placement)));
+        var set = new HashSet<DistributedType>(DistributedUtility.GetLeafCandidateNDSBPs(ttype, placement).Select(ndsbp => new DistributedType(ttype, ndsbp, placement)));
         Assert.Equal(9, set.Count);
     }
 
diff --git a/src/Nncase.Tests/Distributed/UnitTestCost.cs b/src/Nncase.Tests/Distributed/UnitTestCost.cs
new file mode 100644
index 0000000000..d4e842ab38
--- /dev/null
+++ b/src/Nncase.Tests/Distributed/UnitTestCost.cs
@@ -0,0 +1,42 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Metadata;
+using NetFabric.Hyperlinq;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Xunit;
+
+namespace Nncase.Tests.DistributedTest;
+
+public sealed class UnitTestCost
+{
+    [Fact]
+    public void TestPartialToBroadCastCost()
+    {
+        var tensorType = new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 128 });
+        var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+
+        List<CostModel.Cost> costs = new();
+        foreach (var ndsbp in new IRArray<SBP>[] {
+            new SBP[] { SBP.S(2), SBP.P },
+            new SBP[] { SBP.P, SBP.S(2) },
+            new SBP[] { SBP.P, SBP.P },
+            new SBP[] { SBP.P, SBP.S(1) },
+            new SBP[] { SBP.P, SBP.S(3) },
+            new SBP[] { SBP.S(1), SBP.P },
+            new SBP[] { SBP.S(3), SBP.P },
+         })
+        {
+            var input0 = new Var(new DistributedType(tensorType, ndsbp, placement));
+            var candidates = DistributedUtility.GetPartialCandidateBoxings(input0);
+            foreach (var item in candidates)
+            {
+                var cost = CompilerServices.EvaluateCost(item);
+                costs.Add(cost);
+            }
+        }
+    }
+}
diff --git a/src/Nncase.Tests/Distributed/UnitTestDistTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
similarity index 92%
rename from src/Nncase.Tests/Distributed/UnitTestDistTypeInfer.cs
rename to src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
index d3759fcec4..c409d2f0fa 100644
--- a/src/Nncase.Tests/Distributed/UnitTestDistTypeInfer.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
@@ -12,7 +12,7 @@
 namespace Nncase.Tests.DistributedTest;
 
 [TestFixture.AutoSetupTestMethod(InitSession = true)]
-public sealed class UnitTestDistTypeInfer : TestClassBase
+public sealed class UnitTestTypeInfer : TestClassBase
 {
     public static TheoryData<UnaryOp, DistributedType, IRType> InferUnaryData => new() {
         { UnaryOp.Exp,
@@ -67,8 +67,8 @@ public void TestInferMatmulProduct()
         var lhsType = new TensorType(DataTypes.Float32, lhsShape);
         var rhsType = new TensorType(DataTypes.Float32, rhsShape);
         var candiateArgs = new[] {
-            DistributedUtilities.GetLeafCandidateNDSBPs(lhsType, placement).Select(ndsbp => new DistributedType(lhsType, ndsbp, placement)),
-            DistributedUtilities.GetLeafCandidateNDSBPs(rhsType, placement).Select(ndsbp => new DistributedType(rhsType, ndsbp, placement)),
+            DistributedUtility.GetLeafCandidateNDSBPs(lhsType, placement).Select(ndsbp => new DistributedType(lhsType, ndsbp, placement)),
+            DistributedUtility.GetLeafCandidateNDSBPs(rhsType, placement).Select(ndsbp => new DistributedType(rhsType, ndsbp, placement)),
             }.
             CartesianProduct().
             Select(argTypes => argTypes.Select(type => new Var(type)).ToArray());
diff --git a/src/Nncase.Tests/Distributed/UnitTestDistributedUtilities.cs b/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
similarity index 78%
rename from src/Nncase.Tests/Distributed/UnitTestDistributedUtilities.cs
rename to src/Nncase.Tests/Distributed/UnitTestUtilities.cs
index ada1622e22..88d324f147 100644
--- a/src/Nncase.Tests/Distributed/UnitTestDistributedUtilities.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
@@ -10,20 +10,20 @@
 
 namespace Nncase.Tests.DistributedTest;
 
-public sealed class UnitTestDistributedUtilities
+public sealed class UnitTestUtilities
 {
     [Fact]
     public void TestEffiecicy()
     {
         var burst = 256;
         var type1 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(1), SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt"));
-        var eff1 = DistributedUtilities.GetDividedTensorEfficiency(type1, burst);
+        var eff1 = DistributedUtility.GetDividedTensorEfficiency(type1, burst);
 
         var type2 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(1), SBP.S(3) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt"));
-        var eff2 = DistributedUtilities.GetDividedTensorEfficiency(type2, burst);
+        var eff2 = DistributedUtility.GetDividedTensorEfficiency(type2, burst);
 
         var type3 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(3), SBP.S(3) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt"));
-        var eff3 = DistributedUtilities.GetDividedTensorEfficiency(type3, burst);
+        var eff3 = DistributedUtility.GetDividedTensorEfficiency(type3, burst);
         Assert.True(eff1 > eff2);
         Assert.True(eff2 > eff3);
     }

From 5f6b59b42701f12f138e23a828688397a737d8ff Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 18 Sep 2023 14:33:42 +0800
Subject: [PATCH 184/308] add rvv matmul

---
 .../CodeGen/CSourceCompiler.cs                |   1 +
 .../cpu/src/runtime/cmodel/include/matmul.h   |  19 ++-
 modules/cpu/src/runtime/method_table_def.h    |   5 +
 modules/cpu/src/runtime/method_table_impl.h   | 160 +++++++++++-------
 .../Targets/UnitTestCPUTargetTiling.cs        |  18 +-
 5 files changed, 142 insertions(+), 61 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
index 398ac8e444..05d9fd6f82 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
@@ -134,6 +134,7 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
+            // return $"-c \"export PATH=/data/huochenghai/toolchain/riscv64-unknown-linux_gnu_12.0.1/bin:$PATH && cd {sourcePath} && mkdir -p build && cd build && rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=riscv64-unknown-linux-gnu-gcc -DCMAKE_CXX_COMPILER=riscv64-unknown-linux-gnu-g++ -DCMAKE_SYSTEM_PROCESSOR=riscv64 && cmake --build .\"";
             return $"-c \"cd {sourcePath} && mkdir -p build && cd build && rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Debug && cmake --build .\"";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
index b3445dc963..e1b5da5129 100644
--- a/modules/cpu/src/runtime/cmodel/include/matmul.h
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -59,12 +59,21 @@ void contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
             for (size_t h = 0; h < dim2; ++h) {
                 auto ah = new_a_shape[2] == 1 ? 0 : h;
                 auto bh = new_b_shape[2] == 1 ? 0 : h;
+#ifdef __riscv_vector
+                nncase_mt->matmul_unit_impl(
+                    input_a + an * ab_size + ac * ah_size + ah * a_unit_size,
+                    input_b + bn * bb_size + bc * bh_size + bh * b_unit_size,
+                    output + n * ob_size + c * oh_size + h * out_unit_size,
+                    new_a_shape[3], new_a_shape[4], new_b_shape[4],
+                    new_a_shape[4], new_b_shape[4], new_b_shape[4]);
+#else
                 matmul_unit_impl(
                     input_a + an * ab_size + ac * ah_size + ah * a_unit_size,
                     input_b + bn * bb_size + bc * bh_size + bh * b_unit_size,
                     output + n * ob_size + c * oh_size + h * out_unit_size,
                     std::array<size_t, 2>{new_a_shape[3], new_a_shape[4]},
                     std::array<size_t, 2>{new_b_shape[3], new_b_shape[4]});
+#endif
             }
         }
     }
@@ -98,8 +107,15 @@ void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                                     bc * new_b_stride[1] + bh * new_b_stride[2];
                 T *out_ptr = output + n * new_out_stride[0] +
                              c * new_out_stride[1] + h * new_out_stride[2];
+#ifdef __riscv_vector
+                nncase_mt->matmul_unit_impl(in_a_ptr, in_b_ptr, out_ptr, new_a_shape[3],
+                                            new_a_shape[4], new_b_shape[4],
+                                            new_a_stride[3], new_b_stride[3],
+                                            new_b_stride[3]);
+#else
                 for (size_t m = 0; m < new_a_shape[3]; m++) {
-                    T *values = (T*)runtime_util->malloc(new_b_shape[4] * sizeof(T));
+                    T *values =
+                        (T *)runtime_util->malloc(new_b_shape[4] * sizeof(T));
                     for (size_t k = 0; k < new_a_shape[4]; k++) {
                         for (size_t n = 0; n < new_b_shape[4]; n++) {
                             values[n] += in_a_ptr[m * new_a_stride[3] +
@@ -114,6 +130,7 @@ void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                     }
                     runtime_util->free(values);
                 }
+#endif
             }
         }
     }
diff --git a/modules/cpu/src/runtime/method_table_def.h b/modules/cpu/src/runtime/method_table_def.h
index 28d92a8e26..a67f676e67 100644
--- a/modules/cpu/src/runtime/method_table_def.h
+++ b/modules/cpu/src/runtime/method_table_def.h
@@ -67,6 +67,11 @@ typedef struct nncase_method_table {
     void *(*thread_start)(void *(*callable)(void *), void *user,
                           size_t user_size);
     void *(*thread_end)();
+
+    // rvv impl
+    void (*matmul_unit_impl)(const float *input_a, const float *input_b, float *output,
+                      size_t size_m, size_t size_k, size_t size_n, size_t lda,
+                      size_t ldb, size_t ldc);
 } nncase_mt_t;
 
 typedef struct buffer {
diff --git a/modules/cpu/src/runtime/method_table_impl.h b/modules/cpu/src/runtime/method_table_impl.h
index aa183d80ba..68e1db09a8 100644
--- a/modules/cpu/src/runtime/method_table_impl.h
+++ b/modules/cpu/src/runtime/method_table_impl.h
@@ -9,6 +9,9 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#ifdef __riscv_vector
+#include <riscv_vector.h>
+#endif
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
@@ -64,69 +67,108 @@ inline bool bool_binary_logical_and(bool x, bool y) { return x && y; }
 inline bool bool_binary_logical_or(bool x, bool y) { return x || y; }
 inline bool bool_binary_logical_xor(bool x, bool y) { return x ^ y; }
 
-[[maybe_unused]] static nncase_mt_t nncase_mt = {fabsf,
-                                acosf,
-                                acoshf,
-                                asinf,
-                                asinhf,
-                                ceilf,
-                                cosf,
-                                coshf,
-                                expf,
-                                floorf,
-                                logf,
-                                float_unary_logical_not,
-                                float_unary_neg,
-                                roundf,
-                                float_unary_rsqrt,
-                                float_unary_sign,
-                                sinf,
-                                sinhf,
-                                sqrtf,
-                                float_unary_square,
-                                tanhf,
-                                float_binary_add,
-                                float_binary_sub,
-                                float_binary_mul,
-                                float_binary_div,
-                                float_binary_min,
-                                float_binary_max,
-                                float_binary_pow,
-                                float_binary_logical_and,
-                                float_binary_mod,
-                                int32_binary_add,
-                                int32_binary_sub,
-                                int32_binary_mul,
-                                int32_binary_div,
-                                int32_binary_min,
-                                int32_binary_max,
-                                int32_binary_pow,
-                                int32_binary_logical_and,
-                                int32_binary_mod,
-                                int64_binary_add,
-                                int64_binary_sub,
-                                int64_binary_mul,
-                                int64_binary_div,
-                                int64_binary_min,
-                                int64_binary_max,
-                                int64_binary_pow,
-                                int64_binary_logical_and,
-                                int64_binary_mod,
-                                bool_binary_logical_and,
-                                bool_binary_logical_or,
-                                bool_binary_logical_xor};
+#ifdef __riscv_vector
+inline void matmul_unit_impl(const float *input_a, const float *input_b,
+                             float *output, size_t size_m, size_t size_k,
+                             size_t size_n, size_t lda, size_t ldb,
+                             size_t ldc) {
+    size_t vl;
+    for (size_t m = 0; m < size_m; ++m) {
+        const float *b_n_ptr = input_b;
+        float *c_n_ptr = output;
+        for (size_t c_n_count = size_n; c_n_count; c_n_count -= vl) {
+            vl = vsetvl_e32m1(c_n_count);
+            const float *a_k_ptr = input_a;
+            const float *b_k_ptr = b_n_ptr;
+            vfloat32m1_t acc = vle32_v_f32m1(c_n_ptr, vl);
+            for (size_t k = 0; k < size_k; ++k) {
+                vfloat32m1_t b_n_data = vle32_v_f32m1(b_k_ptr, vl);
+                acc = vfmacc_vf_f32m1(acc, *a_k_ptr, b_n_data, vl);
+                b_k_ptr += ldb;
+                a_k_ptr++;
+            }
+            vse32_v_f32m1(c_n_ptr, acc, vl);
+            c_n_ptr += vl;
+            b_n_ptr += vl;
+        }
+        input_a += lda;
+        output += ldc;
+    }
+}
+#else
+inline void
+matmul_unit_impl([[maybe_unused]] const float *input_a,
+                 [[maybe_unused]] const float *input_b,
+                 [[maybe_unused]] float *output, [[maybe_unused]] size_t size_m,
+                 [[maybe_unused]] size_t size_k, [[maybe_unused]] size_t size_n,
+                 [[maybe_unused]] size_t lda, [[maybe_unused]] size_t ldb,
+                 [[maybe_unused]] size_t ldc) {
+    throw std::runtime_error("not supported");
+}
+#endif
+
+[[maybe_unused]] static nncase_mt_t nncase_mt = {
+    fabsf,
+    acosf,
+    acoshf,
+    asinf,
+    asinhf,
+    ceilf,
+    cosf,
+    coshf,
+    expf,
+    floorf,
+    logf,
+    float_unary_logical_not,
+    float_unary_neg,
+    roundf,
+    float_unary_rsqrt,
+    float_unary_sign,
+    sinf,
+    sinhf,
+    sqrtf,
+    float_unary_square,
+    tanhf,
+    float_binary_add,
+    float_binary_sub,
+    float_binary_mul,
+    float_binary_div,
+    float_binary_min,
+    float_binary_max,
+    float_binary_pow,
+    float_binary_logical_and,
+    float_binary_mod,
+    int32_binary_add,
+    int32_binary_sub,
+    int32_binary_mul,
+    int32_binary_div,
+    int32_binary_min,
+    int32_binary_max,
+    int32_binary_pow,
+    int32_binary_logical_and,
+    int32_binary_mod,
+    int64_binary_add,
+    int64_binary_sub,
+    int64_binary_mul,
+    int64_binary_div,
+    int64_binary_min,
+    int64_binary_max,
+    int64_binary_pow,
+    int64_binary_logical_and,
+    int64_binary_mod,
+    bool_binary_logical_and,
+    bool_binary_logical_or,
+    bool_binary_logical_xor,
+    thread_pool::thread_start,
+    thread_pool::thread_end,
+    matmul_unit_impl,
+};
 
 inline void *rt_malloc(size_t size) { return (void *)new uint8_t[size](); }
 
 [[maybe_unused]] static runtime_util_mt runtime_util = {
-    printf,
-    rt_malloc,
-    free,
-    create_thread,
-    join_thread,
-    rt_assert,
-    memcpy,
-    memset};
+    printf,      rt_malloc, free,   create_thread,
+    join_thread, rt_assert, memcpy, memset};
 
 [[maybe_unused]] static hardware_context_mt hw_ctx_mt = {
     hardware_context::lock_block,   hardware_context::mark_block_visit,
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 0d6f73807c..f7077ab929 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -40,12 +40,28 @@ public UnitTestCPUTargetTiling()
     [ClassData(typeof(TilingCaseUnary))]
     [ClassData(typeof(TilingCaseMatmul))]
     [ClassData(typeof(TilingCaseMatmulUnary))]
-    // [ClassData(typeof(TilingCaseLayerNorm))]
+    [ClassData(typeof(TilingCaseLayerNorm))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
         using (var _ = new Diagnostics.DumpScope(main.Name, CompileOptions.DumpFlags))
         {
+
+#if DEBUG
+            for (var i = 0; i < inputs.Length - 1; i++)
+            {
+                using (var fs = Diagnostics.DumpScope.Current.OpenFile($"input_{i}.bin"))
+                {
+                    fs.Write(inputs[i].BytesBuffer);
+                }
+            }
+
+            using (var fs = Diagnostics.DumpScope.Current.OpenFile($"output_0.bin"))
+            {
+                fs.Write(inputs[^1].BytesBuffer);
+            }
+#endif
+
             await Compile(module);
             var output = Testing.RunKModel(File.ReadAllBytes(Path.Join(Diagnostics.DumpScope.Current.Directory, "test.kmodel")), Diagnostics.DumpScope.Current.Directory, inputs);
             var cos = Tests.Comparator.CosSimilarity(output, Value.FromTensor(inputs[^1]))[0];

From 0db199a2dc82b811a296511354745499bd6c4f9b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 18 Sep 2023 15:57:45 +0800
Subject: [PATCH 185/308] add codegen of cpu gather

---
 .../CodeGen/CSourceConvertVisitor.cs          |  3 ++
 .../Evaluator/XPU/Gather.cs                   | 12 +++++++
 .../Evaluator/XPU/XPUModule.cs                |  2 ++
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  5 +++
 modules/Nncase.Modules.CPU/IR/XPU/Gather.cs   | 15 +++++++++
 .../Passes/Tile/SingleCPUFusionConverter.cs   |  8 +++++
 .../Targets/UnitTestCPUTargetTiling.cs        | 32 +++++++++++++++++++
 7 files changed, 77 insertions(+)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Gather.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Gather.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index ad4625738e..3e2d4683ee 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -301,6 +301,9 @@ protected override CSymbol VisitCall(Call expr)
                         IndentScope.Writer.IndWrite("}\n");
                     }
 
+                    break;
+                case IR.XPU.Gather gather:
+                    IndentScope.Writer.Write($"gather({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {gather.Axis})");
                     break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Gather.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Gather.cs
new file mode 100644
index 0000000000..7d97d51ff6
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Gather.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class GatherEvaluator : ITypeInferencer<Gather>
+{
+    public IRType Visit(ITypeInferenceContext context, Gather target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 0d12ee17bb..43063615a8 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -3,6 +3,7 @@
 
 using DryIoc;
 using Nncase.Evaluator.NN;
+using Nncase.Evaluator.Tensors;
 using Nncase.Hosting;
 
 namespace Nncase.Evaluator.XPU;
@@ -20,5 +21,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<BinaryEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<MatmulEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<LayerNormEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<GatherEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 7df63582bb..21df8a26a1 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -41,4 +41,9 @@ public static Call LayerNorm(int axis, float eps, bool useMean, Expr input, Expr
     {
         return new Call(new LayerNorm(axis, eps, useMean, distributedType), input, scale, bias, output);
     }
+
+    public static Call Gather(int axis, Expr input, Expr indices, Expr output)
+    {
+        return new Call(new IR.XPU.Gather(axis), input, indices, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Gather.cs b/modules/Nncase.Modules.CPU/IR/XPU/Gather.cs
new file mode 100644
index 0000000000..6b5902ca76
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Gather.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Gather : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(Gather), 0, "input");
+
+    public static readonly ParameterInfo Indices = new(typeof(Gather), 1, "indices");
+
+    public static readonly ParameterInfo Output = new(typeof(Gather), 2, "output");
+
+    public int Axis { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 89647dcbd2..ea311bdfd7 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -265,6 +265,9 @@ protected override Unit VisitLeafCall(Call expr)
                         case LayerNorm layernorm:
                             GenerateLayerNorm(layernorm, arguments, ret, (DistributedType)expr.Arguments[0].CheckedType);
                             break;
+                        case Gather gather:
+                            GenerateGather(gather, arguments, ret);
+                            break;
                         default:
                             throw new NotSupportedException();
                     }
@@ -322,6 +325,11 @@ private void GenerateLayerNorm(LayerNorm layerNorm, Buffer[] arguments, Buffer r
             _mainBody.Add(IR.F.XPU.LayerNorm(layerNorm.Axis, layerNorm.Epsilon, layerNorm.UseMean, arguments[0], arguments[1], arguments[2], ret, distributedType));
         }
 
+        private void GenerateGather(Gather gahter, Buffer[] arguments, Buffer ret)
+        {
+            _mainBody.Add(IR.F.XPU.Gather(gahter.Axis, arguments[0], arguments[1], ret));
+        }
+
 #if false
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index f7077ab929..45bb21d22b 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -41,6 +41,7 @@ public UnitTestCPUTargetTiling()
     [ClassData(typeof(TilingCaseMatmul))]
     [ClassData(typeof(TilingCaseMatmulUnary))]
     [ClassData(typeof(TilingCaseLayerNorm))]
+    [ClassData(typeof(TilingCaseGather))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -281,3 +282,34 @@ public TilingCaseLayerNorm()
         Add(main, new[] { input_tensor, output });
     }
 }
+
+internal sealed class TilingCaseGather : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseGather()
+    {
+        var inputShape = new[] { 32000, 8192 };
+        var axisShape = new[] { 1, 384 };
+        int axis = 0;
+        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+        var indices = IR.F.Random.Uniform(DataTypes.Int64, 384, 0, 2, axisShape).Evaluate().AsTensor();
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Gather(axis)), fin, indices);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("gather", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}

From 6144034b45862a7034569d7a23051eb468b5d538 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 18 Sep 2023 17:16:41 +0800
Subject: [PATCH 186/308] add concat/slice codegen

---
 .../CodeGen/CSourceConvertVisitor.cs          | 38 ++++++++++-
 .../CodeGen/CSourceExtensions.cs              |  5 +-
 .../Evaluator/XPU/Concat.cs                   | 15 +++++
 .../Nncase.Modules.CPU/Evaluator/XPU/Slice.cs | 15 +++++
 .../Evaluator/XPU/XPUModule.cs                |  2 +
 modules/Nncase.Modules.CPU/IR/XPU/Concat.cs   |  9 +++
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  7 ++
 modules/Nncase.Modules.CPU/IR/XPU/Slice.cs    | 17 +++++
 .../Passes/Tile/SingleCPUFusionConverter.cs   | 40 ++++++++---
 src/Nncase.Core/DistributedType.cs            |  4 +-
 src/Nncase.Core/DistributedUtility.cs         | 11 ++-
 .../Diagnostics/ILPrintVisitor.cs             |  6 +-
 src/Nncase.Evaluator/Math/Binary.cs           |  2 +-
 src/Nncase.Evaluator/Math/MatMul.cs           |  4 +-
 src/Nncase.Evaluator/Math/Unary.cs            |  4 +-
 src/Nncase.Evaluator/NN/LayerNorm.cs          |  6 +-
 src/Nncase.Evaluator/Tensors/Boxing.cs        |  4 +-
 src/Nncase.Evaluator/Tensors/Concat.cs        |  2 +-
 src/Nncase.Evaluator/Tensors/Gather.cs        |  2 +-
 src/Nncase.Evaluator/Tensors/Slice.cs         |  2 +-
 src/Nncase.Evaluator/Tensors/UnSqueeze.cs     |  6 +-
 .../Targets/UnitTestCPUTargetTiling.cs        | 67 ++++++++++++++++++-
 22 files changed, 228 insertions(+), 40 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Concat.cs
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Slice.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Concat.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Slice.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 3e2d4683ee..36c73b285f 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -11,7 +11,6 @@
 using System.Reactive;
 using System.Runtime.InteropServices;
 using System.Text;
-using DryIoc.ImTools;
 using NetFabric.Hyperlinq;
 using Nncase.IR;
 using Nncase.Runtime;
@@ -263,7 +262,7 @@ protected override CSymbol VisitCall(Call expr)
                         IndentScope.Writer.IndWrite($"{{\n");
 
                         var dividedType = DistributedUtility.GetDividedTensorType(layernorm.DistType);
-                        var sbpOnAxis = layernorm.DistType.NdSbp.Where(sbp => sbp is SBPSplit s && s.Axis >= layernorm.Axis).ToArray();
+                        var sbpOnAxis = layernorm.DistType.NdSBP.Where(sbp => sbp is SBPSplit s && s.Axis >= layernorm.Axis).ToArray();
                         switch (sbpOnAxis.Length)
                         {
                             case 0:
@@ -276,7 +275,7 @@ protected override CSymbol VisitCall(Call expr)
                                 IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
                                 IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
                                 IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
-                                if (sbpOnAxis[0] == layernorm.DistType.NdSbp[1])
+                                if (sbpOnAxis[0] == layernorm.DistType.NdSBP[1])
                                 {
                                     IndentScope.Writer.IndWrite($"tdma_reduce_async(sum, sum, reduce_op_t::sum, ctx);\n");
                                     IndentScope.Writer.IndWrite($"tdma_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, ctx);\n");
@@ -305,6 +304,39 @@ protected override CSymbol VisitCall(Call expr)
                 case IR.XPU.Gather gather:
                     IndentScope.Writer.Write($"gather({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {gather.Axis})");
                     break;
+                case IR.XPU.Concat concat:
+                    IndentScope.Writer.Write($"concat({{{string.Join(",", args.SkipLast(1).Select(Visit).Select(s => s.Name))}}}, {Visit(args[^1]).Name}, {concat.Axis})");
+                    break;
+                case IR.XPU.Slice slice:
+                    var begins = ((TensorConst)expr.Arguments[2]).Value.ToArray<int>();
+                    var ends = ((TensorConst)expr.Arguments[3]).Value.ToArray<int>();
+                    var axes = ((TensorConst)expr.Arguments[4]).Value.ToArray<int>().ToList();
+                    var retType = (TensorType)expr.Arguments[1].CheckedType;
+
+                    var newbegins = Enumerable.Repeat(0, retType.Shape.Rank).ToArray();
+                    var newends = retType.Shape.ToArray();
+                    for (int i = 0; i < slice.DistributedType.Placement.Rank; i++)
+                    {
+                        var sbp = slice.DistributedType.NdSBP[i];
+                        if (sbp is SBPSplit { Axis: int axis })
+                        {
+                            if (axes.IndexOf(axis) is int j && j != -1)
+                            {
+                                begins[j] /= slice.DistributedType.Placement.Hierarchy[i];
+                            }
+                        }
+                    }
+
+                    for (int i = 0; i < newbegins.Length; i++)
+                    {
+                        if (axes.IndexOf(i) is int j && j != -1)
+                        {
+                            newbegins[i] += begins[j];
+                        }
+                    }
+
+                    IndentScope.Writer.Write($"__tensor_copy_sync({Visit(expr.Arguments[1]).Name}, {Visit(expr.Arguments[0]).Name}({{{string.Join(',', newbegins.Select(e => e.ToString()))}}},{{{string.Join(',', newends.Select(e => e.ToString()))}}}))");
+                    break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
             }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index 01f0744962..e58a9dd474 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -44,9 +44,8 @@ public static string ToC(this PrimType primType) =>
         _ => throw new NotSupportedException(location.ToString()),
     };
 
-    public static string ToSlicing(this TensorType tensorType, IRArray<SBP> ndsbp, Placement placement)
+    public static string ToSlicing(this TensorType tensorType, string[] begins, IRArray<SBP> ndsbp, Placement placement)
     {
-        var begins = Enumerable.Repeat("0", tensorType.Shape.Rank).ToArray();
         var hstrides = TensorUtilities.GetStrides(placement.Hierarchy.ToArray());
         foreach (var (sbp, i) in ndsbp.Select((s, i) => (s, i)))
         {
@@ -59,6 +58,8 @@ public static string ToSlicing(this TensorType tensorType, IRArray<SBP> ndsbp, P
         return $"({{{string.Join(',', begins)}}}, {{{string.Join(",", tensorType.Shape)}}})";
     }
 
+    public static string ToSlicing(this TensorType tensorType, IRArray<SBP> ndsbp, Placement placement) => ToSlicing(tensorType, Enumerable.Repeat("0", tensorType.Shape.Rank).ToArray(), ndsbp, placement);
+
     public static string ToC(this BinaryOp binaryOp) => binaryOp switch
     {
         BinaryOp.Add => "+",
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Concat.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Concat.cs
new file mode 100644
index 0000000000..1e4f661a81
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Concat.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class ConcatEvaluator : ITypeInferencer<Concat>
+{
+    public IRType Visit(ITypeInferenceContext context, Concat target)
+    {
+        return TupleType.Void;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Slice.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Slice.cs
new file mode 100644
index 0000000000..33e83d591c
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Slice.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class SliceEvaluator : ITypeInferencer<Slice>
+{
+    public IRType Visit(ITypeInferenceContext context, Slice target)
+    {
+        return TupleType.Void;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 43063615a8..941789d034 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -22,5 +22,7 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<MatmulEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<LayerNormEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<GatherEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<ConcatEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<SliceEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Concat.cs b/modules/Nncase.Modules.CPU/IR/XPU/Concat.cs
new file mode 100644
index 0000000000..6270fb618d
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Concat.cs
@@ -0,0 +1,9 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Concat : XPUKernelOp
+{
+    public int Axis { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 21df8a26a1..ec91a9315e 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -46,4 +46,11 @@ public static Call Gather(int axis, Expr input, Expr indices, Expr output)
     {
         return new Call(new IR.XPU.Gather(axis), input, indices, output);
     }
+
+    public static Call Concat(int axis, Expr[] inputs, Expr output)
+    {
+        return new Call(new Concat(axis), inputs.Concat(new[] { output }).ToArray());
+    }
+
+    internal static Expr Slice(TIR.Buffer input, TIR.Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType) => new Call(new Slice(distributedType), input, output, begins, ends, axes);
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Slice.cs b/modules/Nncase.Modules.CPU/IR/XPU/Slice.cs
new file mode 100644
index 0000000000..b7fd780500
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Slice.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Slice : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(Slice), 0, "input");
+
+    public static readonly ParameterInfo Begins = new(typeof(Slice), 1, "begins");
+
+    public static readonly ParameterInfo Ends = new(typeof(Slice), 2, "ends");
+
+    public static readonly ParameterInfo Axes = new(typeof(Slice), 3, "axes");
+
+    public DistributedType DistributedType { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index ea311bdfd7..ef6e1cc284 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -135,12 +135,7 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
             }
 
             var equivalArgs = op.Parameters.
-                Select(param => (param.ParameterKind, expr.Arguments[param.Index]) switch
-                {
-                    (ParameterKind.Input, Expr e) when e is Const or Var => DistributedUtility.GetLeafCandidateBoxings(e, Placement),
-                    (ParameterKind.Attribute, Expr e) when e is Const or Var => new[] { e },
-                    (_, Expr arg) => ExprMemo[arg],
-                }).ToArray();
+                Select(param => GetLeafArgCandidates(param.ParameterKind, expr.Arguments[param.Index])).ToArray();
             var equivalCalls = equivalArgs.
                 CartesianProduct().
                 Select(args => args.ToArray()).
@@ -187,6 +182,14 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
             return equivalCalls.Where(t => t.Valid).Select(t => t.Call).ToArray();
         }
 
+        private IReadOnlyList<Expr> GetLeafArgCandidates(ParameterKind parameterKind, Expr expr) => (parameterKind, expr) switch
+        {
+            (ParameterKind.Input, Expr e) when e is Const or Var => DistributedUtility.GetLeafCandidateBoxings(e, Placement),
+            (ParameterKind.Input, Expr e) when e is IR.Tuple tp => tp.Fields.ToArray().Select(f => GetLeafArgCandidates(parameterKind, f)).CartesianProduct().Select(e => new IR.Tuple(e.ToArray())).ToArray(),
+            (ParameterKind.Attribute, Expr e) when e is Const or Var => new[] { e },
+            (_, Expr arg) => ExprMemo[arg],
+        };
+
         private IEnumerable<(bool Valid, Call Call)> BuildEqualityCalls(Op target, Expr[] args)
         {
             if (!target.Parameters.Where(p => p.ParameterKind == ParameterKind.Input).All(p => IsDistributed(args[p.Index].CheckedType)))
@@ -202,7 +205,7 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
             {
                 var broadcastArgs = args.Select(DistributedUtility.GetPartialCandidateBoxings).ToArray();
 
-                if (broadcastArgs.All(bargs => bargs.Count >= 0))
+                if (!broadcastArgs.All(bargs => bargs.Count == 0))
                 {
                     calls.AddRange(broadcastArgs.Select((bargs, i) => bargs.Any() ? bargs : bargs.Concat(new[] { args[i] })).
                         CartesianProduct().
@@ -267,6 +270,11 @@ protected override Unit VisitLeafCall(Call expr)
                             break;
                         case Gather gather:
                             GenerateGather(gather, arguments, ret);
+                        case Concat concat:
+                            GenerateConcat(concat, ((IR.Tuple)expr.Arguments[0]).Fields.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray(), ret);
+                            break;
+                        case Slice slice:
+                            GenerateSlice(slice, arguments[0], ret, expr.Arguments[1], expr.Arguments[2], expr.Arguments[3], (DistributedType)expr.CheckedType);
                             break;
                         default:
                             throw new NotSupportedException();
@@ -283,19 +291,29 @@ protected override Unit VisitLeafCall(Call expr)
             return default;
         }
 
+        private void GenerateConcat(Concat concat, Buffer[] inputs, Buffer ret)
+        {
+            _mainBody.Add(IR.F.XPU.Concat(concat.Axis, inputs, ret));
+        }
+
+        private void GenerateSlice(Slice slice, Buffer input, Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType)
+        {
+            _mainBody.Add(IR.F.XPU.Slice(input, output, begins, ends, axes, distributedType));
+        }
+
         private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call expr)
         {
             switch (expr.Arguments[0].CheckedType, boxing.NewType)
             {
                 case (TensorType tensorType, DistributedType distTensorType):
                     {
-                        _mainBody.Add(IR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSbp, distTensorType.Placement));
+                        _mainBody.Add(IR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSBP, distTensorType.Placement));
                     }
 
                     break;
                 case (DistributedType distTensorType, TensorType tensorType):
                     {
-                        _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSbp, distTensorType.Placement));
+                        _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSBP, distTensorType.Placement));
                     }
 
                     break;
@@ -418,6 +436,8 @@ private TIR.Buffer AllocOrGetBuffer(Expr expr)
                     case TensorConst c:
                         buffer = T.AttachBuffer(c, out _, name);
                         break;
+                    case IR.Tuple:
+                        return null!;
                     default:
                         throw new NotSupportedException();
                 }
@@ -446,7 +466,7 @@ private Tuple<TensorType, MemoryLocation> GetTypeAndLocation(IRType type)
             TensorType tensorType;
             if (type is DistributedType distTensor)
             {
-                if (!DistributedUtility.IsDistributable(distTensor.TensorType, distTensor.NdSbp.ToArray(), distTensor.Placement, out var tType))
+                if (!DistributedUtility.IsDistributable(distTensor.TensorType, distTensor.NdSBP.ToArray(), distTensor.Placement, out var tType))
                 {
                     throw new NotSupportedException();
                 }
diff --git a/src/Nncase.Core/DistributedType.cs b/src/Nncase.Core/DistributedType.cs
index 02c34ae934..56896ee266 100644
--- a/src/Nncase.Core/DistributedType.cs
+++ b/src/Nncase.Core/DistributedType.cs
@@ -77,7 +77,7 @@ public enum DeviceKind : uint
     public override string ToString() => $"@{Kind} [{string.Join(',', Hierarchy.Zip(Name).Select(t => t.First.ToString() + '@' + t.Second.ToString()))}]";
 }
 
-public sealed record DistributedType(TensorType TensorType, IRArray<SBP> NdSbp, Placement Placement) : IRType
+public sealed record DistributedType(TensorType TensorType, IRArray<SBP> NdSBP, Placement Placement) : IRType
 {
-    public override string ToString() => $"{TensorType}, ({string.Join(',', NdSbp)}), {Placement}";
+    public override string ToString() => $"{TensorType}, ({string.Join(',', NdSBP)}), {Placement}";
 }
diff --git a/src/Nncase.Core/DistributedUtility.cs b/src/Nncase.Core/DistributedUtility.cs
index e5e204be61..774bdc819a 100644
--- a/src/Nncase.Core/DistributedUtility.cs
+++ b/src/Nncase.Core/DistributedUtility.cs
@@ -48,7 +48,12 @@ public static IReadOnlyList<Expr> GetPartialCandidateBoxings(Expr expr)
     {
         if (expr is IR.Tuple tuple)
         {
-            throw new NotSupportedException("current not support!");
+            var candidates = tuple.Fields.ToArray().
+                Select(GetPartialCandidateBoxings).
+                CartesianProduct();
+            return candidates.Any() ? candidates.
+                Select(fs => new IR.Tuple(fs.ToArray())).
+                ToArray() : Array.Empty<Expr>();
         }
 
         var type = (DistributedType)expr.CheckedType;
@@ -57,7 +62,7 @@ public static IReadOnlyList<Expr> GetPartialCandidateBoxings(Expr expr)
         for (int i = 0; i < type.Placement.Rank; i++)
         {
             candidateNdsbps[i] = new List<SBP>();
-            if (type.NdSbp[i] is SBPPartialSum)
+            if (type.NdSBP[i] is SBPPartialSum)
             {
                 candidateNdsbps[i].Add(SBP.B);
                 for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
@@ -137,7 +142,7 @@ private static (IReadOnlyList<int> Tile, IReadOnlyList<int> Shape) GetDividedTil
     {
         var shape = distributedType.TensorType.Shape.ToValueArray();
         var tiles = distributedType.TensorType.Shape.ToValueArray();
-        foreach (var (s, i) in distributedType.NdSbp.OfType<SBPSplit>().Select((s, i) => (s, i)))
+        foreach (var (s, i) in distributedType.NdSBP.OfType<SBPSplit>().Select((s, i) => (s, i)))
         {
             tiles[s.Axis] /= distributedType.Placement.Hierarchy[i];
         }
diff --git a/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs b/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
index 3f65d387b8..9393ae8a5d 100644
--- a/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
@@ -278,7 +278,7 @@ public override string VisitType(TupleType type) =>
     public override string VisitType(DistributedType type)
     {
         var shape = type.TensorType.Shape.ToArray();
-        foreach (var (s, r) in type.NdSbp.Select((s, r) => (s, r)))
+        foreach (var (s, r) in type.NdSBP.Select((s, r) => (s, r)))
         {
             if (s is SBPSplit split)
             {
@@ -290,7 +290,7 @@ public override string VisitType(DistributedType type)
         }
 
         var sshape = shape.Select(s => s.ToString()).ToArray();
-        foreach (var (s, r) in type.NdSbp.Select((s, r) => (s, r)))
+        foreach (var (s, r) in type.NdSBP.Select((s, r) => (s, r)))
         {
             if (s is SBPSplit split)
             {
@@ -298,7 +298,7 @@ public override string VisitType(DistributedType type)
             }
         }
 
-        return $"{{{VisitType(type.TensorType)}, ({string.Join(',', type.NdSbp)}), [{string.Join(',', sshape)}]}}";
+        return $"{{{VisitType(type.TensorType)}, ({string.Join(',', type.NdSBP)}), [{string.Join(',', sshape)}]}}";
     }
 
     /// <inheritdoc/>
diff --git a/src/Nncase.Evaluator/Math/Binary.cs b/src/Nncase.Evaluator/Math/Binary.cs
index 61d3fd06dc..5e64c638b9 100755
--- a/src/Nncase.Evaluator/Math/Binary.cs
+++ b/src/Nncase.Evaluator/Math/Binary.cs
@@ -138,7 +138,7 @@ private IRType Visit(Binary target, DistributedType a, DistributedType b)
         var ndsbp = new SBP[a.Placement.Rank];
         for (int i = 0; i < a.Placement.Rank; i++)
         {
-            switch (a.NdSbp[i], b.NdSbp[i])
+            switch (a.NdSBP[i], b.NdSBP[i])
             {
                 case (SBPSplit sa, SBPSplit sb):
                     if (sa != sb)
diff --git a/src/Nncase.Evaluator/Math/MatMul.cs b/src/Nncase.Evaluator/Math/MatMul.cs
index 8ee68b4263..23c9aaff22 100644
--- a/src/Nncase.Evaluator/Math/MatMul.cs
+++ b/src/Nncase.Evaluator/Math/MatMul.cs
@@ -37,8 +37,8 @@ public static IRType VisitDistributedType(DistributedType a, DistributedType b)
         var ndsbp = new SBP[a.Placement.Rank];
         for (int i = 0; i < a.Placement.Rank; i++)
         {
-            var invalid = new InvalidType($"({a.NdSbp[i]}, {b.NdSbp[i]}) not support");
-            switch (a.NdSbp[i], b.NdSbp[i])
+            var invalid = new InvalidType($"({a.NdSBP[i]}, {b.NdSBP[i]}) not support");
+            switch (a.NdSBP[i], b.NdSBP[i])
             {
                 // split on k
                 case (SBPSplit { Axis: int ax }, SBPSplit { Axis: int bx }):
diff --git a/src/Nncase.Evaluator/Math/Unary.cs b/src/Nncase.Evaluator/Math/Unary.cs
index d3d5cc5c36..5111e4a3b3 100644
--- a/src/Nncase.Evaluator/Math/Unary.cs
+++ b/src/Nncase.Evaluator/Math/Unary.cs
@@ -128,12 +128,12 @@ private IRType Visit(DistributedType inType, UnaryOp unaryOp)
         var ndsbp = new SBP[inType.Placement.Rank];
         for (int i = 0; i < inType.Placement.Rank; i++)
         {
-            if (inType.NdSbp[i] is SBPPartialSum && unaryOp != UnaryOp.Neg)
+            if (inType.NdSBP[i] is SBPPartialSum && unaryOp != UnaryOp.Neg)
             {
                 return invalid;
             }
 
-            ndsbp[i] = inType.NdSbp[i];
+            ndsbp[i] = inType.NdSBP[i];
         }
 
         return new DistributedType(inType.TensorType, ndsbp, inType.Placement);
diff --git a/src/Nncase.Evaluator/NN/LayerNorm.cs b/src/Nncase.Evaluator/NN/LayerNorm.cs
index be36263787..7152fbaa57 100644
--- a/src/Nncase.Evaluator/NN/LayerNorm.cs
+++ b/src/Nncase.Evaluator/NN/LayerNorm.cs
@@ -60,7 +60,7 @@ public Cost Visit(ICostEvaluateContext context, LayerNorm target)
                 var scaleType = context.GetArgumentType<DistributedType>(target, LayerNorm.Scale);
                 var biasType = context.GetArgumentType<DistributedType>(target, LayerNorm.Bias);
                 var ring = GetRingReduceCommunicate(scaleType, new[] { 0, 1 }) + GetRingReduceCommunicate(biasType, new[] { 0, 1 });
-                var reCompute = inputDistributedType.NdSbp.Select((sbp, i) => sbp is SBPSplit ? 1 : inputDistributedType.Placement.Hierarchy[i]).ToArray().Aggregate(1, (acc, rep) => acc * rep);
+                var reCompute = inputDistributedType.NdSBP.Select((sbp, i) => sbp is SBPSplit ? 1 : inputDistributedType.Placement.Hierarchy[i]).ToArray().Aggregate(1, (acc, rep) => acc * rep);
                 return new()
                 {
                     [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType) + ring,
@@ -109,7 +109,7 @@ private IRType Visit(DistributedType input, DistributedType scale, DistributedTy
 
         for (int i = 0; i < input.Placement.Rank; i++)
         {
-            switch (input.NdSbp[i], scale.NdSbp[i], bias.NdSbp[i])
+            switch (input.NdSBP[i], scale.NdSBP[i], bias.NdSBP[i])
             {
                 case (SBPSplit { Axis: int ix }, SBPSplit { Axis: int sx }, SBPSplit { Axis: int bx }) when ix >= raxis && sx == (ix - raxis) && bx == sx:
                     ndsbp[i] = SBP.S(ix);
@@ -131,7 +131,7 @@ private IRType Visit(DistributedType input, DistributedType scale, DistributedTy
     private UInt128 GetRingReduceCommunicate(DistributedType distributedType, int[] axes)
     {
         var ttype = DistributedUtility.GetDividedTensorType(distributedType);
-        var splits = axes.Where(i => distributedType.NdSbp[i] is SBPSplit);
+        var splits = axes.Where(i => distributedType.NdSBP[i] is SBPSplit);
         if (!splits.Any())
         {
             return 0;
diff --git a/src/Nncase.Evaluator/Tensors/Boxing.cs b/src/Nncase.Evaluator/Tensors/Boxing.cs
index e8b7453d02..a36db02da7 100644
--- a/src/Nncase.Evaluator/Tensors/Boxing.cs
+++ b/src/Nncase.Evaluator/Tensors/Boxing.cs
@@ -41,7 +41,7 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
                 };
                 break;
 
-            case (DistributedType a, DistributedType b) when a.Placement == b.Placement && a.NdSbp != b.NdSbp:
+            case (DistributedType a, DistributedType b) when a.Placement == b.Placement && a.NdSBP != b.NdSBP:
                 {
                     var fullLoadStore = new Cost()
                     {
@@ -53,7 +53,7 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
                     float gatherPart = 1;
                     for (int i = 0; i < a.Placement.Rank; i++)
                     {
-                        switch (a.NdSbp[i], b.NdSbp[i])
+                        switch (a.NdSBP[i], b.NdSBP[i])
                         {
                             case (SBPSplit { Axis: int ax }, SBP sbpout):
                                 switch (sbpout)
diff --git a/src/Nncase.Evaluator/Tensors/Concat.cs b/src/Nncase.Evaluator/Tensors/Concat.cs
index b382899ca4..1c87c1b1f8 100644
--- a/src/Nncase.Evaluator/Tensors/Concat.cs
+++ b/src/Nncase.Evaluator/Tensors/Concat.cs
@@ -191,7 +191,7 @@ private IRType Visit(TupleType inputs, int axis)
 
         for (int i = 0; i < distributedType.Placement.Rank; i++)
         {
-            var sbps = inputs.OfType<DistributedType>().Select(d => d.NdSbp[i]).ToArray();
+            var sbps = inputs.OfType<DistributedType>().Select(d => d.NdSBP[i]).ToArray();
             if (sbps.Any(sbp => sbp is SBPSplit { Axis: int x } && x == axis))
             {
                 return new InvalidType("not support distribute on concat axis");
diff --git a/src/Nncase.Evaluator/Tensors/Gather.cs b/src/Nncase.Evaluator/Tensors/Gather.cs
index aa9e5bec65..fbfff9049f 100644
--- a/src/Nncase.Evaluator/Tensors/Gather.cs
+++ b/src/Nncase.Evaluator/Tensors/Gather.cs
@@ -106,7 +106,7 @@ private IRType Visit(DistributedType input, int axis, DistributedType index)
 
         for (int i = 0; i < input.Placement.Rank; i++)
         {
-            switch (input.NdSbp[i], index.NdSbp[i])
+            switch (input.NdSBP[i], index.NdSBP[i])
             {
                 case (SBPSplit { Axis: int ix }, _) when ix == axis:
                     return new InvalidType($"the input can't split on {axis}");
diff --git a/src/Nncase.Evaluator/Tensors/Slice.cs b/src/Nncase.Evaluator/Tensors/Slice.cs
index 5cc2c2b310..2c7655d8e6 100644
--- a/src/Nncase.Evaluator/Tensors/Slice.cs
+++ b/src/Nncase.Evaluator/Tensors/Slice.cs
@@ -240,6 +240,6 @@ private IRType Visit(ITypeInferenceContext context, Slice target, DistributedTyp
             return new InvalidType("not support input tensor type infer");
         }
 
-        return new DistributedType(tensorType, input.NdSbp, input.Placement);
+        return new DistributedType(tensorType, input.NdSBP, input.Placement);
     }
 }
diff --git a/src/Nncase.Evaluator/Tensors/UnSqueeze.cs b/src/Nncase.Evaluator/Tensors/UnSqueeze.cs
index 0370d54ae5..e2472bb99f 100644
--- a/src/Nncase.Evaluator/Tensors/UnSqueeze.cs
+++ b/src/Nncase.Evaluator/Tensors/UnSqueeze.cs
@@ -115,14 +115,14 @@ private IRType Visit(ITypeInferenceContext context, Unsqueeze target, Distribute
     {
         var tensorType = (TensorType)Visit(context, target, input.TensorType);
 
-        var ndsbp = new SBP[input.NdSbp.Count];
+        var ndsbp = new SBP[input.NdSBP.Count];
 
         if (context.GetArgument(target, Unsqueeze.Dim) is TensorConst tdims)
         {
             var dimsValue = tdims.Value.Cast<int>();
-            for (int i = 0; i < input.NdSbp.Count; i++)
+            for (int i = 0; i < input.NdSBP.Count; i++)
             {
-                ndsbp[i] = input.NdSbp[i] switch
+                ndsbp[i] = input.NdSBP[i] switch
                 {
                     SBPSplit { Axis: int axis } => SBP.S(axis + dimsValue.Select(i => i <= axis).Count(b => b)),
                     SBP sbp => sbp,
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 45bb21d22b..6744836e7d 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -45,7 +45,7 @@ public UnitTestCPUTargetTiling()
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
-        using (var _ = new Diagnostics.DumpScope(main.Name, CompileOptions.DumpFlags))
+        using (new Diagnostics.DumpScope(main.Name, CompileOptions.DumpFlags))
         {
 
 #if DEBUG
@@ -82,6 +82,71 @@ private async Task Compile(IRModule module)
     }
 }
 
+internal sealed class TilingCaseSlice : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseSlice()
+    {
+        var in_a = new Var("in_a", new TensorType(DataTypes.Float32, new[] { 1, 1, 1, 128 }));
+
+        Fusion fusion;
+        {
+            var fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, new[] { 1, 1, 1, 128 }));
+            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Slice()), fin_a, new[] { 64 }, new[] { 128 }, new[] { 3 }, new[] { 1 });
+            fusion = new Fusion("cpu", v1, fin_a);
+        }
+
+        var main = new Function("slice", new Call(fusion, in_a), new[] { in_a });
+        Add(main, Array.Empty<Tensor>());
+    }
+}
+
+internal sealed class TilingCaseConcat : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseConcat()
+    {
+        var in_a = new Var("in_a", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 64 }));
+        var in_b = new Var("in_b", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 64 }));
+
+        Fusion fusion;
+        {
+            var fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 64 }));
+            var fin_b = new Var("fin_b", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 64 }));
+            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Concat(3)), new IR.Tuple(fin_a, fin_b));
+            fusion = new Fusion("cpu", v1, fin_a, fin_b);
+        }
+
+        var main = new Function("concat", new Call(fusion, in_a, in_b), new[] { in_a, in_b });
+        Add(main, Array.Empty<Tensor>());
+    }
+}
+
+internal sealed class TilingCaseMatmulLayerNorm : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseMatmulLayerNorm()
+    {
+        var hid_in = new Var("hidden_in", new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 }));
+
+        Fusion fusion;
+        {
+            var scale = IR.F.Tensors.ConstantOfShape(new[] { 8192 }, 1.0f).Evaluate().AsTensor();
+            var bias = IR.F.Tensors.ConstantOfShape(new[] { 8192 }, 0.0f).Evaluate().AsTensor();
+            var weights = IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 64, 8192, 128 }).Evaluate().AsTensor();
+            var gdata = IR.F.Random.Normal(DataTypes.Float32, new[] { 384, 128 }).Evaluate().AsTensor();
+
+            var fin = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 }));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.LayerNorm(2, 1e-6f, false)), fin, scale, bias);
+            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Unsqueeze()), v0, new[] { 0 });
+            var v2 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), v1, weights);
+            var v3 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Unary(UnaryOp.Exp)), v2);
+
+            fusion = new Fusion("cpu", v3, fin);
+        }
+
+        var main = new Function("matmul_layernorm", new Call(fusion, hid_in), new[] { hid_in });
+        Add(main, new Tensor[] { });
+    }
+}
+
 internal sealed class TilingCaseMHA : TheoryData<Function>
 {
     public TilingCaseMHA()

From 8b6a17e4124ef70cfd850ffb9c0a07cc7c6b7f8e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 18 Sep 2023 17:20:11 +0800
Subject: [PATCH 187/308] merge

---
 .../CodeGen/CSourceConvertVisitor.cs          |  2 +-
 .../Passes/Tile/SingleCPUFusionConverter.cs   |  5 ++--
 src/Nncase.Core/IR/Tensors/Functional.cs      |  3 +-
 .../Core/UnitTestTensorUtilities.cs           | 30 ++++++++++++-------
 .../Targets/UnitTestCPUTargetTiling.cs        |  6 ++--
 5 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 36c73b285f..fab6cfff7f 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -335,7 +335,7 @@ protected override CSymbol VisitCall(Call expr)
                         }
                     }
 
-                    IndentScope.Writer.Write($"__tensor_copy_sync({Visit(expr.Arguments[1]).Name}, {Visit(expr.Arguments[0]).Name}({{{string.Join(',', newbegins.Select(e => e.ToString()))}}},{{{string.Join(',', newends.Select(e => e.ToString()))}}}))");
+                    IndentScope.Writer.Write($"__tensor_copy_sync(std::move({Visit(expr.Arguments[1]).Name}), {Visit(expr.Arguments[0]).Name}({{{string.Join(',', newbegins.Select(e => e.ToString()))}}},{{{string.Join(',', newends.Select(e => e.ToString()))}}}))");
                     break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index ef6e1cc284..7d103fa0b1 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -270,6 +270,7 @@ protected override Unit VisitLeafCall(Call expr)
                             break;
                         case Gather gather:
                             GenerateGather(gather, arguments, ret);
+                            break;
                         case Concat concat:
                             GenerateConcat(concat, ((IR.Tuple)expr.Arguments[0]).Fields.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray(), ret);
                             break;
@@ -305,13 +306,13 @@ private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call
         {
             switch (expr.Arguments[0].CheckedType, boxing.NewType)
             {
-                case (TensorType tensorType, DistributedType distTensorType):
+                case (TensorType, DistributedType distTensorType):
                     {
                         _mainBody.Add(IR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSBP, distTensorType.Placement));
                     }
 
                     break;
-                case (DistributedType distTensorType, TensorType tensorType):
+                case (DistributedType distTensorType, TensorType):
                     {
                         _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSBP, distTensorType.Placement));
                     }
diff --git a/src/Nncase.Core/IR/Tensors/Functional.cs b/src/Nncase.Core/IR/Tensors/Functional.cs
index ab3924488a..74973ca9ea 100644
--- a/src/Nncase.Core/IR/Tensors/Functional.cs
+++ b/src/Nncase.Core/IR/Tensors/Functional.cs
@@ -70,7 +70,8 @@ public static Call Bitcast(PrimType type, Expr input, PrimType newType, Expr sha
     public static Call Cast(Expr input, DataType newType, CastMode castMode = CastMode.KDefault) =>
         new Call(new Cast(newType, castMode), input);
 
-    public static Call Boxing(Expr input, IRType type) {
+    public static Call Boxing(Expr input, IRType type)
+    {
         if (input.CheckedType == type)
         {
             throw new NotSupportedException();
diff --git a/src/Nncase.Tests/Core/UnitTestTensorUtilities.cs b/src/Nncase.Tests/Core/UnitTestTensorUtilities.cs
index 649e23127f..7e8a70c2bb 100644
--- a/src/Nncase.Tests/Core/UnitTestTensorUtilities.cs
+++ b/src/Nncase.Tests/Core/UnitTestTensorUtilities.cs
@@ -57,54 +57,64 @@ public void TestIsContiguousSlice()
         int start;
         Assert.True(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..512, 0..14, 0..14 }, out start));
+          new[] { 0..1, 0..512, 0..14, 0..14 },
+          out start));
         Assert.Equal(0, start);
 
         Assert.True(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..1, 0..1, 0..14 }, out start));
+          new[] { 0..1, 0..1, 0..1, 0..14 },
+          out start));
         Assert.Equal(0, start);
 
         Assert.True(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..1, 0..1, 7..14 }, out start));
+          new[] { 0..1, 0..1, 0..1, 7..14 },
+          out start));
         Assert.Equal(0, start);
 
         Assert.True(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..1, 7..14, 0..14 }, out start));
+          new[] { 0..1, 0..1, 7..14, 0..14 },
+          out start));
         Assert.Equal(0, start);
 
         Assert.False(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..512, 0..7, 0..14 }, out start));
+          new[] { 0..1, 0..512, 0..7, 0..14 },
+          out start));
         Assert.Equal(2, start);
 
         Assert.False(TensorUtilities.IsContiguousSlice(
             dim1,
-            new[] { 0..1, 0..512, 0..7, 0..14, 0..1 }, out start));
+            new[] { 0..1, 0..512, 0..7, 0..14, 0..1 },
+            out start));
         Assert.Equal(4, start);
 
         Assert.False(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 10..512, 0..1, 0..1 }, out start));
+          new[] { 0..1, 10..512, 0..1, 0..1 },
+          out start));
         Assert.Equal(2, start);
 
         Assert.False(TensorUtilities.IsContiguousSlice(
           dim1,
-          new[] { 0..1, 0..512, 0..7, 0..1 }, out start));
+          new[] { 0..1, 0..512, 0..7, 0..1 },
+          out start));
         Assert.Equal(3, start);
 
         var dim2 = new[] { 1, 512, 1, 196 };
 
         Assert.True(TensorUtilities.IsContiguousSlice(
               dim2,
-              new[] { 0..1, 0..128, 0..1, 0..196 }, out start));
+              new[] { 0..1, 0..128, 0..1, 0..196 },
+              out start));
         Assert.Equal(0, start);
 
         Assert.True(TensorUtilities.IsContiguousSlice(
               dim2,
-              new[] { 0..1, 0..1, 0..1, 10..15 }, out start));
+              new[] { 0..1, 0..1, 0..1, 10..15 },
+              out start));
         Assert.Equal(0, start);
     }
 
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 6744836e7d..16e39ba0aa 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -47,7 +47,6 @@ public async Task TestCpuFunction(Function main, Tensor[] inputs)
         var module = new IR.IRModule(main);
         using (new Diagnostics.DumpScope(main.Name, CompileOptions.DumpFlags))
         {
-
 #if DEBUG
             for (var i = 0; i < inputs.Length - 1; i++)
             {
@@ -131,7 +130,7 @@ public TilingCaseMatmulLayerNorm()
             var scale = IR.F.Tensors.ConstantOfShape(new[] { 8192 }, 1.0f).Evaluate().AsTensor();
             var bias = IR.F.Tensors.ConstantOfShape(new[] { 8192 }, 0.0f).Evaluate().AsTensor();
             var weights = IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 64, 8192, 128 }).Evaluate().AsTensor();
-            var gdata = IR.F.Random.Normal(DataTypes.Float32, new[] { 384, 128 }).Evaluate().AsTensor();
+            _ = IR.F.Random.Normal(DataTypes.Float32, new[] { 384, 128 }).Evaluate().AsTensor();
 
             var fin = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 }));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.LayerNorm(2, 1e-6f, false)), fin, scale, bias);
@@ -143,7 +142,7 @@ public TilingCaseMatmulLayerNorm()
         }
 
         var main = new Function("matmul_layernorm", new Call(fusion, hid_in), new[] { hid_in });
-        Add(main, new Tensor[] { });
+        Add(main, Array.Empty<Tensor>());
     }
 }
 
@@ -330,6 +329,7 @@ public TilingCaseLayerNorm()
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.LayerNorm(axis, 1e-5f, false)), fin, scale, bias);
             fusion = new Fusion("cpu", v0, fin);
         }
+
         var main = new Function("layernorm", new Call(fusion, input), new[] { input });
 
         var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();

From 3eac14b787126b0a6c3243183a26f45d9efc525d Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 18 Sep 2023 17:26:29 +0800
Subject: [PATCH 188/308] add codegen of cpu softmax

---
 .../CodeGen/CSourceConvertVisitor.cs          |  3 ++
 .../Evaluator/XPU/Softmax.cs                  | 12 ++++++++
 .../Evaluator/XPU/XPUModule.cs                |  1 +
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  5 ++++
 modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs  | 13 ++++++++
 .../Passes/Tile/SingleCPUFusionConverter.cs   |  8 +++++
 src/Nncase.Core/IR/NN/SoftMax.cs              |  2 +-
 src/Nncase.Evaluator/NN/Softmax.cs            | 16 ++++++++--
 .../Targets/UnitTestCPUTargetTiling.cs        | 30 +++++++++++++++++++
 9 files changed, 86 insertions(+), 4 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Softmax.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index fab6cfff7f..0236d4be2a 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -337,6 +337,9 @@ protected override CSymbol VisitCall(Call expr)
 
                     IndentScope.Writer.Write($"__tensor_copy_sync(std::move({Visit(expr.Arguments[1]).Name}), {Visit(expr.Arguments[0]).Name}({{{string.Join(',', newbegins.Select(e => e.ToString()))}}},{{{string.Join(',', newends.Select(e => e.ToString()))}}}))");
                     break;
+                case IR.XPU.Softmax softmax:
+                    IndentScope.Writer.Write($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {softmax.Axis})");
+                    break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
             }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Softmax.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Softmax.cs
new file mode 100644
index 0000000000..409788a1d5
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Softmax.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class SoftmaxEvaluator : ITypeInferencer<Softmax>
+{
+    public IRType Visit(ITypeInferenceContext context, Softmax target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 941789d034..44f4616018 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -24,5 +24,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<GatherEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<ConcatEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<SliceEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<SoftmaxEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index ec91a9315e..a1451e0ed5 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -53,4 +53,9 @@ public static Call Concat(int axis, Expr[] inputs, Expr output)
     }
 
     internal static Expr Slice(TIR.Buffer input, TIR.Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType) => new Call(new Slice(distributedType), input, output, begins, ends, axes);
+
+    public static Call Softmax(int axis, Expr input, Expr output)
+    {
+        return new Call(new IR.XPU.Softmax(axis), input, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs b/modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs
new file mode 100644
index 0000000000..f96b87fbd0
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Softmax : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(Softmax), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(Softmax), 1, "output");
+
+    public int Axis { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 7d103fa0b1..5ea8df5a1c 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -277,6 +277,9 @@ protected override Unit VisitLeafCall(Call expr)
                         case Slice slice:
                             GenerateSlice(slice, arguments[0], ret, expr.Arguments[1], expr.Arguments[2], expr.Arguments[3], (DistributedType)expr.CheckedType);
                             break;
+                        case Softmax softmax:
+                            GenerateSoftmax(softmax, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), arguments, ret);
+                            break;
                         default:
                             throw new NotSupportedException();
                     }
@@ -349,6 +352,11 @@ private void GenerateGather(Gather gahter, Buffer[] arguments, Buffer ret)
             _mainBody.Add(IR.F.XPU.Gather(gahter.Axis, arguments[0], arguments[1], ret));
         }
 
+        private void GenerateSoftmax(Softmax softmax, int axis, Buffer[] arguments, Buffer ret)
+        {
+            _mainBody.Add(IR.F.XPU.Softmax(axis, arguments[0], ret));
+        }
+
 #if false
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
diff --git a/src/Nncase.Core/IR/NN/SoftMax.cs b/src/Nncase.Core/IR/NN/SoftMax.cs
index 686696f032..919f8ac76c 100644
--- a/src/Nncase.Core/IR/NN/SoftMax.cs
+++ b/src/Nncase.Core/IR/NN/SoftMax.cs
@@ -33,7 +33,7 @@ public sealed partial class Softmax : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Softmax), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Softmax), 0, "input", ParameterKind.Input);
 
     /// <summary>
     /// Gets axis.
diff --git a/src/Nncase.Evaluator/NN/Softmax.cs b/src/Nncase.Evaluator/NN/Softmax.cs
index ef5afafbe9..7b02112b8f 100644
--- a/src/Nncase.Evaluator/NN/Softmax.cs
+++ b/src/Nncase.Evaluator/NN/Softmax.cs
@@ -81,14 +81,19 @@ public IValue Visit(IEvaluateContext context, Softmax softMax)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Softmax target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Softmax.Input);
-        return Visit(input);
+        var input = context.CheckArgumentType<IRType>(target, Softmax.Input);
+        return input switch
+        {
+            TensorType t => Visit(t),
+            DistributedType d => Visit(d),
+            _ => new InvalidType(input.GetType().Name),
+        };
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Softmax target)
     {
-        var ret = context.GetReturnType<TensorType>();
+        var ret = context.GetReturnType<IRType>();
         return new()
         {
             [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(ret),
@@ -118,6 +123,11 @@ private IRType Visit(TensorType input)
     {
         return input;
     }
+
+    private IRType Visit(DistributedType input)
+    {
+        return input;
+    }
 }
 
 /// <summary>
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 16e39ba0aa..f9586cf055 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -42,6 +42,7 @@ public UnitTestCPUTargetTiling()
     [ClassData(typeof(TilingCaseMatmulUnary))]
     [ClassData(typeof(TilingCaseLayerNorm))]
     [ClassData(typeof(TilingCaseGather))]
+    [ClassData(typeof(TilingCaseSoftmax))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -378,3 +379,32 @@ public TilingCaseGather()
         Add(main, new[] { input_tensor, output });
     }
 }
+
+internal sealed class TilingCaseSoftmax : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseSoftmax()
+    {
+        var inputShape = new[] { 1, 64, 384, 384 };
+        int axis = 3;
+        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.Softmax()), fin, axis);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("softmax", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}

From 974d92392160867d2fd1637a682d23935babfe1b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 18 Sep 2023 19:03:40 +0800
Subject: [PATCH 189/308] update slice cpu case

---
 src/Nncase.Evaluator/Tensors/Slice.cs         | 11 +++++--
 .../Targets/UnitTestCPUTargetTiling.cs        | 30 ++++++++++++-------
 2 files changed, 29 insertions(+), 12 deletions(-)

diff --git a/src/Nncase.Evaluator/Tensors/Slice.cs b/src/Nncase.Evaluator/Tensors/Slice.cs
index 2c7655d8e6..71362c62c7 100644
--- a/src/Nncase.Evaluator/Tensors/Slice.cs
+++ b/src/Nncase.Evaluator/Tensors/Slice.cs
@@ -235,11 +235,18 @@ end is TensorConst ends_con &&
 
     private IRType Visit(ITypeInferenceContext context, Slice target, DistributedType input)
     {
-        if (Visit(context, target, input.TensorType) is not TensorType tensorType)
+        var outType = Visit(context, target, input.TensorType);
+        if (outType is not TensorType tensorType)
         {
             return new InvalidType("not support input tensor type infer");
         }
 
-        return new DistributedType(tensorType, input.NdSBP, input.Placement);
+        var axes = ((TensorConst)context.GetArgument(target, Slice.Axes)).Value.ToArray<int>();
+        if (input.NdSBP.Any(sbp => sbp is SBPSplit s && axes.Contains(s.Axis)))
+        {
+            return new InvalidType("not support input tensor type infer");
+        }
+
+        return new DistributedType((TensorType)outType, input.NdSBP, input.Placement);
     }
 }
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index f9586cf055..9fabedb1c6 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -36,13 +36,14 @@ public UnitTestCPUTargetTiling()
     [Theory]
 
     // [ClassData(typeof(TilingCaseMHA))]
-    [ClassData(typeof(TilingCaseBinaryMul))]
-    [ClassData(typeof(TilingCaseUnary))]
-    [ClassData(typeof(TilingCaseMatmul))]
-    [ClassData(typeof(TilingCaseMatmulUnary))]
-    [ClassData(typeof(TilingCaseLayerNorm))]
-    [ClassData(typeof(TilingCaseGather))]
-    [ClassData(typeof(TilingCaseSoftmax))]
+    // [ClassData(typeof(TilingCaseBinaryMul))]
+    // [ClassData(typeof(TilingCaseUnary))]
+    // [ClassData(typeof(TilingCaseMatmul))]
+    // [ClassData(typeof(TilingCaseMatmulUnary))]
+    // [ClassData(typeof(TilingCaseLayerNorm))]
+    // [ClassData(typeof(TilingCaseGather))]
+    // [ClassData(typeof(TilingCaseSoftmax))]
+    [ClassData(typeof(TilingCaseSlice))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -86,17 +87,26 @@ internal sealed class TilingCaseSlice : TheoryData<Function, Tensor[]>
 {
     public TilingCaseSlice()
     {
-        var in_a = new Var("in_a", new TensorType(DataTypes.Float32, new[] { 1, 1, 1, 128 }));
+        var shape = new[] { 1, 1, 64, 128 };
+        var in_a = new Var("in_a", new TensorType(DataTypes.Float32, shape));
 
         Fusion fusion;
+        Var fin_a;
         {
-            var fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, new[] { 1, 1, 1, 128 }));
+            fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, shape));
             var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Slice()), fin_a, new[] { 64 }, new[] { 128 }, new[] { 3 }, new[] { 1 });
             fusion = new Fusion("cpu", v1, fin_a);
         }
 
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin_a, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
         var main = new Function("slice", new Call(fusion, in_a), new[] { in_a });
-        Add(main, Array.Empty<Tensor>());
+        Add(main, new[] { input_tensor, output });
     }
 }
 

From db9a14a206f8a6006c9e3e6b83f61bcbb340a765 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 19 Sep 2023 11:19:22 +0800
Subject: [PATCH 190/308] fix slice

---
 modules/Nncase.Modules.CPU/IR/XPU/Functional.cs                 | 2 +-
 .../Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index a1451e0ed5..4cdbdb3aea 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -52,7 +52,7 @@ public static Call Concat(int axis, Expr[] inputs, Expr output)
         return new Call(new Concat(axis), inputs.Concat(new[] { output }).ToArray());
     }
 
-    internal static Expr Slice(TIR.Buffer input, TIR.Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType) => new Call(new Slice(distributedType), input, output, begins, ends, axes);
+    public static Expr Slice(TIR.Buffer input, TIR.Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType) => new Call(new Slice(distributedType), input, output, begins, ends, axes);
 
     public static Call Softmax(int axis, Expr input, Expr output)
     {
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 5ea8df5a1c..74aa5a8330 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -203,7 +203,7 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
             calls.Add((valid, call));
             if (!valid)
             {
-                var broadcastArgs = args.Select(DistributedUtility.GetPartialCandidateBoxings).ToArray();
+                var broadcastArgs = args.Zip(target.Parameters).Select(t => t.Second.ParameterKind == ParameterKind.Input ? DistributedUtility.GetPartialCandidateBoxings(t.First) : Array.Empty<Expr>()).ToArray();
 
                 if (!broadcastArgs.All(bargs => bargs.Count == 0))
                 {

From 67644ecc221967e0c74d186ad473e58cd0517762 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 19 Sep 2023 11:20:54 +0800
Subject: [PATCH 191/308] fix cpu concat

---
 .../CodeGen/CSourceConvertVisitor.cs          |  2 +-
 .../cpu/src/runtime/cmodel/include/concat.h   |  4 +--
 modules/cpu/src/runtime/cmodel/include/tdma.h | 14 +++++------
 .../Targets/UnitTestCPUTargetTiling.cs        | 25 ++++++++++++++-----
 4 files changed, 29 insertions(+), 16 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 0236d4be2a..caf9fdede0 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -305,7 +305,7 @@ protected override CSymbol VisitCall(Call expr)
                     IndentScope.Writer.Write($"gather({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {gather.Axis})");
                     break;
                 case IR.XPU.Concat concat:
-                    IndentScope.Writer.Write($"concat({{{string.Join(",", args.SkipLast(1).Select(Visit).Select(s => s.Name))}}}, {Visit(args[^1]).Name}, {concat.Axis})");
+                    IndentScope.Writer.Write($"concat({{{string.Join(",", args.SkipLast(1).Select(Visit).Select(s => "&" + s.Name))}}}, {Visit(args[^1]).Name}, {concat.Axis})");
                     break;
                 case IR.XPU.Slice slice:
                     var begins = ((TensorConst)expr.Arguments[2]).Value.ToArray<int>();
diff --git a/modules/cpu/src/runtime/cmodel/include/concat.h b/modules/cpu/src/runtime/cmodel/include/concat.h
index 3122c10341..2fe3f2e24c 100644
--- a/modules/cpu/src/runtime/cmodel/include/concat.h
+++ b/modules/cpu/src/runtime/cmodel/include/concat.h
@@ -34,9 +34,9 @@ find_input_id_and_index(size_t index,
 } // namespace
 
 template <class T>
-void concat(gsl::span<const gsl::byte *const> inputs, T *output,
+void concat(gsl::span<const gsl::byte *> inputs, T *output,
                  gsl::span<const size_t> out_shape,
-                 gsl::span<const strides_t> &in_strides,
+                 gsl::span<const strides_t> in_strides,
                  gsl::span<const size_t> out_strides, size_t axis,
                  gsl::span<const size_t> concat_dims) noexcept {
     return apply(out_shape, [&](gsl::span<const size_t> out_index) -> void {
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index b50ec37a04..c7c152162c 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -161,24 +161,24 @@ void reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
 }
 
 template <typename T, loc_t BLoc>
-void concat(std::initializer_list<tensor<T, loc_t::local>> inits,
+void concat(std::initializer_list<tensor<T, loc_t::local>*> inits,
             tensor<T, BLoc> &output, size_t axis) {
-    itlib::small_vector<const gsl::byte *const, 8> inputs(inits.size());
+    itlib::small_vector<const gsl::byte *, 8> inputs(inits.size());
     itlib::small_vector<strides_t> in_strides(inits.size());
     auto concat_dims = dims_t(inits.size(), 1);
     for (size_t i = 0; i < inits.size(); ++i) {
-        if (inits[i].dimension().size() != 0) {
-            concat_dims[i] = inits[i].dimension()[axis];
+        if ((*(inits.begin()+i))->dimension().size() != 0) {
+            concat_dims[i] = (*(inits.begin() + i))->dimension()[axis];
         }
     }
 
     for (auto &in : inits) {
-        inputs.push_back((const gsl::byte *const)(in.data().data()));
-        in_strides.push_back(in.strides());
+        inputs.push_back((const gsl::byte *)(in->data().data()));
+        in_strides.push_back(in->strides());
     }
 
     kernels::concat(inputs, output.data().data(), output.dimension(),
-                    in_strides, output.strides(), axis, concat_dims);
+                    gsl::make_span(in_strides).as_span<const strides_t>(), output.strides(), axis, concat_dims);
 }
 
 template <typename T>
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 9fabedb1c6..d0005a6ff8 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -43,7 +43,8 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseLayerNorm))]
     // [ClassData(typeof(TilingCaseGather))]
     // [ClassData(typeof(TilingCaseSoftmax))]
-    [ClassData(typeof(TilingCaseSlice))]
+    // [ClassData(typeof(TilingCaseSlice))]
+    [ClassData(typeof(TilingCaseConcat))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -114,19 +115,31 @@ internal sealed class TilingCaseConcat : TheoryData<Function, Tensor[]>
 {
     public TilingCaseConcat()
     {
-        var in_a = new Var("in_a", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 64 }));
-        var in_b = new Var("in_b", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 64 }));
+        var in_a_shape = new[] { 1, 64, 384, 64 };
+        var in_b_shape = new[] { 1, 64, 384, 64 };
+        var in_a = new Var("in_a", new TensorType(DataTypes.Float32, in_a_shape));
+        var in_b = new Var("in_b", new TensorType(DataTypes.Float32, in_b_shape));
 
         Fusion fusion;
+        Var fin_a, fin_b;
         {
-            var fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 64 }));
-            var fin_b = new Var("fin_b", new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 64 }));
+            fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, in_a_shape));
+            fin_b = new Var("fin_b", new TensorType(DataTypes.Float32, in_b_shape));
             var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Concat(3)), new IR.Tuple(fin_a, fin_b));
             fusion = new Fusion("cpu", v1, fin_a, fin_b);
         }
 
+        var input_a_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, in_a_shape).Evaluate().AsTensor();
+        var input_b_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 4, in_b_shape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin_a, Value.FromTensor(input_a_tensor) },
+            { fin_b, Value.FromTensor(input_b_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
         var main = new Function("concat", new Call(fusion, in_a, in_b), new[] { in_a, in_b });
-        Add(main, Array.Empty<Tensor>());
+        Add(main, new[] { input_a_tensor, input_b_tensor, output });
     }
 }
 

From 77d41520729bb54d7331cc4b1c402877c1e5b55a Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 19 Sep 2023 13:58:26 +0800
Subject: [PATCH 192/308] fix cpu concat

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index c7c152162c..9735765147 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -161,20 +161,20 @@ void reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
 }
 
 template <typename T, loc_t BLoc>
-void concat(std::initializer_list<tensor<T, loc_t::local>*> inits,
+void concat(itlib::small_vector<tensor<T, loc_t::local> *> inits,
             tensor<T, BLoc> &output, size_t axis) {
     itlib::small_vector<const gsl::byte *, 8> inputs(inits.size());
     itlib::small_vector<strides_t> in_strides(inits.size());
     auto concat_dims = dims_t(inits.size(), 1);
     for (size_t i = 0; i < inits.size(); ++i) {
-        if ((*(inits.begin()+i))->dimension().size() != 0) {
-            concat_dims[i] = (*(inits.begin() + i))->dimension()[axis];
+        if (inits[i]->dimension().size() != 0) {
+            concat_dims[i] = inits[i]->dimension()[axis];
         }
     }
 
-    for (auto &in : inits) {
-        inputs.push_back((const gsl::byte *)(in->data().data()));
-        in_strides.push_back(in->strides());
+    for (size_t i = 0; i < inits.size(); ++i) {
+        inputs[i] = ((const gsl::byte *)(inits[i]->data().data()));
+        in_strides[i] = (inits[i]->strides());
     }
 
     kernels::concat(inputs, output.data().data(), output.dimension(),

From 62bdc8413408f27661940da9ebc423bf37bbf9e6 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Tue, 19 Sep 2023 07:03:19 +0000
Subject: [PATCH 193/308] Apply code-format changes

---
 .../cpu/src/runtime/cmodel/include/binary.h   |    2 +-
 .../cpu/src/runtime/cmodel/include/concat.h   |    8 +-
 .../cpu/src/runtime/cmodel/include/gather.h   |    2 +-
 .../runtime/cmodel/include/hardware_context.h |    2 +-
 .../src/runtime/cmodel/include/layernorm.h    |    2 +-
 .../cpu/src/runtime/cmodel/include/matmul.h   |    8 +-
 .../cpu/src/runtime/cmodel/include/reduce.h   |   10 +-
 .../runtime/cmodel/include/runtime_utils.h    |   14 +-
 .../cpu/src/runtime/cmodel/include/slice.h    |    2 +-
 .../runtime/cmodel/include/small_vector.hpp   |    2 +-
 .../cpu/src/runtime/cmodel/include/softmax.h  |    2 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h |    7 +-
 .../cpu/src/runtime/cmodel/include/tensor.h   |   10 +-
 .../src/runtime/cmodel/include/transpose.h    |    2 +-
 .../cpu/src/runtime/cmodel/include/unary.h    |    2 +-
 .../cmodel/tests/decoder_layer/kernel.h       |    8 +-
 .../cmodel/tests/decoder_layer/shared_def.h   |   15 +-
 .../src/runtime/cmodel/tests/demo2/main.cpp   |   10 +-
 .../src/runtime/cmodel/tests/embed/kernel.h   |   12 +-
 .../src/runtime/cmodel/tests/embed/main.cpp   |    4 +-
 .../runtime/cmodel/tests/embed/shared_def.h   |    3 +-
 .../src/runtime/cmodel/tests/head/kernel.h    |    3 +-
 .../src/runtime/cmodel/tests/head/main.cpp    |    2 +-
 .../src/runtime/cmodel/tests/norm/kernel.h    |    4 +-
 .../runtime/cmodel/tests/norm/shared_def.h    |    3 +-
 .../runtime/cmodel/tests/unary/shared_def.h   |    3 +-
 modules/cpu/src/runtime/elfloader.cpp         |    6 +-
 modules/cpu/src/runtime/elfloader.h           |   15 +-
 modules/cpu/src/runtime/gsl-lite.hpp          | 6054 ++++++++---------
 modules/cpu/src/runtime/hardware_context.cpp  |   95 +-
 modules/cpu/src/runtime/hardware_context.h    |    5 +-
 modules/cpu/src/runtime/io_utils.h            |    2 +-
 modules/cpu/src/runtime/method_table_def.h    |    6 +-
 modules/cpu/src/runtime/runtime_utils.h       |   20 +-
 modules/cpu/src/runtime/shared_memory.h       |    2 +-
 tests/onnx_test_runner.py                     |    5 +-
 36 files changed, 3119 insertions(+), 3233 deletions(-)
 mode change 100755 => 100644 modules/cpu/src/runtime/cmodel/tests/unary/shared_def.h

diff --git a/modules/cpu/src/runtime/cmodel/include/binary.h b/modules/cpu/src/runtime/cmodel/include/binary.h
index 5193c039a7..5372d78493 100644
--- a/modules/cpu/src/runtime/cmodel/include/binary.h
+++ b/modules/cpu/src/runtime/cmodel/include/binary.h
@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#include <apply.h>
 #include "../../gsl-lite.hpp"
+#include <apply.h>
 #include <runtime_utils.h>
 
 using namespace nncase::runtime::cpu;
diff --git a/modules/cpu/src/runtime/cmodel/include/concat.h b/modules/cpu/src/runtime/cmodel/include/concat.h
index 2fe3f2e24c..381eaf2486 100644
--- a/modules/cpu/src/runtime/cmodel/include/concat.h
+++ b/modules/cpu/src/runtime/cmodel/include/concat.h
@@ -35,10 +35,10 @@ find_input_id_and_index(size_t index,
 
 template <class T>
 void concat(gsl::span<const gsl::byte *> inputs, T *output,
-                 gsl::span<const size_t> out_shape,
-                 gsl::span<const strides_t> in_strides,
-                 gsl::span<const size_t> out_strides, size_t axis,
-                 gsl::span<const size_t> concat_dims) noexcept {
+            gsl::span<const size_t> out_shape,
+            gsl::span<const strides_t> in_strides,
+            gsl::span<const size_t> out_strides, size_t axis,
+            gsl::span<const size_t> concat_dims) noexcept {
     return apply(out_shape, [&](gsl::span<const size_t> out_index) -> void {
         auto in_id_index =
             find_input_id_and_index(out_index[axis], concat_dims);
diff --git a/modules/cpu/src/runtime/cmodel/include/gather.h b/modules/cpu/src/runtime/cmodel/include/gather.h
index c867196437..a6cb03902d 100644
--- a/modules/cpu/src/runtime/cmodel/include/gather.h
+++ b/modules/cpu/src/runtime/cmodel/include/gather.h
@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#include <apply.h>
 #include "../../gsl-lite.hpp"
+#include <apply.h>
 #include <runtime_utils.h>
 
 namespace kernels {
diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_context.h b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
index 291f15941d..413f84c9e1 100644
--- a/modules/cpu/src/runtime/cmodel/include/hardware_context.h
+++ b/modules/cpu/src/runtime/cmodel/include/hardware_context.h
@@ -28,7 +28,7 @@ class hardware_context {
     }
     void *global_var = nullptr;
 
-    hardware_context_mt* impl_;
+    hardware_context_mt *impl_;
 };
 
 static hardware_context global_hardware_ctx;
diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index 8ccb233c6d..d1962ed6c4 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -28,7 +28,7 @@ void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *output,
             mean = 0;
         }
         auto sigma = nncase_mt->float_unary_sqrt(sum_sqr[o_offset] / norm_size -
-                                                mean * mean + eps);
+                                                 mean * mean + eps);
 
         auto input_offset = offset(input_stride, input_index);
         auto in_offset = offset(gamma_strides, input_index.subspan(axis));
diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
index e1b5da5129..04ae5c4165 100644
--- a/modules/cpu/src/runtime/cmodel/include/matmul.h
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -108,10 +108,10 @@ void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                 T *out_ptr = output + n * new_out_stride[0] +
                              c * new_out_stride[1] + h * new_out_stride[2];
 #ifdef __riscv_vector
-                nncase_mt->matmul_unit_impl(in_a_ptr, in_b_ptr, out_ptr, new_a_shape[3],
-                                            new_a_shape[4], new_b_shape[4],
-                                            new_a_stride[3], new_b_stride[3],
-                                            new_b_stride[3]);
+                nncase_mt->matmul_unit_impl(in_a_ptr, in_b_ptr, out_ptr,
+                                            new_a_shape[3], new_a_shape[4],
+                                            new_b_shape[4], new_a_stride[3],
+                                            new_b_stride[3], new_b_stride[3]);
 #else
                 for (size_t m = 0; m < new_a_shape[3]; m++) {
                     T *values =
diff --git a/modules/cpu/src/runtime/cmodel/include/reduce.h b/modules/cpu/src/runtime/cmodel/include/reduce.h
index dbfb037b4e..ff1943a7f7 100644
--- a/modules/cpu/src/runtime/cmodel/include/reduce.h
+++ b/modules/cpu/src/runtime/cmodel/include/reduce.h
@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#include <apply.h>
 #include "../../gsl-lite.hpp"
+#include <apply.h>
 #include <runtime_utils.h>
 
 enum class reduce_op_t : uint8_t {
@@ -146,9 +146,11 @@ void reduce(reduce_op_t op, const T *init_value, const T *input, T *output,
             gsl::span<const size_t> out_strides, bool keep_dims) noexcept {
     auto out_shape = get_reduced_shape(in_shape, axis, keep_dims);
     switch (op) {
-        REDUCE_IMPL(reduce_op_t::mean, [](T a, T b) { return a + b; },
-                    [block_size = (T)get_reduce_block_size(in_shape, axis)](
-                        T v) { return v / block_size; });
+        REDUCE_IMPL(
+            reduce_op_t::mean, [](T a, T b) { return a + b; },
+            [block_size = (T)get_reduce_block_size(in_shape, axis)](T v) {
+                return v / block_size;
+            });
         REDUCE_IMPL_NO_POST(reduce_op_t::min,
                             [](T a, T b) { return a > b ? b : a; });
         REDUCE_IMPL_NO_POST(reduce_op_t::max,
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
index f210a2df0e..13e161b793 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
@@ -1,9 +1,9 @@
 #pragma once
 
-#include <cstddef>
 #include "../../gsl-lite.hpp"
-#include <runtime_types.h>
 #include "../../method_table_def.h"
+#include <cstddef>
+#include <runtime_types.h>
 
 using namespace nncase::runtime::cpu;
 
@@ -69,8 +69,9 @@ inline size_t offset(gsl::span<const size_t> strides,
     if (strides.size() == 0 || index.size() == 0) {
         return 0;
     }
-    runtime_util->rt_assert(strides.size() == index.size(),
-                           (char *)"strides and index must have the same rank");
+    runtime_util->rt_assert(
+        strides.size() == index.size(),
+        (char *)"strides and index must have the same rank");
     return element_offset<size_t>(strides, index);
 }
 
@@ -149,8 +150,9 @@ template <typename T> double cosine(const T *v1, const T *v2, size_t size) {
     for (size_t i = 0; i < 10; i++) {
         runtime_util->printf("%f, %f\n", (float)v1[i], (float)v2[i]);
     }
-    return dot(v1, v2, size) / ((nncase_mt->float_unary_sqrt(dot(v1, v1, size)) *
-                                 nncase_mt->float_unary_sqrt(dot(v2, v2, size))));
+    return dot(v1, v2, size) /
+           ((nncase_mt->float_unary_sqrt(dot(v1, v1, size)) *
+             nncase_mt->float_unary_sqrt(dot(v2, v2, size))));
 }
 
 inline dims_t get_reduced_offset(gsl::span<const size_t> in_offset,
diff --git a/modules/cpu/src/runtime/cmodel/include/slice.h b/modules/cpu/src/runtime/cmodel/include/slice.h
index 080858d4e7..2582c9e95a 100644
--- a/modules/cpu/src/runtime/cmodel/include/slice.h
+++ b/modules/cpu/src/runtime/cmodel/include/slice.h
@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#include <apply.h>
 #include "../../gsl-lite.hpp"
+#include <apply.h>
 #include <runtime_utils.h>
 
 namespace kernels {
diff --git a/modules/cpu/src/runtime/cmodel/include/small_vector.hpp b/modules/cpu/src/runtime/cmodel/include/small_vector.hpp
index 839ae8eb2e..f93e3efc93 100644
--- a/modules/cpu/src/runtime/cmodel/include/small_vector.hpp
+++ b/modules/cpu/src/runtime/cmodel/include/small_vector.hpp
@@ -134,8 +134,8 @@
 //
 #pragma once
 
-#include <cstddef>
 #include "gsl-lite.hpp"
+#include <cstddef>
 #include <memory>
 #include <type_traits>
 
diff --git a/modules/cpu/src/runtime/cmodel/include/softmax.h b/modules/cpu/src/runtime/cmodel/include/softmax.h
index d01366479e..c0245a52ea 100644
--- a/modules/cpu/src/runtime/cmodel/include/softmax.h
+++ b/modules/cpu/src/runtime/cmodel/include/softmax.h
@@ -76,7 +76,7 @@ void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
             output[in_idx] = nncase_mt->float_unary_exp(in);
         } else {
             runtime_util->rt_assert(false,
-                                   (char *)"Not supported Type in softmax!");
+                                    (char *)"Not supported Type in softmax!");
         }
 
         tmp[out_idx] += output[in_idx];
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 9735765147..0446b2af90 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -178,7 +178,8 @@ void concat(itlib::small_vector<tensor<T, loc_t::local> *> inits,
     }
 
     kernels::concat(inputs, output.data().data(), output.dimension(),
-                    gsl::make_span(in_strides).as_span<const strides_t>(), output.strides(), axis, concat_dims);
+                    gsl::make_span(in_strides).as_span<const strides_t>(),
+                    output.strides(), axis, concat_dims);
 }
 
 template <typename T>
@@ -303,7 +304,7 @@ void reduce_async_visit_func1(int visited, thread_context &ctx,
     if (visited == 1) {
         if (global_hardware_ctx.global_var != nullptr) {
             runtime_util->rt_assert(false,
-                                   (char *)"the global var has been used!");
+                                    (char *)"the global var has been used!");
         }
         gather_span =
             (T *)runtime_util->malloc(sizeof(T) * compute_size(new_dims));
@@ -376,7 +377,7 @@ void all_reduce_async_visit_func1(int visited, thread_context &ctx,
     if (visited == 1) {
         if (global_hardware_ctx.global_var != nullptr) {
             runtime_util->rt_assert(false,
-                                   (char *)"the global var has been used!");
+                                    (char *)"the global var has been used!");
         }
         gather_span =
             (T *)runtime_util->malloc(sizeof(T) * compute_size(new_dims));
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index 1c57de32b4..1291e44309 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -1,10 +1,10 @@
 #pragma once
 
-#include <cstddef>
 #include "../../gsl-lite.hpp"
+#include "../../method_table_def.h"
+#include <cstddef>
 #include <hardware_def.h>
 #include <runtime_utils.h>
-#include "../../method_table_def.h"
 
 enum class loc_t : uint8_t {
     shared,
@@ -35,7 +35,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
           strides_(get_default_strides(dims_)),
           size_(compute_size(dims_)) {
         if (size_ != data_.size()) {
-            runtime_util->rt_assert(false, (char*)"Invalid tensor size");
+            runtime_util->rt_assert(false, (char *)"Invalid tensor size");
         }
     }
 
@@ -46,7 +46,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
           strides_(strides),
           size_(compute_size(dims_, strides_)) {
         if (size_ != data_.size()) {
-            runtime_util->rt_assert(false, (char*)"Invalid tensor size");
+            runtime_util->rt_assert(false, (char *)"Invalid tensor size");
         }
     }
 
@@ -83,7 +83,7 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
         auto subspan_offset = offset(strides_, begins);
         data_ = parent->data_.subspan(subspan_offset);
         if (data_.size() < size_) {
-            runtime_util->rt_assert(false, (char*)"Invalid tensor size");
+            runtime_util->rt_assert(false, (char *)"Invalid tensor size");
         }
     }
 
diff --git a/modules/cpu/src/runtime/cmodel/include/transpose.h b/modules/cpu/src/runtime/cmodel/include/transpose.h
index 2979efe69a..507f99fdef 100644
--- a/modules/cpu/src/runtime/cmodel/include/transpose.h
+++ b/modules/cpu/src/runtime/cmodel/include/transpose.h
@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#include <apply.h>
 #include "../../gsl-lite.hpp"
+#include <apply.h>
 #include <runtime_utils.h>
 
 namespace kernels {
diff --git a/modules/cpu/src/runtime/cmodel/include/unary.h b/modules/cpu/src/runtime/cmodel/include/unary.h
index 23a92be28e..67072f4372 100644
--- a/modules/cpu/src/runtime/cmodel/include/unary.h
+++ b/modules/cpu/src/runtime/cmodel/include/unary.h
@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#include <apply.h>
 #include "../../gsl-lite.hpp"
+#include <apply.h>
 #include <runtime_utils.h>
 
 using namespace nncase::runtime::cpu;
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
index 9a32d3345d..043387ea27 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
@@ -270,8 +270,8 @@ void stage1_kernel(
     binary(v27, attn_mask, v28, binary_op_t::add);
 #if DUMP
     {
-        tdma_store_async(
-            v28, (*ImmOutputs[6])({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 384}));
+        tdma_store_async(v28, (*ImmOutputs[6])({0, 16 * tid, 48 * bid, 0},
+                                               {1, 16, 48, 384}));
     }
 #endif
     /*
@@ -304,8 +304,8 @@ void stage1_kernel(
     tdma_wait(ctx);
 #if DUMP
     {
-        tdma_store_async(
-            v32, (*ImmOutputs[7])({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}));
+        tdma_store_async(v32, (*ImmOutputs[7])({0, 16 * tid, 48 * bid, 0},
+                                               {1, 16, 48, 128}));
     }
 #endif
     // #if 0
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
index 0c7a5333c1..343b6c2b4f 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
@@ -1,15 +1,13 @@
 #include <tdma.h>
 
 namespace shared {
-static tensor<float, loc_t::shared>
-    *V2; // [1, 64, 384, 128] [1, 64, 48@b, 128]
+static tensor<float, loc_t::shared> *V2; // [1, 64, 384, 128] [1, 64, 48@b, 128]
 
 static tensor<float, loc_t::shared> *V5; // {1, 64, 48, 128}
 
 static tensor<float, loc_t::shared> *V13; // {1, 64, 48, 128}
 
-static tensor<float, loc_t::shared>
-    *V16; // [1, 64, 48, 128] [1, 64, 48@b, 128]
+static tensor<float, loc_t::shared> *V16; // [1, 64, 48, 128] [1, 64, 48@b, 128]
 
 static tensor<float, loc_t::shared>
     *V25; // [1, 64, 384, 128] [1, 8@b, 384, 384]
@@ -26,12 +24,9 @@ static tensor<float, loc_t::shared>
 
 static tensor<float, loc_t::shared> *V35; // [1, 384, 8192]
 
-static tensor<float, loc_t::shared>
-    *V38; // [1, 384, 22016] [1, 48@b, 22016]
+static tensor<float, loc_t::shared> *V38; // [1, 384, 22016] [1, 48@b, 22016]
 
-static tensor<float, loc_t::shared>
-    *V40; // [1, 384, 8192] [1, 48@b, 22016]
+static tensor<float, loc_t::shared> *V40; // [1, 384, 8192] [1, 48@b, 22016]
 
-static tensor<float, loc_t::shared>
-    *V42; // [1, 384, 8192] [1, 48@b, 8192]
+static tensor<float, loc_t::shared> *V42; // [1, 384, 8192] [1, 48@b, 8192]
 } // namespace shared
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
index 193af3b0ce..e4da440978 100644
--- a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
@@ -140,8 +140,8 @@ int main([[maybe_unused]] int argc, char **argv) {
     pthread_join(t_7_3, NULL);
 
     auto cos = cosine(QKH.data().begin(),
-                 gsl::make_span(src_QKH).as_span<float>().begin(),
-                 QKH.data().size());
+                      gsl::make_span(src_QKH).as_span<float>().begin(),
+                      QKH.data().size());
     printf("QKH cosine %f\n", cos);
 
     cos = cosine(Softmax.data().begin(),
@@ -154,11 +154,11 @@ int main([[maybe_unused]] int argc, char **argv) {
                  YM.data().size());
     printf("YM cosine %f\n", cos);
 
-    to_file(Norm.data(),"ONorm.bin");
+    to_file(Norm.data(), "ONorm.bin");
 
     cos = cosine(Norm.data().begin(),
-                      gsl::make_span(src_Norm).as_span<float>().begin(),
-                      Norm.data().size());
+                 gsl::make_span(src_Norm).as_span<float>().begin(),
+                 Norm.data().size());
     printf("Norm cosine %f\n", cos);
     return 0;
 }
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h b/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
index 5a845739d3..0fd6f0a8f6 100644
--- a/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
@@ -8,9 +8,11 @@ using namespace shared;
 #define DUMP 0
 
 void stage1_kernel(
-    [[maybe_unused]] tensor<int64_t, loc_t::device> &Position_ids, /* [1, 384] */
-    [[maybe_unused]] tensor<float, loc_t::device> &GatherData,   /* [32000, 8192] */
-    [[maybe_unused]] tensor<float, loc_t::device> &Output          /* [1, 384, 8192] */
+    [[maybe_unused]] tensor<int64_t, loc_t::device>
+        &Position_ids, /* [1, 384] */
+    [[maybe_unused]] tensor<float, loc_t::device>
+        &GatherData,                                      /* [32000, 8192] */
+    [[maybe_unused]] tensor<float, loc_t::device> &Output /* [1, 384, 8192] */
 ) {
     thread_context ctx(bid, tid);
     tensor<int64_t> position_ids({1, 384});
@@ -22,6 +24,6 @@ void stage1_kernel(
                     GatherData({0, 256 * (CORES * bid + tid)}, {384, 256}));
     gather(gather_data, position_ids, output, 0);
 
-    tdma_store_async(
-        output, Output({0, 0, 256 * (CORES * bid + tid)}, {1, 384, 256}));
+    tdma_store_async(output,
+                     Output({0, 0, 256 * (CORES * bid + tid)}, {1, 384, 256}));
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp b/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
index d127978464..a1f07bfa11 100644
--- a/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
@@ -27,8 +27,8 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
-void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt, nncase_mt_t *nncase_mt_impl,
-            uint8_t **inputs) {
+void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
+            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
     runtime_util = rt_util_mt;
     nncase_mt = nncase_mt_impl;
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h
index b18a608408..30a07a72cb 100644
--- a/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h
@@ -1,4 +1,3 @@
 #include <tdma.h>
 
-namespace shared {
-} // namespace shared
\ No newline at end of file
+namespace shared {} // namespace shared
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/kernel.h b/modules/cpu/src/runtime/cmodel/tests/head/kernel.h
index b71794212e..af67e500d0 100644
--- a/modules/cpu/src/runtime/cmodel/tests/head/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/head/kernel.h
@@ -21,5 +21,6 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
     tensor_block_mma_sync(hidden_in, w, *output, false, ctx);
 
     auto output_1 = (*output)({0, 0, 8000 * tid}, {1, 48, 8000});
-    tdma_store_async(output_1, Output({0, 48 * bid, 8000 * tid}, {1, 48, 8000}));
+    tdma_store_async(output_1,
+                     Output({0, 48 * bid, 8000 * tid}, {1, 48, 8000}));
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
index cd2d73d5d5..b981599f2f 100644
--- a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
@@ -7,7 +7,7 @@
         return arg;                                                            \
     }
 
-#define MALLOC_SHARED(b, name, shape)                                                \
+#define MALLOC_SHARED(b, name, shape)                                          \
     auto shared##b = tensor<float, loc_t::shared>(shape);                      \
     block##b::shared::name = &shared##b;
 
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h b/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h
index 9da86e34e5..15725a764a 100644
--- a/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h
@@ -19,6 +19,6 @@ void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
     tensor<float> sum_sqr({1, 12});
     reduce_sum_sqr(hidden_in, sum, sum_sqr);
     layernorm(hidden_in, sum, sum_sqr, output, 2, 8192, true);
-    tdma_store_async(
-        output, Output({0, 12 * (CORES * bid + tid), 0}, {1, 12, 8192}));
+    tdma_store_async(output,
+                     Output({0, 12 * (CORES * bid + tid), 0}, {1, 12, 8192}));
 }
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/norm/shared_def.h
index b18a608408..30a07a72cb 100644
--- a/modules/cpu/src/runtime/cmodel/tests/norm/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/shared_def.h
@@ -1,4 +1,3 @@
 #include <tdma.h>
 
-namespace shared {
-} // namespace shared
\ No newline at end of file
+namespace shared {} // namespace shared
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/shared_def.h b/modules/cpu/src/runtime/cmodel/tests/unary/shared_def.h
old mode 100755
new mode 100644
index b18a608408..30a07a72cb
--- a/modules/cpu/src/runtime/cmodel/tests/unary/shared_def.h
+++ b/modules/cpu/src/runtime/cmodel/tests/unary/shared_def.h
@@ -1,4 +1,3 @@
 #include <tdma.h>
 
-namespace shared {
-} // namespace shared
\ No newline at end of file
+namespace shared {} // namespace shared
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/cpu/src/runtime/elfloader.cpp
index 97badbec43..d8e1afc0aa 100644
--- a/modules/cpu/src/runtime/elfloader.cpp
+++ b/modules/cpu/src/runtime/elfloader.cpp
@@ -5,8 +5,10 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace nncase::runtime::cpu;
 
-int elfloader::invoke_elf(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs, uint8_t *rdata) {
+int elfloader::invoke_elf(hardware_context_mt *hw_ctx_impl,
+                          runtime_util_mt *rt_util_mt,
+                          nncase_mt_t *nncase_mt_impl, uint8_t **inputs,
+                          uint8_t *rdata) {
 
     check(el_init(&ctx_), "initialising");
 
diff --git a/modules/cpu/src/runtime/elfloader.h b/modules/cpu/src/runtime/elfloader.h
index ac81c18ea8..b8f5c86905 100644
--- a/modules/cpu/src/runtime/elfloader.h
+++ b/modules/cpu/src/runtime/elfloader.h
@@ -1,6 +1,6 @@
 #pragma once
-#include "hardware_def.h"
 #include "elfload.h"
+#include "hardware_def.h"
 #include <inttypes.h>
 #include <math.h>
 #include <nncase/runtime/cpu/compiler_defs.h>
@@ -8,14 +8,16 @@
 #include <stdlib.h>
 #include <string.h>
 #if defined(__linux__)
-#include <sys/mman.h>
 #include "method_table_impl.h"
+#include <sys/mman.h>
 #endif
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
-typedef void (*entrypoint_t)(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs, uint8_t *rdata);
+typedef void (*entrypoint_t)(hardware_context_mt *hw_ctx_impl,
+                             runtime_util_mt *rt_util_mt,
+                             nncase_mt_t *nncase_mt_impl, uint8_t **inputs,
+                             uint8_t *rdata);
 
 class elfloader {
   public:
@@ -50,8 +52,9 @@ class elfloader {
         }
     }
 
-    int invoke_elf(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs, uint8_t *rdata);
+    int invoke_elf(hardware_context_mt *hw_ctx_impl,
+                   runtime_util_mt *rt_util_mt, nncase_mt_t *nncase_mt_impl,
+                   uint8_t **inputs, uint8_t *rdata);
 
   private:
     void *ptr_;
diff --git a/modules/cpu/src/runtime/gsl-lite.hpp b/modules/cpu/src/runtime/gsl-lite.hpp
index 859f9ccc58..084210f03f 100644
--- a/modules/cpu/src/runtime/gsl-lite.hpp
+++ b/modules/cpu/src/runtime/gsl-lite.hpp
@@ -19,349 +19,399 @@
 #define GSL_GSL_LITE_HPP_INCLUDED
 
 #include <algorithm> // for swap() [pre-C++11], equal(), lexicographical_compare()
+#include <cstddef>   // for size_t, ptrdiff_t, nullptr_t
 #include <exception> // for exception, terminate(), uncaught_exceptions()
-#include <iterator>  // for data(), size(), reverse_iterator<>, iterator_traits<>
+#include <ios>       // for ios_base, streamsize
+#include <iosfwd>    // for basic_ostream<>
+#include <iterator> // for data(), size(), reverse_iterator<>, iterator_traits<>
 #include <limits>
 #include <memory>    // for addressof(), unique_ptr<>, shared_ptr<>
-#include <iosfwd>    // for basic_ostream<>
-#include <ios>       // for ios_base, streamsize
 #include <stdexcept> // for logic_error
 #include <string>
-#include <utility>   // for move(), forward<>(), swap()
-#include <cstddef>   // for size_t, ptrdiff_t, nullptr_t
+#include <utility> // for move(), forward<>(), swap()
 
-#define  gsl_lite_MAJOR  0
-#define  gsl_lite_MINOR  37
-#define  gsl_lite_PATCH  0
+#define gsl_lite_MAJOR 0
+#define gsl_lite_MINOR 37
+#define gsl_lite_PATCH 0
 
-#define  gsl_lite_VERSION  gsl_STRINGIFY(gsl_lite_MAJOR) "." gsl_STRINGIFY(gsl_lite_MINOR) "." gsl_STRINGIFY(gsl_lite_PATCH)
+#define gsl_lite_VERSION                                                       \
+    gsl_STRINGIFY(gsl_lite_MAJOR) "." gsl_STRINGIFY(                           \
+        gsl_lite_MINOR) "." gsl_STRINGIFY(gsl_lite_PATCH)
 
 // gsl-lite backward compatibility:
 
-#if !defined( gsl_CONFIG_DEFAULTS_VERSION )
-# define gsl_CONFIG_DEFAULTS_VERSION gsl_lite_MAJOR
+#if !defined(gsl_CONFIG_DEFAULTS_VERSION)
+#define gsl_CONFIG_DEFAULTS_VERSION gsl_lite_MAJOR
 #endif
 
 #ifdef gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR
-# define gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR  gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR
-# pragma message ("gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR is deprecated since gsl-lite 0.7; replace with gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR, or consider span(with_container, cont).")
-#endif
-
-#if defined( gsl_CONFIG_CONTRACT_LEVEL_ON )
-# pragma message ("gsl_CONFIG_CONTRACT_LEVEL_ON is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_ON.")
-# define gsl_CONFIG_CONTRACT_CHECKING_ON
-#endif
-#if defined( gsl_CONFIG_CONTRACT_LEVEL_OFF )
-# pragma message ("gsl_CONFIG_CONTRACT_LEVEL_OFF is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_OFF.")
-# define gsl_CONFIG_CONTRACT_CHECKING_OFF
-#endif
-#if   defined( gsl_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY )
-# pragma message ("gsl_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF.")
-# define gsl_CONFIG_CONTRACT_CHECKING_ON
-# define gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF
-#elif defined( gsl_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY )
-# pragma message ("gsl_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF.")
-# define gsl_CONFIG_CONTRACT_CHECKING_ON
-# define gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF
+#define gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR                    \
+    gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR
+#pragma message(                                                               \
+    "gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR is deprecated since gsl-lite 0.7; replace with gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR, or consider span(with_container, cont).")
+#endif
+
+#if defined(gsl_CONFIG_CONTRACT_LEVEL_ON)
+#pragma message(                                                               \
+    "gsl_CONFIG_CONTRACT_LEVEL_ON is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_ON.")
+#define gsl_CONFIG_CONTRACT_CHECKING_ON
+#endif
+#if defined(gsl_CONFIG_CONTRACT_LEVEL_OFF)
+#pragma message(                                                               \
+    "gsl_CONFIG_CONTRACT_LEVEL_OFF is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_OFF.")
+#define gsl_CONFIG_CONTRACT_CHECKING_OFF
+#endif
+#if defined(gsl_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY)
+#pragma message(                                                               \
+    "gsl_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF.")
+#define gsl_CONFIG_CONTRACT_CHECKING_ON
+#define gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF
+#elif defined(gsl_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY)
+#pragma message(                                                               \
+    "gsl_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF.")
+#define gsl_CONFIG_CONTRACT_CHECKING_ON
+#define gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF
 #endif
 
 // M-GSL compatibility:
 
-#if defined( GSL_THROW_ON_CONTRACT_VIOLATION )
-# define gsl_CONFIG_CONTRACT_VIOLATION_THROWS
+#if defined(GSL_THROW_ON_CONTRACT_VIOLATION)
+#define gsl_CONFIG_CONTRACT_VIOLATION_THROWS
 #endif
 
-#if defined( GSL_TERMINATE_ON_CONTRACT_VIOLATION )
-# define gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES
+#if defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION)
+#define gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES
 #endif
 
-#if defined( GSL_UNENFORCED_ON_CONTRACT_VIOLATION )
-# define gsl_CONFIG_CONTRACT_CHECKING_OFF
+#if defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION)
+#define gsl_CONFIG_CONTRACT_CHECKING_OFF
 #endif
 
 // Configuration: Features
 
-#ifndef  gsl_FEATURE_WITH_CONTAINER_TO_STD
-# define gsl_FEATURE_WITH_CONTAINER_TO_STD  99
+#ifndef gsl_FEATURE_WITH_CONTAINER_TO_STD
+#define gsl_FEATURE_WITH_CONTAINER_TO_STD 99
 #endif
 
-#ifndef  gsl_FEATURE_MAKE_SPAN_TO_STD
-# define gsl_FEATURE_MAKE_SPAN_TO_STD  99
+#ifndef gsl_FEATURE_MAKE_SPAN_TO_STD
+#define gsl_FEATURE_MAKE_SPAN_TO_STD 99
 #endif
 
-#ifndef  gsl_FEATURE_BYTE_SPAN_TO_STD
-# define gsl_FEATURE_BYTE_SPAN_TO_STD  99
+#ifndef gsl_FEATURE_BYTE_SPAN_TO_STD
+#define gsl_FEATURE_BYTE_SPAN_TO_STD 99
 #endif
 
-#ifndef  gsl_FEATURE_IMPLICIT_MACRO
-# define gsl_FEATURE_IMPLICIT_MACRO  0
+#ifndef gsl_FEATURE_IMPLICIT_MACRO
+#define gsl_FEATURE_IMPLICIT_MACRO 0
 #endif
 
-#ifndef  gsl_FEATURE_OWNER_MACRO
-# define gsl_FEATURE_OWNER_MACRO  (gsl_CONFIG_DEFAULTS_VERSION == 0)
+#ifndef gsl_FEATURE_OWNER_MACRO
+#define gsl_FEATURE_OWNER_MACRO (gsl_CONFIG_DEFAULTS_VERSION == 0)
 #endif
 
-#ifndef  gsl_FEATURE_EXPERIMENTAL_RETURN_GUARD
-# define gsl_FEATURE_EXPERIMENTAL_RETURN_GUARD  0
+#ifndef gsl_FEATURE_EXPERIMENTAL_RETURN_GUARD
+#define gsl_FEATURE_EXPERIMENTAL_RETURN_GUARD 0
 #endif
 
-#ifndef  gsl_FEATURE_GSL_LITE_NAMESPACE
-# define gsl_FEATURE_GSL_LITE_NAMESPACE  (gsl_CONFIG_DEFAULTS_VERSION >= 1)
+#ifndef gsl_FEATURE_GSL_LITE_NAMESPACE
+#define gsl_FEATURE_GSL_LITE_NAMESPACE (gsl_CONFIG_DEFAULTS_VERSION >= 1)
 #endif
 
 // Configuration: Other
 
-#if defined( gsl_CONFIG_TRANSPARENT_NOT_NULL ) && gsl_CONFIG_TRANSPARENT_NOT_NULL && defined( gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF )
-# error configuration option gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF is meaningless if gsl_CONFIG_TRANSPARENT_NOT_NULL=1
+#if defined(gsl_CONFIG_TRANSPARENT_NOT_NULL) &&                                \
+    gsl_CONFIG_TRANSPARENT_NOT_NULL &&                                         \
+    defined(gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF)
+#error configuration option gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF is meaningless if gsl_CONFIG_TRANSPARENT_NOT_NULL=1
 #endif
 
-#ifndef  gsl_CONFIG_DEPRECATE_TO_LEVEL
-# if gsl_CONFIG_DEFAULTS_VERSION >= 1
-#  define gsl_CONFIG_DEPRECATE_TO_LEVEL  6
-# else
-#  define gsl_CONFIG_DEPRECATE_TO_LEVEL  0
-# endif
+#ifndef gsl_CONFIG_DEPRECATE_TO_LEVEL
+#if gsl_CONFIG_DEFAULTS_VERSION >= 1
+#define gsl_CONFIG_DEPRECATE_TO_LEVEL 6
+#else
+#define gsl_CONFIG_DEPRECATE_TO_LEVEL 0
+#endif
 #endif
 
-#ifndef  gsl_CONFIG_SPAN_INDEX_TYPE
-# define gsl_CONFIG_SPAN_INDEX_TYPE  std::size_t
+#ifndef gsl_CONFIG_SPAN_INDEX_TYPE
+#define gsl_CONFIG_SPAN_INDEX_TYPE std::size_t
 #endif
 
-#ifndef  gsl_CONFIG_INDEX_TYPE
-# if gsl_CONFIG_DEFAULTS_VERSION >= 1
+#ifndef gsl_CONFIG_INDEX_TYPE
+#if gsl_CONFIG_DEFAULTS_VERSION >= 1
 // p0122r3 uses std::ptrdiff_t
-#  define gsl_CONFIG_INDEX_TYPE  std::ptrdiff_t
-# else
-#  define gsl_CONFIG_INDEX_TYPE  gsl_CONFIG_SPAN_INDEX_TYPE
-# endif
+#define gsl_CONFIG_INDEX_TYPE std::ptrdiff_t
+#else
+#define gsl_CONFIG_INDEX_TYPE gsl_CONFIG_SPAN_INDEX_TYPE
+#endif
 #endif
 
-#ifndef  gsl_CONFIG_NOT_NULL_EXPLICIT_CTOR
-# define gsl_CONFIG_NOT_NULL_EXPLICIT_CTOR  (gsl_CONFIG_DEFAULTS_VERSION >= 1)
+#ifndef gsl_CONFIG_NOT_NULL_EXPLICIT_CTOR
+#define gsl_CONFIG_NOT_NULL_EXPLICIT_CTOR (gsl_CONFIG_DEFAULTS_VERSION >= 1)
 #endif
 
-#ifndef  gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF
-# define gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF  0
+#ifndef gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF
+#define gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF 0
 #endif
 
-#ifndef  gsl_CONFIG_TRANSPARENT_NOT_NULL
-# define gsl_CONFIG_TRANSPARENT_NOT_NULL  (gsl_CONFIG_DEFAULTS_VERSION >= 1)
+#ifndef gsl_CONFIG_TRANSPARENT_NOT_NULL
+#define gsl_CONFIG_TRANSPARENT_NOT_NULL (gsl_CONFIG_DEFAULTS_VERSION >= 1)
 #endif
 
-#ifndef  gsl_CONFIG_CONFIRMS_COMPILATION_ERRORS
-# define gsl_CONFIG_CONFIRMS_COMPILATION_ERRORS  0
+#ifndef gsl_CONFIG_CONFIRMS_COMPILATION_ERRORS
+#define gsl_CONFIG_CONFIRMS_COMPILATION_ERRORS 0
 #endif
 
-#ifndef  gsl_CONFIG_ALLOWS_SPAN_COMPARISON
-# define gsl_CONFIG_ALLOWS_SPAN_COMPARISON  (gsl_CONFIG_DEFAULTS_VERSION == 0)
+#ifndef gsl_CONFIG_ALLOWS_SPAN_COMPARISON
+#define gsl_CONFIG_ALLOWS_SPAN_COMPARISON (gsl_CONFIG_DEFAULTS_VERSION == 0)
 #endif
 
-#ifndef  gsl_CONFIG_ALLOWS_NONSTRICT_SPAN_COMPARISON
-# define gsl_CONFIG_ALLOWS_NONSTRICT_SPAN_COMPARISON  1
+#ifndef gsl_CONFIG_ALLOWS_NONSTRICT_SPAN_COMPARISON
+#define gsl_CONFIG_ALLOWS_NONSTRICT_SPAN_COMPARISON 1
 #endif
 
-#ifndef  gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR
-# define gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR  0
+#ifndef gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR
+#define gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR 0
 #endif
 
-#ifndef  gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION
-# define gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION  (gsl_CONFIG_DEFAULTS_VERSION >= 1)
+#ifndef gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION
+#define gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION                                 \
+    (gsl_CONFIG_DEFAULTS_VERSION >= 1)
 #endif
 
-#if 1 < defined( gsl_CONFIG_CONTRACT_CHECKING_AUDIT ) + defined( gsl_CONFIG_CONTRACT_CHECKING_ON ) + defined( gsl_CONFIG_CONTRACT_CHECKING_OFF )
-# error only one of gsl_CONFIG_CONTRACT_CHECKING_AUDIT, gsl_CONFIG_CONTRACT_CHECKING_ON, and gsl_CONFIG_CONTRACT_CHECKING_OFF may be defined
+#if 1 < defined(gsl_CONFIG_CONTRACT_CHECKING_AUDIT) +                          \
+            defined(gsl_CONFIG_CONTRACT_CHECKING_ON) +                         \
+            defined(gsl_CONFIG_CONTRACT_CHECKING_OFF)
+#error only one of gsl_CONFIG_CONTRACT_CHECKING_AUDIT, gsl_CONFIG_CONTRACT_CHECKING_ON, and gsl_CONFIG_CONTRACT_CHECKING_OFF may be defined
 #endif
-#if 1 < defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS ) + defined( gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES ) + defined( gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER )
-# error only one of gsl_CONFIG_CONTRACT_VIOLATION_THROWS, gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES, and gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER may be defined
+#if 1 < defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS) +                        \
+            defined(gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES) +                \
+            defined(gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER)
+#error only one of gsl_CONFIG_CONTRACT_VIOLATION_THROWS, gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES, and gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER may be defined
 #endif
-#if 1 < defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME ) + defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE )
-# error only one of gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME and gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE may be defined
+#if 1 < defined(gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME) +                      \
+            defined(gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE)
+#error only one of gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME and gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE may be defined
 #endif
 
 // C++ language version detection (C++20 is speculative):
 // Note: VC14.0/1900 (VS2015) lacks too much from C++14.
 
-#ifndef   gsl_CPLUSPLUS
-# if defined(_MSVC_LANG ) && !defined(__clang__)
-#  define gsl_CPLUSPLUS  (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
-# else
-#  define gsl_CPLUSPLUS  __cplusplus
-# endif
+#ifndef gsl_CPLUSPLUS
+#if defined(_MSVC_LANG) && !defined(__clang__)
+#define gsl_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)
+#else
+#define gsl_CPLUSPLUS __cplusplus
+#endif
 #endif
 
-#define gsl_CPP98_OR_GREATER  ( gsl_CPLUSPLUS >= 199711L )
-#define gsl_CPP11_OR_GREATER  ( gsl_CPLUSPLUS >= 201103L )
-#define gsl_CPP14_OR_GREATER  ( gsl_CPLUSPLUS >= 201402L )
-#define gsl_CPP17_OR_GREATER  ( gsl_CPLUSPLUS >= 201703L )
-#define gsl_CPP20_OR_GREATER  ( gsl_CPLUSPLUS >= 202000L )
+#define gsl_CPP98_OR_GREATER (gsl_CPLUSPLUS >= 199711L)
+#define gsl_CPP11_OR_GREATER (gsl_CPLUSPLUS >= 201103L)
+#define gsl_CPP14_OR_GREATER (gsl_CPLUSPLUS >= 201402L)
+#define gsl_CPP17_OR_GREATER (gsl_CPLUSPLUS >= 201703L)
+#define gsl_CPP20_OR_GREATER (gsl_CPLUSPLUS >= 202000L)
 
 // C++ language version (represent 98 as 3):
 
-#define gsl_CPLUSPLUS_V  ( gsl_CPLUSPLUS / 100 - (gsl_CPLUSPLUS > 200000 ? 2000 : 1994) )
+#define gsl_CPLUSPLUS_V                                                        \
+    (gsl_CPLUSPLUS / 100 - (gsl_CPLUSPLUS > 200000 ? 2000 : 1994))
 
 // half-open range [lo..hi):
-#define gsl_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
+#define gsl_BETWEEN(v, lo, hi) ((lo) <= (v) && (v) < (hi))
 
 // Compiler versions:
 
-// MSVC++  6.0  _MSC_VER == 1200  gsl_COMPILER_MSVC_VERSION ==  60  (Visual Studio 6.0)
-// MSVC++  7.0  _MSC_VER == 1300  gsl_COMPILER_MSVC_VERSION ==  70  (Visual Studio .NET 2002)
-// MSVC++  7.1  _MSC_VER == 1310  gsl_COMPILER_MSVC_VERSION ==  71  (Visual Studio .NET 2003)
-// MSVC++  8.0  _MSC_VER == 1400  gsl_COMPILER_MSVC_VERSION ==  80  (Visual Studio 2005)
-// MSVC++  9.0  _MSC_VER == 1500  gsl_COMPILER_MSVC_VERSION ==  90  (Visual Studio 2008)
-// MSVC++ 10.0  _MSC_VER == 1600  gsl_COMPILER_MSVC_VERSION == 100  (Visual Studio 2010)
-// MSVC++ 11.0  _MSC_VER == 1700  gsl_COMPILER_MSVC_VERSION == 110  (Visual Studio 2012)
-// MSVC++ 12.0  _MSC_VER == 1800  gsl_COMPILER_MSVC_VERSION == 120  (Visual Studio 2013)
-// MSVC++ 14.0  _MSC_VER == 1900  gsl_COMPILER_MSVC_VERSION == 140  (Visual Studio 2015)
-// MSVC++ 14.1  _MSC_VER >= 1910  gsl_COMPILER_MSVC_VERSION == 141  (Visual Studio 2017)
-// MSVC++ 14.2  _MSC_VER >= 1920  gsl_COMPILER_MSVC_VERSION == 142  (Visual Studio 2019)
-
-#if defined(_MSC_VER ) && !defined(__clang__)
-# define gsl_COMPILER_MSVC_VER           (_MSC_VER )
-# define gsl_COMPILER_MSVC_VERSION       (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900 ) ) )
-# define gsl_COMPILER_MSVC_VERSION_FULL  (_MSC_VER - 100 * ( 5 + (_MSC_VER < 1900 ) ) )
+// MSVC++  6.0  _MSC_VER == 1200  gsl_COMPILER_MSVC_VERSION ==  60  (Visual
+// Studio 6.0) MSVC++  7.0  _MSC_VER == 1300  gsl_COMPILER_MSVC_VERSION ==  70
+// (Visual Studio .NET 2002) MSVC++  7.1  _MSC_VER == 1310
+// gsl_COMPILER_MSVC_VERSION ==  71  (Visual Studio .NET 2003) MSVC++  8.0
+// _MSC_VER == 1400  gsl_COMPILER_MSVC_VERSION ==  80  (Visual Studio 2005)
+// MSVC++  9.0  _MSC_VER == 1500  gsl_COMPILER_MSVC_VERSION ==  90  (Visual
+// Studio 2008) MSVC++ 10.0  _MSC_VER == 1600  gsl_COMPILER_MSVC_VERSION == 100
+// (Visual Studio 2010) MSVC++ 11.0  _MSC_VER == 1700  gsl_COMPILER_MSVC_VERSION
+// == 110  (Visual Studio 2012) MSVC++ 12.0  _MSC_VER == 1800
+// gsl_COMPILER_MSVC_VERSION == 120  (Visual Studio 2013) MSVC++ 14.0  _MSC_VER
+// == 1900  gsl_COMPILER_MSVC_VERSION == 140  (Visual Studio 2015) MSVC++ 14.1
+// _MSC_VER >= 1910  gsl_COMPILER_MSVC_VERSION == 141  (Visual Studio 2017)
+// MSVC++ 14.2  _MSC_VER >= 1920  gsl_COMPILER_MSVC_VERSION == 142  (Visual
+// Studio 2019)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define gsl_COMPILER_MSVC_VER (_MSC_VER)
+#define gsl_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * (5 + (_MSC_VER < 1900)))
+#define gsl_COMPILER_MSVC_VERSION_FULL                                         \
+    (_MSC_VER - 100 * (5 + (_MSC_VER < 1900)))
 #else
-# define gsl_COMPILER_MSVC_VER           0
-# define gsl_COMPILER_MSVC_VERSION       0
-# define gsl_COMPILER_MSVC_VERSION_FULL  0
-#endif
-
-#define gsl_COMPILER_VERSION( major, minor, patch ) ( 10 * ( 10 * (major) + (minor) ) + (patch) )
-
-// AppleClang  7.0.0  __apple_build_version__ ==  7000172  gsl_COMPILER_APPLECLANG_VERSION ==  700  (Xcode 7.0, 7.0.1)          (LLVM 3.7.0)
-// AppleClang  7.0.0  __apple_build_version__ ==  7000176  gsl_COMPILER_APPLECLANG_VERSION ==  700  (Xcode 7.1)                 (LLVM 3.7.0)
-// AppleClang  7.0.2  __apple_build_version__ ==  7000181  gsl_COMPILER_APPLECLANG_VERSION ==  702  (Xcode 7.2, 7.2.1)          (LLVM 3.7.0)
-// AppleClang  7.3.0  __apple_build_version__ ==  7030029  gsl_COMPILER_APPLECLANG_VERSION ==  730  (Xcode 7.3)                 (LLVM 3.8.0)
-// AppleClang  7.3.0  __apple_build_version__ ==  7030031  gsl_COMPILER_APPLECLANG_VERSION ==  730  (Xcode 7.3.1)               (LLVM 3.8.0)
-// AppleClang  8.0.0  __apple_build_version__ ==  8000038  gsl_COMPILER_APPLECLANG_VERSION ==  800  (Xcode 8.0)                 (LLVM 3.9.0)
-// AppleClang  8.0.0  __apple_build_version__ ==  8000042  gsl_COMPILER_APPLECLANG_VERSION ==  800  (Xcode 8.1, 8.2, 8.2.1)     (LLVM 3.9.0)
-// AppleClang  8.1.0  __apple_build_version__ ==  8020038  gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3)                 (LLVM 3.9.0)
-// AppleClang  8.1.0  __apple_build_version__ ==  8020041  gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3.1)               (LLVM 3.9.0)
-// AppleClang  8.1.0  __apple_build_version__ ==  8020042  gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3.2, 8.3.3)        (LLVM 3.9.0)
-// AppleClang  9.0.0  __apple_build_version__ ==  9000037  gsl_COMPILER_APPLECLANG_VERSION ==  900  (Xcode 9.0)                 (LLVM 4.0.0?)
-// AppleClang  9.0.0  __apple_build_version__ ==  9000038  gsl_COMPILER_APPLECLANG_VERSION ==  900  (Xcode 9.1)                 (LLVM 4.0.0?)
-// AppleClang  9.0.0  __apple_build_version__ ==  9000039  gsl_COMPILER_APPLECLANG_VERSION ==  900  (Xcode 9.2)                 (LLVM 4.0.0?)
-// AppleClang  9.1.0  __apple_build_version__ ==  9020039  gsl_COMPILER_APPLECLANG_VERSION ==  910  (Xcode 9.3, 9.3.1)          (LLVM 5.0.2?)
-// AppleClang  9.1.0  __apple_build_version__ ==  9020039  gsl_COMPILER_APPLECLANG_VERSION ==  910  (Xcode 9.4, 9.4.1)          (LLVM 5.0.2?)
-// AppleClang 10.0.0  __apple_build_version__ == 10001145  gsl_COMPILER_APPLECLANG_VERSION == 1000  (Xcode 10.0, 10.1)          (LLVM 6.0.1?)
-// AppleClang 10.0.1  __apple_build_version__ == 10010046  gsl_COMPILER_APPLECLANG_VERSION == 1001  (Xcode 10.2, 10.2.1, 10.3)  (LLVM 7.0.0?)
-// AppleClang 11.0.0  __apple_build_version__ == 11000033  gsl_COMPILER_APPLECLANG_VERSION == 1100  (Xcode 11.1, 11.2, 11.3)    (LLVM 8.0.0?)
-
-#if defined( __apple_build_version__ )
-# define gsl_COMPILER_APPLECLANG_VERSION gsl_COMPILER_VERSION( __clang_major__, __clang_minor__, __clang_patchlevel__ )
-# define gsl_COMPILER_CLANG_VERSION 0
-#elif defined( __clang__ )
-# define gsl_COMPILER_APPLECLANG_VERSION 0
-# define gsl_COMPILER_CLANG_VERSION gsl_COMPILER_VERSION( __clang_major__, __clang_minor__, __clang_patchlevel__ )
+#define gsl_COMPILER_MSVC_VER 0
+#define gsl_COMPILER_MSVC_VERSION 0
+#define gsl_COMPILER_MSVC_VERSION_FULL 0
+#endif
+
+#define gsl_COMPILER_VERSION(major, minor, patch)                              \
+    (10 * (10 * (major) + (minor)) + (patch))
+
+// AppleClang  7.0.0  __apple_build_version__ ==  7000172
+// gsl_COMPILER_APPLECLANG_VERSION ==  700  (Xcode 7.0, 7.0.1) (LLVM 3.7.0)
+// AppleClang  7.0.0  __apple_build_version__ ==  7000176
+// gsl_COMPILER_APPLECLANG_VERSION ==  700  (Xcode 7.1) (LLVM 3.7.0)
+// AppleClang  7.0.2  __apple_build_version__ ==  7000181
+// gsl_COMPILER_APPLECLANG_VERSION ==  702  (Xcode 7.2, 7.2.1) (LLVM 3.7.0)
+// AppleClang  7.3.0  __apple_build_version__ ==  7030029
+// gsl_COMPILER_APPLECLANG_VERSION ==  730  (Xcode 7.3) (LLVM 3.8.0)
+// AppleClang  7.3.0  __apple_build_version__ ==  7030031
+// gsl_COMPILER_APPLECLANG_VERSION ==  730  (Xcode 7.3.1) (LLVM 3.8.0)
+// AppleClang  8.0.0  __apple_build_version__ ==  8000038
+// gsl_COMPILER_APPLECLANG_VERSION ==  800  (Xcode 8.0) (LLVM 3.9.0)
+// AppleClang  8.0.0  __apple_build_version__ ==  8000042
+// gsl_COMPILER_APPLECLANG_VERSION ==  800  (Xcode 8.1, 8.2, 8.2.1) (LLVM 3.9.0)
+// AppleClang  8.1.0  __apple_build_version__ ==  8020038
+// gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3) (LLVM 3.9.0)
+// AppleClang  8.1.0  __apple_build_version__ ==  8020041
+// gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3.1) (LLVM 3.9.0)
+// AppleClang  8.1.0  __apple_build_version__ ==  8020042
+// gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3.2, 8.3.3) (LLVM 3.9.0)
+// AppleClang  9.0.0  __apple_build_version__ ==  9000037
+// gsl_COMPILER_APPLECLANG_VERSION ==  900  (Xcode 9.0) (LLVM 4.0.0?) AppleClang
+// 9.0.0  __apple_build_version__ ==  9000038  gsl_COMPILER_APPLECLANG_VERSION
+// ==  900  (Xcode 9.1)                 (LLVM 4.0.0?) AppleClang  9.0.0
+// __apple_build_version__ ==  9000039  gsl_COMPILER_APPLECLANG_VERSION ==  900
+// (Xcode 9.2)                 (LLVM 4.0.0?) AppleClang  9.1.0
+// __apple_build_version__ ==  9020039  gsl_COMPILER_APPLECLANG_VERSION ==  910
+// (Xcode 9.3, 9.3.1)          (LLVM 5.0.2?) AppleClang  9.1.0
+// __apple_build_version__ ==  9020039  gsl_COMPILER_APPLECLANG_VERSION ==  910
+// (Xcode 9.4, 9.4.1)          (LLVM 5.0.2?) AppleClang 10.0.0
+// __apple_build_version__ == 10001145  gsl_COMPILER_APPLECLANG_VERSION == 1000
+// (Xcode 10.0, 10.1)          (LLVM 6.0.1?) AppleClang 10.0.1
+// __apple_build_version__ == 10010046  gsl_COMPILER_APPLECLANG_VERSION == 1001
+// (Xcode 10.2, 10.2.1, 10.3)  (LLVM 7.0.0?) AppleClang 11.0.0
+// __apple_build_version__ == 11000033  gsl_COMPILER_APPLECLANG_VERSION == 1100
+// (Xcode 11.1, 11.2, 11.3)    (LLVM 8.0.0?)
+
+#if defined(__apple_build_version__)
+#define gsl_COMPILER_APPLECLANG_VERSION                                        \
+    gsl_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#define gsl_COMPILER_CLANG_VERSION 0
+#elif defined(__clang__)
+#define gsl_COMPILER_APPLECLANG_VERSION 0
+#define gsl_COMPILER_CLANG_VERSION                                             \
+    gsl_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
 #else
-# define gsl_COMPILER_APPLECLANG_VERSION 0
-# define gsl_COMPILER_CLANG_VERSION 0
+#define gsl_COMPILER_APPLECLANG_VERSION 0
+#define gsl_COMPILER_CLANG_VERSION 0
 #endif
 
 #if defined(__GNUC__) && !defined(__clang__)
-# define gsl_COMPILER_GNUC_VERSION gsl_COMPILER_VERSION( __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__ )
+#define gsl_COMPILER_GNUC_VERSION                                              \
+    gsl_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
 #else
-# define gsl_COMPILER_GNUC_VERSION 0
+#define gsl_COMPILER_GNUC_VERSION 0
 #endif
 
 // Compiler non-strict aliasing:
 
 #if defined(__clang__) || defined(__GNUC__)
-# define gsl_may_alias  __attribute__((__may_alias__))
+#define gsl_may_alias __attribute__((__may_alias__))
 #else
-# define gsl_may_alias
+#define gsl_may_alias
 #endif
 
 // Presence of gsl, language and library features:
 
-#define gsl_IN_STD( v )  ( ((v) == 98 ? 3 : (v)) >= gsl_CPLUSPLUS_V )
+#define gsl_IN_STD(v) (((v) == 98 ? 3 : (v)) >= gsl_CPLUSPLUS_V)
 
-#define gsl_DEPRECATE_TO_LEVEL( level )  ( level <= gsl_CONFIG_DEPRECATE_TO_LEVEL )
-#define gsl_FEATURE_TO_STD(   feature )  ( gsl_IN_STD( gsl_FEATURE( feature##_TO_STD ) ) )
-#define gsl_FEATURE(          feature )  ( gsl_FEATURE_##feature )
-#define gsl_CONFIG(           feature )  ( gsl_CONFIG_##feature )
-#define gsl_HAVE(             feature )  ( gsl_HAVE_##feature )
+#define gsl_DEPRECATE_TO_LEVEL(level) (level <= gsl_CONFIG_DEPRECATE_TO_LEVEL)
+#define gsl_FEATURE_TO_STD(feature) (gsl_IN_STD(gsl_FEATURE(feature##_TO_STD)))
+#define gsl_FEATURE(feature) (gsl_FEATURE_##feature)
+#define gsl_CONFIG(feature) (gsl_CONFIG_##feature)
+#define gsl_HAVE(feature) (gsl_HAVE_##feature)
 
 // Presence of wide character support:
 
 #ifdef __DJGPP__
-# define gsl_HAVE_WCHAR 0
+#define gsl_HAVE_WCHAR 0
 #else
-# define gsl_HAVE_WCHAR 1
+#define gsl_HAVE_WCHAR 1
 #endif
 
 // Presence of language & library features:
 
-#if gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 500) || gsl_BETWEEN(gsl_COMPILER_CLANG_VERSION, 1, 360) || gsl_COMPILER_APPLECLANG_VERSION
-# ifdef __EXCEPTIONS
-#  define gsl_HAVE_EXCEPTIONS  1
-# else
-#  define gsl_HAVE_EXCEPTIONS  0
-# endif // __EXCEPTIONS
+#if gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 500) ||                          \
+    gsl_BETWEEN(gsl_COMPILER_CLANG_VERSION, 1, 360) ||                         \
+    gsl_COMPILER_APPLECLANG_VERSION
+#ifdef __EXCEPTIONS
+#define gsl_HAVE_EXCEPTIONS 1
+#else
+#define gsl_HAVE_EXCEPTIONS 0
+#endif // __EXCEPTIONS
 #elif gsl_COMPILER_GNUC_VERSION >= 500 || gsl_COMPILER_CLANG_VERSION >= 500
-# ifdef __cpp_exceptions
-#  define gsl_HAVE_EXCEPTIONS  1
-# else
-#  define gsl_HAVE_EXCEPTIONS  0
-# endif // __cpp_exceptions
+#ifdef __cpp_exceptions
+#define gsl_HAVE_EXCEPTIONS 1
+#else
+#define gsl_HAVE_EXCEPTIONS 0
+#endif // __cpp_exceptions
 #elif gsl_COMPILER_MSVC_VERSION
-# ifdef _CPPUNWIND
-#  define gsl_HAVE_EXCEPTIONS  1
-# else
-#  define gsl_HAVE_EXCEPTIONS  0
-# endif // _CPPUNWIND
+#ifdef _CPPUNWIND
+#define gsl_HAVE_EXCEPTIONS 1
+#else
+#define gsl_HAVE_EXCEPTIONS 0
+#endif // _CPPUNWIND
 #else
 // For all other compilers, assume exceptions are always enabled.
-# define  gsl_HAVE_EXCEPTIONS  1
+#define gsl_HAVE_EXCEPTIONS 1
 #endif
 
-#if defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS ) && !gsl_HAVE( EXCEPTIONS )
+#if defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS) && !gsl_HAVE(EXCEPTIONS)
 # error Cannot use gsl_CONFIG_CONTRACT_VIOLATION_THROWS if exceptions are disabled.
-#endif // defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS ) && !gsl_HAVE( EXCEPTIONS )
+#endif // defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS ) && !gsl_HAVE(
+       // EXCEPTIONS )
 
 #ifdef _HAS_CPP0X
-# define gsl_HAS_CPP0X  _HAS_CPP0X
+#define gsl_HAS_CPP0X _HAS_CPP0X
 #else
-# define gsl_HAS_CPP0X  0
+#define gsl_HAS_CPP0X 0
 #endif
 
-#define gsl_CPP11_100  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1600)
-#define gsl_CPP11_110  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1700)
-#define gsl_CPP11_120  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1800)
-#define gsl_CPP11_140  (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
+#define gsl_CPP11_100 (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1600)
+#define gsl_CPP11_110 (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1700)
+#define gsl_CPP11_120 (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1800)
+#define gsl_CPP11_140 (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
 
-#define gsl_CPP14_000  (gsl_CPP14_OR_GREATER)
-#define gsl_CPP14_120  (gsl_CPP14_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1800)
-#define gsl_CPP14_140  (gsl_CPP14_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
+#define gsl_CPP14_000 (gsl_CPP14_OR_GREATER)
+#define gsl_CPP14_120 (gsl_CPP14_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1800)
+#define gsl_CPP14_140 (gsl_CPP14_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
 
-#define gsl_CPP17_000  (gsl_CPP17_OR_GREATER)
-#define gsl_CPP17_140  (gsl_CPP17_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
+#define gsl_CPP17_000 (gsl_CPP17_OR_GREATER)
+#define gsl_CPP17_140 (gsl_CPP17_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
 
-#define gsl_CPP11_140_CPP0X_90   (gsl_CPP11_140 || (gsl_COMPILER_MSVC_VER >= 1500 && gsl_HAS_CPP0X))
-#define gsl_CPP11_140_CPP0X_100  (gsl_CPP11_140 || (gsl_COMPILER_MSVC_VER >= 1600 && gsl_HAS_CPP0X))
+#define gsl_CPP11_140_CPP0X_90                                                 \
+    (gsl_CPP11_140 || (gsl_COMPILER_MSVC_VER >= 1500 && gsl_HAS_CPP0X))
+#define gsl_CPP11_140_CPP0X_100                                                \
+    (gsl_CPP11_140 || (gsl_COMPILER_MSVC_VER >= 1600 && gsl_HAS_CPP0X))
 
 // Presence of C++11 language features:
 
-#define gsl_HAVE_AUTO                   gsl_CPP11_100
-#define gsl_HAVE_NULLPTR                gsl_CPP11_100
-#define gsl_HAVE_RVALUE_REFERENCE       gsl_CPP11_100
-#define gsl_HAVE_FUNCTION_REF_QUALIFIER ( gsl_CPP14_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 481 ) )
+#define gsl_HAVE_AUTO gsl_CPP11_100
+#define gsl_HAVE_NULLPTR gsl_CPP11_100
+#define gsl_HAVE_RVALUE_REFERENCE gsl_CPP11_100
+#define gsl_HAVE_FUNCTION_REF_QUALIFIER                                        \
+    (gsl_CPP14_140 && !gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 481))
 
-#define gsl_HAVE_ENUM_CLASS             gsl_CPP11_110
+#define gsl_HAVE_ENUM_CLASS gsl_CPP11_110
 
-#define gsl_HAVE_ALIAS_TEMPLATE         gsl_CPP11_120
-#define gsl_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG  gsl_CPP11_120
-#define gsl_HAVE_EXPLICIT               gsl_CPP11_120
-#define gsl_HAVE_INITIALIZER_LIST       gsl_CPP11_120
-#define gsl_HAVE_VARIADIC_TEMPLATE      gsl_CPP11_120
-#define gsl_HAVE_IS_DELETE              gsl_CPP11_120
+#define gsl_HAVE_ALIAS_TEMPLATE gsl_CPP11_120
+#define gsl_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG gsl_CPP11_120
+#define gsl_HAVE_EXPLICIT gsl_CPP11_120
+#define gsl_HAVE_INITIALIZER_LIST gsl_CPP11_120
+#define gsl_HAVE_VARIADIC_TEMPLATE gsl_CPP11_120
+#define gsl_HAVE_IS_DELETE gsl_CPP11_120
 
-#define gsl_HAVE_CONSTEXPR_11           gsl_CPP11_140
-#define gsl_HAVE_IS_DEFAULT             gsl_CPP11_140
-#define gsl_HAVE_NOEXCEPT               gsl_CPP11_140
-#define gsl_HAVE_NORETURN               ( gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 480 ) )
+#define gsl_HAVE_CONSTEXPR_11 gsl_CPP11_140
+#define gsl_HAVE_IS_DEFAULT gsl_CPP11_140
+#define gsl_HAVE_NOEXCEPT gsl_CPP11_140
+#define gsl_HAVE_NORETURN                                                      \
+    (gsl_CPP11_140 && !gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 480))
 
-#define gsl_HAVE_EXPRESSION_SFINAE      gsl_CPP11_140
+#define gsl_HAVE_EXPRESSION_SFINAE gsl_CPP11_140
 
 #if gsl_CPP11_OR_GREATER
 // see above
@@ -369,1207 +419,1200 @@
 
 // Presence of C++14 language features:
 
-#define gsl_HAVE_CONSTEXPR_14           ( gsl_CPP14_000 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 600 ) )
-#define gsl_HAVE_DECLTYPE_AUTO          gsl_CPP14_140
-#define gsl_HAVE_DEPRECATED             ( gsl_CPP14_140 && ! gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 142 ) )
+#define gsl_HAVE_CONSTEXPR_14                                                  \
+    (gsl_CPP14_000 && !gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 600))
+#define gsl_HAVE_DECLTYPE_AUTO gsl_CPP14_140
+#define gsl_HAVE_DEPRECATED                                                    \
+    (gsl_CPP14_140 && !gsl_BETWEEN(gsl_COMPILER_MSVC_VERSION, 1, 142))
 
 // Presence of C++17 language features:
 // MSVC: template parameter deduction guides since Visual Studio 2017 v15.7
 
-#define gsl_HAVE_ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE  gsl_CPP17_000
-#define gsl_HAVE_DEDUCTION_GUIDES       ( gsl_CPP17_000 && ! gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION_FULL, 1, 1414 ) )
-#define gsl_HAVE_NODISCARD              gsl_CPP17_000
-#define gsl_HAVE_CONSTEXPR_17           gsl_CPP17_OR_GREATER
+#define gsl_HAVE_ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE gsl_CPP17_000
+#define gsl_HAVE_DEDUCTION_GUIDES                                              \
+    (gsl_CPP17_000 && !gsl_BETWEEN(gsl_COMPILER_MSVC_VERSION_FULL, 1, 1414))
+#define gsl_HAVE_NODISCARD gsl_CPP17_000
+#define gsl_HAVE_CONSTEXPR_17 gsl_CPP17_OR_GREATER
 
 // Presence of C++20 language features:
 
-#define gsl_HAVE_CONSTEXPR_20           gsl_CPP20_OR_GREATER
+#define gsl_HAVE_CONSTEXPR_20 gsl_CPP20_OR_GREATER
 
 // Presence of C++ library features:
 
-#define gsl_HAVE_ADDRESSOF              gsl_CPP17_000
-#define gsl_HAVE_ARRAY                  gsl_CPP11_110
-#define gsl_HAVE_TYPE_TRAITS            gsl_CPP11_110
-#define gsl_HAVE_TR1_TYPE_TRAITS        gsl_CPP11_110
+#define gsl_HAVE_ADDRESSOF gsl_CPP17_000
+#define gsl_HAVE_ARRAY gsl_CPP11_110
+#define gsl_HAVE_TYPE_TRAITS gsl_CPP11_110
+#define gsl_HAVE_TR1_TYPE_TRAITS gsl_CPP11_110
 
-#define gsl_HAVE_CONTAINER_DATA_METHOD  gsl_CPP11_140_CPP0X_90
-#define gsl_HAVE_STD_DATA               gsl_CPP17_000
+#define gsl_HAVE_CONTAINER_DATA_METHOD gsl_CPP11_140_CPP0X_90
+#define gsl_HAVE_STD_DATA gsl_CPP17_000
 #ifdef __cpp_lib_ssize
-# define gsl_HAVE_STD_SSIZE             1
+#define gsl_HAVE_STD_SSIZE 1
 #else
-# define gsl_HAVE_STD_SSIZE             ( gsl_COMPILER_GNUC_VERSION >= 1000 && __cplusplus > 201703L )
+#define gsl_HAVE_STD_SSIZE                                                     \
+    (gsl_COMPILER_GNUC_VERSION >= 1000 && __cplusplus > 201703L)
 #endif
 
-#define gsl_HAVE_SIZED_TYPES            gsl_CPP11_140
+#define gsl_HAVE_SIZED_TYPES gsl_CPP11_140
 
-#define gsl_HAVE_MAKE_SHARED            gsl_CPP11_140_CPP0X_100
-#define gsl_HAVE_SHARED_PTR             gsl_CPP11_140_CPP0X_100
-#define gsl_HAVE_UNIQUE_PTR             gsl_CPP11_140_CPP0X_100
+#define gsl_HAVE_MAKE_SHARED gsl_CPP11_140_CPP0X_100
+#define gsl_HAVE_SHARED_PTR gsl_CPP11_140_CPP0X_100
+#define gsl_HAVE_UNIQUE_PTR gsl_CPP11_140_CPP0X_100
 
-#define gsl_HAVE_MAKE_UNIQUE            gsl_CPP14_120
+#define gsl_HAVE_MAKE_UNIQUE gsl_CPP14_120
 
-#define gsl_HAVE_UNCAUGHT_EXCEPTIONS    gsl_CPP17_140
+#define gsl_HAVE_UNCAUGHT_EXCEPTIONS gsl_CPP17_140
 
-#define gsl_HAVE_ADD_CONST              gsl_HAVE_TYPE_TRAITS
-#define gsl_HAVE_INTEGRAL_CONSTANT      gsl_HAVE_TYPE_TRAITS
-#define gsl_HAVE_REMOVE_CONST           gsl_HAVE_TYPE_TRAITS
-#define gsl_HAVE_REMOVE_REFERENCE       gsl_HAVE_TYPE_TRAITS
-#define gsl_HAVE_REMOVE_CVREF           gsl_CPP20_OR_GREATER
+#define gsl_HAVE_ADD_CONST gsl_HAVE_TYPE_TRAITS
+#define gsl_HAVE_INTEGRAL_CONSTANT gsl_HAVE_TYPE_TRAITS
+#define gsl_HAVE_REMOVE_CONST gsl_HAVE_TYPE_TRAITS
+#define gsl_HAVE_REMOVE_REFERENCE gsl_HAVE_TYPE_TRAITS
+#define gsl_HAVE_REMOVE_CVREF gsl_CPP20_OR_GREATER
 
-#define gsl_HAVE_TR1_ADD_CONST          gsl_HAVE_TR1_TYPE_TRAITS
-#define gsl_HAVE_TR1_INTEGRAL_CONSTANT  gsl_HAVE_TR1_TYPE_TRAITS
-#define gsl_HAVE_TR1_REMOVE_CONST       gsl_HAVE_TR1_TYPE_TRAITS
-#define gsl_HAVE_TR1_REMOVE_REFERENCE   gsl_HAVE_TR1_TYPE_TRAITS
+#define gsl_HAVE_TR1_ADD_CONST gsl_HAVE_TR1_TYPE_TRAITS
+#define gsl_HAVE_TR1_INTEGRAL_CONSTANT gsl_HAVE_TR1_TYPE_TRAITS
+#define gsl_HAVE_TR1_REMOVE_CONST gsl_HAVE_TR1_TYPE_TRAITS
+#define gsl_HAVE_TR1_REMOVE_REFERENCE gsl_HAVE_TR1_TYPE_TRAITS
 
 // C++ feature usage:
 
-#if gsl_HAVE( ADDRESSOF )
-# define gsl_ADDRESSOF(x)  std::addressof(x)
+#if gsl_HAVE(ADDRESSOF)
+#define gsl_ADDRESSOF(x) std::addressof(x)
 #else
-# define gsl_ADDRESSOF(x)  (&x)
+#define gsl_ADDRESSOF(x) (&x)
 #endif
 
-#if gsl_HAVE( CONSTEXPR_11 )
-# define gsl_constexpr constexpr
+#if gsl_HAVE(CONSTEXPR_11)
+#define gsl_constexpr constexpr
 #else
-# define gsl_constexpr /*constexpr*/
+#define gsl_constexpr /*constexpr*/
 #endif
 
-#if gsl_HAVE( CONSTEXPR_14 )
-# define gsl_constexpr14 constexpr
+#if gsl_HAVE(CONSTEXPR_14)
+#define gsl_constexpr14 constexpr
 #else
-# define gsl_constexpr14 /*constexpr*/
+#define gsl_constexpr14 /*constexpr*/
 #endif
 
-#if gsl_HAVE( CONSTEXPR_17 )
-# define gsl_constexpr17 constexpr
+#if gsl_HAVE(CONSTEXPR_17)
+#define gsl_constexpr17 constexpr
 #else
-# define gsl_constexpr17 /*constexpr*/
+#define gsl_constexpr17 /*constexpr*/
 #endif
 
-#if gsl_HAVE( CONSTEXPR_20 )
-# define gsl_constexpr20 constexpr
+#if gsl_HAVE(CONSTEXPR_20)
+#define gsl_constexpr20 constexpr
 #else
-# define gsl_constexpr20 /*constexpr*/
+#define gsl_constexpr20 /*constexpr*/
 #endif
 
-#if gsl_HAVE( EXPLICIT )
-# define gsl_explicit explicit
+#if gsl_HAVE(EXPLICIT)
+#define gsl_explicit explicit
 #else
-# define gsl_explicit /*explicit*/
+#define gsl_explicit /*explicit*/
 #endif
 
-#if gsl_FEATURE( IMPLICIT_MACRO )
-# define implicit /*implicit*/
+#if gsl_FEATURE(IMPLICIT_MACRO)
+#define implicit /*implicit*/
 #endif
 
-#if gsl_HAVE( IS_DELETE )
-# define gsl_is_delete = delete
+#if gsl_HAVE(IS_DELETE)
+#define gsl_is_delete = delete
 #else
-# define gsl_is_delete
+#define gsl_is_delete
 #endif
 
-#if gsl_HAVE( IS_DELETE )
-# define gsl_is_delete_access public
+#if gsl_HAVE(IS_DELETE)
+#define gsl_is_delete_access public
 #else
-# define gsl_is_delete_access private
+#define gsl_is_delete_access private
 #endif
 
-#if !gsl_HAVE( NOEXCEPT ) || defined( gsl_TESTING_ )
-# define gsl_noexcept /*noexcept*/
+#if !gsl_HAVE(NOEXCEPT) || defined(gsl_TESTING_)
+#define gsl_noexcept /*noexcept*/
 #else
-# define gsl_noexcept noexcept
+#define gsl_noexcept noexcept
 #endif
 
-#if gsl_HAVE( NULLPTR )
-# define gsl_nullptr  nullptr
+#if gsl_HAVE(NULLPTR)
+#define gsl_nullptr nullptr
 #else
-# define gsl_nullptr  NULL
+#define gsl_nullptr NULL
 #endif
 
-#if gsl_HAVE( NODISCARD )
-# define gsl_NODISCARD [[nodiscard]]
+#if gsl_HAVE(NODISCARD)
+#define gsl_NODISCARD [[nodiscard]]
 #else
-# define gsl_NODISCARD
+#define gsl_NODISCARD
 #endif
 
-#if gsl_HAVE( NORETURN )
-# define gsl_NORETURN [[noreturn]]
+#if gsl_HAVE(NORETURN)
+#define gsl_NORETURN [[noreturn]]
 #elif defined(_MSC_VER)
-# define gsl_NORETURN __declspec(noreturn)
+#define gsl_NORETURN __declspec(noreturn)
 #else
-# define gsl_NORETURN
+#define gsl_NORETURN
 #endif
 
-#if gsl_HAVE( DEPRECATED ) && !defined( gsl_TESTING_ )
-# define gsl_DEPRECATED             [[deprecated]]
-# define gsl_DEPRECATED_MSG( msg )  [[deprecated( msg )]]
+#if gsl_HAVE(DEPRECATED) && !defined(gsl_TESTING_)
+#define gsl_DEPRECATED [[deprecated]]
+#define gsl_DEPRECATED_MSG(msg) [[deprecated(msg)]]
 #else
-# define gsl_DEPRECATED
-# define gsl_DEPRECATED_MSG( msg )
-#endif
-
-#if gsl_HAVE( TYPE_TRAITS )
-
-#define gsl_DEFINE_ENUM_BITMASK_OPERATORS_( ENUM )                    \
-    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM                   \
-    operator~( ENUM val ) gsl_noexcept                                \
-    {                                                                 \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
-        return ENUM( ~U( val ) );                                     \
-    }                                                                 \
-    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM                   \
-    operator|( ENUM lhs, ENUM rhs ) gsl_noexcept                      \
-    {                                                                 \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
-        return ENUM( U( lhs ) | U( rhs ) );                           \
-    }                                                                 \
-    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM                   \
-    operator&( ENUM lhs, ENUM rhs ) gsl_noexcept                      \
-    {                                                                 \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
-        return ENUM( U( lhs ) & U( rhs ) );                           \
-    }                                                                 \
-    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM                   \
-    operator^( ENUM lhs, ENUM rhs ) gsl_noexcept                      \
-    {                                                                 \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
-        return ENUM( U( lhs ) ^ U( rhs ) );                           \
-    }                                                                 \
-    gsl_api inline gsl_constexpr14 ENUM &                             \
-    operator|=( ENUM & lhs, ENUM rhs ) gsl_noexcept                   \
-    {                                                                 \
-        return lhs = lhs | rhs;                                       \
-    }                                                                 \
-    gsl_api inline gsl_constexpr14 ENUM &                             \
-    operator&=( ENUM & lhs, ENUM rhs ) gsl_noexcept                   \
-    {                                                                 \
-        return lhs = lhs & rhs;                                       \
-    }                                                                 \
-    gsl_api inline gsl_constexpr14 ENUM &                             \
-    operator^=( ENUM & lhs, ENUM rhs ) gsl_noexcept                   \
-    {                                                                 \
-        return lhs = lhs ^ rhs;                                       \
-    }
-
-#define gsl_DEFINE_ENUM_RELATIONAL_OPERATORS_( ENUM )                 \
-    gsl_NODISCARD gsl_api inline gsl_constexpr bool                   \
-    operator<( ENUM lhs, ENUM rhs ) gsl_noexcept                      \
-    {                                                                 \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
-        return U( lhs ) < U( rhs );                                   \
-    }                                                                 \
-    gsl_NODISCARD gsl_api inline gsl_constexpr bool                   \
-    operator>( ENUM lhs, ENUM rhs ) gsl_noexcept                      \
-    {                                                                 \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
-        return U( lhs ) > U( rhs );                                   \
-    }                                                                 \
-    gsl_NODISCARD gsl_api inline gsl_constexpr bool                   \
-    operator<=( ENUM lhs, ENUM rhs ) gsl_noexcept                     \
-    {                                                                 \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
-        return U( lhs ) <= U( rhs );                                  \
-    }                                                                 \
-    gsl_NODISCARD gsl_api inline gsl_constexpr bool                   \
-    operator>=( ENUM lhs, ENUM rhs ) gsl_noexcept                     \
-    {                                                                 \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U; \
-        return U( lhs ) >= U( rhs );                                  \
+#define gsl_DEPRECATED
+#define gsl_DEPRECATED_MSG(msg)
+#endif
+
+#if gsl_HAVE(TYPE_TRAITS)
+
+#define gsl_DEFINE_ENUM_BITMASK_OPERATORS_(ENUM)                               \
+    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM operator~(ENUM val)        \
+        gsl_noexcept {                                                         \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
+        return ENUM(~U(val));                                                  \
+    }                                                                          \
+    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM operator|(                 \
+        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
+        return ENUM(U(lhs) | U(rhs));                                          \
+    }                                                                          \
+    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM operator&(                 \
+        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
+        return ENUM(U(lhs) & U(rhs));                                          \
+    }                                                                          \
+    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM operator^(                 \
+        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
+        return ENUM(U(lhs) ^ U(rhs));                                          \
+    }                                                                          \
+    gsl_api inline gsl_constexpr14 ENUM &operator|=(ENUM &lhs, ENUM rhs)       \
+        gsl_noexcept {                                                         \
+        return lhs = lhs | rhs;                                                \
+    }                                                                          \
+    gsl_api inline gsl_constexpr14 ENUM &operator&=(ENUM &lhs, ENUM rhs)       \
+        gsl_noexcept {                                                         \
+        return lhs = lhs & rhs;                                                \
+    }                                                                          \
+    gsl_api inline gsl_constexpr14 ENUM &operator^=(ENUM &lhs, ENUM rhs)       \
+        gsl_noexcept {                                                         \
+        return lhs = lhs ^ rhs;                                                \
+    }
+
+#define gsl_DEFINE_ENUM_RELATIONAL_OPERATORS_(ENUM)                            \
+    gsl_NODISCARD gsl_api inline gsl_constexpr bool operator<(                 \
+        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
+        return U(lhs) < U(rhs);                                                \
+    }                                                                          \
+    gsl_NODISCARD gsl_api inline gsl_constexpr bool operator>(                 \
+        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
+        return U(lhs) > U(rhs);                                                \
+    }                                                                          \
+    gsl_NODISCARD gsl_api inline gsl_constexpr bool operator<=(                \
+        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
+        return U(lhs) <= U(rhs);                                               \
+    }                                                                          \
+    gsl_NODISCARD gsl_api inline gsl_constexpr bool operator>=(                \
+        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
+        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
+        return U(lhs) >= U(rhs);                                               \
     }
 
-    //
-    // Defines bitmask operators `|`, `&`, `^`, `~`, `|=`, `&=`, and `^=` for the given enum type.
-    //ᅟ
-    //ᅟ    enum class Vegetables {
-    //ᅟ        tomato   = 0b001,
-    //ᅟ        onion    = 0b010,
-    //ᅟ        eggplant = 0b100
-    //ᅟ    };
-    //ᅟ    gsl_DEFINE_ENUM_BITMASK_OPERATORS( Vegetables )
-    //
-#define gsl_DEFINE_ENUM_BITMASK_OPERATORS( ENUM ) gsl_DEFINE_ENUM_BITMASK_OPERATORS_( ENUM )
+//
+// Defines bitmask operators `|`, `&`, `^`, `~`, `|=`, `&=`, and `^=` for the
+// given enum type.
+//ᅟ
+//ᅟ    enum class Vegetables {
+//ᅟ        tomato   = 0b001,
+//ᅟ        onion    = 0b010,
+//ᅟ        eggplant = 0b100
+//ᅟ    };
+//ᅟ    gsl_DEFINE_ENUM_BITMASK_OPERATORS( Vegetables )
+//
+#define gsl_DEFINE_ENUM_BITMASK_OPERATORS(ENUM)                                \
+    gsl_DEFINE_ENUM_BITMASK_OPERATORS_(ENUM)
 
-    //
-    // Defines relational operators `<`, `>`, `<=`, `>=` for the given enum type.
-    //ᅟ
-    //ᅟ    enum class OperatorPrecedence {
-    //ᅟ        additive = 0,
-    //ᅟ        multiplicative = 1,
-    //ᅟ        power = 2
-    //ᅟ    };
-    //ᅟ    gsl_DEFINE_ENUM_RELATIONAL_OPERATORS( OperatorPrecedence )
-    //
-#define gsl_DEFINE_ENUM_RELATIONAL_OPERATORS( ENUM ) gsl_DEFINE_ENUM_RELATIONAL_OPERATORS_( ENUM )
+//
+// Defines relational operators `<`, `>`, `<=`, `>=` for the given enum type.
+//ᅟ
+//ᅟ    enum class OperatorPrecedence {
+//ᅟ        additive = 0,
+//ᅟ        multiplicative = 1,
+//ᅟ        power = 2
+//ᅟ    };
+//ᅟ    gsl_DEFINE_ENUM_RELATIONAL_OPERATORS( OperatorPrecedence )
+//
+#define gsl_DEFINE_ENUM_RELATIONAL_OPERATORS(ENUM)                             \
+    gsl_DEFINE_ENUM_RELATIONAL_OPERATORS_(ENUM)
 
 #endif // gsl_HAVE( TYPE_TRAITS )
 
-#define gsl_DIMENSION_OF( a ) ( sizeof(a) / sizeof(0[a]) )
-
+#define gsl_DIMENSION_OF(a) (sizeof(a) / sizeof(0 [a]))
 
 // Method enabling (C++98, VC120 (VS2013) cannot use __VA_ARGS__)
 
-#if gsl_HAVE( EXPRESSION_SFINAE )
-# define gsl_DECLTYPE_(T, EXPR) decltype( EXPR )
+#if gsl_HAVE(EXPRESSION_SFINAE)
+#define gsl_DECLTYPE_(T, EXPR) decltype(EXPR)
 #else
-# define gsl_DECLTYPE_(T, EXPR) T
+#define gsl_DECLTYPE_(T, EXPR) T
 #endif
 
-// NOTE: When using SFINAE in gsl-lite, please note that overloads of function templates must always use SFINAE with non-type default arguments
-//       as explained in https://en.cppreference.com/w/cpp/types/enable_if#Notes. `gsl_ENABLE_IF_()` implements graceful fallback to default
-//       type arguments (for compilers that don't support non-type default arguments); please verify that this is appropriate in the given
+// NOTE: When using SFINAE in gsl-lite, please note that overloads of function
+// templates must always use SFINAE with non-type default arguments
+//       as explained in
+//       https://en.cppreference.com/w/cpp/types/enable_if#Notes.
+//       `gsl_ENABLE_IF_()` implements graceful fallback to default type
+//       arguments (for compilers that don't support non-type default
+//       arguments); please verify that this is appropriate in the given
 //       situation, and add additional checks if necessary.
 //
-//       Also, please note that `gsl_ENABLE_IF_()` doesn't enforce the constraint at all if no compiler/library support is available (i.e. pre-C++11).
-
-#if gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
-# if !gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 140 ) // VS 2013 seems to have trouble with SFINAE for default non-type arguments
-#  define gsl_ENABLE_IF_(VA) , typename std::enable_if< ( VA ), int >::type = 0
-# else
-#  define gsl_ENABLE_IF_(VA) , typename = typename std::enable_if< ( VA ), ::gsl::detail::enabler >::type
-# endif
+//       Also, please note that `gsl_ENABLE_IF_()` doesn't enforce the
+//       constraint at all if no compiler/library support is available (i.e.
+//       pre-C++11).
+
+#if gsl_HAVE(TYPE_TRAITS) && gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG)
+#if !gsl_BETWEEN(gsl_COMPILER_MSVC_VERSION, 1,                                 \
+                 140) // VS 2013 seems to have trouble with SFINAE for default
+                      // non-type arguments
+#define gsl_ENABLE_IF_(VA) , typename std::enable_if<(VA), int>::type = 0
 #else
-# define  gsl_ENABLE_IF_(VA)
+#define gsl_ENABLE_IF_(VA)                                                     \
+    , typename = typename std::enable_if<(VA), ::gsl::detail::enabler>::type
+#endif
+#else
+#define gsl_ENABLE_IF_(VA)
 #endif
-
 
 // Other features:
 
-#define gsl_HAVE_CONSTRAINED_SPAN_CONTAINER_CTOR  \
-    ( gsl_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG && gsl_HAVE_CONTAINER_DATA_METHOD )
+#define gsl_HAVE_CONSTRAINED_SPAN_CONTAINER_CTOR                               \
+    (gsl_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG && gsl_HAVE_CONTAINER_DATA_METHOD)
 
 // Note: !defined(__NVCC__) doesn't work with nvcc here:
-#define gsl_HAVE_UNCONSTRAINED_SPAN_CONTAINER_CTOR  \
-    ( gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR && (__NVCC__== 0) )
+#define gsl_HAVE_UNCONSTRAINED_SPAN_CONTAINER_CTOR                             \
+    (gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR && (__NVCC__ == 0))
 
 // GSL API (e.g. for CUDA platform):
 
 // Guidelines for using `gsl_api`:
 //
-// NVCC imposes the restriction that a function annotated `__host__ __device__` cannot call host-only or device-only functions.
-// This makes `gsl_api` inappropriate for generic functions that call unknown code, e.g. the template constructors of `span<>`
-// or functions like `finally()` which accept an arbitrary  function object.
-// It is often preferable to annotate functions only with `gsl_constexpr` or `gsl_constexpr14`. The "extended constexpr" mode
-// of NVCC (currently an experimental feature) will implicitly consider constexpr functions `__host__ __device__` functions
-// but tolerates calls to host-only or device-only functions.
-
-#ifndef   gsl_api
-# ifdef   __CUDACC__
-#  define gsl_api __host__ __device__
-# else
-#  define gsl_api /*gsl_api*/
-# endif
+// NVCC imposes the restriction that a function annotated `__host__ __device__`
+// cannot call host-only or device-only functions. This makes `gsl_api`
+// inappropriate for generic functions that call unknown code, e.g. the template
+// constructors of `span<>` or functions like `finally()` which accept an
+// arbitrary  function object. It is often preferable to annotate functions only
+// with `gsl_constexpr` or `gsl_constexpr14`. The "extended constexpr" mode of
+// NVCC (currently an experimental feature) will implicitly consider constexpr
+// functions `__host__ __device__` functions but tolerates calls to host-only or
+// device-only functions.
+
+#ifndef gsl_api
+#ifdef __CUDACC__
+#define gsl_api __host__ __device__
+#else
+#define gsl_api /*gsl_api*/
+#endif
 #endif
 
 // Additional includes:
 
-#if gsl_HAVE( ARRAY )
-# include <array>
+#if gsl_HAVE(ARRAY)
+#include <array>
 #endif
 
-#if !gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR ) || !gsl_HAVE( AUTO )
-# include <vector>
+#if !gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR) || !gsl_HAVE(AUTO)
+#include <vector>
 #endif
 
-#if gsl_HAVE( INITIALIZER_LIST )
-# include <initializer_list>
+#if gsl_HAVE(INITIALIZER_LIST)
+#include <initializer_list>
 #endif
 
-#if gsl_HAVE( TYPE_TRAITS )
-# include <type_traits> // for enable_if<>,
-                        // add_const<>, add_pointer<>, common_type<>, make_signed<>, remove_cv<>, remove_const<>, remove_volatile<>, remove_reference<>, remove_cvref<>, remove_pointer<>, underlying_type<>,
-                        // is_assignable<>, is_constructible<>, is_const<>, is_convertible<>, is_integral<>, is_pointer<>, is_signed<>,
-                        // integral_constant<>, declval()
-#elif gsl_HAVE( TR1_TYPE_TRAITS )
-# include <tr1/type_traits> // for add_const<>, remove_cv<>, remove_const<>, remove_volatile<>, remove_reference<>, integral_constant<>
+#if gsl_HAVE(TYPE_TRAITS)
+#include <type_traits> // for enable_if<>,
+    // add_const<>, add_pointer<>, common_type<>, make_signed<>, remove_cv<>, remove_const<>, remove_volatile<>, remove_reference<>, remove_cvref<>, remove_pointer<>, underlying_type<>,
+    // is_assignable<>, is_constructible<>, is_const<>, is_convertible<>, is_integral<>, is_pointer<>, is_signed<>,
+    // integral_constant<>, declval()
+#elif gsl_HAVE(TR1_TYPE_TRAITS)
+#include <tr1/type_traits> // for add_const<>, remove_cv<>, remove_const<>, remove_volatile<>, remove_reference<>, integral_constant<>
 #endif
 
 // MSVC warning suppression macros:
 
 #if gsl_COMPILER_MSVC_VERSION >= 140 && !defined(__NVCC__)
-# define gsl_SUPPRESS_MSGSL_WARNING(expr)        [[gsl::suppress(expr)]]
-# define gsl_SUPPRESS_MSVC_WARNING(code, descr)  __pragma(warning(suppress: code) )
-# define gsl_DISABLE_MSVC_WARNINGS(codes)        __pragma(warning(push))  __pragma(warning(disable: codes))
-# define gsl_RESTORE_MSVC_WARNINGS()             __pragma(warning(pop ))
+#define gsl_SUPPRESS_MSGSL_WARNING(expr) [[gsl::suppress(expr)]]
+#define gsl_SUPPRESS_MSVC_WARNING(code, descr)                                 \
+    __pragma(warning(suppress : code))
+#define gsl_DISABLE_MSVC_WARNINGS(codes)                                       \
+    __pragma(warning(push)) __pragma(warning(disable : codes))
+#define gsl_RESTORE_MSVC_WARNINGS() __pragma(warning(pop))
 #else
 // TODO: define for Clang
-# define gsl_SUPPRESS_MSGSL_WARNING(expr)
-# define gsl_SUPPRESS_MSVC_WARNING(code, descr)
-# define gsl_DISABLE_MSVC_WARNINGS(codes)
-# define gsl_RESTORE_MSVC_WARNINGS()
+#define gsl_SUPPRESS_MSGSL_WARNING(expr)
+#define gsl_SUPPRESS_MSVC_WARNING(code, descr)
+#define gsl_DISABLE_MSVC_WARNINGS(codes)
+#define gsl_RESTORE_MSVC_WARNINGS()
 #endif
 
 // Suppress the following MSVC GSL warnings:
-// - C26432: gsl::c.21 : if you define or delete any default operation in the type '...', define or delete them all
-// - C26410: gsl::r.32 : the parameter 'ptr' is a reference to const unique pointer, use const T* or const T& instead
-// - C26415: gsl::r.30 : smart pointer parameter 'ptr' is used only to access contained pointer. Use T* or T& instead
-// - C26418: gsl::r.36 : shared pointer parameter 'ptr' is not copied or moved. Use T* or T& instead
+// - C26432: gsl::c.21 : if you define or delete any default operation in the
+// type '...', define or delete them all
+// - C26410: gsl::r.32 : the parameter 'ptr' is a reference to const unique
+// pointer, use const T* or const T& instead
+// - C26415: gsl::r.30 : smart pointer parameter 'ptr' is used only to access
+// contained pointer. Use T* or T& instead
+// - C26418: gsl::r.36 : shared pointer parameter 'ptr' is not copied or moved.
+// Use T* or T& instead
 // - C26472: gsl::t.1  : don't use a static_cast for arithmetic conversions;
-//                       use brace initialization, gsl::narrow_cast or gsl::narrow
+//                       use brace initialization, gsl::narrow_cast or
+//                       gsl::narrow
 // - C26439: gsl::f.6  : special function 'function' can be declared 'noexcept'
 // - C26440: gsl::f.6  : function 'function' can be declared 'noexcept'
-// - C26455: gsl::f.6  : default constructor may not throw. Declare it 'noexcept'
-// - C26473: gsl::t.1  : don't cast between pointer types where the source type and the target type are the same
+// - C26455: gsl::f.6  : default constructor may not throw. Declare it
+// 'noexcept'
+// - C26473: gsl::t.1  : don't cast between pointer types where the source type
+// and the target type are the same
 // - C26481: gsl::b.1  : don't use pointer arithmetic. Use span instead
 // - C26482: gsl::b.2  : only index into arrays using constant expressions
-// - C26446: gdl::b.4  : prefer to use gsl::at() instead of unchecked subscript operator
+// - C26446: gdl::b.4  : prefer to use gsl::at() instead of unchecked subscript
+// operator
 // - C26490: gsl::t.1  : don't use reinterpret_cast
-// - C26487: gsl::l.4  : don't return a pointer '(<some number>'s result)' that may be invalid
+// - C26487: gsl::l.4  : don't return a pointer '(<some number>'s result)' that
+// may be invalid
 
-gsl_DISABLE_MSVC_WARNINGS( 26432 26410 26415 26418 26472 26439 26440 26455 26473 26481 26482 26446 26490 26487 )
+gsl_DISABLE_MSVC_WARNINGS(
+    26432 26410 26415 26418 26472 26439 26440 26455 26473 26481 26482 26446 26490 26487)
 
-namespace gsl {
+    namespace gsl {
 
-// forward declare span<>:
+    // forward declare span<>:
 
-template< class T >
-class span;
+    template <class T> class span;
 
-// C++11 emulation:
+    // C++11 emulation:
 
-namespace std11 {
+    namespace std11 {
 
-#if gsl_HAVE( ADD_CONST )
+#if gsl_HAVE(ADD_CONST)
 
-using std::add_const;
+    using std::add_const;
 
-#elif gsl_HAVE( TR1_ADD_CONST )
+#elif gsl_HAVE(TR1_ADD_CONST)
 
-using std::tr1::add_const;
+    using std::tr1::add_const;
 
 #else
 
-template< class T > struct add_const { typedef const T type; };
+    template <class T> struct add_const { typedef const T type; };
 
 #endif // gsl_HAVE( ADD_CONST )
 
-#if gsl_HAVE( REMOVE_CONST )
+#if gsl_HAVE(REMOVE_CONST)
 
-using std::remove_cv;
-using std::remove_const;
-using std::remove_volatile;
+    using std::remove_const;
+    using std::remove_cv;
+    using std::remove_volatile;
 
-#elif gsl_HAVE( TR1_REMOVE_CONST )
+#elif gsl_HAVE(TR1_REMOVE_CONST)
 
-using std::tr1::remove_cv;
-using std::tr1::remove_const;
-using std::tr1::remove_volatile;
+    using std::tr1::remove_const;
+    using std::tr1::remove_cv;
+    using std::tr1::remove_volatile;
 
 #else
 
-template< class T > struct remove_const          { typedef T type; };
-template< class T > struct remove_const<T const> { typedef T type; };
+    template <class T> struct remove_const { typedef T type; };
+    template <class T> struct remove_const<T const> { typedef T type; };
 
-template< class T > struct remove_volatile             { typedef T type; };
-template< class T > struct remove_volatile<T volatile> { typedef T type; };
+    template <class T> struct remove_volatile { typedef T type; };
+    template <class T> struct remove_volatile<T volatile> { typedef T type; };
 
-template< class T >
-struct remove_cv
-{
-    typedef typename remove_volatile<typename remove_const<T>::type>::type type;
-};
+    template <class T> struct remove_cv {
+        typedef
+            typename remove_volatile<typename remove_const<T>::type>::type type;
+    };
 
 #endif // gsl_HAVE( REMOVE_CONST )
 
-#if gsl_HAVE( REMOVE_REFERENCE )
+#if gsl_HAVE(REMOVE_REFERENCE)
 
-using std::remove_reference;
+    using std::remove_reference;
 
-#elif gsl_HAVE( TR1_REMOVE_REFERENCE )
+#elif gsl_HAVE(TR1_REMOVE_REFERENCE)
 
-using std::tr1::remove_reference;
+    using std::tr1::remove_reference;
 
 #else
 
-template< class T > struct remove_reference { typedef T type; };
-template< class T > struct remove_reference<T&> { typedef T type; };
-# if gsl_HAVE( RVALUE_REFERENCE )
-template< class T > struct remove_reference<T&&> { typedef T type; };
-# endif
+    template <class T> struct remove_reference { typedef T type; };
+    template <class T> struct remove_reference<T &> { typedef T type; };
+#if gsl_HAVE(RVALUE_REFERENCE)
+    template <class T> struct remove_reference<T &&> { typedef T type; };
+#endif
 
 #endif // gsl_HAVE( REMOVE_REFERENCE )
 
+#if gsl_HAVE(INTEGRAL_CONSTANT)
 
-#if gsl_HAVE( INTEGRAL_CONSTANT )
-
-using std::integral_constant;
-using std::true_type;
-using std::false_type;
+    using std::false_type;
+    using std::integral_constant;
+    using std::true_type;
 
-#elif gsl_HAVE( TR1_INTEGRAL_CONSTANT )
+#elif gsl_HAVE(TR1_INTEGRAL_CONSTANT)
 
-using std::tr1::integral_constant;
-using std::tr1::true_type;
-using std::tr1::false_type;
+    using std::tr1::false_type;
+    using std::tr1::integral_constant;
+    using std::tr1::true_type;
 
 #else
 
-template< class T, T v > struct integral_constant { enum { value = v }; };
-typedef integral_constant< bool, true  > true_type;
-typedef integral_constant< bool, false > false_type;
+    template <class T, T v> struct integral_constant {
+        enum { value = v };
+    };
+    typedef integral_constant<bool, true> true_type;
+    typedef integral_constant<bool, false> false_type;
 
 #endif
 
-#if gsl_HAVE( TYPE_TRAITS )
+#if gsl_HAVE(TYPE_TRAITS)
 
-using std::underlying_type;
+    using std::underlying_type;
 
-#elif gsl_HAVE( TR1_TYPE_TRAITS )
+#elif gsl_HAVE(TR1_TYPE_TRAITS)
 
-using std::tr1::underlying_type;
+    using std::tr1::underlying_type;
 
 #else
 
-// We could try to define `underlying_type<>` for pre-C++11 here, but let's not until someone actually needs it.
+    // We could try to define `underlying_type<>` for pre-C++11 here, but let's
+    // not until someone actually needs it.
 
 #endif
 
-} // namespace std11
+    } // namespace std11
 
-// C++14 emulation:
+    // C++14 emulation:
 
-namespace std14 {
+    namespace std14 {
 
-#if gsl_HAVE( UNIQUE_PTR )
-# if gsl_HAVE( MAKE_UNIQUE )
+#if gsl_HAVE(UNIQUE_PTR)
+#if gsl_HAVE(MAKE_UNIQUE)
 
-using std::make_unique;
+    using std::make_unique;
 
-# elif gsl_HAVE( VARIADIC_TEMPLATE )
+#elif gsl_HAVE(VARIADIC_TEMPLATE)
 
-template< class T, class... Args >
-std::unique_ptr<T> make_unique( Args &&... args )
-{
-    return std::unique_ptr<T>( new T( std::forward<Args>( args )... ) );
-}
+    template <class T, class... Args>
+    std::unique_ptr<T> make_unique(Args &&...args) {
+        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+    }
 
-# endif // gsl_HAVE( MAKE_UNIQUE ), gsl_HAVE( VARIADIC_TEMPLATE )
+#endif // gsl_HAVE( MAKE_UNIQUE ), gsl_HAVE( VARIADIC_TEMPLATE )
 #endif // gsl_HAVE( UNIQUE_PTR )
 
-} // namespace std14
+    } // namespace std14
 
-namespace detail {
+    namespace detail {
 
-#if gsl_HAVE( VARIADIC_TEMPLATE )
+#if gsl_HAVE(VARIADIC_TEMPLATE)
 
-template < bool V0, class T0, class... Ts > struct conjunction_ { using type = T0; };
-template < class T0, class T1, class... Ts > struct conjunction_<true, T0, T1, Ts...> : conjunction_<T1::value, T1, Ts...> { };
-template < bool V0, class T0, class... Ts > struct disjunction_ { using type = T0; };
-template < class T0, class T1, class... Ts > struct disjunction_<false, T0, T1, Ts...> : disjunction_<T1::value, T1, Ts...> { };
+    template <bool V0, class T0, class... Ts> struct conjunction_ {
+        using type = T0;
+    };
+    template <class T0, class T1, class... Ts>
+    struct conjunction_<true, T0, T1, Ts...>
+        : conjunction_<T1::value, T1, Ts...> {};
+    template <bool V0, class T0, class... Ts> struct disjunction_ {
+        using type = T0;
+    };
+    template <class T0, class T1, class... Ts>
+    struct disjunction_<false, T0, T1, Ts...>
+        : disjunction_<T1::value, T1, Ts...> {};
 
 #endif
 
-} // namespace detail
+    } // namespace detail
 
-// C++17 emulation:
+    // C++17 emulation:
 
-namespace std17 {
+    namespace std17 {
 
-template< bool v > struct bool_constant : std11::integral_constant<bool, v>{};
+    template <bool v>
+    struct bool_constant : std11::integral_constant<bool, v> {};
 
 #if gsl_CPP11_120
 
-template < class... Ts > struct conjunction;
-template < > struct conjunction< > : std11::true_type { };
-template < class T0, class... Ts > struct conjunction<T0, Ts...> : detail::conjunction_<T0::value, T0, Ts...>::type { };
-template < class... Ts > struct disjunction;
-template < > struct disjunction< > : std11::false_type { };
-template < class T0, class... Ts > struct disjunction<T0, Ts...> : detail::disjunction_<T0::value, T0, Ts...>::type { };
-template < class T > struct negation : std11::integral_constant<bool, !T::value> { };
+    template <class... Ts> struct conjunction;
+    template <> struct conjunction<> : std11::true_type {};
+    template <class T0, class... Ts>
+    struct conjunction<T0, Ts...>
+        : detail::conjunction_<T0::value, T0, Ts...>::type {};
+    template <class... Ts> struct disjunction;
+    template <> struct disjunction<> : std11::false_type {};
+    template <class T0, class... Ts>
+    struct disjunction<T0, Ts...>
+        : detail::disjunction_<T0::value, T0, Ts...>::type {};
+    template <class T>
+    struct negation : std11::integral_constant<bool, !T::value> {};
 
-# if gsl_CPP14_OR_GREATER
+#if gsl_CPP14_OR_GREATER
 
-template < class... Ts > constexpr bool conjunction_v = conjunction<Ts...>::value;
-template < class... Ts > constexpr bool disjunction_v = disjunction<Ts...>::value;
-template < class T > constexpr bool negation_v = negation<T>::value;
+    template <class... Ts>
+    constexpr bool conjunction_v = conjunction<Ts...>::value;
+    template <class... Ts>
+    constexpr bool disjunction_v = disjunction<Ts...>::value;
+    template <class T> constexpr bool negation_v = negation<T>::value;
 
-# endif // gsl_CPP14_OR_GREATER
+#endif // gsl_CPP14_OR_GREATER
 
-template< class... Ts >
-struct make_void { typedef void type; };
+    template <class... Ts> struct make_void { typedef void type; };
 
-template< class... Ts >
-using void_t = typename make_void< Ts... >::type;
+    template <class... Ts> using void_t = typename make_void<Ts...>::type;
 
 #endif // gsl_CPP11_120
 
-#if gsl_HAVE( STD_DATA )
+#if gsl_HAVE(STD_DATA)
 
-using std::data;
-using std::size;
+    using std::data;
+    using std::size;
 
-#elif gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+#elif gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR)
 
-template< class T, size_t N >
-gsl_api inline gsl_constexpr auto size( T const(&)[N] ) gsl_noexcept -> size_t
-{
-    return N;
-}
+    template <class T, size_t N>
+    gsl_api inline gsl_constexpr auto size(T const (&)[N]) gsl_noexcept
+        -> size_t {
+        return N;
+    }
 
-template< class C >
-inline gsl_constexpr auto size( C const & cont ) -> decltype( cont.size() )
-{
-    return cont.size();
-}
+    template <class C>
+    inline gsl_constexpr auto size(C const &cont) -> decltype(cont.size()) {
+        return cont.size();
+    }
 
-template< class T, size_t N >
-gsl_api inline gsl_constexpr auto data( T(&arr)[N] ) gsl_noexcept -> T*
-{
-    return &arr[0];
-}
+    template <class T, size_t N>
+    gsl_api inline gsl_constexpr auto data(T (&arr)[N]) gsl_noexcept -> T * {
+        return &arr[0];
+    }
 
-template< class C >
-inline gsl_constexpr auto data( C & cont ) -> decltype( cont.data() )
-{
-    return cont.data();
-}
+    template <class C>
+    inline gsl_constexpr auto data(C &cont) -> decltype(cont.data()) {
+        return cont.data();
+    }
 
-template< class C >
-inline gsl_constexpr auto data( C const & cont ) -> decltype( cont.data() )
-{
-    return cont.data();
-}
+    template <class C>
+    inline gsl_constexpr auto data(C const &cont) -> decltype(cont.data()) {
+        return cont.data();
+    }
 
-template< class E >
-inline gsl_constexpr auto data( std::initializer_list<E> il ) gsl_noexcept -> E const *
-{
-    return il.begin();
-}
+    template <class E>
+    inline gsl_constexpr auto data(std::initializer_list<E> il) gsl_noexcept
+        -> E const * {
+        return il.begin();
+    }
 
 #endif // span_HAVE( DATA )
 
-} // namespace std17
+    } // namespace std17
 
-// C++20 emulation:
+    // C++20 emulation:
 
-namespace std20 {
+    namespace std20 {
 
 #if gsl_CPP11_100
 
-struct identity
-{
-    template < class T >
-    gsl_constexpr T && operator ()( T && arg ) const gsl_noexcept
-    {
-        return std::forward<T>( arg );
-    }
-};
+    struct identity {
+        template <class T>
+        gsl_constexpr T &&operator()(T &&arg) const gsl_noexcept {
+            return std::forward<T>(arg);
+        }
+    };
 
 #endif // gsl_CPP11_100
 
-template< class T >
-struct type_identity
-{
-    typedef T type;
-};
-#if gsl_HAVE( ALIAS_TEMPLATE )
-template< class T >
-using type_identity_t = typename type_identity<T>::type;
+    template <class T> struct type_identity { typedef T type; };
+#if gsl_HAVE(ALIAS_TEMPLATE)
+    template <class T> using type_identity_t = typename type_identity<T>::type;
 #endif // gsl_HAVE( ALIAS_TEMPLATE )
 
-#if gsl_HAVE( STD_SSIZE )
+#if gsl_HAVE(STD_SSIZE)
 
-using std::ssize;
+    using std::ssize;
 
-#elif gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
+#elif gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR)
 
-template < class C >
-gsl_constexpr auto ssize( C const & c )
-    -> typename std::common_type<std::ptrdiff_t, typename std::make_signed<decltype(c.size())>::type>::type
-{
-    using R = typename std::common_type<std::ptrdiff_t, typename std::make_signed<decltype(c.size())>::type>::type;
-    return static_cast<R>( c.size() );
-}
+    template <class C>
+    gsl_constexpr auto ssize(C const &c) -> typename std::common_type<
+        std::ptrdiff_t,
+        typename std::make_signed<decltype(c.size())>::type>::type {
+        using R = typename std::common_type<
+            std::ptrdiff_t,
+            typename std::make_signed<decltype(c.size())>::type>::type;
+        return static_cast<R>(c.size());
+    }
 
-template <class T, std::size_t N>
-gsl_constexpr auto ssize( T const(&)[N] ) gsl_noexcept -> std::ptrdiff_t
-{
-    return std::ptrdiff_t( N );
-}
+    template <class T, std::size_t N>
+    gsl_constexpr auto ssize(T const (&)[N]) gsl_noexcept -> std::ptrdiff_t {
+        return std::ptrdiff_t(N);
+    }
 
 #endif // gsl_HAVE( STD_SSIZE )
 
-#if gsl_HAVE( REMOVE_CVREF )
+#if gsl_HAVE(REMOVE_CVREF)
 
-using std::remove_cvref;
+    using std::remove_cvref;
 
 #else
 
-template< class T > struct remove_cvref { typedef typename std11::remove_cv< typename std11::remove_reference< T >::type >::type type; };
+    template <class T> struct remove_cvref {
+        typedef typename std11::remove_cv<
+            typename std11::remove_reference<T>::type>::type type;
+    };
 
 #endif // gsl_HAVE( REMOVE_CVREF )
 
-} // namespace std20
+    } // namespace std20
 
-namespace detail {
+    namespace detail {
 
-/// for nsel_REQUIRES_T
+    /// for nsel_REQUIRES_T
 
-/*enum*/ class enabler{};
+    /*enum*/ class enabler {};
 
-#if gsl_HAVE( TYPE_TRAITS )
+#if gsl_HAVE(TYPE_TRAITS)
 
-template< class Q >
-struct is_span_oracle : std::false_type{};
+    template <class Q> struct is_span_oracle : std::false_type {};
 
-template< class T>
-struct is_span_oracle< span<T> > : std::true_type{};
+    template <class T> struct is_span_oracle<span<T>> : std::true_type {};
 
-template< class Q >
-struct is_span : is_span_oracle< typename std::remove_cv<Q>::type >{};
+    template <class Q>
+    struct is_span : is_span_oracle<typename std::remove_cv<Q>::type> {};
 
-template< class Q >
-struct is_std_array_oracle : std::false_type{};
+    template <class Q> struct is_std_array_oracle : std::false_type {};
 
-#if gsl_HAVE( ARRAY )
+#if gsl_HAVE(ARRAY)
 
-template< class T, std::size_t Extent >
-struct is_std_array_oracle< std::array<T, Extent> > : std::true_type{};
+    template <class T, std::size_t Extent>
+    struct is_std_array_oracle<std::array<T, Extent>> : std::true_type {};
 
 #endif
 
-template< class Q >
-struct is_std_array : is_std_array_oracle< typename std::remove_cv<Q>::type >{};
+    template <class Q>
+    struct is_std_array
+        : is_std_array_oracle<typename std::remove_cv<Q>::type> {};
 
-template< class Q >
-struct is_array : std::false_type{};
+    template <class Q> struct is_array : std::false_type {};
 
-template< class T >
-struct is_array<T[]> : std::true_type{};
-
-template< class T, std::size_t N >
-struct is_array<T[N]> : std::true_type{};
-
-# if gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 )
-
-template< class, class = void >
-struct has_size_and_data : std::false_type{};
-
-template< class C >
-struct has_size_and_data
-<
-    C, std17::void_t<
-        decltype( std17::size(std::declval<C>()) ),
-        decltype( std17::data(std::declval<C>()) ) >
-> : std::true_type{};
-
-template< class, class, class = void >
-struct is_compatible_element : std::false_type {};
-
-template< class C, class E >
-struct is_compatible_element
-<
-    C, E, std17::void_t<
-        decltype( std17::data(std::declval<C>()) ),
-        typename std::remove_pointer<decltype( std17::data( std::declval<C&>() ) )>::type(*)[] >
-> : std::is_convertible< typename std::remove_pointer<decltype( std17::data( std::declval<C&>() ) )>::type(*)[], E(*)[] >{};
-
-template< class C >
-struct is_container : std17::bool_constant
-<
-    ! is_span< C >::value
-    && ! is_array< C >::value
-    && ! is_std_array< C >::value
-    &&   has_size_and_data< C >::value
->{};
-
-template< class C, class E >
-struct is_compatible_container : std17::bool_constant
-<
-    is_container<C>::value
-    && is_compatible_element<C,E>::value
->{};
-
-# else // ^^^ gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 ) ^^^ / vvv ! gsl_CPP11_140 || gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 ) vvv
-
-template<
-    class C, class E
-        , typename = typename std::enable_if<
-            ! is_span< C >::value
-            && ! is_array< C >::value
-            && ! is_std_array< C >::value
-            && ( std::is_convertible< typename std::remove_pointer<decltype( std17::data( std::declval<C&>() ) )>::type(*)[], E(*)[] >::value)
-        //  &&   has_size_and_data< C >::value
-        , enabler>::type
-        , class = decltype( std17::size(std::declval<C>()) )
-        , class = decltype( std17::data(std::declval<C>()) )
->
-#  if gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 140 )
-// VS2013 has insufficient support for expression SFINAE; we cannot make `is_compatible_container<>` a proper type trait here
-struct is_compatible_container : std::true_type { };
-#  else
-struct is_compatible_container_r { is_compatible_container_r(int); };
-template< class C, class E >
-std::true_type  is_compatible_container_f( is_compatible_container_r<C, E> );
-template< class C, class E >
-std::false_type is_compatible_container_f( ... );
-
-template< class C, class E >
-struct is_compatible_container : decltype( is_compatible_container_f< C, E >( 0 ) ) { };
-#  endif // gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 140 )
-
-# endif // gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 )
+    template <class T> struct is_array<T[]> : std::true_type {};
+
+    template <class T, std::size_t N> struct is_array<T[N]> : std::true_type {};
+
+#if gsl_CPP11_140 && !gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 500)
+
+    template <class, class = void>
+    struct has_size_and_data : std::false_type {};
+
+    template <class C>
+    struct has_size_and_data<
+        C, std17::void_t<decltype(std17::size(std::declval<C>())),
+                         decltype(std17::data(std::declval<C>()))>>
+        : std::true_type {};
+
+    template <class, class, class = void>
+    struct is_compatible_element : std::false_type {};
+
+    template <class C, class E>
+    struct is_compatible_element<
+        C, E,
+        std17::void_t<decltype(std17::data(std::declval<C>())),
+                      typename std::remove_pointer<decltype(
+                          std17::data(std::declval<C &>()))>::type (*)[]>>
+        : std::is_convertible<typename std::remove_pointer<decltype(std17::data(
+                                  std::declval<C &>()))>::type (*)[],
+                              E (*)[]> {};
+
+    template <class C>
+    struct is_container
+        : std17::bool_constant<!is_span<C>::value && !is_array<C>::value &&
+                               !is_std_array<C>::value &&
+                               has_size_and_data<C>::value> {};
+
+    template <class C, class E>
+    struct is_compatible_container
+        : std17::bool_constant<is_container<C>::value &&
+                               is_compatible_element<C, E>::value> {};
+
+#else // ^^^ gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 )
+      // ^^^ / vvv ! gsl_CPP11_140 || gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1,
+      // 500 ) vvv
+
+    template <class C, class E,
+              typename = typename std::enable_if<
+                  !is_span<C>::value && !is_array<C>::value &&
+                      !is_std_array<C>::value &&
+                      (std::is_convertible<
+                          typename std::remove_pointer<decltype(
+                              std17::data(std::declval<C &>()))>::type (*)[],
+                          E (*)[]>::value)
+                  //  &&   has_size_and_data< C >::value
+                  ,
+                  enabler>::type,
+              class = decltype(std17::size(std::declval<C>())),
+              class = decltype(std17::data(std::declval<C>()))>
+#if gsl_BETWEEN(gsl_COMPILER_MSVC_VERSION, 1, 140)
+    // VS2013 has insufficient support for expression SFINAE; we cannot make
+    // `is_compatible_container<>` a proper type trait here
+    struct is_compatible_container : std::true_type {
+    };
+#else
+    struct is_compatible_container_r {
+        is_compatible_container_r(int);
+    };
+    template <class C, class E>
+    std::true_type is_compatible_container_f(is_compatible_container_r<C, E>);
+    template <class C, class E> std::false_type is_compatible_container_f(...);
+
+    template <class C, class E>
+    struct is_compatible_container
+        : decltype(is_compatible_container_f<C, E>(0)) {};
+#endif // gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 140 )
+
+#endif // gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 )
 
 #endif // gsl_HAVE( TYPE_TRAITS )
 
-} // namespace detail
+    } // namespace detail
 
-//
-// GSL.util: utilities
-//
+    //
+    // GSL.util: utilities
+    //
 
-// Integer type for indices (e.g. in a loop).
-typedef gsl_CONFIG_INDEX_TYPE index;
+    // Integer type for indices (e.g. in a loop).
+    typedef gsl_CONFIG_INDEX_TYPE index;
 
 //
 // GSL.owner: ownership pointers
 //
-#if gsl_HAVE( SHARED_PTR )
-  using std::unique_ptr;
-  using std::shared_ptr;
-  using std::make_shared;
-# if gsl_HAVE( MAKE_UNIQUE ) || gsl_HAVE( VARIADIC_TEMPLATE )
-  using std14::make_unique;
-# endif
-#endif
-
-#if  gsl_HAVE( ALIAS_TEMPLATE )
-  template< class T
-#if gsl_HAVE( TYPE_TRAITS )
-          , typename = typename std::enable_if< std::is_pointer<T>::value >::type
-#endif
-  >
-  using owner = T;
+#if gsl_HAVE(SHARED_PTR)
+    using std::make_shared;
+    using std::shared_ptr;
+    using std::unique_ptr;
+#if gsl_HAVE(MAKE_UNIQUE) || gsl_HAVE(VARIADIC_TEMPLATE)
+    using std14::make_unique;
+#endif
+#endif
+
+#if gsl_HAVE(ALIAS_TEMPLATE)
+    template <class T
+#if gsl_HAVE(TYPE_TRAITS)
+              ,
+              typename =
+                  typename std::enable_if<std::is_pointer<T>::value>::type
+#endif
+              >
+    using owner = T;
 #elif gsl_CONFIG_DEFAULTS_VERSION == 0
-  // TODO vNext: remove
-  template< class T > struct owner { typedef T type; };
+    // TODO vNext: remove
+    template <class T> struct owner { typedef T type; };
 #endif
 
-#define gsl_HAVE_OWNER_TEMPLATE  gsl_HAVE_ALIAS_TEMPLATE
+#define gsl_HAVE_OWNER_TEMPLATE gsl_HAVE_ALIAS_TEMPLATE
 
 // TODO vNext: remove
-#if gsl_FEATURE( OWNER_MACRO )
-# if gsl_HAVE( OWNER_TEMPLATE )
-#  define Owner(t)  ::gsl::owner<t>
-# else
-#  define Owner(t)  ::gsl::owner<t>::type
-# endif
+#if gsl_FEATURE(OWNER_MACRO)
+#if gsl_HAVE(OWNER_TEMPLATE)
+#define Owner(t) ::gsl::owner<t>
+#else
+#define Owner(t) ::gsl::owner<t>::type
+#endif
 #endif
 
-//
-// GSL.assert: assertions
-//
+    //
+    // GSL.assert: assertions
+    //
 
-#if gsl_HAVE( TYPE_TRAITS )
-# define gsl_ELIDE_CONTRACT_( x )  static_assert(::std::is_constructible<bool, decltype( x )>::value, "argument of contract check must be convertible to bool")
+#if gsl_HAVE(TYPE_TRAITS)
+#define gsl_ELIDE_CONTRACT_(x)                                                 \
+    static_assert(::std::is_constructible<bool, decltype(x)>::value,           \
+                  "argument of contract check must be convertible to bool")
 #else
-# define gsl_ELIDE_CONTRACT_( x )
+#define gsl_ELIDE_CONTRACT_(x)
 #endif
 
-#if defined( __CUDACC__ ) && defined( __CUDA_ARCH__ )
-# define  gsl_ASSUME( x )  gsl_ELIDE_CONTRACT_( x ) /* there is no assume intrinsic in CUDA device code */
+#if defined(__CUDACC__) && defined(__CUDA_ARCH__)
+#define gsl_ASSUME(x)                                                          \
+    gsl_ELIDE_CONTRACT_(                                                       \
+        x) /* there is no assume intrinsic in CUDA device code */
 #elif gsl_COMPILER_MSVC_VERSION
-# define  gsl_ASSUME( x )  __assume( x )
+#define gsl_ASSUME(x) __assume(x)
 #elif gsl_COMPILER_GNUC_VERSION
-#  define gsl_ASSUME( x )  (( x ) ? static_cast<void>(0) : __builtin_unreachable())
+#define gsl_ASSUME(x) ((x) ? static_cast<void>(0) : __builtin_unreachable())
 #elif defined(__has_builtin)
-# if __has_builtin(__builtin_unreachable)
-#  define gsl_ASSUME( x )  (( x ) ? static_cast<void>(0) : __builtin_unreachable())
-# endif
-#else
-# define  gsl_ASSUME( x )  gsl_ELIDE_CONTRACT_( x ) /* unknown compiler; cannot rely on assume intrinsic */
+#if __has_builtin(__builtin_unreachable)
+#define gsl_ASSUME(x) ((x) ? static_cast<void>(0) : __builtin_unreachable())
 #endif
-
-#if defined( gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER )
-#  define  gsl_CONTRACT_CHECK_( str, x )  ( ( x ) ? static_cast<void>(0) : ::gsl::fail_fast_assert_handler( #x, "GSL: " str, __FILE__, __LINE__ ) )
-#elif defined( __CUDACC__ ) && defined( __CUDA_ARCH__ )
-#  define  gsl_CONTRACT_CHECK_( str, x )  assert( ( x ) && str )
-#elif   defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
-#  define  gsl_CONTRACT_CHECK_( str, x )  ( ( x ) ? static_cast<void>(0) : ::gsl::detail::fail_fast_throw( "GSL: " str " at " __FILE__ ":" gsl_STRINGIFY(__LINE__) ) )
+#else
+#define gsl_ASSUME(x)                                                          \
+    gsl_ELIDE_CONTRACT_(                                                       \
+        x) /* unknown compiler; cannot rely on assume intrinsic */
+#endif
+
+#if defined(gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER)
+#define gsl_CONTRACT_CHECK_(str, x)                                            \
+    ((x) ? static_cast<void>(0)                                                \
+         : ::gsl::fail_fast_assert_handler(#x, "GSL: " str, __FILE__,          \
+                                           __LINE__))
+#elif defined(__CUDACC__) && defined(__CUDA_ARCH__)
+#define gsl_CONTRACT_CHECK_(str, x) assert((x) && str)
+#elif defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS)
+#define gsl_CONTRACT_CHECK_(str, x)                                            \
+    ((x) ? static_cast<void>(0)                                                \
+         : ::gsl::detail::fail_fast_throw("GSL: " str " at " __FILE__          \
+                                          ":" gsl_STRINGIFY(__LINE__)))
 #else // defined( gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES ) [default]
-#  define  gsl_CONTRACT_CHECK_( str, x )  ( ( x ) ? static_cast<void>(0) : ::gsl::detail::fail_fast_terminate() )
+#define gsl_CONTRACT_CHECK_(str, x)                                            \
+    ((x) ? static_cast<void>(0) : ::gsl::detail::fail_fast_terminate())
 #endif
 
-#if defined( gsl_CONFIG_CONTRACT_CHECKING_OFF ) || defined( gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF )
-# if defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME )
-#  define gsl_Expects( x )       gsl_ASSUME( x )
-# else // defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE ) [default]
-#  define gsl_Expects( x )       gsl_ELIDE_CONTRACT_( x )
-# endif
+#if defined(gsl_CONFIG_CONTRACT_CHECKING_OFF) ||                               \
+    defined(gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF)
+#if defined(gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME)
+#define gsl_Expects(x) gsl_ASSUME(x)
+#else // defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE ) [default]
+#define gsl_Expects(x) gsl_ELIDE_CONTRACT_(x)
+#endif
 #else
-# define  gsl_Expects( x )       gsl_CONTRACT_CHECK_( "Precondition failure", x )
+#define gsl_Expects(x) gsl_CONTRACT_CHECK_("Precondition failure", x)
 #endif
-#define   Expects( x )           gsl_Expects( x )
+#define Expects(x) gsl_Expects(x)
 
-#if !defined( gsl_CONFIG_CONTRACT_CHECKING_AUDIT ) || defined( gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF )
-# define  gsl_ExpectsAudit( x )  gsl_ELIDE_CONTRACT_( x )
+#if !defined(gsl_CONFIG_CONTRACT_CHECKING_AUDIT) ||                            \
+    defined(gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF)
+#define gsl_ExpectsAudit(x) gsl_ELIDE_CONTRACT_(x)
 #else
-# define  gsl_ExpectsAudit( x )  gsl_CONTRACT_CHECK_( "Precondition failure (audit)", x )
+#define gsl_ExpectsAudit(x)                                                    \
+    gsl_CONTRACT_CHECK_("Precondition failure (audit)", x)
 #endif
 
-#if defined( gsl_CONFIG_CONTRACT_CHECKING_OFF ) || defined( gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF )
-# if defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME )
-#  define gsl_Ensures( x )       gsl_ASSUME( x )
-# else // defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE ) [default]
-#  define gsl_Ensures( x )       gsl_ELIDE_CONTRACT_( x )
-# endif
+#if defined(gsl_CONFIG_CONTRACT_CHECKING_OFF) ||                               \
+    defined(gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF)
+#if defined(gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME)
+#define gsl_Ensures(x) gsl_ASSUME(x)
+#else // defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE ) [default]
+#define gsl_Ensures(x) gsl_ELIDE_CONTRACT_(x)
+#endif
 #else
-# define  gsl_Ensures( x )       gsl_CONTRACT_CHECK_( "Postcondition failure", x )
+#define gsl_Ensures(x) gsl_CONTRACT_CHECK_("Postcondition failure", x)
 #endif
-#define   Ensures( x )           gsl_Ensures( x )
+#define Ensures(x) gsl_Ensures(x)
 
-#if !defined( gsl_CONFIG_CONTRACT_CHECKING_AUDIT ) || defined( gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF )
-# define  gsl_EnsuresAudit( x )  gsl_ELIDE_CONTRACT_( x )
+#if !defined(gsl_CONFIG_CONTRACT_CHECKING_AUDIT) ||                            \
+    defined(gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF)
+#define gsl_EnsuresAudit(x) gsl_ELIDE_CONTRACT_(x)
 #else
-# define  gsl_EnsuresAudit( x )  gsl_CONTRACT_CHECK_( "Postcondition failure (audit)", x )
+#define gsl_EnsuresAudit(x)                                                    \
+    gsl_CONTRACT_CHECK_("Postcondition failure (audit)", x)
 #endif
 
-#define gsl_STRINGIFY(  x )  gsl_STRINGIFY_( x )
-#define gsl_STRINGIFY_( x )  #x
-
-struct fail_fast : public std::logic_error
-{
-    explicit fail_fast( char const * message )
-    : std::logic_error( message ) {}
-};
+#define gsl_STRINGIFY(x) gsl_STRINGIFY_(x)
+#define gsl_STRINGIFY_(x) #x
 
-namespace detail {
+    struct fail_fast : public std::logic_error {
+        explicit fail_fast(char const *message) : std::logic_error(message) {}
+    };
 
+    namespace detail {
 
-#if gsl_HAVE( EXCEPTIONS )
-gsl_NORETURN inline void fail_fast_throw( char const * message )
-{
-    throw fail_fast( message );
-}
+#if gsl_HAVE(EXCEPTIONS)
+    gsl_NORETURN inline void fail_fast_throw(char const *message) {
+        throw fail_fast(message);
+    }
 #endif // gsl_HAVE( EXCEPTIONS )
-gsl_NORETURN inline void fail_fast_terminate() gsl_noexcept
-{
-    std::terminate();
-}
+    gsl_NORETURN inline void fail_fast_terminate() gsl_noexcept {
+        std::terminate();
+    }
 
-} // namespace detail
+    } // namespace detail
 
-// Should be defined by user
-gsl_api void fail_fast_assert_handler( char const * const expression, char const * const message, char const * const file, int line );
+    // Should be defined by user
+    gsl_api void fail_fast_assert_handler(char const *const expression,
+                                          char const *const message,
+                                          char const *const file, int line);
 
-#if   defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
+#if defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS)
 
-# if gsl_HAVE( EXCEPTIONS )
-gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use contract checking macros instead")
-gsl_constexpr14 inline
-void fail_fast_assert( bool cond, char const * const message )
-{
-    if ( !cond )
-        throw fail_fast( message );
-}
-# endif // gsl_HAVE( EXCEPTIONS )
+#if gsl_HAVE(EXCEPTIONS)
+    gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use "
+                       "contract checking macros instead")
+        gsl_constexpr14 inline void
+        fail_fast_assert(bool cond, char const *const message) {
+        if (!cond)
+            throw fail_fast(message);
+    }
+#endif // gsl_HAVE( EXCEPTIONS )
 
-#elif defined( gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER )
+#elif defined(gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER)
 
-gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use contract checking macros instead")
-gsl_api gsl_constexpr14 inline
-void fail_fast_assert( bool cond, char const * const expression, char const * const message, char const * const file, int line )
-{
-    if ( !cond )
-        ::gsl::fail_fast_assert_handler( expression, message, file, line );
-}
+    gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use "
+                       "contract checking macros instead")
+        gsl_api gsl_constexpr14 inline void
+        fail_fast_assert(bool cond, char const *const expression,
+                         char const *const message, char const *const file,
+                         int line) {
+        if (!cond)
+            ::gsl::fail_fast_assert_handler(expression, message, file, line);
+    }
 
 #else // defined( gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES ) [default]
 
-gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use contract checking macros instead")
-gsl_constexpr14 inline
-void fail_fast_assert( bool cond ) gsl_noexcept
-{
-    if ( !cond )
-        std::terminate();
-}
+    gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use "
+                       "contract checking macros instead")
+        gsl_constexpr14 inline void
+        fail_fast_assert(bool cond) gsl_noexcept {
+        if (!cond)
+            std::terminate();
+    }
 
 #endif
 
+    //
+    // GSL.util: utilities
+    //
 
-//
-// GSL.util: utilities
-//
-
-#if gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+#if gsl_FEATURE(EXPERIMENTAL_RETURN_GUARD)
 
-// Add uncaught_exceptions for pre-2017 MSVC, GCC and Clang
-// Return unsigned char to save stack space, uncaught_exceptions can only increase by 1 in a scope
+    // Add uncaught_exceptions for pre-2017 MSVC, GCC and Clang
+    // Return unsigned char to save stack space, uncaught_exceptions can only
+    // increase by 1 in a scope
 
-namespace detail {
+    namespace detail {
 
-gsl_api inline unsigned char to_uchar( unsigned x ) gsl_noexcept
-{
-    return static_cast<unsigned char>( x );
-}
+    gsl_api inline unsigned char to_uchar(unsigned x) gsl_noexcept {
+        return static_cast<unsigned char>(x);
+    }
 
-} // namespace detail
+    } // namespace detail
 
-namespace std11 {
+    namespace std11 {
 
-#if gsl_HAVE( UNCAUGHT_EXCEPTIONS )
+#if gsl_HAVE(UNCAUGHT_EXCEPTIONS)
 
-inline unsigned char uncaught_exceptions() gsl_noexcept
-{
-    return detail::to_uchar( std::uncaught_exceptions() );
-}
+    inline unsigned char uncaught_exceptions() gsl_noexcept {
+        return detail::to_uchar(std::uncaught_exceptions());
+    }
 
 #elif gsl_COMPILER_MSVC_VERSION
 
-extern "C" char * __cdecl _getptd();
-inline unsigned char uncaught_exceptions() gsl_noexcept
-{
-    return detail::to_uchar( *reinterpret_cast<unsigned*>(_getptd() + (sizeof(void*) == 8 ? 0x100 : 0x90) ) );
-}
+    extern "C" char *__cdecl _getptd();
+    inline unsigned char uncaught_exceptions() gsl_noexcept {
+        return detail::to_uchar(*reinterpret_cast<unsigned *>(
+            _getptd() + (sizeof(void *) == 8 ? 0x100 : 0x90)));
+    }
 
-#elif gsl_COMPILER_CLANG_VERSION || gsl_COMPILER_GNUC_VERSION || gsl_COMPILER_APPLECLANG_VERSION
+#elif gsl_COMPILER_CLANG_VERSION || gsl_COMPILER_GNUC_VERSION ||               \
+    gsl_COMPILER_APPLECLANG_VERSION
 
-extern "C" char * __cxa_get_globals();
-inline unsigned char uncaught_exceptions() gsl_noexcept
-{
-    return detail::to_uchar( *reinterpret_cast<unsigned*>(__cxa_get_globals() + sizeof(void*) ) );
-}
+    extern "C" char *__cxa_get_globals();
+    inline unsigned char uncaught_exceptions() gsl_noexcept {
+        return detail::to_uchar(*reinterpret_cast<unsigned *>(
+            __cxa_get_globals() + sizeof(void *)));
+    }
 #endif
-} // namespace std11
+    } // namespace std11
 #endif
 
 #if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 110
 
-template< class F >
-class final_action
-{
-public:
-    explicit final_action( F action ) gsl_noexcept
-        : action_( std::move( action ) )
-        , invoke_( true )
-    {}
-
-    final_action( final_action && other ) gsl_noexcept
-        : action_( std::move( other.action_ ) )
-        , invoke_( other.invoke_ )
-    {
-        other.invoke_ = false;
-    }
-
-    gsl_SUPPRESS_MSGSL_WARNING(f.6)
-    virtual ~final_action() gsl_noexcept
-    {
-        if ( invoke_ )
-            action_();
-    }
+    template <class F> class final_action {
+      public:
+        explicit final_action(F action) gsl_noexcept
+            : action_(std::move(action)),
+              invoke_(true) {}
 
-gsl_is_delete_access:
-    final_action( final_action const  & ) gsl_is_delete;
-    final_action & operator=( final_action const & ) gsl_is_delete;
-    final_action & operator=( final_action && ) gsl_is_delete;
+        final_action(final_action &&other) gsl_noexcept
+            : action_(std::move(other.action_)),
+              invoke_(other.invoke_) {
+            other.invoke_ = false;
+        }
 
-protected:
-    void dismiss() gsl_noexcept
-    {
-        invoke_ = false;
-    }
+        gsl_SUPPRESS_MSGSL_WARNING(f .6) virtual ~final_action() gsl_noexcept {
+            if (invoke_)
+                action_();
+        }
 
-private:
-    F action_;
-    bool invoke_;
-};
+        gsl_is_delete_access : final_action(final_action const &) gsl_is_delete;
+        final_action &operator=(final_action const &) gsl_is_delete;
+        final_action &operator=(final_action &&) gsl_is_delete;
 
-template< class F >
-inline final_action<F> finally( F const & action ) gsl_noexcept
-{
-    return final_action<F>( action );
-}
+      protected:
+        void dismiss() gsl_noexcept { invoke_ = false; }
 
-template< class F >
-inline final_action<F> finally( F && action ) gsl_noexcept
-{
-    return final_action<F>( std::forward<F>( action ) );
-}
+      private:
+        F action_;
+        bool invoke_;
+    };
 
-#if gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+    template <class F>
+    inline final_action<F> finally(F const &action) gsl_noexcept {
+        return final_action<F>(action);
+    }
 
-template< class F >
-class final_action_return : public final_action<F>
-{
-public:
-    explicit final_action_return( F && action ) gsl_noexcept
-        : final_action<F>( std::move( action ) )
-        , exception_count( std11::uncaught_exceptions() )
-    {}
-
-    final_action_return( final_action_return && other ) gsl_noexcept
-        : final_action<F>( std::move( other ) )
-        , exception_count( std11::uncaught_exceptions() )
-    {}
-
-    ~final_action_return() override
-    {
-        if ( std11::uncaught_exceptions() != exception_count )
-            this->dismiss();
+    template <class F>
+    inline final_action<F> finally(F && action) gsl_noexcept {
+        return final_action<F>(std::forward<F>(action));
     }
 
-gsl_is_delete_access:
-    final_action_return( final_action_return const & ) gsl_is_delete;
-    final_action_return & operator=( final_action_return const & ) gsl_is_delete;
+#if gsl_FEATURE(EXPERIMENTAL_RETURN_GUARD)
 
-private:
-    unsigned char exception_count;
-};
+    template <class F> class final_action_return : public final_action<F> {
+      public:
+        explicit final_action_return(F &&action) gsl_noexcept
+            : final_action<F>(std::move(action)),
+              exception_count(std11::uncaught_exceptions()) {}
 
-template< class F >
-inline final_action_return<F> on_return( F const & action ) gsl_noexcept
-{
-    return final_action_return<F>( action );
-}
+        final_action_return(final_action_return &&other) gsl_noexcept
+            : final_action<F>(std::move(other)),
+              exception_count(std11::uncaught_exceptions()) {}
 
-template< class F >
-inline final_action_return<F> on_return( F && action ) gsl_noexcept
-{
-    return final_action_return<F>( std::forward<F>( action ) );
-}
+        ~final_action_return() override {
+            if (std11::uncaught_exceptions() != exception_count)
+                this->dismiss();
+        }
 
-template< class F >
-class final_action_error : public final_action<F>
-{
-public:
-    explicit final_action_error( F && action ) gsl_noexcept
-        : final_action<F>( std::move( action ) )
-        , exception_count( std11::uncaught_exceptions() )
-    {}
-
-    final_action_error( final_action_error && other ) gsl_noexcept
-        : final_action<F>( std::move( other ) )
-        , exception_count( std11::uncaught_exceptions() )
-    {}
-
-    ~final_action_error() override
-    {
-        if ( std11::uncaught_exceptions() == exception_count )
-            this->dismiss();
-    }
+        gsl_is_delete_access
+            : final_action_return(final_action_return const &) gsl_is_delete;
+        final_action_return &
+        operator=(final_action_return const &) gsl_is_delete;
 
-gsl_is_delete_access:
-    final_action_error( final_action_error const & ) gsl_is_delete;
-    final_action_error & operator=( final_action_error const & ) gsl_is_delete;
+      private:
+        unsigned char exception_count;
+    };
 
-private:
-    unsigned char exception_count;
-};
+    template <class F>
+    inline final_action_return<F> on_return(F const &action) gsl_noexcept {
+        return final_action_return<F>(action);
+    }
 
-template< class F >
-inline final_action_error<F> on_error( F const & action ) gsl_noexcept
-{
-    return final_action_error<F>( action );
-}
+    template <class F>
+    inline final_action_return<F> on_return(F && action) gsl_noexcept {
+        return final_action_return<F>(std::forward<F>(action));
+    }
 
-template< class F >
-inline final_action_error<F> on_error( F && action ) gsl_noexcept
-{
-    return final_action_error<F>( std::forward<F>( action ) );
-}
+    template <class F> class final_action_error : public final_action<F> {
+      public:
+        explicit final_action_error(F &&action) gsl_noexcept
+            : final_action<F>(std::move(action)),
+              exception_count(std11::uncaught_exceptions()) {}
 
-#endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+        final_action_error(final_action_error &&other) gsl_noexcept
+            : final_action<F>(std::move(other)),
+              exception_count(std11::uncaught_exceptions()) {}
 
-#else // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 110
+        ~final_action_error() override {
+            if (std11::uncaught_exceptions() == exception_count)
+                this->dismiss();
+        }
 
-class final_action
-{
-public:
-    typedef void (*Action)();
+        gsl_is_delete_access
+            : final_action_error(final_action_error const &) gsl_is_delete;
+        final_action_error &operator=(final_action_error const &) gsl_is_delete;
 
-    final_action( Action action )
-    : action_( action )
-    , invoke_( true )
-    {}
+      private:
+        unsigned char exception_count;
+    };
 
-    final_action( final_action const & other )
-        : action_( other.action_ )
-        , invoke_( other.invoke_ )
-    {
-        other.invoke_ = false;
+    template <class F>
+    inline final_action_error<F> on_error(F const &action) gsl_noexcept {
+        return final_action_error<F>(action);
     }
 
-    virtual ~final_action()
-    {
-        if ( invoke_ )
-            action_();
+    template <class F>
+    inline final_action_error<F> on_error(F && action) gsl_noexcept {
+        return final_action_error<F>(std::forward<F>(action));
     }
 
-protected:
-    void dismiss()
-    {
-        invoke_ = false;
-    }
+#endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
 
-private:
-    final_action & operator=( final_action const & );
+#else // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 110
 
-private:
-    Action action_;
-    mutable bool invoke_;
-};
+    class final_action {
+      public:
+        typedef void (*Action)();
 
-template< class F >
-inline final_action finally( F const & f )
-{
-    return final_action(( f ));
-}
+        final_action(Action action) : action_(action), invoke_(true) {}
 
-#if gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
+        final_action(final_action const &other)
+            : action_(other.action_), invoke_(other.invoke_) {
+            other.invoke_ = false;
+        }
 
-class final_action_return : public final_action
-{
-public:
-    explicit final_action_return( Action action )
-        : final_action( action )
-        , exception_count( std11::uncaught_exceptions() )
-    {}
+        virtual ~final_action() {
+            if (invoke_)
+                action_();
+        }
 
-    ~final_action_return()
-    {
-        if ( std11::uncaught_exceptions() != exception_count )
-            this->dismiss();
+      protected:
+        void dismiss() { invoke_ = false; }
+
+      private:
+        final_action &operator=(final_action const &);
+
+      private:
+        Action action_;
+        mutable bool invoke_;
+    };
+
+    template <class F> inline final_action finally(F const &f) {
+        return final_action((f));
     }
 
-private:
-    final_action_return & operator=( final_action_return const & );
+#if gsl_FEATURE(EXPERIMENTAL_RETURN_GUARD)
 
-private:
-    unsigned char exception_count;
-};
+    class final_action_return : public final_action {
+      public:
+        explicit final_action_return(Action action)
+            : final_action(action),
+              exception_count(std11::uncaught_exceptions()) {}
 
-template< class F >
-inline final_action_return on_return( F const & action )
-{
-    return final_action_return( action );
-}
+        ~final_action_return() {
+            if (std11::uncaught_exceptions() != exception_count)
+                this->dismiss();
+        }
 
-class final_action_error : public final_action
-{
-public:
-    explicit final_action_error( Action action )
-        : final_action( action )
-        , exception_count( std11::uncaught_exceptions() )
-    {}
+      private:
+        final_action_return &operator=(final_action_return const &);
 
-    ~final_action_error()
-    {
-        if ( std11::uncaught_exceptions() == exception_count )
-            this->dismiss();
+      private:
+        unsigned char exception_count;
+    };
+
+    template <class F> inline final_action_return on_return(F const &action) {
+        return final_action_return(action);
     }
 
-private:
-    final_action_error & operator=( final_action_error const & );
+    class final_action_error : public final_action {
+      public:
+        explicit final_action_error(Action action)
+            : final_action(action),
+              exception_count(std11::uncaught_exceptions()) {}
 
-private:
-    unsigned char exception_count;
-};
+        ~final_action_error() {
+            if (std11::uncaught_exceptions() == exception_count)
+                this->dismiss();
+        }
 
-template< class F >
-inline final_action_error on_error( F const & action )
-{
-    return final_action_error( action );
-}
+      private:
+        final_action_error &operator=(final_action_error const &);
+
+      private:
+        unsigned char exception_count;
+    };
+
+    template <class F> inline final_action_error on_error(F const &action) {
+        return final_action_error(action);
+    }
 
 #endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
 
@@ -1577,2209 +1620,2085 @@ inline final_action_error on_error( F const & action )
 
 #if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
 
-template< class T, class U >
-gsl_api inline gsl_constexpr T narrow_cast( U && u ) gsl_noexcept
-{
-    return static_cast<T>( std::forward<U>( u ) );
-}
+    template <class T, class U>
+    gsl_api inline gsl_constexpr T narrow_cast(U && u) gsl_noexcept {
+        return static_cast<T>(std::forward<U>(u));
+    }
 
 #else
 
-template< class T, class U >
-gsl_api inline T narrow_cast( U u ) gsl_noexcept
-{
-    return static_cast<T>( u );
-}
+    template <class T, class U> gsl_api inline T narrow_cast(U u) gsl_noexcept {
+        return static_cast<T>(u);
+    }
 
 #endif // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
 
-struct narrowing_error : public std::exception {};
+    struct narrowing_error : public std::exception {};
 
-#if gsl_HAVE( TYPE_TRAITS )
+#if gsl_HAVE(TYPE_TRAITS)
 
-namespace detail {
+    namespace detail {
 
-    template< class T, class U >
-    struct is_same_signedness : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value>
-    {};
+    template <class T, class U>
+    struct is_same_signedness
+        : public std::integral_constant<bool, std::is_signed<T>::value ==
+                                                  std::is_signed<U>::value> {};
 
-# if defined( __NVCC__ )
-    // We do this to circumvent NVCC warnings about pointless unsigned comparisons with 0.
-    template< class T >
-    gsl_constexpr gsl_api bool is_negative( T value, std::true_type /*isSigned*/ ) gsl_noexcept
-    {
+#if defined(__NVCC__)
+    // We do this to circumvent NVCC warnings about pointless unsigned
+    // comparisons with 0.
+    template <class T>
+    gsl_constexpr gsl_api bool
+    is_negative(T value, std::true_type /*isSigned*/) gsl_noexcept {
         return value < T();
     }
-    template< class T >
-    gsl_constexpr gsl_api bool is_negative( T /*value*/, std::false_type /*isUnsigned*/ ) gsl_noexcept
-    {
+    template <class T>
+    gsl_constexpr gsl_api bool
+    is_negative(T /*value*/, std::false_type /*isUnsigned*/) gsl_noexcept {
         return false;
     }
-    template< class T, class U >
-    gsl_constexpr gsl_api bool have_same_sign( T t, U u, std::true_type /*isSameSignedness*/ ) gsl_noexcept
-    {
+    template <class T, class U>
+    gsl_constexpr gsl_api bool
+    have_same_sign(T t, U u, std::true_type /*isSameSignedness*/) gsl_noexcept {
         return true;
     }
-    template< class T, class U >
-    gsl_constexpr gsl_api bool have_same_sign( T t, U u, std::false_type /*isSameSignedness*/ ) gsl_noexcept
-    {
-        return detail::is_negative( t, std::is_signed<T>() ) == detail::is_negative( u, std::is_signed<U>() );
+    template <class T, class U>
+    gsl_constexpr gsl_api bool
+    have_same_sign(T t, U u,
+                   std::false_type /*isSameSignedness*/) gsl_noexcept {
+        return detail::is_negative(t, std::is_signed<T>()) ==
+               detail::is_negative(u, std::is_signed<U>());
     }
-# endif // defined( __NVCC__ )
+#endif // defined( __NVCC__ )
 
-} // namespace detail
+    } // namespace detail
 
 #endif
 
-#if gsl_HAVE( EXCEPTIONS ) || !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION
-template< class T, class U >
-# if !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION && !defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
-gsl_api
-# endif // !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION && !defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
-inline T narrow( U u )
-{
-    T t = static_cast<T>( u );
+#if gsl_HAVE(EXCEPTIONS) || !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION
+    template <class T, class U>
+#if !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION &&                                 \
+    !defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS)
+    gsl_api
+#endif // !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION && !defined(
+       // gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
+        inline T
+        narrow(U u) {
+        T t = static_cast<T>(u);
+
+        if (static_cast<U>(t) != u) {
+#if gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION ||                                  \
+    defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS)
+            throw narrowing_error();
+#else
+            std::terminate();
+#endif
+        }
 
-    if ( static_cast<U>( t ) != u )
-    {
-# if gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION || defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
-        throw narrowing_error();
-# else
-        std::terminate();
-# endif
-    }
-
-# if gsl_HAVE( TYPE_TRAITS )
-#  if defined( __NVCC__ )
-    if ( ! detail::have_same_sign( t, u, detail::is_same_signedness<T, U>() ) )
-#  else
-    gsl_SUPPRESS_MSVC_WARNING( 4127, "conditional expression is constant" )
-    if ( ! detail::is_same_signedness<T, U>::value && ( t < T() ) != ( u < U() ) )
-#  endif
-# else
-    // Don't assume T() works:
-    gsl_SUPPRESS_MSVC_WARNING( 4127, "conditional expression is constant" )
-    if ( ( t < 0 ) != ( u < 0 ) )
-# endif
-    {
-# if gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION || defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
-        throw narrowing_error();
-# else
-        std::terminate();
-# endif
-    }
+#if gsl_HAVE(TYPE_TRAITS)
+#if defined(__NVCC__)
+        if (!detail::have_same_sign(t, u, detail::is_same_signedness<T, U>()))
+#else
+        gsl_SUPPRESS_MSVC_WARNING(
+            4127,
+            "conditional expression is constant") if (!detail::
+                                                          is_same_signedness<
+                                                              T, U>::value &&
+                                                      (t < T()) != (u < U()))
+#endif
+#else
+        // Don't assume T() works:
+        gsl_SUPPRESS_MSVC_WARNING(
+            4127, "conditional expression is constant") if ((t < 0) != (u < 0))
+#endif
+        {
+#if gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION ||                                  \
+    defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS)
+            throw narrowing_error();
+#else
+            std::terminate();
+#endif
+        }
 
-    return t;
-}
+        return t;
+    }
 #endif // gsl_HAVE( EXCEPTIONS ) || !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION
 
-template< class T, class U >
-gsl_api inline T narrow_failfast( U u )
-{
-    T t = static_cast<T>( u );
+    template <class T, class U> gsl_api inline T narrow_failfast(U u) {
+        T t = static_cast<T>(u);
 
-    gsl_Expects( static_cast<U>( t ) == u );
+        gsl_Expects(static_cast<U>(t) == u);
 
-#if gsl_HAVE( TYPE_TRAITS )
-# if defined( __NVCC__ )
-    gsl_Expects( ::gsl::detail::have_same_sign( t, u, ::gsl::detail::is_same_signedness<T, U>() ) );
-# else
-    gsl_SUPPRESS_MSVC_WARNING( 4127, "conditional expression is constant" )
-    gsl_Expects( ( ::gsl::detail::is_same_signedness<T, U>::value || ( t < T() ) == ( u < U() ) ) );
-# endif
+#if gsl_HAVE(TYPE_TRAITS)
+#if defined(__NVCC__)
+        gsl_Expects(::gsl::detail::have_same_sign(
+            t, u, ::gsl::detail::is_same_signedness<T, U>()));
+#else
+        gsl_SUPPRESS_MSVC_WARNING(4127, "conditional expression is constant")
+            gsl_Expects((::gsl::detail::is_same_signedness<T, U>::value ||
+                         (t < T()) == (u < U())));
+#endif
 #else
-    // Don't assume T() works:
-    gsl_SUPPRESS_MSVC_WARNING( 4127, "conditional expression is constant" )
-    gsl_Expects( ( t < 0 ) == ( u < 0 ) );
+        // Don't assume T() works:
+        gsl_SUPPRESS_MSVC_WARNING(4127, "conditional expression is constant")
+            gsl_Expects((t < 0) == (u < 0));
 #endif
 
-    return t;
-}
+        return t;
+    }
 
+    //
+    // at() - Bounds-checked way of accessing static arrays, std::array,
+    // std::vector.
+    //
 
-//
-// at() - Bounds-checked way of accessing static arrays, std::array, std::vector.
-//
+    template <class T, size_t N>
+    gsl_api inline gsl_constexpr14 T &at(T(&arr)[N], size_t pos) {
+        gsl_Expects(pos < N);
+        return arr[pos];
+    }
 
-template< class T, size_t N >
-gsl_api inline gsl_constexpr14 T & at( T(&arr)[N], size_t pos )
-{
-    gsl_Expects( pos < N );
-    return arr[pos];
-}
-
-template< class Container >
-inline gsl_constexpr14 typename Container::value_type & at( Container & cont, size_t pos )
-{
-    gsl_Expects( pos < cont.size() );
-    return cont[pos];
-}
+    template <class Container>
+    inline gsl_constexpr14 typename Container::value_type &at(Container & cont,
+                                                              size_t pos) {
+        gsl_Expects(pos < cont.size());
+        return cont[pos];
+    }
 
-template< class Container >
-inline gsl_constexpr14 typename Container::value_type const & at( Container const & cont, size_t pos )
-{
-    gsl_Expects( pos < cont.size() );
-    return cont[pos];
-}
+    template <class Container>
+    inline gsl_constexpr14 typename Container::value_type const &at(
+        Container const &cont, size_t pos) {
+        gsl_Expects(pos < cont.size());
+        return cont[pos];
+    }
 
-#if gsl_HAVE( INITIALIZER_LIST )
+#if gsl_HAVE(INITIALIZER_LIST)
 
-template< class T >
-inline const gsl_constexpr14 T at( std::initializer_list<T> cont, size_t pos )
-{
-    gsl_Expects( pos < cont.size() );
-    return *( cont.begin() + pos );
-}
+    template <class T>
+    inline const gsl_constexpr14 T at(std::initializer_list<T> cont,
+                                      size_t pos) {
+        gsl_Expects(pos < cont.size());
+        return *(cont.begin() + pos);
+    }
 #endif
 
-template< class T >
-gsl_api inline gsl_constexpr14 T & at( span<T> s, size_t pos )
-{
-    return s[ pos ];
-}
+    template <class T>
+    gsl_api inline gsl_constexpr14 T &at(span<T> s, size_t pos) {
+        return s[pos];
+    }
 
-//
-// GSL.views: views
-//
+    //
+    // GSL.views: views
+    //
 
-//
-// not_null<> - Wrap any indirection and enforce non-null.
-//
+    //
+    // not_null<> - Wrap any indirection and enforce non-null.
+    //
 
-template< class T >
-class not_null;
+    template <class T> class not_null;
 
-namespace detail {
+    namespace detail {
 
 // helper class to figure out the pointed-to type of a pointer
 #if gsl_CPP11_OR_GREATER
-template< class T, class E = void >
-struct element_type_helper
-{
-    // For types without a member element_type (this will handle raw pointers)
-    typedef typename std::remove_reference< decltype( *std::declval<T>() ) >::type type;
-};
-
-template< class T >
-struct element_type_helper< T, std17::void_t< typename T::element_type > >
-{
-    // For types with a member element_type
-    typedef typename T::element_type type;
-};
+    template <class T, class E = void> struct element_type_helper {
+        // For types without a member element_type (this will handle raw
+        // pointers)
+        typedef
+            typename std::remove_reference<decltype(*std::declval<T>())>::type
+                type;
+    };
+
+    template <class T>
+    struct element_type_helper<T, std17::void_t<typename T::element_type>> {
+        // For types with a member element_type
+        typedef typename T::element_type type;
+    };
 #else
-// Pre-C++11, we cannot have decltype, so we cannot handle types without a member element_type
-template< class T, class E = void >
-struct element_type_helper
-{
-    typedef typename T::element_type type;
-};
+    // Pre-C++11, we cannot have decltype, so we cannot handle types without a
+    // member element_type
+    template <class T, class E = void> struct element_type_helper {
+        typedef typename T::element_type type;
+    };
 
-template< class T >
-struct element_type_helper< T* >
-{
-    typedef T type;
-};
+    template <class T> struct element_type_helper<T *> { typedef T type; };
 #endif
 
-template< class T >
-struct is_not_null_oracle : std11::false_type { };
-template< class T >
-struct is_not_null_oracle< not_null<T> > : std11::true_type { };
+    template <class T> struct is_not_null_oracle : std11::false_type {};
+    template <class T>
+    struct is_not_null_oracle<not_null<T>> : std11::true_type {};
 
-template< class T, bool IsCopyable = true >
-struct not_null_data;
-#if gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS )
-template< class T >
-struct not_null_data< T, false >
-{
-    T ptr_;
+    template <class T, bool IsCopyable = true> struct not_null_data;
+#if gsl_HAVE(RVALUE_REFERENCE) && gsl_HAVE(TYPE_TRAITS)
+    template <class T> struct not_null_data<T, false> {
+        T ptr_;
 
-    gsl_constexpr14 not_null_data( T && _ptr ) gsl_noexcept
-    : ptr_( std::move( _ptr ) )
-    {
-    }
-    
-    gsl_constexpr14 not_null_data( not_null_data && other ) gsl_noexcept
-    : ptr_( std::move( other.ptr_ ) )
-    {
-    }
-    gsl_constexpr14 not_null_data & operator=( not_null_data && other ) gsl_noexcept
-    {
-        ptr_ = std::move( other.ptr_ );
-        return *this;
-    }
+        gsl_constexpr14 not_null_data(T &&_ptr) gsl_noexcept
+            : ptr_(std::move(_ptr)) {}
 
-gsl_is_delete_access:
-    not_null_data( not_null_data const & other ) gsl_is_delete;
-    not_null_data & operator=( not_null_data const & other ) gsl_is_delete;
-};
+        gsl_constexpr14 not_null_data(not_null_data &&other) gsl_noexcept
+            : ptr_(std::move(other.ptr_)) {}
+        gsl_constexpr14 not_null_data &
+        operator=(not_null_data &&other) gsl_noexcept {
+            ptr_ = std::move(other.ptr_);
+            return *this;
+        }
+
+        gsl_is_delete_access
+            : not_null_data(not_null_data const &other) gsl_is_delete;
+        not_null_data &operator=(not_null_data const &other) gsl_is_delete;
+    };
 #endif // gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS )
-template< class T >
-struct not_null_data< T, true >
-{
-    T ptr_;
+    template <class T> struct not_null_data<T, true> {
+        T ptr_;
 
-    gsl_constexpr14 not_null_data( T const & _ptr ) gsl_noexcept
-    : ptr_( _ptr )
-    {
-    }
+        gsl_constexpr14 not_null_data(T const &_ptr) gsl_noexcept : ptr_(_ptr) {
+        }
 
-#if gsl_HAVE( RVALUE_REFERENCE )
-    gsl_constexpr14 not_null_data( T && _ptr ) gsl_noexcept
-    : ptr_( std::move( _ptr ) )
-    {
-    }
-    
-    gsl_constexpr14 not_null_data( not_null_data && other ) gsl_noexcept
-    : ptr_( std::move( other.ptr_ ) )
-    {
-    }
-    gsl_constexpr14 not_null_data & operator=( not_null_data && other ) gsl_noexcept
-    {
-        ptr_ = std::move( other.ptr_ );
-        return *this;
-    }
+#if gsl_HAVE(RVALUE_REFERENCE)
+        gsl_constexpr14 not_null_data(T &&_ptr) gsl_noexcept
+            : ptr_(std::move(_ptr)) {}
+
+        gsl_constexpr14 not_null_data(not_null_data &&other) gsl_noexcept
+            : ptr_(std::move(other.ptr_)) {}
+        gsl_constexpr14 not_null_data &
+        operator=(not_null_data &&other) gsl_noexcept {
+            ptr_ = std::move(other.ptr_);
+            return *this;
+        }
 #endif // gsl_HAVE( RVALUE_REFERENCE )
 
-    gsl_constexpr14 not_null_data( not_null_data const & other )
-    : ptr_( other.ptr_ )
-    {
-        gsl_Expects( ptr_ != gsl_nullptr );
-    }
-    gsl_constexpr14 not_null_data & operator=( not_null_data const & other )
-    {
-        gsl_Expects( other.ptr_ != gsl_nullptr );
-        ptr_ = other.ptr_;
-        return *this;
-    }
-};
+        gsl_constexpr14 not_null_data(not_null_data const &other)
+            : ptr_(other.ptr_) {
+            gsl_Expects(ptr_ != gsl_nullptr);
+        }
+        gsl_constexpr14 not_null_data &operator=(not_null_data const &other) {
+            gsl_Expects(other.ptr_ != gsl_nullptr);
+            ptr_ = other.ptr_;
+            return *this;
+        }
+    };
 
-template< class T >
-struct is_copyable
-#if gsl_HAVE( TYPE_TRAITS )
-: std11::integral_constant< bool, std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value >
+    template <class T>
+    struct is_copyable
+#if gsl_HAVE(TYPE_TRAITS)
+        : std11::integral_constant<bool, std::is_copy_constructible<T>::value &&
+                                             std::is_copy_assignable<T>::value>
 #else
-: std11::true_type
+        : std11::true_type
+#endif
+    {
+    };
+#if gsl_HAVE(TYPE_TRAITS) && gsl_HAVE(UNIQUE_PTR) &&                           \
+    gsl_BETWEEN(gsl_COMPILER_MSVC_VERSION, 1, 140)
+    // Type traits are buggy in VC++ 2013, so we explicitly declare
+    // `unique_ptr<>` non-copyable.
+    template <class T, class Deleter>
+    struct is_copyable<std::unique_ptr<T, Deleter>> : std11::false_type {};
+#endif
+
+    } // namespace detail
+
+    template <class T> class not_null {
+      private:
+        detail::not_null_data<T, detail::is_copyable<T>::value> data_;
+
+        // need to access `not_null<U>::data_`
+        template <class U> friend class not_null;
+
+      public:
+        typedef typename detail::element_type_helper<T>::type element_type;
+
+#if gsl_HAVE(TYPE_TRAITS)
+        static_assert(std::is_assignable<T &, std::nullptr_t>::value,
+                      "T cannot be assigned nullptr.");
+#endif
+
+#if gsl_CONFIG(NOT_NULL_EXPLICIT_CTOR)
+#if gsl_HAVE(RVALUE_REFERENCE)
+        template <class U
+        // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>,
+        // unique_ptr<X>>` tries to instantiate the copy constructor of
+        // `unique_ptr<>`, triggering an error. Note that Apple Clang's
+        // `__clang_major__` etc. are different from regular Clang.
+#if gsl_HAVE(TYPE_TRAITS) && gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) &&        \
+    !gsl_BETWEEN(gsl_COMPILER_CLANG_VERSION, 1, 400) &&                        \
+    !gsl_BETWEEN(gsl_COMPILER_APPLECLANG_VERSION, 1, 1001)
+                  // We *have* to use SFINAE with an NTTP arg here, otherwise
+                  // the overload is ambiguous.
+                  ,
+                  typename std::enable_if<(std::is_constructible<T, U>::value),
+                                          int>::type = 0
+#endif
+                  >
+        gsl_constexpr14 explicit not_null(U other)
+            : data_(T(std::move(other))) {
+            gsl_Expects(data_.ptr_ != gsl_nullptr);
+        }
+#else  // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
+        template <class U>
+        gsl_constexpr14 explicit not_null(U const &other) : data_(T(other)) {
+            gsl_Expects(data_.ptr_ != gsl_nullptr);
+        }
+#endif // gsl_HAVE( RVALUE_REFERENCE )
+#else  // a.k.a. !gsl_CONFIG( NOT_NULL_EXPLICIT_CTOR )
+#if gsl_HAVE(RVALUE_REFERENCE)
+        // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>,
+        // unique_ptr<X>>` tries to instantiate the copy constructor of
+        // `unique_ptr<>`, triggering an error. Note that Apple Clang's
+        // `__clang_major__` etc. are different from regular Clang.
+#if gsl_HAVE(TYPE_TRAITS) && gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) &&        \
+    !gsl_BETWEEN(gsl_COMPILER_CLANG_VERSION, 1, 400) &&                        \
+    !gsl_BETWEEN(gsl_COMPILER_APPLECLANG_VERSION, 1, 1001)
+        template <class U
+                  // We *have* to use SFINAE with an NTTP arg here, otherwise
+                  // the overload is ambiguous.
+                  ,
+                  typename std::enable_if<(std::is_constructible<T, U>::value &&
+                                           !std::is_convertible<U, T>::value),
+                                          int>::type = 0>
+        gsl_constexpr14 explicit not_null(U other)
+            : data_(T(std::move(other))) {
+            gsl_Expects(data_.ptr_ != gsl_nullptr);
+        }
+
+        template <class U
+                  // We *have* to use SFINAE with an NTTP arg here, otherwise
+                  // the overload is ambiguous.
+                  ,
+                  typename std::enable_if<(std::is_convertible<U, T>::value),
+                                          int>::type = 0>
+        gsl_constexpr14 not_null(U other) : data_(T(std::move(other))) {
+            gsl_Expects(data_.ptr_ != gsl_nullptr);
+        }
+#else  // a.k.a. !( gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE(
+       // DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN(
+       // gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN(
+       // gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
+        // If type_traits are not available, then we can't distinguish
+        // `is_convertible<>` and `is_constructible<>`, so we unconditionally
+        // permit implicit construction.
+        template <class U>
+        gsl_constexpr14 not_null(U other) : data_(T(std::move(other))) {
+            gsl_Expects(data_.ptr_ != gsl_nullptr);
+        }
+#endif // gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+       // && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN(
+       // gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
+#else  // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
+        template <class U>
+        gsl_constexpr14 not_null(U const &other) : data_(T(other)) {
+            gsl_Expects(data_.ptr_ != gsl_nullptr);
+        }
+#endif // gsl_HAVE( RVALUE_REFERENCE )
+#endif // gsl_CONFIG( NOT_NULL_EXPLICIT_CTOR )
+
+#if gsl_HAVE(RVALUE_REFERENCE)
+        // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>,
+        // unique_ptr<X>>` tries to instantiate the copy constructor of
+        // `unique_ptr<>`, triggering an error. Note that Apple Clang's
+        // `__clang_major__` etc. are different from regular Clang.
+#if gsl_HAVE(TYPE_TRAITS) && gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) &&        \
+    !gsl_BETWEEN(gsl_COMPILER_CLANG_VERSION, 1, 400) &&                        \
+    !gsl_BETWEEN(gsl_COMPILER_APPLECLANG_VERSION, 1, 1001)
+        template <class U
+                  // We *have* to use SFINAE with an NTTP arg here, otherwise
+                  // the overload is ambiguous.
+                  ,
+                  typename std::enable_if<(std::is_constructible<T, U>::value &&
+                                           !std::is_convertible<U, T>::value),
+                                          int>::type = 0>
+        gsl_constexpr14 explicit not_null(not_null<U> other)
+            : data_(T(std::move(other.data_.ptr_))) {
+            gsl_Expects(data_.ptr_ != gsl_nullptr);
+        }
+
+        template <class U
+                  // We *have* to use SFINAE with an NTTP arg here, otherwise
+                  // the overload is ambiguous.
+                  ,
+                  typename std::enable_if<(std::is_convertible<U, T>::value),
+                                          int>::type = 0>
+        gsl_constexpr14 not_null(not_null<U> other)
+            : data_(T(std::move(other.data_.ptr_))) {
+            gsl_Expects(data_.ptr_ != gsl_nullptr);
+        }
+#else  // a.k.a. !( gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE(
+       // DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN(
+       // gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN(
+       // gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
+        // If type_traits are not available, then we can't distinguish
+        // `is_convertible<>` and `is_constructible<>`, so we unconditionally
+        // permit implicit construction.
+        template <class U>
+        gsl_constexpr14 not_null(not_null<U> other)
+            : data_(T(std::move(other.data_.ptr_))) {
+            gsl_Expects(data_.ptr_ != gsl_nullptr);
+        }
+        template <class U>
+        gsl_constexpr14 not_null<T> &operator=(not_null<U> other) {
+            gsl_Expects(other.data_.ptr_ != gsl_nullptr);
+            data_.ptr_ = std::move(other.data_.ptr_);
+            return *this;
+        }
+#endif // gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+       // && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN(
+       // gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
+#else  // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
+        template <class U>
+        gsl_constexpr14 not_null(not_null<U> const &other)
+            : data_(T(other.data_.ptr_)) {
+            gsl_Expects(data_.ptr_ != gsl_nullptr);
+        }
+        template <class U>
+        gsl_constexpr14 not_null<T> &operator=(not_null<U> const &other) {
+            gsl_Expects(other.data_.ptr_ != gsl_nullptr);
+            data_.ptr_ = other.data_.ptr_;
+            return *this;
+        }
+#endif // gsl_HAVE( RVALUE_REFERENCE )
+
+#if gsl_CONFIG(TRANSPARENT_NOT_NULL)
+        gsl_constexpr14 element_type *get() const {
+            gsl_Ensures(data_.ptr_ != gsl_nullptr);
+            return data_.ptr_.get();
+        }
+#else
+#if gsl_CONFIG(NOT_NULL_GET_BY_CONST_REF)
+        gsl_constexpr14 T const &get() const {
+            gsl_Ensures(data_.ptr_ != gsl_nullptr);
+            return data_.ptr_;
+        }
+#else
+        gsl_constexpr14 T get() const {
+            gsl_Ensures(data_.ptr_ != gsl_nullptr);
+            return data_.ptr_;
+        }
 #endif
-{
-};
-#if gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( UNIQUE_PTR ) && gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 140 )
-// Type traits are buggy in VC++ 2013, so we explicitly declare `unique_ptr<>` non-copyable.
-template< class T, class Deleter >
-struct is_copyable< std::unique_ptr< T, Deleter > > : std11::false_type
-{
-};
 #endif
 
-} // namespace detail
+        // We want an implicit conversion operator that can be used to convert
+        // from both lvalues (by const reference or by copy) and rvalues (by
+        // move). So it seems like we could define
+        //
+        //     template< class U >
+        //     operator U const &() const & { ... }
+        //     template< class U >
+        //     operator U &&() && { ... }
+        //
+        // However, having two conversion operators with different return types
+        // renders the assignment operator of the result type ambiguous:
+        //
+        //     not_null<std::unique_ptr<T>> p( ... );
+        //     std::unique_ptr<U> q;
+        //     q = std::move( p ); // ambiguous
+        //
+        // To avoid this ambiguity, we have both overloads of the conversion
+        // operator return `U` rather than `U const &` or `U &&`. This implies
+        // that converting an lvalue always induces a copy, which can cause
+        // unnecessary copies or even fail to compile in some situations:
+        //
+        //     not_null<std::shared_ptr<T>> sp( ... );
+        //     std::shared_ptr<U> const & rs = sp; // unnecessary copy
+        //     std::unique_ptr<U> const & ru = p; // error: cannot copy
+        //     `unique_ptr<T>`
+        //
+        // However, these situations are rather unusual, and the following, more
+        // frequent situations remain unimpaired:
+        //
+        //     std::shared_ptr<U> vs = sp; // no extra copy
+        //     std::unique_ptr<U> vu = std::move( p );
+
+#if gsl_HAVE(RVALUE_REFERENCE) && gsl_HAVE(TYPE_TRAITS) &&                     \
+    gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) && gsl_HAVE(EXPLICIT)
+        // explicit conversion operator
+
+        template <class U
+                  // We *have* to use SFINAE with an NTTP arg here, otherwise
+                  // the overload is ambiguous.
+                  ,
+                  typename std::enable_if<
+                      (std::is_constructible<U, T const &>::value &&
+                       !std::is_convertible<T, U>::value &&
+                       !detail::is_not_null_oracle<U>::value),
+                      int>::type = 0>
+        gsl_constexpr14 explicit operator U() const
+#if gsl_HAVE(FUNCTION_REF_QUALIFIER)
+            &
+#endif
+        {
+            gsl_Ensures(data_.ptr_ != gsl_nullptr);
+            return U(data_.ptr_);
+        }
+#if gsl_HAVE(FUNCTION_REF_QUALIFIER)
+        template <
+            class U
+            // We *have* to use SFINAE with an NTTP arg here, otherwise the
+            // overload is ambiguous.
+            ,
+            typename std::enable_if<(std::is_constructible<U, T>::value &&
+                                     !std::is_convertible<T, U>::value &&
+                                     !detail::is_not_null_oracle<U>::value),
+                                    int>::type = 0>
+        gsl_constexpr14 explicit operator U() && {
+            gsl_Ensures(data_.ptr_ != gsl_nullptr);
+            return U(std::move(data_.ptr_));
+        }
+#endif
 
-template< class T >
-class not_null
-{
-private:
-    detail::not_null_data< T, detail::is_copyable< T >::value > data_;
-
-    // need to access `not_null<U>::data_`
-    template< class U >
-    friend class not_null;
-
-public:
-    typedef typename detail::element_type_helper<T>::type element_type;
-
-#if gsl_HAVE( TYPE_TRAITS )
-    static_assert( std::is_assignable<T&, std::nullptr_t>::value, "T cannot be assigned nullptr." );
-#endif
-
-#if gsl_CONFIG( NOT_NULL_EXPLICIT_CTOR )
-# if gsl_HAVE( RVALUE_REFERENCE )
-    template< class U
-    // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>, unique_ptr<X>>` tries to instantiate the copy constructor of `unique_ptr<>`, triggering an error.
-    // Note that Apple Clang's `__clang_major__` etc. are different from regular Clang.
-#  if gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
-        , typename std::enable_if< ( std::is_constructible<T, U>::value ), int >::type = 0
-#  endif
-    >
-    gsl_constexpr14 explicit not_null( U other )
-    : data_( T( std::move( other ) ) )
-    {
-        gsl_Expects( data_.ptr_ != gsl_nullptr );
-    }
-# else // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
-    template< class U >
-    gsl_constexpr14 explicit not_null( U const& other )
-    : data_( T( other ) )
-    {
-        gsl_Expects( data_.ptr_ != gsl_nullptr );
-    }
-# endif // gsl_HAVE( RVALUE_REFERENCE )
-#else // a.k.a. !gsl_CONFIG( NOT_NULL_EXPLICIT_CTOR )
-# if gsl_HAVE( RVALUE_REFERENCE )
-    // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>, unique_ptr<X>>` tries to instantiate the copy constructor of `unique_ptr<>`, triggering an error.
-    // Note that Apple Clang's `__clang_major__` etc. are different from regular Clang.
-#  if gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-    template< class U
-        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
-        , typename std::enable_if< ( std::is_constructible<T, U>::value && !std::is_convertible<U, T>::value ), int >::type = 0
-    >
-    gsl_constexpr14 explicit not_null( U other )
-    : data_( T( std::move( other ) ) )
-    {
-        gsl_Expects( data_.ptr_ != gsl_nullptr );
-    }
+        // implicit conversion operator
+        template <class U
+                  // We *have* to use SFINAE with an NTTP arg here, otherwise
+                  // the overload is ambiguous.
+                  ,
+                  typename std::enable_if<
+                      (std::is_constructible<U, T const &>::value &&
+                       std::is_convertible<T, U>::value &&
+                       !detail::is_not_null_oracle<U>::value),
+                      int>::type = 0>
+        gsl_constexpr14 operator U() const
+#if gsl_HAVE(FUNCTION_REF_QUALIFIER)
+            &
+#endif
+        {
+            gsl_Ensures(data_.ptr_ != gsl_nullptr);
+            return data_.ptr_;
+        }
+#if gsl_HAVE(FUNCTION_REF_QUALIFIER)
+        template <
+            class U
+            // We *have* to use SFINAE with an NTTP arg here, otherwise the
+            // overload is ambiguous.
+            ,
+            typename std::enable_if<(std::is_convertible<T, U>::value &&
+                                     !detail::is_not_null_oracle<U>::value),
+                                    int>::type = 0>
+        gsl_constexpr14 operator U() && {
+            gsl_Ensures(data_.ptr_ != gsl_nullptr);
+            return std::move(data_.ptr_);
+        }
+#endif
+#else  // a.k.a. #if !( gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS )
+       // && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && gsl_HAVE( EXPLICIT ) )
+        template <class U> gsl_constexpr14 operator U() const {
+            gsl_Ensures(data_.ptr_ != gsl_nullptr);
+            return data_.ptr_;
+        }
+#endif // gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE(
+       // DEFAULT_FUNCTION_TEMPLATE_ARG ) && gsl_HAVE( EXPLICIT )
 
-    template< class U
-        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
-        , typename std::enable_if< ( std::is_convertible<U, T>::value ), int >::type = 0
-    >
-    gsl_constexpr14 not_null( U other )
-    : data_( T( std::move( other ) ) )
-    {
-        gsl_Expects( data_.ptr_ != gsl_nullptr );
-    }
-#  else // a.k.a. !( gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-    // If type_traits are not available, then we can't distinguish `is_convertible<>` and `is_constructible<>`, so we unconditionally permit implicit construction.
-    template< class U >
-    gsl_constexpr14 not_null( U other )
-    : data_( T( std::move( other ) ) )
-    {
-        gsl_Expects( data_.ptr_ != gsl_nullptr );
-    }
-#  endif // gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-# else // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
-    template< class U >
-    gsl_constexpr14 not_null( U const& other )
-    : data_( T( other ) )
-    {
-        gsl_Expects( data_.ptr_ != gsl_nullptr );
-    }
-# endif // gsl_HAVE( RVALUE_REFERENCE )
-#endif // gsl_CONFIG( NOT_NULL_EXPLICIT_CTOR )
+        gsl_constexpr14 T const &operator->() const {
+            gsl_Ensures(data_.ptr_ != gsl_nullptr);
+            return data_.ptr_;
+        }
 
-# if gsl_HAVE( RVALUE_REFERENCE )
-    // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>, unique_ptr<X>>` tries to instantiate the copy constructor of `unique_ptr<>`, triggering an error.
-    // Note that Apple Clang's `__clang_major__` etc. are different from regular Clang.
-#  if gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-    template< class U
-        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
-        , typename std::enable_if< ( std::is_constructible<T, U>::value && !std::is_convertible<U, T>::value ), int >::type = 0
-    >
-    gsl_constexpr14 explicit not_null( not_null<U> other )
-    : data_( T( std::move( other.data_.ptr_ ) ) )
-    {
-        gsl_Expects( data_.ptr_ != gsl_nullptr );
-    }
+        gsl_constexpr14 element_type &operator*() const {
+            gsl_Ensures(data_.ptr_ != gsl_nullptr);
+            return *data_.ptr_;
+        }
 
-    template< class U
-        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
-        , typename std::enable_if< ( std::is_convertible<U, T>::value ), int >::type = 0
-    >
-    gsl_constexpr14 not_null( not_null<U> other )
-    : data_( T( std::move( other.data_.ptr_ ) ) )
-    {
-        gsl_Expects( data_.ptr_ != gsl_nullptr );
+#if gsl_HAVE(RVALUE_REFERENCE)
+        // Visual C++ 2013 doesn't generate default move constructors, so we
+        // declare them explicitly.
+        gsl_constexpr14 not_null(not_null &&other) gsl_noexcept
+            : data_(std::move(other.data_)) {
+            gsl_Expects(data_.ptr_ != gsl_nullptr);
+        }
+        gsl_constexpr14 not_null &operator=(not_null &&other) gsl_noexcept {
+            gsl_Expects(other.data_.ptr_ != gsl_nullptr);
+            data_ = std::move(other.data_);
+            return *this;
+        }
+#endif // gsl_HAVE( RVALUE_REFERENCE )
+
+#if gsl_HAVE(IS_DEFAULT)
+        gsl_constexpr14 not_null(not_null const &other) = default;
+        gsl_constexpr14 not_null &operator=(not_null const &other) = default;
+#endif
+
+        gsl_is_delete_access : not_null() gsl_is_delete;
+        // prevent compilation when initialized with a nullptr or literal 0:
+#if gsl_HAVE(NULLPTR)
+        not_null(std::nullptr_t) gsl_is_delete;
+        not_null &operator=(std::nullptr_t) gsl_is_delete;
+#else
+        not_null(int) gsl_is_delete;
+        not_null &operator=(int) gsl_is_delete;
+#endif
+
+        // unwanted operators...pointers only point to single objects!
+        not_null &operator++() gsl_is_delete;
+        not_null &operator--() gsl_is_delete;
+        not_null operator++(int) gsl_is_delete;
+        not_null operator--(int) gsl_is_delete;
+        not_null &operator+(size_t) gsl_is_delete;
+        not_null &operator+=(size_t) gsl_is_delete;
+        not_null &operator-(size_t) gsl_is_delete;
+        not_null &operator-=(size_t) gsl_is_delete;
+        not_null &operator+=(std::ptrdiff_t) gsl_is_delete;
+        not_null &operator-=(std::ptrdiff_t) gsl_is_delete;
+        void operator[](std::ptrdiff_t) const gsl_is_delete;
+    };
+#if gsl_HAVE(DEDUCTION_GUIDES)
+    template <class U> not_null(U) -> not_null<U>;
+    template <class U> not_null(not_null<U>) -> not_null<U>;
+#endif
+
+#if gsl_HAVE(NULLPTR)
+    void make_not_null(std::nullptr_t) gsl_is_delete;
+#endif // gsl_HAVE( NULLPTR )
+#if gsl_HAVE(RVALUE_REFERENCE)
+    template <class U> not_null<U> make_not_null(U u) {
+        return not_null<U>(std::move(u));
     }
-#  else // a.k.a. !( gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-    // If type_traits are not available, then we can't distinguish `is_convertible<>` and `is_constructible<>`, so we unconditionally permit implicit construction.
-    template< class U >
-    gsl_constexpr14 not_null( not_null<U> other )
-    : data_( T( std::move( other.data_.ptr_ ) ) )
-    {
-        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    template <class U> not_null<U> make_not_null(not_null<U> u) {
+        return std::move(u);
     }
-    template< class U >
-    gsl_constexpr14 not_null<T>& operator=( not_null<U> other )
-    {
-        gsl_Expects( other.data_.ptr_ != gsl_nullptr );
-        data_.ptr_ = std::move( other.data_.ptr_ );
-        return *this;
-    }
-#  endif // gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN( gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-# else // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
-    template< class U >
-    gsl_constexpr14 not_null( not_null<U> const& other )
-    : data_( T( other.data_.ptr_ ) )
-    {
-        gsl_Expects( data_.ptr_ != gsl_nullptr );
+#else  // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
+    template <class U> not_null<U> make_not_null(U const &u) {
+        return not_null<U>(u);
     }
-    template< class U >
-    gsl_constexpr14 not_null<T>& operator=( not_null<U> const & other )
-    {
-        gsl_Expects( other.data_.ptr_ != gsl_nullptr );
-        data_.ptr_ = other.data_.ptr_;
-        return *this;
+    template <class U> not_null<U> make_not_null(not_null<U> const &u) {
+        return u;
     }
-# endif // gsl_HAVE( RVALUE_REFERENCE )
+#endif // gsl_HAVE( RVALUE_REFERENCE )
 
-#if gsl_CONFIG( TRANSPARENT_NOT_NULL )
-    gsl_constexpr14 element_type *
-    get() const
-    {
-        gsl_Ensures( data_.ptr_ != gsl_nullptr );
-        return data_.ptr_.get();
-    }
+    // not_null with implicit constructor, allowing copy-initialization:
+
+    template <class T> class not_null_ic : public not_null<T> {
+      public:
+        template <class U gsl_ENABLE_IF_((std::is_constructible<T, U>::value))>
+        gsl_constexpr14
+#if gsl_HAVE(RVALUE_REFERENCE)
+        not_null_ic(U &&u)
+            : not_null<T>(std::forward<U>(u))
 #else
-# if gsl_CONFIG( NOT_NULL_GET_BY_CONST_REF )
-    gsl_constexpr14 T const & get() const
-    {
-        gsl_Ensures( data_.ptr_ != gsl_nullptr );
-        return data_.ptr_;
-    }
-# else
-    gsl_constexpr14 T get() const
-    {
-        gsl_Ensures( data_.ptr_ != gsl_nullptr );
-        return data_.ptr_;
-    }
-# endif
+        not_null_ic(U const &u)
+            : not_null<T>(u)
 #endif
-
-    // We want an implicit conversion operator that can be used to convert from both lvalues (by
-    // const reference or by copy) and rvalues (by move). So it seems like we could define
-    //
-    //     template< class U >
-    //     operator U const &() const & { ... }
-    //     template< class U >
-    //     operator U &&() && { ... }
-    //
-    // However, having two conversion operators with different return types renders the assignment
-    // operator of the result type ambiguous:
-    //
-    //     not_null<std::unique_ptr<T>> p( ... );
-    //     std::unique_ptr<U> q;
-    //     q = std::move( p ); // ambiguous
-    //
-    // To avoid this ambiguity, we have both overloads of the conversion operator return `U`
-    // rather than `U const &` or `U &&`. This implies that converting an lvalue always induces
-    // a copy, which can cause unnecessary copies or even fail to compile in some situations:
-    //
-    //     not_null<std::shared_ptr<T>> sp( ... );
-    //     std::shared_ptr<U> const & rs = sp; // unnecessary copy
-    //     std::unique_ptr<U> const & ru = p; // error: cannot copy `unique_ptr<T>`
-    //
-    // However, these situations are rather unusual, and the following, more frequent situations
-    // remain unimpaired:
-    //
-    //     std::shared_ptr<U> vs = sp; // no extra copy
-    //     std::unique_ptr<U> vu = std::move( p );
-
-#if gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && gsl_HAVE( EXPLICIT )
-    // explicit conversion operator
-
-    template< class U
-        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
-        , typename std::enable_if< ( std::is_constructible<U, T const &>::value && !std::is_convertible<T, U>::value && !detail::is_not_null_oracle<U>::value ), int >::type = 0
-    >
-    gsl_constexpr14 explicit
-    operator U() const
-# if gsl_HAVE( FUNCTION_REF_QUALIFIER )
-    &
-# endif
-    {
-        gsl_Ensures( data_.ptr_ != gsl_nullptr );
-        return U( data_.ptr_ );
-    }
-# if gsl_HAVE( FUNCTION_REF_QUALIFIER )
-    template< class U
-        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
-        , typename std::enable_if< ( std::is_constructible<U, T>::value && !std::is_convertible<T, U>::value && !detail::is_not_null_oracle<U>::value ), int >::type = 0
-    >
-    gsl_constexpr14 explicit
-    operator U() &&
-    {
-        gsl_Ensures( data_.ptr_ != gsl_nullptr );
-        return U( std::move( data_.ptr_ ) );
-    }
-# endif
-
-    // implicit conversion operator
-    template< class U
-        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
-        , typename std::enable_if< ( std::is_constructible<U, T const &>::value && std::is_convertible<T, U>::value && !detail::is_not_null_oracle<U>::value ), int >::type = 0
-    >
-    gsl_constexpr14
-    operator U() const
-# if gsl_HAVE( FUNCTION_REF_QUALIFIER )
-    &
-# endif
-    {
-        gsl_Ensures( data_.ptr_ != gsl_nullptr );
-        return data_.ptr_;
-    }
-# if gsl_HAVE( FUNCTION_REF_QUALIFIER )
-    template< class U
-        // We *have* to use SFINAE with an NTTP arg here, otherwise the overload is ambiguous.
-        , typename std::enable_if< ( std::is_convertible<T, U>::value && !detail::is_not_null_oracle<U>::value ), int >::type = 0
-    >
-    gsl_constexpr14
-    operator U() &&
-    {
-        gsl_Ensures( data_.ptr_ != gsl_nullptr );
-        return std::move( data_.ptr_ );
-    }
-# endif
-#else // a.k.a. #if !( gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && gsl_HAVE( EXPLICIT ) )
-    template< class U >
-    gsl_constexpr14
-    operator U() const
-    {
-        gsl_Ensures( data_.ptr_ != gsl_nullptr );
-        return data_.ptr_;
+        {
+        }
+    };
+
+    // more not_null unwanted operators
+
+    template <class T, class U>
+    std::ptrdiff_t operator-(not_null<T> const &, not_null<U> const &)
+        gsl_is_delete;
+
+    template <class T>
+    not_null<T> operator-(not_null<T> const &, std::ptrdiff_t) gsl_is_delete;
+
+    template <class T>
+    not_null<T> operator+(not_null<T> const &, std::ptrdiff_t) gsl_is_delete;
+
+    template <class T>
+    not_null<T> operator+(std::ptrdiff_t, not_null<T> const &) gsl_is_delete;
+
+    // not_null comparisons
+
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() ==
+                                                 std::declval<U const>())
+    operator==(not_null<T> const &l, not_null<U> const &r) {
+        return l.operator->() == r.operator->();
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() ==
+                                                 std::declval<U const>())
+    operator==(not_null<T> const &l, U const &r) {
+        return l.operator->() == r;
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() ==
+                                                 std::declval<U const>())
+    operator==(T const &l, not_null<U> const &r) {
+        return l == r.operator->();
+    }
+
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() <
+                                                 std::declval<U const>())
+    operator<(not_null<T> const &l, not_null<U> const &r) {
+        return l.operator->() < r.operator->();
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() <
+                                                 std::declval<U const>())
+    operator<(not_null<T> const &l, U const &r) {
+        return l.operator->() < r;
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() <
+                                                 std::declval<U const>())
+    operator<(T const &l, not_null<U> const &r) {
+        return l < r.operator->();
+    }
+
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(
+        bool, !(std::declval<T const>() == std::declval<U const>()))
+    operator!=(not_null<T> const &l, not_null<U> const &r) {
+        return !(l == r);
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(
+        bool, !(std::declval<T const>() == std::declval<U const>()))
+    operator!=(not_null<T> const &l, U const &r) {
+        return !(l == r);
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(
+        bool, !(std::declval<T const>() == std::declval<U const>()))
+    operator!=(T const &l, not_null<U> const &r) {
+        return !(l == r);
+    }
+
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(
+        bool, !(std::declval<U const>() < std::declval<T const>()))
+    operator<=(not_null<T> const &l, not_null<U> const &r) {
+        return !(r < l);
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(
+        bool, !(std::declval<U const>() < std::declval<T const>()))
+    operator<=(not_null<T> const &l, U const &r) {
+        return !(r < l);
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(
+        bool, !(std::declval<U const>() < std::declval<T const>()))
+    operator<=(T const &l, not_null<U> const &r) {
+        return !(r < l);
+    }
+
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<U const>() <
+                                                 std::declval<T const>())
+    operator>(not_null<T> const &l, not_null<U> const &r) {
+        return r < l;
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<U const>() <
+                                                 std::declval<T const>())
+    operator>(not_null<T> const &l, U const &r) {
+        return r < l;
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<U const>() <
+                                                 std::declval<T const>())
+    operator>(T const &l, not_null<U> const &r) {
+        return r < l;
+    }
+
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(
+        bool, !(std::declval<T const>() < std::declval<U const>()))
+    operator>=(not_null<T> const &l, not_null<U> const &r) {
+        return !(l < r);
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(
+        bool, !(std::declval<T const>() < std::declval<U const>()))
+    operator>=(not_null<T> const &l, U const &r) {
+        return !(l < r);
+    }
+    template <class T, class U>
+    inline gsl_constexpr gsl_DECLTYPE_(
+        bool, !(std::declval<T const>() < std::declval<U const>()))
+    operator>=(T const &l, not_null<U> const &r) {
+        return !(l < r);
+    }
+
+    // print not_null
+
+    template <class CharType, class Traits, class T>
+    std::basic_ostream<CharType, Traits> &operator<<(
+        std::basic_ostream<CharType, Traits> &os, not_null<T> const &p) {
+        return os << p.operator->();
     }
-#endif // gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && gsl_HAVE( EXPLICIT )
 
-    gsl_constexpr14 T const &
-    operator->() const
-    {
-        gsl_Ensures( data_.ptr_ != gsl_nullptr );
-        return data_.ptr_;
+//
+// Byte-specific type.
+//
+#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
+    enum class gsl_may_alias byte : unsigned char {};
+#else
+    struct gsl_may_alias byte {
+        typedef unsigned char type;
+        type v;
+    };
+#endif
+
+    template <class T>
+    gsl_api inline gsl_constexpr byte to_byte(T v) gsl_noexcept {
+#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
+        return static_cast<byte>(v);
+#elif gsl_HAVE(CONSTEXPR_11)
+        return {static_cast<typename byte::type>(v)};
+#else
+        byte b = {static_cast<typename byte::type>(v)};
+        return b;
+#endif
     }
 
-    gsl_constexpr14 element_type &
-    operator*() const
-    {
-        gsl_Ensures( data_.ptr_ != gsl_nullptr );
-        return *data_.ptr_;
+    template <class IntegerType gsl_ENABLE_IF_(
+        (std::is_integral<IntegerType>::value))>
+    gsl_api inline gsl_constexpr IntegerType to_integer(byte b) gsl_noexcept {
+#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
+        return static_cast<typename std::underlying_type<byte>::type>(b);
+#else
+        return b.v;
+#endif
     }
 
-#if gsl_HAVE( RVALUE_REFERENCE )
-    // Visual C++ 2013 doesn't generate default move constructors, so we declare them explicitly.
-    gsl_constexpr14 not_null( not_null && other ) gsl_noexcept
-    : data_( std::move( other.data_ ) )
-    {
-        gsl_Expects( data_.ptr_ != gsl_nullptr );
+    gsl_api inline gsl_constexpr unsigned char to_uchar(byte b) gsl_noexcept {
+        return to_integer<unsigned char>(b);
     }
-    gsl_constexpr14 not_null & operator=( not_null && other ) gsl_noexcept
-    {
-        gsl_Expects( other.data_.ptr_ != gsl_nullptr );
-        data_ = std::move( other.data_ );
-        return *this;
-    }
-#endif // gsl_HAVE( RVALUE_REFERENCE )
 
-#if gsl_HAVE( IS_DEFAULT )
-    gsl_constexpr14 not_null( not_null const & other ) = default;
-    gsl_constexpr14 not_null & operator=( not_null const & other ) = default;
-#endif
+    gsl_api inline gsl_constexpr unsigned char to_uchar(int i) gsl_noexcept {
+        return static_cast<unsigned char>(i);
+    }
 
-gsl_is_delete_access:
-    not_null() gsl_is_delete;
-    // prevent compilation when initialized with a nullptr or literal 0:
-#if gsl_HAVE( NULLPTR )
-    not_null(             std::nullptr_t ) gsl_is_delete;
-    not_null & operator=( std::nullptr_t ) gsl_is_delete;
+    template <class IntegerType gsl_ENABLE_IF_(
+        (std::is_integral<IntegerType>::value))>
+    gsl_api inline gsl_constexpr14 byte &operator<<=(byte &b, IntegerType shift)
+        gsl_noexcept {
+#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
+        return b = ::gsl::to_byte(::gsl::to_uchar(b) << shift);
 #else
-    not_null(             int ) gsl_is_delete;
-    not_null & operator=( int ) gsl_is_delete;
-#endif
-
-    // unwanted operators...pointers only point to single objects!
-    not_null & operator++() gsl_is_delete;
-    not_null & operator--() gsl_is_delete;
-    not_null   operator++( int ) gsl_is_delete;
-    not_null   operator--( int ) gsl_is_delete;
-    not_null & operator+ ( size_t ) gsl_is_delete;
-    not_null & operator+=( size_t ) gsl_is_delete;
-    not_null & operator- ( size_t ) gsl_is_delete;
-    not_null & operator-=( size_t ) gsl_is_delete;
-    not_null & operator+=( std::ptrdiff_t ) gsl_is_delete;
-    not_null & operator-=( std::ptrdiff_t ) gsl_is_delete;
-    void       operator[]( std::ptrdiff_t ) const gsl_is_delete;
-};
-#if gsl_HAVE( DEDUCTION_GUIDES )
-template< class U >
-not_null( U ) -> not_null<U>;
-template< class U >
-not_null( not_null<U> ) -> not_null<U>;
+        b.v = ::gsl::to_uchar(b.v << shift);
+        return b;
 #endif
+    }
 
-#if gsl_HAVE( NULLPTR )
-void make_not_null( std::nullptr_t ) gsl_is_delete;
-#endif // gsl_HAVE( NULLPTR )
-#if gsl_HAVE( RVALUE_REFERENCE )
-template< class U >
-not_null<U> make_not_null( U u )
-{
-    return not_null<U>( std::move( u ) );
-}
-template< class U >
-not_null<U> make_not_null( not_null<U> u )
-{
-    return std::move( u );
-}
-#else // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
-template< class U >
-not_null<U> make_not_null( U const & u )
-{
-    return not_null<U>( u );
-}
-template< class U >
-not_null<U> make_not_null( not_null<U> const & u )
-{
-    return u;
-}
-#endif // gsl_HAVE( RVALUE_REFERENCE )
-
-
-// not_null with implicit constructor, allowing copy-initialization:
+    template <class IntegerType gsl_ENABLE_IF_(
+        (std::is_integral<IntegerType>::value))>
+    gsl_api inline gsl_constexpr byte operator<<(byte b, IntegerType shift)
+        gsl_noexcept {
+        return ::gsl::to_byte(::gsl::to_uchar(b) << shift);
+    }
 
-template< class T >
-class not_null_ic : public not_null<T>
-{
-public:
-    template< class U
-        gsl_ENABLE_IF_(( std::is_constructible<T, U>::value ))
-    >
-    gsl_constexpr14
-#if gsl_HAVE( RVALUE_REFERENCE )
-    not_null_ic( U && u )
-    : not_null<T>( std::forward<U>( u ) )
+    template <class IntegerType gsl_ENABLE_IF_(
+        (std::is_integral<IntegerType>::value))>
+    gsl_api inline gsl_constexpr14 byte &operator>>=(byte &b, IntegerType shift)
+        gsl_noexcept {
+#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
+        return b = ::gsl::to_byte(::gsl::to_uchar(b) >> shift);
 #else
-    not_null_ic( U const & u )
-    : not_null<T>( u )
+        b.v = ::gsl::to_uchar(b.v >> shift);
+        return b;
 #endif
-    {}
-};
-
-// more not_null unwanted operators
-
-template< class T, class U >
-std::ptrdiff_t operator-( not_null<T> const &, not_null<U> const & ) gsl_is_delete;
-
-template< class T >
-not_null<T> operator-( not_null<T> const &, std::ptrdiff_t ) gsl_is_delete;
-
-template< class T >
-not_null<T> operator+( not_null<T> const &, std::ptrdiff_t ) gsl_is_delete;
-
-template< class T >
-not_null<T> operator+( std::ptrdiff_t, not_null<T> const & ) gsl_is_delete;
+    }
 
-// not_null comparisons
+    template <class IntegerType gsl_ENABLE_IF_(
+        (std::is_integral<IntegerType>::value))>
+    gsl_api inline gsl_constexpr byte operator>>(byte b, IntegerType shift)
+        gsl_noexcept {
+        return ::gsl::to_byte(::gsl::to_uchar(b) >> shift);
+    }
 
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() == std::declval<U const>() )
-operator==( not_null<T> const & l, not_null<U> const & r )
-{
-    return l.operator->() == r.operator->();
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() == std::declval<U const>() )
-operator==( not_null<T> const & l, U const & r )
-{
-    return l.operator->() == r;
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() == std::declval<U const>() )
-operator==( T const & l, not_null<U> const & r )
-{
-    return l == r.operator->();
-}
+#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
+    gsl_DEFINE_ENUM_BITMASK_OPERATORS(byte)
+        gsl_DEFINE_ENUM_RELATIONAL_OPERATORS(byte)
+#else  // a.k.a. !gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+    gsl_api inline gsl_constexpr bool operator==(byte l, byte r) gsl_noexcept {
+        return l.v == r.v;
+    }
 
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() < std::declval<U const>() )
-operator<( not_null<T> const & l, not_null<U> const & r )
-{
-    return l.operator->() < r.operator->();
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() < std::declval<U const>() )
-operator<( not_null<T> const & l, U const & r )
-{
-    return l.operator->() < r;
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<T const>() < std::declval<U const>() )
-operator<( T const & l, not_null<U> const & r )
-{
-    return l < r.operator->();
-}
+    gsl_api inline gsl_constexpr bool operator!=(byte l, byte r) gsl_noexcept {
+        return !(l == r);
+    }
 
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() == std::declval<U const>() ) )
-operator!=( not_null<T> const & l, not_null<U> const & r )
-{
-    return !( l == r );
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() == std::declval<U const>() ) )
-operator!=( not_null<T> const & l, U const & r )
-{
-    return !( l == r );
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() == std::declval<U const>() ) )
-operator!=( T const & l, not_null<U> const & r )
-{
-    return !( l == r );
-}
+    gsl_api inline gsl_constexpr bool operator<(byte l, byte r) gsl_noexcept {
+        return l.v < r.v;
+    }
 
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<U const>() < std::declval<T const>() ) )
-operator<=( not_null<T> const & l, not_null<U> const & r )
-{
-    return !( r < l );
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<U const>() < std::declval<T const>() ) )
-operator<=( not_null<T> const & l, U const & r )
-{
-    return !( r < l );
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<U const>() < std::declval<T const>() ) )
-operator<=( T const & l, not_null<U> const & r )
-{
-    return !( r < l );
-}
+    gsl_api inline gsl_constexpr bool operator<=(byte l, byte r) gsl_noexcept {
+        return !(r < l);
+    }
 
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<U const>() < std::declval<T const>() )
-operator>( not_null<T> const & l, not_null<U> const & r )
-{
-    return r < l;
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<U const>() < std::declval<T const>() )
-operator>( not_null<T> const & l, U const & r )
-{
-    return r < l;
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, std::declval<U const>() < std::declval<T const>() )
-operator>( T const & l, not_null<U> const & r )
-{
-    return r < l;
-}
+    gsl_api inline gsl_constexpr bool operator>(byte l, byte r) gsl_noexcept {
+        return (r < l);
+    }
 
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() < std::declval<U const>() ) )
-operator>=( not_null<T> const & l, not_null<U> const & r )
-{
-    return !( l < r );
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() < std::declval<U const>() ) )
-operator>=( not_null<T> const & l, U const & r )
-{
-    return !( l < r );
-}
-template< class T, class U >
-inline gsl_constexpr gsl_DECLTYPE_( bool, !( std::declval<T const>() < std::declval<U const>() ) )
-operator>=( T const & l, not_null<U> const & r )
-{
-    return !( l < r );
-}
+    gsl_api inline gsl_constexpr bool operator>=(byte l, byte r) gsl_noexcept {
+        return !(l < r);
+    }
 
-// print not_null
+    gsl_api inline gsl_constexpr14 byte &operator|=(byte &l, byte r)
+        gsl_noexcept {
+        l.v |= r.v;
+        return l;
+    }
 
-template< class CharType, class Traits, class T >
-std::basic_ostream< CharType, Traits > & operator<<( std::basic_ostream< CharType, Traits > & os, not_null<T> const & p )
-{
-    return os << p.operator->();
-}
+    gsl_api inline gsl_constexpr byte operator|(byte l, byte r) gsl_noexcept {
+        return ::gsl::to_byte(l.v | r.v);
+    }
 
+    gsl_api inline gsl_constexpr14 byte &operator&=(byte &l, byte r)
+        gsl_noexcept {
+        l.v &= r.v;
+        return l;
+    }
 
-//
-// Byte-specific type.
-//
-#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
-  enum class gsl_may_alias byte : unsigned char {};
-#else
-  struct gsl_may_alias byte { typedef unsigned char type; type v; };
-#endif
+    gsl_api inline gsl_constexpr byte operator&(byte l, byte r) gsl_noexcept {
+        return ::gsl::to_byte(l.v & r.v);
+    }
 
-template< class T >
-gsl_api inline gsl_constexpr byte to_byte( T v ) gsl_noexcept
-{
-#if    gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
-    return static_cast<byte>( v );
-#elif  gsl_HAVE( CONSTEXPR_11 )
-    return { static_cast<typename byte::type>( v ) };
-#else
-    byte b = { static_cast<typename byte::type>( v ) }; return b;
-#endif
-}
+    gsl_api inline gsl_constexpr14 byte &operator^=(byte &l, byte r)
+        gsl_noexcept {
+        l.v ^= r.v;
+        return l;
+    }
 
-template< class IntegerType  gsl_ENABLE_IF_(( std::is_integral<IntegerType>::value )) >
-gsl_api inline gsl_constexpr IntegerType to_integer( byte b ) gsl_noexcept
-{
-#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
-    return static_cast<typename std::underlying_type<byte>::type>( b );
-#else
-    return b.v;
-#endif
-}
+    gsl_api inline gsl_constexpr byte operator^(byte l, byte r) gsl_noexcept {
+        return ::gsl::to_byte(l.v ^ r.v);
+    }
 
-gsl_api inline gsl_constexpr unsigned char to_uchar( byte b ) gsl_noexcept
-{
-    return to_integer<unsigned char>( b );
-}
+    gsl_api inline gsl_constexpr byte operator~(byte b) gsl_noexcept {
+        return ::gsl::to_byte(~b.v);
+    }
+#endif // gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
 
-gsl_api inline gsl_constexpr unsigned char to_uchar( int i ) gsl_noexcept
-{
-    return static_cast<unsigned char>( i );
-}
+#if gsl_FEATURE_TO_STD(WITH_CONTAINER)
 
-template< class IntegerType  gsl_ENABLE_IF_(( std::is_integral<IntegerType>::value )) >
-gsl_api inline gsl_constexpr14 byte & operator<<=( byte & b, IntegerType shift ) gsl_noexcept
-{
-#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
-    return b = ::gsl::to_byte( ::gsl::to_uchar( b ) << shift );
-#else
-    b.v = ::gsl::to_uchar( b.v << shift ); return b;
-#endif
-}
+        // Tag to select span constructor taking a container:
 
-template< class IntegerType  gsl_ENABLE_IF_(( std::is_integral<IntegerType>::value )) >
-gsl_api inline gsl_constexpr byte operator<<( byte b, IntegerType shift ) gsl_noexcept
-{
-    return ::gsl::to_byte( ::gsl::to_uchar( b ) << shift );
-}
+        struct with_container_t {
+        gsl_constexpr with_container_t() gsl_noexcept {}
+    };
+    const gsl_constexpr with_container_t
+        with_container; // TODO: this can lead to ODR violations because the
+                        // symbol will be defined in multiple translation units
 
-template< class IntegerType  gsl_ENABLE_IF_(( std::is_integral<IntegerType>::value )) >
-gsl_api inline gsl_constexpr14 byte & operator>>=( byte & b, IntegerType shift ) gsl_noexcept
-{
-#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
-    return b = ::gsl::to_byte( ::gsl::to_uchar( b ) >> shift );
-#else
-    b.v = ::gsl::to_uchar( b.v >> shift ); return b;
 #endif
-}
-
-template< class IntegerType  gsl_ENABLE_IF_(( std::is_integral<IntegerType>::value )) >
-gsl_api inline gsl_constexpr byte operator>>( byte b, IntegerType shift ) gsl_noexcept
-{
-    return ::gsl::to_byte( ::gsl::to_uchar( b ) >> shift );
-}
-
-#if gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
-gsl_DEFINE_ENUM_BITMASK_OPERATORS( byte )
-gsl_DEFINE_ENUM_RELATIONAL_OPERATORS( byte )
-#else // a.k.a. !gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
-gsl_api inline gsl_constexpr bool operator==( byte l, byte r ) gsl_noexcept
-{
-    return l.v == r.v;
-}
-
-gsl_api inline gsl_constexpr bool operator!=( byte l, byte r ) gsl_noexcept
-{
-    return !( l == r );
-}
 
-gsl_api inline gsl_constexpr bool operator< ( byte l, byte r ) gsl_noexcept
-{
-    return l.v < r.v;
-}
+    //
+    // span<> - A 1D view of contiguous T's, replace (*,len).
+    //
+    template <class T> class span {
+        template <class U> friend class span;
 
-gsl_api inline gsl_constexpr bool operator<=( byte l, byte r ) gsl_noexcept
-{
-    return !( r < l );
-}
+      public:
+        typedef gsl_CONFIG_SPAN_INDEX_TYPE index_type;
 
-gsl_api inline gsl_constexpr bool operator> ( byte l, byte r ) gsl_noexcept
-{
-    return ( r < l );
-}
+        typedef T element_type;
+        typedef typename std11::remove_cv<T>::type value_type;
 
-gsl_api inline gsl_constexpr bool operator>=( byte l, byte r ) gsl_noexcept
-{
-    return !( l < r );
-}
+        typedef T &reference;
+        typedef T *pointer;
+        typedef T const *const_pointer;
+        typedef T const &const_reference;
 
-gsl_api inline gsl_constexpr14 byte & operator|=( byte & l, byte r ) gsl_noexcept
-{
-    l.v |= r.v; return l;
-}
-
-gsl_api inline gsl_constexpr byte operator|( byte l, byte r ) gsl_noexcept
-{
-    return ::gsl::to_byte( l.v | r.v );
-}
-
-gsl_api inline gsl_constexpr14 byte & operator&=( byte & l, byte r ) gsl_noexcept
-{
-    l.v &= r.v; return l;
-}
+        typedef pointer iterator;
+        typedef const_pointer const_iterator;
 
-gsl_api inline gsl_constexpr byte operator&( byte l, byte r ) gsl_noexcept
-{
-    return ::gsl::to_byte( l.v & r.v );
-}
+        typedef std::reverse_iterator<iterator> reverse_iterator;
+        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
-gsl_api inline gsl_constexpr14 byte & operator^=( byte & l, byte r ) gsl_noexcept
-{
-    l.v ^= r.v; return l;
-}
+        typedef typename std::iterator_traits<iterator>::difference_type
+            difference_type;
 
-gsl_api inline gsl_constexpr byte operator^( byte l, byte r ) gsl_noexcept
-{
-    return ::gsl::to_byte( l.v ^ r.v );
-}
+        // 26.7.3.2 Constructors, copy, and assignment [span.cons]
 
-gsl_api inline gsl_constexpr byte operator~( byte b ) gsl_noexcept
-{
-    return ::gsl::to_byte( ~b.v );
-}
-#endif // gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
+        gsl_api gsl_constexpr14 span() gsl_noexcept : first_(gsl_nullptr),
+                                                      last_(gsl_nullptr) {}
 
-#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
+#if !gsl_DEPRECATE_TO_LEVEL(5)
 
-// Tag to select span constructor taking a container:
+#if gsl_HAVE(NULLPTR)
+        gsl_api gsl_constexpr14 span(std::nullptr_t, index_type size_in)
+            : first_(nullptr), last_(nullptr) {
+            gsl_Expects(size_in == 0);
+        }
+#endif
 
-struct with_container_t { gsl_constexpr with_container_t() gsl_noexcept {} };
-const  gsl_constexpr   with_container_t with_container; // TODO: this can lead to ODR violations because the symbol will be defined in multiple translation units
+#if gsl_HAVE(IS_DELETE)
+        gsl_DEPRECATED gsl_api gsl_constexpr span(reference data_in)
+            : span(&data_in, 1) {}
 
+        gsl_api gsl_constexpr span(element_type &&) = delete;
 #endif
 
-//
-// span<> - A 1D view of contiguous T's, replace (*,len).
-//
-template< class T >
-class span
-{
-    template< class U > friend class span;
+#endif // deprecate
 
-public:
-    typedef gsl_CONFIG_SPAN_INDEX_TYPE index_type;
+        gsl_api gsl_constexpr14 span(pointer data_in, index_type size_in)
+            : first_(data_in), last_(data_in + size_in) {
+            gsl_Expects(size_in == 0 ||
+                        (size_in > 0 && data_in != gsl_nullptr));
+        }
 
-    typedef T element_type;
-    typedef typename std11::remove_cv< T >::type value_type;
+        gsl_api gsl_constexpr14 span(pointer first_in, pointer last_in)
+            : first_(first_in), last_(last_in) {
+            gsl_Expects(first_in <= last_in);
+        }
 
-    typedef T & reference;
-    typedef T * pointer;
-    typedef T const * const_pointer;
-    typedef T const & const_reference;
+#if !gsl_DEPRECATE_TO_LEVEL(5)
 
-    typedef pointer       iterator;
-    typedef const_pointer const_iterator;
+        template <class U>
+        gsl_api gsl_constexpr14 span(U *data_in, index_type size_in)
+            : first_(data_in), last_(data_in + size_in) {
+            gsl_Expects(size_in == 0 ||
+                        (size_in > 0 && data_in != gsl_nullptr));
+        }
 
-    typedef std::reverse_iterator< iterator >       reverse_iterator;
-    typedef std::reverse_iterator< const_iterator > const_reverse_iterator;
+#endif // deprecate
 
-    typedef typename std::iterator_traits< iterator >::difference_type difference_type;
+#if !gsl_DEPRECATE_TO_LEVEL(5)
+        template <class U, size_t N>
+        gsl_api gsl_constexpr span(U (&arr)[N]) gsl_noexcept
+            : first_(gsl_ADDRESSOF(arr[0])),
+              last_(gsl_ADDRESSOF(arr[0]) + N) {}
+#else
+        template <size_t N gsl_ENABLE_IF_(
+            (std::is_convertible<value_type (*)[], element_type (*)[]>::value))>
+        gsl_api gsl_constexpr span(element_type (&arr)[N]) gsl_noexcept
+            : first_(gsl_ADDRESSOF(arr[0])),
+              last_(gsl_ADDRESSOF(arr[0]) + N) {}
+#endif // deprecate
 
-    // 26.7.3.2 Constructors, copy, and assignment [span.cons]
+#if gsl_HAVE(ARRAY)
+#if !gsl_DEPRECATE_TO_LEVEL(5)
 
-    gsl_api gsl_constexpr14 span() gsl_noexcept
-        : first_( gsl_nullptr )
-        , last_ ( gsl_nullptr )
-    {
-    }
+        template <class U, size_t N>
+        gsl_constexpr span(std::array<U, N> &arr)
+            : first_(arr.data()), last_(arr.data() + N) {}
 
-#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
+        template <class U, size_t N>
+        gsl_constexpr span(std::array<U, N> const &arr)
+            : first_(arr.data()), last_(arr.data() + N) {}
 
-#if gsl_HAVE( NULLPTR )
-    gsl_api gsl_constexpr14 span( std::nullptr_t, index_type size_in )
-        : first_( nullptr )
-        , last_ ( nullptr )
-    {
-        gsl_Expects( size_in == 0 );
-    }
-#endif
+#else
 
-#if gsl_HAVE( IS_DELETE )
-    gsl_DEPRECATED
-    gsl_api gsl_constexpr span( reference data_in )
-        : span( &data_in, 1 )
-    {}
+        template <size_t N gsl_ENABLE_IF_(
+            (std::is_convertible<value_type (*)[], element_type (*)[]>::value))>
+        gsl_constexpr span(std::array<value_type, N> &arr)
+            : first_(arr.data()), last_(arr.data() + N) {}
 
-    gsl_api gsl_constexpr span( element_type && ) = delete;
-#endif
+        template <size_t N gsl_ENABLE_IF_(
+            (std::is_convertible<value_type (*)[], element_type (*)[]>::value))>
+        gsl_constexpr span(std::array<value_type, N> const &arr)
+            : first_(arr.data()), last_(arr.data() + N) {}
 
 #endif // deprecate
+#endif // gsl_HAVE( ARRAY )
 
-    gsl_api gsl_constexpr14 span( pointer data_in, index_type size_in )
-        : first_( data_in )
-        , last_ ( data_in + size_in )
-    {
-        gsl_Expects( size_in == 0 || ( size_in > 0 && data_in != gsl_nullptr ) );
-    }
+#if gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR)
+        template <class Container gsl_ENABLE_IF_(
+            (detail::is_compatible_container<Container, element_type>::value))>
+        gsl_constexpr span(Container &cont) gsl_noexcept
+            : first_(std17::data(cont)),
+              last_(std17::data(cont) + std17::size(cont)) {}
 
-    gsl_api gsl_constexpr14 span( pointer first_in, pointer last_in )
-        : first_( first_in )
-        , last_ ( last_in )
-    {
-        gsl_Expects( first_in <= last_in );
-    }
+        template <class Container gsl_ENABLE_IF_(
+            (std::is_const<element_type>::value &&
+             detail::is_compatible_container<Container, element_type>::value))>
+        gsl_constexpr span(Container const &cont) gsl_noexcept
+            : first_(std17::data(cont)),
+              last_(std17::data(cont) + std17::size(cont)) {}
 
-#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
+#elif gsl_HAVE(UNCONSTRAINED_SPAN_CONTAINER_CTOR)
 
-    template< class U >
-    gsl_api gsl_constexpr14 span( U * data_in, index_type size_in )
-        : first_( data_in )
-        , last_ ( data_in + size_in )
-    {
-        gsl_Expects( size_in == 0 || ( size_in > 0 && data_in != gsl_nullptr ) );
-    }
+        template <class Container>
+        gsl_constexpr span(Container &cont)
+            : first_(cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF(cont[0])),
+              last_(cont.size() == 0 ? gsl_nullptr
+                                     : gsl_ADDRESSOF(cont[0]) + cont.size()) {}
 
-#endif // deprecate
+        template <class Container>
+        gsl_constexpr span(Container const &cont)
+            : first_(cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF(cont[0])),
+              last_(cont.size() == 0 ? gsl_nullptr
+                                     : gsl_ADDRESSOF(cont[0]) + cont.size()) {}
 
-#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
-    template< class U, size_t N >
-    gsl_api gsl_constexpr span( U (&arr)[N] ) gsl_noexcept
-        : first_( gsl_ADDRESSOF( arr[0] ) )
-        , last_ ( gsl_ADDRESSOF( arr[0] ) + N )
-    {}
-#else
-    template< size_t N
-        gsl_ENABLE_IF_(( std::is_convertible<value_type(*)[], element_type(*)[] >::value ))
-    >
-    gsl_api gsl_constexpr span( element_type (&arr)[N] ) gsl_noexcept
-        : first_( gsl_ADDRESSOF( arr[0] ) )
-        , last_ ( gsl_ADDRESSOF( arr[0] ) + N )
-    {}
-#endif // deprecate
+#endif
 
-#if gsl_HAVE( ARRAY )
-#if ! gsl_DEPRECATE_TO_LEVEL( 5 )
+#if gsl_FEATURE_TO_STD(WITH_CONTAINER)
 
-    template< class U, size_t N >
-    gsl_constexpr span( std::array< U, N > & arr )
-        : first_( arr.data() )
-        , last_ ( arr.data() + N )
-    {}
+        template <class Container>
+        gsl_constexpr span(with_container_t, Container &cont) gsl_noexcept
+            : first_(cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF(cont[0])),
+              last_(cont.size() == 0 ? gsl_nullptr
+                                     : gsl_ADDRESSOF(cont[0]) + cont.size()) {}
 
-    template< class U, size_t N >
-    gsl_constexpr span( std::array< U, N > const & arr )
-        : first_( arr.data() )
-        , last_ ( arr.data() + N )
-    {}
+        template <class Container>
+        gsl_constexpr span(with_container_t, Container const &cont) gsl_noexcept
+            : first_(cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF(cont[0])),
+              last_(cont.size() == 0 ? gsl_nullptr
+                                     : gsl_ADDRESSOF(cont[0]) + cont.size()) {}
 
-#else
+#endif
 
-    template< size_t N
-        gsl_ENABLE_IF_(( std::is_convertible<value_type(*)[], element_type(*)[] >::value ))
-    >
-    gsl_constexpr span( std::array< value_type, N > & arr )
-        : first_( arr.data() )
-        , last_ ( arr.data() + N )
-    {}
-
-    template< size_t N
-        gsl_ENABLE_IF_(( std::is_convertible<value_type(*)[], element_type(*)[] >::value ))
-    >
-    gsl_constexpr span( std::array< value_type, N > const & arr )
-        : first_( arr.data() )
-        , last_ ( arr.data() + N )
-    {}
+#if !gsl_DEPRECATE_TO_LEVEL(4)
+        // constructor taking shared_ptr deprecated since 0.29.0
 
-#endif // deprecate
-#endif // gsl_HAVE( ARRAY )
+#if gsl_HAVE(SHARED_PTR)
+        gsl_DEPRECATED gsl_constexpr span(shared_ptr<element_type> const &ptr)
+            : first_(ptr.get()),
+              last_(ptr.get() ? ptr.get() + 1 : gsl_nullptr) {}
+#endif
+
+        // constructors taking unique_ptr deprecated since 0.29.0
+
+#if gsl_HAVE(UNIQUE_PTR)
+#if gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG)
+        template <class ArrayElementType =
+                      typename std::add_pointer<element_type>::type>
+#else
+        template <class ArrayElementType>
+#endif
+        gsl_DEPRECATED gsl_constexpr
+        span(unique_ptr<ArrayElementType> const &ptr, index_type count)
+            : first_(ptr.get()), last_(ptr.get() + count) {
+        }
 
-#if gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
-    template< class Container
-        gsl_ENABLE_IF_(( detail::is_compatible_container< Container, element_type >::value ))
-    >
-    gsl_constexpr span( Container & cont ) gsl_noexcept
-        : first_( std17::data( cont ) )
-        , last_ ( std17::data( cont ) + std17::size( cont ) )
-    {}
-
-    template< class Container
-        gsl_ENABLE_IF_((
-            std::is_const< element_type >::value
-            && detail::is_compatible_container< Container, element_type >::value
-        ))
-    >
-    gsl_constexpr span( Container const & cont ) gsl_noexcept
-        : first_( std17::data( cont ) )
-        , last_ ( std17::data( cont ) + std17::size( cont ) )
-    {}
-
-#elif gsl_HAVE( UNCONSTRAINED_SPAN_CONTAINER_CTOR )
-
-    template< class Container >
-    gsl_constexpr span( Container & cont )
-        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
-        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
-    {}
-
-    template< class Container >
-    gsl_constexpr span( Container const & cont )
-        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
-        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
-    {}
-
-#endif
-
-#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
-
-    template< class Container >
-    gsl_constexpr span( with_container_t, Container & cont ) gsl_noexcept
-        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
-        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
-    {}
-
-    template< class Container >
-    gsl_constexpr span( with_container_t, Container const & cont ) gsl_noexcept
-        : first_( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) )
-        , last_ ( cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF( cont[0] ) + cont.size() )
-    {}
-
-#endif
-
-#if !gsl_DEPRECATE_TO_LEVEL( 4 )
-    // constructor taking shared_ptr deprecated since 0.29.0
-
-# if gsl_HAVE( SHARED_PTR )
-    gsl_DEPRECATED
-    gsl_constexpr span( shared_ptr<element_type> const & ptr )
-        : first_( ptr.get() )
-        , last_ ( ptr.get() ? ptr.get() + 1 : gsl_nullptr )
-    {}
-# endif
-
-    // constructors taking unique_ptr deprecated since 0.29.0
-
-# if gsl_HAVE( UNIQUE_PTR )
-#  if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
-    template< class ArrayElementType = typename std::add_pointer<element_type>::type >
-#  else
-    template< class ArrayElementType >
-#  endif
-    gsl_DEPRECATED
-    gsl_constexpr span( unique_ptr<ArrayElementType> const & ptr, index_type count )
-        : first_( ptr.get() )
-        , last_ ( ptr.get() + count )
-    {}
-
-    gsl_DEPRECATED
-    gsl_constexpr span( unique_ptr<element_type> const & ptr )
-        : first_( ptr.get() )
-        , last_ ( ptr.get() ? ptr.get() + 1 : gsl_nullptr )
-    {}
-# endif
+        gsl_DEPRECATED gsl_constexpr span(unique_ptr<element_type> const &ptr)
+            : first_(ptr.get()),
+              last_(ptr.get() ? ptr.get() + 1 : gsl_nullptr) {}
+#endif
 
 #endif // deprecate shared_ptr, unique_ptr
 
-#if gsl_HAVE( IS_DEFAULT ) && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 430, 600)
-    gsl_constexpr span( span && ) gsl_noexcept = default;
-    gsl_constexpr span( span const & ) = default;
+#if gsl_HAVE(IS_DEFAULT) && !gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 430, 600)
+        gsl_constexpr span(span &&) gsl_noexcept = default;
+        gsl_constexpr span(span const &) = default;
 #else
-    gsl_api gsl_constexpr span( span const & other )
-        : first_( other.begin() )
-        , last_ ( other.end() )
-    {}
+        gsl_api gsl_constexpr span(span const &other)
+            : first_(other.begin()), last_(other.end()) {}
 #endif
 
-#if gsl_HAVE( IS_DEFAULT )
-    gsl_constexpr14 span & operator=( span && ) gsl_noexcept = default;
-    gsl_constexpr14 span & operator=( span const & ) gsl_noexcept = default;
+#if gsl_HAVE(IS_DEFAULT)
+        gsl_constexpr14 span &operator=(span &&) gsl_noexcept = default;
+        gsl_constexpr14 span &operator=(span const &) gsl_noexcept = default;
 #else
-    gsl_constexpr14 span & operator=( span other ) gsl_noexcept
-    {
-        first_ = other.first_;
-        last_ = other.last_;
-        return *this;
-    }
+        gsl_constexpr14 span &operator=(span other) gsl_noexcept {
+            first_ = other.first_;
+            last_ = other.last_;
+            return *this;
+        }
 #endif
 
-    template< class U
-        gsl_ENABLE_IF_(( std::is_convertible<U(*)[], element_type(*)[]>::value ))
-    >
-    gsl_api gsl_constexpr span( span<U> const & other )
-        : first_( other.begin() )
-        , last_ ( other.end() )
-    {}
+        template <class U gsl_ENABLE_IF_(
+            (std::is_convertible<U (*)[], element_type (*)[]>::value))>
+        gsl_api gsl_constexpr span(span<U> const &other)
+            : first_(other.begin()), last_(other.end()) {}
 
 #if 0
     // Converting from other span ?
     template< class U > operator=();
 #endif
 
-    // 26.7.3.3 Subviews [span.sub]
+        // 26.7.3.3 Subviews [span.sub]
 
-    gsl_api gsl_constexpr14 span first( index_type count ) const
-    {
-        gsl_Expects( std::size_t( count ) <= std::size_t( this->size() ) );
-        return span( this->data(), count );
-    }
+        gsl_api gsl_constexpr14 span first(index_type count) const {
+            gsl_Expects(std::size_t(count) <= std::size_t(this->size()));
+            return span(this->data(), count);
+        }
 
-    gsl_api gsl_constexpr14 span last( index_type count ) const
-    {
-        gsl_Expects( std::size_t( count ) <= std::size_t( this->size() ) );
-        return span( this->data() + this->size() - count, count );
-    }
+        gsl_api gsl_constexpr14 span last(index_type count) const {
+            gsl_Expects(std::size_t(count) <= std::size_t(this->size()));
+            return span(this->data() + this->size() - count, count);
+        }
 
-    gsl_api gsl_constexpr14 span subspan( index_type offset ) const
-    {
-        gsl_Expects( std::size_t( offset ) <= std::size_t( this->size() ) );
-        return span( this->data() + offset, this->size() - offset );
-    }
+        gsl_api gsl_constexpr14 span subspan(index_type offset) const {
+            gsl_Expects(std::size_t(offset) <= std::size_t(this->size()));
+            return span(this->data() + offset, this->size() - offset);
+        }
 
-    gsl_api gsl_constexpr14 span subspan( index_type offset, index_type count ) const
-    {
-        gsl_Expects(
-            std::size_t( offset ) <= std::size_t( this->size() ) &&
-            std::size_t( count ) <= std::size_t( this->size() - offset ) );
-        return span( this->data() + offset, count );
-    }
+        gsl_api gsl_constexpr14 span subspan(index_type offset,
+                                             index_type count) const {
+            gsl_Expects(std::size_t(offset) <= std::size_t(this->size()) &&
+                        std::size_t(count) <=
+                            std::size_t(this->size() - offset));
+            return span(this->data() + offset, count);
+        }
 
-    // 26.7.3.4 Observers [span.obs]
+        // 26.7.3.4 Observers [span.obs]
 
-    gsl_api gsl_constexpr index_type size() const gsl_noexcept
-    {
-        return narrow_cast<index_type>( last_ - first_ );
-    }
+        gsl_api gsl_constexpr index_type size() const gsl_noexcept {
+            return narrow_cast<index_type>(last_ - first_);
+        }
 
-    gsl_api gsl_constexpr std::ptrdiff_t ssize() const gsl_noexcept
-    {
-        return narrow_cast<std::ptrdiff_t>( last_ - first_ );
-    }
+        gsl_api gsl_constexpr std::ptrdiff_t ssize() const gsl_noexcept {
+            return narrow_cast<std::ptrdiff_t>(last_ - first_);
+        }
 
-    gsl_api gsl_constexpr index_type size_bytes() const gsl_noexcept
-    {
-        return size() * narrow_cast<index_type>( sizeof( element_type ) );
-    }
+        gsl_api gsl_constexpr index_type size_bytes() const gsl_noexcept {
+            return size() * narrow_cast<index_type>(sizeof(element_type));
+        }
 
-    gsl_api gsl_constexpr bool empty() const gsl_noexcept
-    {
-        return size() == 0;
-    }
+        gsl_api gsl_constexpr bool empty() const gsl_noexcept {
+            return size() == 0;
+        }
 
-    // 26.7.3.5 Element access [span.elem]
+        // 26.7.3.5 Element access [span.elem]
 
-    gsl_api gsl_constexpr14 reference operator[]( index_type pos ) const
-    {
-        gsl_Expects( pos < size() );
-        return first_[ pos ];
-    }
+        gsl_api gsl_constexpr14 reference operator[](index_type pos) const {
+            gsl_Expects(pos < size());
+            return first_[pos];
+        }
 
-#if ! gsl_DEPRECATE_TO_LEVEL( 6 )
-    gsl_DEPRECATED_MSG("use subscript indexing instead")
-    gsl_api gsl_constexpr14 reference operator()( index_type pos ) const
-    {
-        return (*this)[ pos ];
-    }
+#if !gsl_DEPRECATE_TO_LEVEL(6)
+        gsl_DEPRECATED_MSG("use subscript indexing instead") gsl_api
+            gsl_constexpr14 reference
+            operator()(index_type pos) const {
+            return (*this)[pos];
+        }
 
-    gsl_DEPRECATED_MSG("use subscript indexing instead")
-    gsl_api gsl_constexpr14 reference at( index_type pos ) const
-    {
-        return (*this)[ pos ];
-    }
+        gsl_DEPRECATED_MSG("use subscript indexing instead") gsl_api
+            gsl_constexpr14 reference at(index_type pos) const {
+            return (*this)[pos];
+        }
 #endif // deprecate
 
-    gsl_api gsl_constexpr14 reference front() const
-    {
-        gsl_Expects( first_ != last_ );
-        return *first_;
-    }
+        gsl_api gsl_constexpr14 reference front() const {
+            gsl_Expects(first_ != last_);
+            return *first_;
+        }
 
-    gsl_api gsl_constexpr14 reference back() const
-    {
-        gsl_Expects( first_ != last_ );
-        return *(last_ - 1);
-    }
+        gsl_api gsl_constexpr14 reference back() const {
+            gsl_Expects(first_ != last_);
+            return *(last_ - 1);
+        }
 
-    gsl_api gsl_constexpr pointer data() const gsl_noexcept
-    {
-        return first_;
-    }
+        gsl_api gsl_constexpr pointer data() const gsl_noexcept {
+            return first_;
+        }
 
-    // 26.7.3.6 Iterator support [span.iterators]
+        // 26.7.3.6 Iterator support [span.iterators]
 
-    gsl_api gsl_constexpr iterator begin() const gsl_noexcept
-    {
-        return iterator( first_ );
-    }
+        gsl_api gsl_constexpr iterator begin() const gsl_noexcept {
+            return iterator(first_);
+        }
 
-    gsl_api gsl_constexpr iterator end() const gsl_noexcept
-    {
-        return iterator( last_ );
-    }
+        gsl_api gsl_constexpr iterator end() const gsl_noexcept {
+            return iterator(last_);
+        }
 
-    gsl_api gsl_constexpr const_iterator cbegin() const gsl_noexcept
-    {
+        gsl_api gsl_constexpr const_iterator cbegin() const gsl_noexcept {
 #if gsl_CPP11_OR_GREATER
-        return { begin() };
+            return {begin()};
 #else
-        return const_iterator( begin() );
+            return const_iterator(begin());
 #endif
-    }
+        }
 
-    gsl_api gsl_constexpr const_iterator cend() const gsl_noexcept
-    {
+        gsl_api gsl_constexpr const_iterator cend() const gsl_noexcept {
 #if gsl_CPP11_OR_GREATER
-        return { end() };
+            return {end()};
 #else
-        return const_iterator( end() );
+            return const_iterator(end());
 #endif
-    }
+        }
 
-    gsl_constexpr17 reverse_iterator rbegin() const gsl_noexcept
-    {
-        return reverse_iterator( end() );
-    }
+        gsl_constexpr17 reverse_iterator rbegin() const gsl_noexcept {
+            return reverse_iterator(end());
+        }
 
-    gsl_constexpr17 reverse_iterator rend() const gsl_noexcept
-    {
-        return reverse_iterator( begin() );
-    }
+        gsl_constexpr17 reverse_iterator rend() const gsl_noexcept {
+            return reverse_iterator(begin());
+        }
 
-    gsl_constexpr17 const_reverse_iterator crbegin() const gsl_noexcept
-    {
-        return const_reverse_iterator( cend() );
-    }
+        gsl_constexpr17 const_reverse_iterator crbegin() const gsl_noexcept {
+            return const_reverse_iterator(cend());
+        }
 
-    gsl_constexpr17 const_reverse_iterator crend() const gsl_noexcept
-    {
-        return const_reverse_iterator( cbegin() );
-    }
+        gsl_constexpr17 const_reverse_iterator crend() const gsl_noexcept {
+            return const_reverse_iterator(cbegin());
+        }
 
-    gsl_constexpr14 void swap( span & other ) gsl_noexcept
-    {
-        std::swap( first_, other.first_ );
-        std::swap( last_ , other.last_  );
-    }
+        gsl_constexpr14 void swap(span &other) gsl_noexcept {
+            std::swap(first_, other.first_);
+            std::swap(last_, other.last_);
+        }
 
-#if ! gsl_DEPRECATE_TO_LEVEL( 3 )
-    // member length() deprecated since 0.29.0
+#if !gsl_DEPRECATE_TO_LEVEL(3)
+        // member length() deprecated since 0.29.0
 
-    gsl_DEPRECATED_MSG("use size() instead")
-    gsl_api gsl_constexpr index_type length() const gsl_noexcept
-    {
-        return size();
-    }
+        gsl_DEPRECATED_MSG("use size() instead") gsl_api gsl_constexpr
+            index_type length() const gsl_noexcept {
+            return size();
+        }
 
-    // member length_bytes() deprecated since 0.29.0
+        // member length_bytes() deprecated since 0.29.0
 
-    gsl_DEPRECATED_MSG("use size_bytes() instead")
-    gsl_api gsl_constexpr index_type length_bytes() const gsl_noexcept
-    {
-        return size_bytes();
-    }
+        gsl_DEPRECATED_MSG("use size_bytes() instead") gsl_api gsl_constexpr
+            index_type length_bytes() const gsl_noexcept {
+            return size_bytes();
+        }
 #endif
 
-#if ! gsl_DEPRECATE_TO_LEVEL( 2 )
-    // member as_bytes(), as_writeable_bytes deprecated since 0.17.0
+#if !gsl_DEPRECATE_TO_LEVEL(2)
+        // member as_bytes(), as_writeable_bytes deprecated since 0.17.0
 
-    gsl_DEPRECATED_MSG("use free function gsl::as_bytes() instead")
-    gsl_api span< const byte > as_bytes() const gsl_noexcept
-    {
-        return span< const byte >( reinterpret_cast<const byte *>( data() ), size_bytes() ); // NOLINT
-    }
+        gsl_DEPRECATED_MSG("use free function gsl::as_bytes() instead")
+            gsl_api span<const byte> as_bytes() const gsl_noexcept {
+            return span<const byte>(reinterpret_cast<const byte *>(data()),
+                                    size_bytes()); // NOLINT
+        }
 
-    gsl_DEPRECATED_MSG("use free function gsl::as_writable_bytes() instead")
-    gsl_api span< byte > as_writeable_bytes() const gsl_noexcept
-    {
-        return span< byte >( reinterpret_cast<byte *>( data() ), size_bytes() ); // NOLINT
-    }
+        gsl_DEPRECATED_MSG("use free function gsl::as_writable_bytes() instead")
+            gsl_api span<byte> as_writeable_bytes() const gsl_noexcept {
+            return span<byte>(reinterpret_cast<byte *>(data()),
+                              size_bytes()); // NOLINT
+        }
 
 #endif
 
-    template< class U >
-    gsl_api span< U > as_span() const
-    {
-        gsl_Expects( ( this->size_bytes() % sizeof(U) ) == 0 );
-        return span< U >( reinterpret_cast<U *>( this->data() ), this->size_bytes() / sizeof( U ) ); // NOLINT
-    }
+        template <class U> gsl_api span<U> as_span() const {
+            gsl_Expects((this->size_bytes() % sizeof(U)) == 0);
+            return span<U>(reinterpret_cast<U *>(this->data()),
+                           this->size_bytes() / sizeof(U)); // NOLINT
+        }
 
-private:
-    pointer first_;
-    pointer last_;
-};
+      private:
+        pointer first_;
+        pointer last_;
+    };
 
-// class template argument deduction guides:
+    // class template argument deduction guides:
 
-#if gsl_HAVE( DEDUCTION_GUIDES )   // gsl_CPP17_OR_GREATER
+#if gsl_HAVE(DEDUCTION_GUIDES) // gsl_CPP17_OR_GREATER
 
-template< class T, size_t N >
-span( T (&)[N] ) -> span<T /*, N*/>;
+    template <class T, size_t N> span(T(&)[N]) -> span<T /*, N*/>;
 
-template< class T, size_t N >
-span( std::array<T, N> & ) -> span<T /*, N*/>;
+    template <class T, size_t N> span(std::array<T, N> &) -> span<T /*, N*/>;
 
-template< class T, size_t N >
-span( std::array<T, N> const & ) -> span<const T /*, N*/>;
+    template <class T, size_t N>
+    span(std::array<T, N> const &) -> span<const T /*, N*/>;
 
-template< class Container >
-span( Container& ) -> span<typename Container::value_type>;
+    template <class Container>
+    span(Container &) -> span<typename Container::value_type>;
 
-template< class Container >
-span( Container const & ) -> span<const typename Container::value_type>;
+    template <class Container>
+    span(Container const &) -> span<const typename Container::value_type>;
 
 #endif // gsl_HAVE( DEDUCTION_GUIDES )
 
-// 26.7.3.7 Comparison operators [span.comparison]
+    // 26.7.3.7 Comparison operators [span.comparison]
 
-#if gsl_CONFIG( ALLOWS_SPAN_COMPARISON )
-# if gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+#if gsl_CONFIG(ALLOWS_SPAN_COMPARISON)
+#if gsl_CONFIG(ALLOWS_NONSTRICT_SPAN_COMPARISON)
 
-template< class T, class U >
-gsl_SUPPRESS_MSGSL_WARNING(stl.1)
-inline gsl_constexpr bool operator==( span<T> const & l, span<U> const & r )
-{
-    return  l.size()  == r.size()
-        && (l.begin() == r.begin() || std::equal( l.begin(), l.end(), r.begin() ) );
-}
+    template <class T, class U>
+    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr bool operator==(
+        span<T> const &l, span<U> const &r) {
+        return l.size() == r.size() &&
+               (l.begin() == r.begin() ||
+                std::equal(l.begin(), l.end(), r.begin()));
+    }
 
-template< class T, class U >
-gsl_SUPPRESS_MSGSL_WARNING(stl.1)
-inline gsl_constexpr bool operator< ( span<T> const & l, span<U> const & r )
-{
-    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
-}
+    template <class T, class U>
+    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr bool operator<(
+        span<T> const &l, span<U> const &r) {
+        return std::lexicographical_compare(l.begin(), l.end(), r.begin(),
+                                            r.end());
+    }
 
-# else // a.k.a. !gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+#else  // a.k.a. !gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
 
-template< class T >
-gsl_SUPPRESS_MSGSL_WARNING(stl.1)
-inline gsl_constexpr bool operator==( span<T> const & l, span<T> const & r )
-{
-    return  l.size()  == r.size()
-        && (l.begin() == r.begin() || std::equal( l.begin(), l.end(), r.begin() ) );
-}
+    template <class T>
+    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr bool operator==(
+        span<T> const &l, span<T> const &r) {
+        return l.size() == r.size() &&
+               (l.begin() == r.begin() ||
+                std::equal(l.begin(), l.end(), r.begin()));
+    }
 
-template< class T >
-gsl_SUPPRESS_MSGSL_WARNING(stl.1)
-inline gsl_constexpr bool operator< ( span<T> const & l, span<T> const & r )
-{
-    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
-}
-# endif // gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+    template <class T>
+    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr bool operator<(
+        span<T> const &l, span<T> const &r) {
+        return std::lexicographical_compare(l.begin(), l.end(), r.begin(),
+                                            r.end());
+    }
+#endif // gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
 
-template< class T, class U >
-inline gsl_constexpr bool operator!=( span<T> const & l, span<U> const & r )
-{
-    return !( l == r );
-}
+    template <class T, class U>
+    inline gsl_constexpr bool operator!=(span<T> const &l, span<U> const &r) {
+        return !(l == r);
+    }
 
-template< class T, class U >
-inline gsl_constexpr bool operator<=( span<T> const & l, span<U> const & r )
-{
-    return !( r < l );
-}
+    template <class T, class U>
+    inline gsl_constexpr bool operator<=(span<T> const &l, span<U> const &r) {
+        return !(r < l);
+    }
 
-template< class T, class U >
-inline gsl_constexpr bool operator> ( span<T> const & l, span<U> const & r )
-{
-    return ( r < l );
-}
+    template <class T, class U>
+    inline gsl_constexpr bool operator>(span<T> const &l, span<U> const &r) {
+        return (r < l);
+    }
 
-template< class T, class U >
-inline gsl_constexpr bool operator>=( span<T> const & l, span<U> const & r )
-{
-    return !( l < r );
-}
+    template <class T, class U>
+    inline gsl_constexpr bool operator>=(span<T> const &l, span<U> const &r) {
+        return !(l < r);
+    }
 #endif // gsl_CONFIG( ALLOWS_SPAN_COMPARISON )
 
-// span algorithms
+    // span algorithms
 
-template< class T >
-gsl_api inline gsl_constexpr std::size_t size( span<T> const & spn )
-{
-    return static_cast<std::size_t>( spn.size() );
-}
+    template <class T>
+    gsl_api inline gsl_constexpr std::size_t size(span<T> const &spn) {
+        return static_cast<std::size_t>(spn.size());
+    }
 
-template< class T >
-gsl_api inline gsl_constexpr std::ptrdiff_t ssize( span<T> const & spn )
-{
-    return spn.ssize();
-}
+    template <class T>
+    gsl_api inline gsl_constexpr std::ptrdiff_t ssize(span<T> const &spn) {
+        return spn.ssize();
+    }
 
-namespace detail {
+    namespace detail {
 
-template< class II, class N, class OI >
-gsl_api gsl_constexpr14 inline OI copy_n( II first, N count, OI result )
-{
-    if ( count > 0 )
-    {
-        *result++ = *first;
-        for ( N i = 1; i < count; ++i )
-        {
-            *result++ = *++first;
+    template <class II, class N, class OI>
+    gsl_api gsl_constexpr14 inline OI copy_n(II first, N count, OI result) {
+        if (count > 0) {
+            *result++ = *first;
+            for (N i = 1; i < count; ++i) {
+                *result++ = *++first;
+            }
         }
+        return result;
     }
-    return result;
-}
-}
+    } // namespace detail
 
-template< class T, class U >
-gsl_api gsl_constexpr14 inline void copy( span<T> src, span<U> dest )
-{
-#if gsl_CPP14_OR_GREATER // gsl_HAVE( TYPE_TRAITS ) (circumvent Travis clang 3.4)
-    static_assert( std::is_assignable<U &, T const &>::value, "Cannot assign elements of source span to elements of destination span" );
+    template <class T, class U>
+    gsl_api gsl_constexpr14 inline void copy(span<T> src, span<U> dest) {
+#if gsl_CPP14_OR_GREATER // gsl_HAVE( TYPE_TRAITS ) (circumvent Travis
+                         // clang 3.4)
+        static_assert(std::is_assignable<U &, T const &>::value,
+                      "Cannot assign elements of source span to elements of "
+                      "destination span");
 #endif
-    gsl_Expects( dest.size() >= src.size() );
-    detail::copy_n( src.data(), src.size(), dest.data() );
-}
+        gsl_Expects(dest.size() >= src.size());
+        detail::copy_n(src.data(), src.size(), dest.data());
+    }
 
-// span creator functions (see ctors)
+    // span creator functions (see ctors)
 
-template< class T >
-gsl_api inline span< const byte > as_bytes( span<T> spn ) gsl_noexcept
-{
-    return span< const byte >( reinterpret_cast<const byte *>( spn.data() ), spn.size_bytes() ); // NOLINT
-}
+    template <class T>
+    gsl_api inline span<const byte> as_bytes(span<T> spn) gsl_noexcept {
+        return span<const byte>(reinterpret_cast<const byte *>(spn.data()),
+                                spn.size_bytes()); // NOLINT
+    }
 
-template< class T>
-gsl_api inline span< byte > as_writable_bytes( span<T> spn ) gsl_noexcept
-{
-    return span< byte >( reinterpret_cast<byte *>( spn.data() ), spn.size_bytes() ); // NOLINT
-}
+    template <class T>
+    gsl_api inline span<byte> as_writable_bytes(span<T> spn) gsl_noexcept {
+        return span<byte>(reinterpret_cast<byte *>(spn.data()),
+                          spn.size_bytes()); // NOLINT
+    }
 
-#if ! gsl_DEPRECATE_TO_LEVEL( 6 )
-template< class T>
-gsl_DEPRECATED_MSG("use as_writable_bytes() (different spelling) instead")
-gsl_api inline span< byte > as_writeable_bytes( span<T> spn ) gsl_noexcept
-{
-    return span< byte >( reinterpret_cast<byte *>( spn.data() ), spn.size_bytes() ); // NOLINT
-}
+#if !gsl_DEPRECATE_TO_LEVEL(6)
+    template <class T>
+    gsl_DEPRECATED_MSG("use as_writable_bytes() (different spelling) instead")
+        gsl_api inline span<byte>
+        as_writeable_bytes(span<T> spn) gsl_noexcept {
+        return span<byte>(reinterpret_cast<byte *>(spn.data()),
+                          spn.size_bytes()); // NOLINT
+    }
 #endif // deprecate
 
-#if gsl_FEATURE_TO_STD( MAKE_SPAN )
+#if gsl_FEATURE_TO_STD(MAKE_SPAN)
 
-template< class T >
-gsl_api inline gsl_constexpr span<T>
-make_span( T * ptr, typename span<T>::index_type count )
-{
-    return span<T>( ptr, count );
-}
+    template <class T>
+    gsl_api inline gsl_constexpr span<T> make_span(
+        T * ptr, typename span<T>::index_type count) {
+        return span<T>(ptr, count);
+    }
 
-template< class T >
-gsl_api inline gsl_constexpr span<T>
-make_span( T * first, T * last )
-{
-    return span<T>( first, last );
-}
+    template <class T>
+    gsl_api inline gsl_constexpr span<T> make_span(T * first, T * last) {
+        return span<T>(first, last);
+    }
 
-template< class T, size_t N >
-gsl_api inline gsl_constexpr span<T>
-make_span( T (&arr)[N] )
-{
-    return span<T>( gsl_ADDRESSOF( arr[0] ), N );
-}
+    template <class T, size_t N>
+    gsl_api inline gsl_constexpr span<T> make_span(T(&arr)[N]) {
+        return span<T>(gsl_ADDRESSOF(arr[0]), N);
+    }
 
-#if gsl_HAVE( ARRAY )
+#if gsl_HAVE(ARRAY)
 
-template< class T, size_t N >
-inline gsl_constexpr span<T>
-make_span( std::array<T,N> & arr )
-{
-    return span<T>( arr );
-}
+    template <class T, size_t N>
+    inline gsl_constexpr span<T> make_span(std::array<T, N> & arr) {
+        return span<T>(arr);
+    }
 
-template< class T, size_t N >
-inline gsl_constexpr span<const T>
-make_span( std::array<T,N> const & arr )
-{
-    return span<const T>( arr );
-}
+    template <class T, size_t N>
+    inline gsl_constexpr span<const T> make_span(std::array<T, N> const &arr) {
+        return span<const T>(arr);
+    }
 #endif
 
-#if gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR ) && gsl_HAVE( AUTO )
+#if gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR) && gsl_HAVE(AUTO)
 
-template< class Container, class EP = decltype( std17::data(std::declval<Container&>())) >
-inline gsl_constexpr auto
-make_span( Container & cont ) -> span< typename std::remove_pointer<EP>::type >
-{
-    return span< typename std::remove_pointer<EP>::type >( cont );
-}
+    template <class Container,
+              class EP = decltype(std17::data(std::declval<Container &>()))>
+    inline gsl_constexpr auto make_span(Container & cont)
+        ->span<typename std::remove_pointer<EP>::type> {
+        return span<typename std::remove_pointer<EP>::type>(cont);
+    }
 
-template< class Container, class EP = decltype( std17::data(std::declval<Container&>())) >
-inline gsl_constexpr auto
-make_span( Container const & cont ) -> span< const typename std::remove_pointer<EP>::type >
-{
-    return span< const typename std::remove_pointer<EP>::type >( cont );
-}
+    template <class Container,
+              class EP = decltype(std17::data(std::declval<Container &>()))>
+    inline gsl_constexpr auto make_span(Container const &cont)
+        ->span<const typename std::remove_pointer<EP>::type> {
+        return span<const typename std::remove_pointer<EP>::type>(cont);
+    }
 
 #else
 
-template< class T >
-inline span<T>
-make_span( std::vector<T> & cont )
-{
-    return span<T>( with_container, cont );
-}
+    template <class T> inline span<T> make_span(std::vector<T> & cont) {
+        return span<T>(with_container, cont);
+    }
 
-template< class T >
-inline span<const T>
-make_span( std::vector<T> const & cont )
-{
-    return span<const T>( with_container, cont );
-}
+    template <class T>
+    inline span<const T> make_span(std::vector<T> const &cont) {
+        return span<const T>(with_container, cont);
+    }
 #endif
 
-#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
+#if gsl_FEATURE_TO_STD(WITH_CONTAINER)
 
-template< class Container >
-inline gsl_constexpr span<typename Container::value_type>
-make_span( with_container_t, Container & cont ) gsl_noexcept
-{
-    return span< typename Container::value_type >( with_container, cont );
-}
+    template <class Container>
+    inline gsl_constexpr span<typename Container::value_type> make_span(
+        with_container_t, Container & cont) gsl_noexcept {
+        return span<typename Container::value_type>(with_container, cont);
+    }
 
-template< class Container >
-inline gsl_constexpr span<const typename Container::value_type>
-make_span( with_container_t, Container const & cont ) gsl_noexcept
-{
-    return span< const typename Container::value_type >( with_container, cont );
-}
+    template <class Container>
+    inline gsl_constexpr span<const typename Container::value_type> make_span(
+        with_container_t, Container const &cont) gsl_noexcept {
+        return span<const typename Container::value_type>(with_container, cont);
+    }
 
 #endif // gsl_FEATURE_TO_STD( WITH_CONTAINER )
 
-#if !gsl_DEPRECATE_TO_LEVEL( 4 )
-template< class Ptr >
-gsl_DEPRECATED
-inline span<typename Ptr::element_type>
-make_span( Ptr & ptr )
-{
-    return span<typename Ptr::element_type>( ptr );
-}
+#if !gsl_DEPRECATE_TO_LEVEL(4)
+    template <class Ptr>
+    gsl_DEPRECATED inline span<typename Ptr::element_type> make_span(Ptr &
+                                                                     ptr) {
+        return span<typename Ptr::element_type>(ptr);
+    }
 #endif // !gsl_DEPRECATE_TO_LEVEL( 4 )
 
-template< class Ptr >
-gsl_DEPRECATED
-inline span<typename Ptr::element_type>
-make_span( Ptr & ptr, typename span<typename Ptr::element_type>::index_type count )
-{
-    return span<typename Ptr::element_type>( ptr, count );
-}
+    template <class Ptr>
+    gsl_DEPRECATED inline span<typename Ptr::element_type> make_span(
+        Ptr & ptr,
+        typename span<typename Ptr::element_type>::index_type count) {
+        return span<typename Ptr::element_type>(ptr, count);
+    }
 
 #endif // gsl_FEATURE_TO_STD( MAKE_SPAN )
 
-#if gsl_FEATURE_TO_STD( BYTE_SPAN )
+#if gsl_FEATURE_TO_STD(BYTE_SPAN)
 
-template< class T >
-gsl_api inline gsl_constexpr span<byte>
-byte_span( T & t ) gsl_noexcept
-{
-    return span<byte>( reinterpret_cast<byte *>( &t ), sizeof(T) );
-}
+    template <class T>
+    gsl_api inline gsl_constexpr span<byte> byte_span(T & t) gsl_noexcept {
+        return span<byte>(reinterpret_cast<byte *>(&t), sizeof(T));
+    }
 
-template< class T >
-gsl_api inline gsl_constexpr span<const byte>
-byte_span( T const & t ) gsl_noexcept
-{
-    return span<const byte>( reinterpret_cast<byte const *>( &t ), sizeof(T) );
-}
+    template <class T>
+    gsl_api inline gsl_constexpr span<const byte> byte_span(T const &t)
+        gsl_noexcept {
+        return span<const byte>(reinterpret_cast<byte const *>(&t), sizeof(T));
+    }
 
 #endif // gsl_FEATURE_TO_STD( BYTE_SPAN )
 
-//
-// basic_string_span:
-//
+    //
+    // basic_string_span:
+    //
 
-template< class T >
-class basic_string_span;
+    template <class T> class basic_string_span;
 
-namespace detail {
+    namespace detail {
 
-template< class T >
-struct is_basic_string_span_oracle : std11::false_type {};
+    template <class T>
+    struct is_basic_string_span_oracle : std11::false_type {};
 
-template< class T >
-struct is_basic_string_span_oracle< basic_string_span<T> > : std11::true_type {};
+    template <class T>
+    struct is_basic_string_span_oracle<basic_string_span<T>>
+        : std11::true_type {};
 
-template< class T >
-struct is_basic_string_span : is_basic_string_span_oracle< typename std11::remove_cv<T>::type > {};
+    template <class T>
+    struct is_basic_string_span
+        : is_basic_string_span_oracle<typename std11::remove_cv<T>::type> {};
 
-template< class T >
-gsl_api inline gsl_constexpr14 std::size_t string_length( T * ptr, std::size_t max )
-{
-    if ( ptr == gsl_nullptr || max <= 0 )
-        return 0;
+    template <class T>
+    gsl_api inline gsl_constexpr14 std::size_t string_length(T *ptr,
+                                                             std::size_t max) {
+        if (ptr == gsl_nullptr || max <= 0)
+            return 0;
 
-    std::size_t len = 0;
-    while ( len < max && ptr[len] ) // NOLINT
-        ++len;
+        std::size_t len = 0;
+        while (len < max && ptr[len]) // NOLINT
+            ++len;
 
-    return len;
-}
+        return len;
+    }
 
-} // namespace detail
+    } // namespace detail
 
-//
-// basic_string_span<> - A view of contiguous characters, replace (*,len).
-//
-template< class T >
-class basic_string_span
-{
-public:
-    typedef T element_type;
-    typedef span<T> span_type;
+    //
+    // basic_string_span<> - A view of contiguous characters, replace (*,len).
+    //
+    template <class T> class basic_string_span {
+      public:
+        typedef T element_type;
+        typedef span<T> span_type;
 
-    typedef typename span_type::index_type index_type;
-    typedef typename span_type::difference_type difference_type;
+        typedef typename span_type::index_type index_type;
+        typedef typename span_type::difference_type difference_type;
 
-    typedef typename span_type::pointer pointer ;
-    typedef typename span_type::reference reference ;
+        typedef typename span_type::pointer pointer;
+        typedef typename span_type::reference reference;
 
-    typedef typename span_type::iterator iterator ;
-    typedef typename span_type::const_iterator const_iterator ;
-    typedef typename span_type::reverse_iterator reverse_iterator;
-    typedef typename span_type::const_reverse_iterator const_reverse_iterator;
+        typedef typename span_type::iterator iterator;
+        typedef typename span_type::const_iterator const_iterator;
+        typedef typename span_type::reverse_iterator reverse_iterator;
+        typedef
+            typename span_type::const_reverse_iterator const_reverse_iterator;
 
-    // construction:
+        // construction:
 
-#if gsl_HAVE( IS_DEFAULT )
-    gsl_constexpr basic_string_span() gsl_noexcept = default;
+#if gsl_HAVE(IS_DEFAULT)
+        gsl_constexpr basic_string_span() gsl_noexcept = default;
 #else
-    gsl_api gsl_constexpr basic_string_span() gsl_noexcept {}
+        gsl_api gsl_constexpr basic_string_span() gsl_noexcept {}
+#endif
+
+#if gsl_HAVE(NULLPTR)
+        gsl_api gsl_constexpr basic_string_span(std::nullptr_t) gsl_noexcept
+            : span_(nullptr, static_cast<index_type>(0)) {}
 #endif
 
-#if gsl_HAVE( NULLPTR )
-    gsl_api gsl_constexpr basic_string_span( std::nullptr_t ) gsl_noexcept
-    : span_( nullptr, static_cast<index_type>( 0 ) )
-    {}
+#ifdef __CUDACC_RELAXED_CONSTEXPR__
+        gsl_api
+#endif // __CUDACC_RELAXED_CONSTEXPR__
+            gsl_constexpr
+            basic_string_span(pointer ptr)
+            : span_(remove_z(ptr, (std::numeric_limits<index_type>::max)())) {
+        }
+
+        gsl_api gsl_constexpr basic_string_span(pointer ptr, index_type count)
+            : span_(ptr, count) {}
+
+        gsl_api gsl_constexpr basic_string_span(pointer firstElem,
+                                                pointer lastElem)
+            : span_(firstElem, lastElem) {}
+
+        template <std::size_t N>
+        gsl_api gsl_constexpr basic_string_span(element_type (&arr)[N])
+            : span_(remove_z(gsl_ADDRESSOF(arr[0]), N)) {}
+
+#if gsl_HAVE(ARRAY)
+
+        template <std::size_t N>
+        gsl_constexpr basic_string_span(
+            std::array<typename std11::remove_const<element_type>::type, N>
+                &arr)
+            : span_(remove_z(arr)) {}
+
+        template <std::size_t N>
+        gsl_constexpr basic_string_span(
+            std::array<typename std11::remove_const<element_type>::type,
+                       N> const &arr)
+            : span_(remove_z(arr)) {}
+
 #endif
 
-#ifdef __CUDACC_RELAXED_CONSTEXPR__
-    gsl_api
-#endif // __CUDACC_RELAXED_CONSTEXPR__
-    gsl_constexpr basic_string_span( pointer ptr )
-    : span_( remove_z( ptr, (std::numeric_limits<index_type>::max)() ) )
-    {}
-
-    gsl_api gsl_constexpr basic_string_span( pointer ptr, index_type count )
-    : span_( ptr, count )
-    {}
-
-    gsl_api gsl_constexpr basic_string_span( pointer firstElem, pointer lastElem )
-    : span_( firstElem, lastElem )
-    {}
-
-    template< std::size_t N >
-    gsl_api gsl_constexpr basic_string_span( element_type (&arr)[N] )
-    : span_( remove_z( gsl_ADDRESSOF( arr[0] ), N ) )
-    {}
-
-#if gsl_HAVE( ARRAY )
-
-    template< std::size_t N >
-    gsl_constexpr basic_string_span( std::array< typename std11::remove_const<element_type>::type, N> & arr )
-    : span_( remove_z( arr ) )
-    {}
-
-    template< std::size_t N >
-    gsl_constexpr basic_string_span( std::array< typename std11::remove_const<element_type>::type, N> const & arr )
-    : span_( remove_z( arr ) )
-    {}
-
-#endif
-
-#if gsl_HAVE( CONSTRAINED_SPAN_CONTAINER_CTOR )
-
-    // Exclude: array, [basic_string,] basic_string_span
-
-    template< class Container
-        gsl_ENABLE_IF_((
-            ! detail::is_std_array< Container >::value
-            && ! detail::is_basic_string_span< Container >::value
-            && std::is_convertible< typename Container::pointer, pointer >::value
-            && std::is_convertible< typename Container::pointer, decltype(std::declval<Container>().data()) >::value
-        ))
-    >
-    gsl_constexpr basic_string_span( Container & cont )
-    : span_( ( cont ) )
-    {}
-
-    // Exclude: array, [basic_string,] basic_string_span
-
-    template< class Container
-        gsl_ENABLE_IF_((
-            ! detail::is_std_array< Container >::value
-            && ! detail::is_basic_string_span< Container >::value
-            && std::is_convertible< typename Container::pointer, pointer >::value
-            && std::is_convertible< typename Container::pointer, decltype(std::declval<Container const &>().data()) >::value
-        ))
-    >
-    gsl_constexpr basic_string_span( Container const & cont )
-    : span_( ( cont ) )
-    {}
-
-#elif gsl_HAVE( UNCONSTRAINED_SPAN_CONTAINER_CTOR )
-
-    template< class Container >
-    gsl_constexpr basic_string_span( Container & cont )
-    : span_( cont )
-    {}
-
-    template< class Container >
-    gsl_constexpr basic_string_span( Container const & cont )
-    : span_( cont )
-    {}
+#if gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR)
+
+        // Exclude: array, [basic_string,] basic_string_span
+
+        template <class Container gsl_ENABLE_IF_(
+            (!detail::is_std_array<Container>::value &&
+             !detail::is_basic_string_span<Container>::value &&
+             std::is_convertible<typename Container::pointer, pointer>::value &&
+             std::is_convertible<
+                 typename Container::pointer,
+                 decltype(std::declval<Container>().data())>::value))>
+        gsl_constexpr basic_string_span(Container &cont) : span_((cont)) {}
+
+        // Exclude: array, [basic_string,] basic_string_span
+
+        template <class Container gsl_ENABLE_IF_(
+            (!detail::is_std_array<Container>::value &&
+             !detail::is_basic_string_span<Container>::value &&
+             std::is_convertible<typename Container::pointer, pointer>::value &&
+             std::is_convertible<
+                 typename Container::pointer,
+                 decltype(std::declval<Container const &>().data())>::value))>
+        gsl_constexpr basic_string_span(Container const &cont)
+            : span_((cont)) {}
+
+#elif gsl_HAVE(UNCONSTRAINED_SPAN_CONTAINER_CTOR)
+
+        template <class Container>
+        gsl_constexpr basic_string_span(Container &cont) : span_(cont) {}
+
+        template <class Container>
+        gsl_constexpr basic_string_span(Container const &cont) : span_(cont) {}
 
 #else
 
-    template< class U >
-    gsl_api gsl_constexpr basic_string_span( span<U> const & rhs )
-    : span_( rhs )
-    {}
+        template <class U>
+        gsl_api gsl_constexpr basic_string_span(span<U> const &rhs)
+            : span_(rhs) {}
 
 #endif
 
-#if gsl_FEATURE_TO_STD( WITH_CONTAINER )
+#if gsl_FEATURE_TO_STD(WITH_CONTAINER)
 
-    template< class Container >
-    gsl_constexpr basic_string_span( with_container_t, Container & cont )
-    : span_( with_container, cont )
-    {}
+        template <class Container>
+        gsl_constexpr basic_string_span(with_container_t, Container &cont)
+            : span_(with_container, cont) {}
 #endif
 
-#if gsl_HAVE( IS_DEFAULT )
-# if gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 440, 600 )
-    gsl_constexpr basic_string_span( basic_string_span const & rhs ) = default;
+#if gsl_HAVE(IS_DEFAULT)
+#if gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 440, 600)
+        gsl_constexpr basic_string_span(basic_string_span const &rhs) = default;
 
-    gsl_constexpr basic_string_span( basic_string_span && rhs ) = default;
-# else
-    gsl_constexpr basic_string_span( basic_string_span const & rhs ) gsl_noexcept = default;
+        gsl_constexpr basic_string_span(basic_string_span &&rhs) = default;
+#else
+        gsl_constexpr
+        basic_string_span(basic_string_span const &rhs) gsl_noexcept = default;
 
-    gsl_constexpr basic_string_span( basic_string_span && rhs ) gsl_noexcept = default;
-# endif
+        gsl_constexpr
+        basic_string_span(basic_string_span &&rhs) gsl_noexcept = default;
+#endif
 #endif
 
-    template< class U
-        gsl_ENABLE_IF_(( std::is_convertible<typename basic_string_span<U>::pointer, pointer>::value ))
-    >
-    gsl_api gsl_constexpr basic_string_span( basic_string_span<U> const & rhs )
-    : span_( reinterpret_cast<pointer>( rhs.data() ), rhs.length() ) // NOLINT
-    {}
+        template <class U gsl_ENABLE_IF_(
+            (std::is_convertible<typename basic_string_span<U>::pointer,
+                                 pointer>::value))>
+        gsl_api gsl_constexpr basic_string_span(basic_string_span<U> const &rhs)
+            : span_(reinterpret_cast<pointer>(rhs.data()),
+                    rhs.length()) // NOLINT
+        {}
 
 #if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
-    template< class U
-        gsl_ENABLE_IF_(( std::is_convertible<typename basic_string_span<U>::pointer, pointer>::value ))
-    >
-    gsl_api gsl_constexpr basic_string_span( basic_string_span<U> && rhs )
-    : span_( reinterpret_cast<pointer>( rhs.data() ), rhs.length() ) // NOLINT
-    {}
+        template <class U gsl_ENABLE_IF_(
+            (std::is_convertible<typename basic_string_span<U>::pointer,
+                                 pointer>::value))>
+        gsl_api gsl_constexpr basic_string_span(basic_string_span<U> &&rhs)
+            : span_(reinterpret_cast<pointer>(rhs.data()),
+                    rhs.length()) // NOLINT
+        {}
 #endif
 
-    template< class CharTraits, class Allocator >
-    gsl_constexpr basic_string_span(
-        std::basic_string< typename std11::remove_const<element_type>::type, CharTraits, Allocator > & str )
-    : span_( gsl_ADDRESSOF( str[0] ), str.length() )
-    {}
+        template <class CharTraits, class Allocator>
+        gsl_constexpr basic_string_span(
+            std::basic_string<typename std11::remove_const<element_type>::type,
+                              CharTraits, Allocator> &str)
+            : span_(gsl_ADDRESSOF(str[0]), str.length()) {}
 
-    template< class CharTraits, class Allocator >
-    gsl_constexpr basic_string_span(
-        std::basic_string< typename std11::remove_const<element_type>::type, CharTraits, Allocator > const & str )
-    : span_( gsl_ADDRESSOF( str[0] ), str.length() )
-    {}
+        template <class CharTraits, class Allocator>
+        gsl_constexpr basic_string_span(
+            std::basic_string<typename std11::remove_const<element_type>::type,
+                              CharTraits, Allocator> const &str)
+            : span_(gsl_ADDRESSOF(str[0]), str.length()) {}
 
-    // assignment:
+        // assignment:
 
-#if gsl_HAVE( IS_DEFAULT )
-    gsl_constexpr14 basic_string_span & operator=( basic_string_span const & rhs ) gsl_noexcept = default;
+#if gsl_HAVE(IS_DEFAULT)
+        gsl_constexpr14 basic_string_span &
+        operator=(basic_string_span const &rhs) gsl_noexcept = default;
 
-    gsl_constexpr14 basic_string_span & operator=( basic_string_span && rhs ) gsl_noexcept = default;
+        gsl_constexpr14 basic_string_span &
+        operator=(basic_string_span &&rhs) gsl_noexcept = default;
 #endif
 
-    // sub span:
+        // sub span:
 
-    /*gsl_api*/ // currently disabled due to an apparent NVCC bug
-    gsl_constexpr14 basic_string_span first( index_type count ) const
-    {
-        return span_.first( count );
-    }
+        /*gsl_api*/ // currently disabled due to an apparent NVCC bug
+        gsl_constexpr14 basic_string_span first(index_type count) const {
+            return span_.first(count);
+        }
 
-    /*gsl_api*/ // currently disabled due to an apparent NVCC bug
-    gsl_constexpr14 basic_string_span last( index_type count ) const
-    {
-        return span_.last( count );
-    }
+        /*gsl_api*/ // currently disabled due to an apparent NVCC bug
+        gsl_constexpr14 basic_string_span last(index_type count) const {
+            return span_.last(count);
+        }
 
-    /*gsl_api*/ // currently disabled due to an apparent NVCC bug
-    gsl_constexpr14 basic_string_span subspan( index_type offset ) const
-    {
-        return span_.subspan( offset );
-    }
+        /*gsl_api*/ // currently disabled due to an apparent NVCC bug
+        gsl_constexpr14 basic_string_span subspan(index_type offset) const {
+            return span_.subspan(offset);
+        }
 
-    /*gsl_api*/ // currently disabled due to an apparent NVCC bug
-    gsl_constexpr14 basic_string_span subspan( index_type offset, index_type count ) const
-    {
-        return span_.subspan( offset, count );
-    }
+        /*gsl_api*/ // currently disabled due to an apparent NVCC bug
+        gsl_constexpr14 basic_string_span subspan(index_type offset,
+                                                  index_type count) const {
+            return span_.subspan(offset, count);
+        }
 
-    // observers:
+        // observers:
 
-    gsl_api gsl_constexpr index_type length() const gsl_noexcept
-    {
-        return span_.size();
-    }
+        gsl_api gsl_constexpr index_type length() const gsl_noexcept {
+            return span_.size();
+        }
 
-    gsl_api gsl_constexpr index_type size() const gsl_noexcept
-    {
-        return span_.size();
-    }
+        gsl_api gsl_constexpr index_type size() const gsl_noexcept {
+            return span_.size();
+        }
 
-    gsl_api gsl_constexpr index_type length_bytes() const gsl_noexcept
-    {
-        return span_.size_bytes();
-    }
+        gsl_api gsl_constexpr index_type length_bytes() const gsl_noexcept {
+            return span_.size_bytes();
+        }
 
-    gsl_api gsl_constexpr index_type size_bytes() const gsl_noexcept
-    {
-        return span_.size_bytes();
-    }
+        gsl_api gsl_constexpr index_type size_bytes() const gsl_noexcept {
+            return span_.size_bytes();
+        }
 
-    gsl_api gsl_constexpr bool empty() const gsl_noexcept
-    {
-        return size() == 0;
-    }
+        gsl_api gsl_constexpr bool empty() const gsl_noexcept {
+            return size() == 0;
+        }
 
-    gsl_api gsl_constexpr14 reference operator[]( index_type idx ) const
-    {
-        return span_[idx];
-    }
+        gsl_api gsl_constexpr14 reference operator[](index_type idx) const {
+            return span_[idx];
+        }
 
-#if ! gsl_DEPRECATE_TO_LEVEL( 6 )
-    gsl_DEPRECATED_MSG("use subscript indexing instead")
-    gsl_api gsl_constexpr14 reference operator()( index_type idx ) const
-    {
-        return span_[idx];
-    }
+#if !gsl_DEPRECATE_TO_LEVEL(6)
+        gsl_DEPRECATED_MSG("use subscript indexing instead") gsl_api
+            gsl_constexpr14 reference
+            operator()(index_type idx) const {
+            return span_[idx];
+        }
 #endif // deprecate
 
-    gsl_api gsl_constexpr14 reference front() const
-    {
-        return span_.front();
-    }
+        gsl_api gsl_constexpr14 reference front() const {
+            return span_.front();
+        }
 
-    gsl_api gsl_constexpr14 reference back() const
-    {
-        return span_.back();
-    }
+        gsl_api gsl_constexpr14 reference back() const { return span_.back(); }
 
-    gsl_api gsl_constexpr pointer data() const gsl_noexcept
-    {
-        return span_.data();
-    }
+        gsl_api gsl_constexpr pointer data() const gsl_noexcept {
+            return span_.data();
+        }
 
-    gsl_api gsl_constexpr iterator begin() const gsl_noexcept
-    {
-        return span_.begin();
-    }
+        gsl_api gsl_constexpr iterator begin() const gsl_noexcept {
+            return span_.begin();
+        }
 
-    gsl_api gsl_constexpr iterator end() const gsl_noexcept
-    {
-        return span_.end();
-    }
+        gsl_api gsl_constexpr iterator end() const gsl_noexcept {
+            return span_.end();
+        }
 
-    gsl_constexpr17 reverse_iterator rbegin() const gsl_noexcept
-    {
-        return span_.rbegin();
-    }
+        gsl_constexpr17 reverse_iterator rbegin() const gsl_noexcept {
+            return span_.rbegin();
+        }
 
-    gsl_constexpr17 reverse_iterator rend() const gsl_noexcept
-    {
-        return span_.rend();
-    }
+        gsl_constexpr17 reverse_iterator rend() const gsl_noexcept {
+            return span_.rend();
+        }
 
-    // const version not in p0123r2:
+        // const version not in p0123r2:
 
-    gsl_api gsl_constexpr const_iterator cbegin() const gsl_noexcept
-    {
-        return span_.cbegin();
-    }
+        gsl_api gsl_constexpr const_iterator cbegin() const gsl_noexcept {
+            return span_.cbegin();
+        }
 
-    gsl_api gsl_constexpr const_iterator cend() const gsl_noexcept
-    {
-        return span_.cend();
-    }
+        gsl_api gsl_constexpr const_iterator cend() const gsl_noexcept {
+            return span_.cend();
+        }
 
-    gsl_constexpr17 const_reverse_iterator crbegin() const gsl_noexcept
-    {
-        return span_.crbegin();
-    }
+        gsl_constexpr17 const_reverse_iterator crbegin() const gsl_noexcept {
+            return span_.crbegin();
+        }
 
-    gsl_constexpr17 const_reverse_iterator crend() const gsl_noexcept
-    {
-        return span_.crend();
-    }
+        gsl_constexpr17 const_reverse_iterator crend() const gsl_noexcept {
+            return span_.crend();
+        }
 
-private:
-    gsl_api static gsl_constexpr14 span_type remove_z( pointer const & sz, std::size_t max )
-    {
-        return span_type( sz, detail::string_length( sz, max ) );
-    }
+      private:
+        gsl_api static gsl_constexpr14 span_type remove_z(pointer const &sz,
+                                                          std::size_t max) {
+            return span_type(sz, detail::string_length(sz, max));
+        }
 
-#if gsl_HAVE( ARRAY )
-    template< size_t N >
-    static gsl_constexpr14 span_type remove_z( std::array<typename std11::remove_const<element_type>::type, N> & arr )
-    {
-        return remove_z( gsl_ADDRESSOF( arr[0] ), narrow_cast< std::size_t >( N ) );
-    }
+#if gsl_HAVE(ARRAY)
+        template <size_t N>
+        static gsl_constexpr14 span_type
+        remove_z(std::array<typename std11::remove_const<element_type>::type, N>
+                     &arr) {
+            return remove_z(gsl_ADDRESSOF(arr[0]), narrow_cast<std::size_t>(N));
+        }
 
-    template< size_t N >
-    static gsl_constexpr14 span_type remove_z( std::array<typename std11::remove_const<element_type>::type, N> const & arr )
-    {
-        return remove_z( gsl_ADDRESSOF( arr[0] ), narrow_cast< std::size_t >( N ) );
-    }
+        template <size_t N>
+        static gsl_constexpr14 span_type
+        remove_z(std::array<typename std11::remove_const<element_type>::type,
+                            N> const &arr) {
+            return remove_z(gsl_ADDRESSOF(arr[0]), narrow_cast<std::size_t>(N));
+        }
 #endif
 
-private:
-    span_type span_;
-};
+      private:
+        span_type span_;
+    };
 
-// basic_string_span comparison functions:
+    // basic_string_span comparison functions:
 
-#if gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+#if gsl_CONFIG(ALLOWS_NONSTRICT_SPAN_COMPARISON)
 
-template< class T, class U >
-gsl_SUPPRESS_MSGSL_WARNING(stl.1)
-inline gsl_constexpr14 bool operator==( basic_string_span<T> const & l, U const & u ) gsl_noexcept
-{
-    const basic_string_span< typename std11::add_const<T>::type > r( u );
+    template <class T, class U>
+    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator==(
+        basic_string_span<T> const &l, U const &u) gsl_noexcept {
+        const basic_string_span<typename std11::add_const<T>::type> r(u);
 
-    return l.size() == r.size()
-        && std::equal( l.begin(), l.end(), r.begin() );
-}
+        return l.size() == r.size() &&
+               std::equal(l.begin(), l.end(), r.begin());
+    }
 
-template< class T, class U >
-gsl_SUPPRESS_MSGSL_WARNING(stl.1)
-inline gsl_constexpr14 bool operator<( basic_string_span<T> const & l, U const & u ) gsl_noexcept
-{
-    const basic_string_span< typename std11::add_const<T>::type > r( u );
+    template <class T, class U>
+    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator<(
+        basic_string_span<T> const &l, U const &u) gsl_noexcept {
+        const basic_string_span<typename std11::add_const<T>::type> r(u);
 
-    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
-}
+        return std::lexicographical_compare(l.begin(), l.end(), r.begin(),
+                                            r.end());
+    }
 
-#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+#if gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG)
 
-template< class T, class U
-    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
->
-gsl_SUPPRESS_MSGSL_WARNING(stl.1)
-inline gsl_constexpr14 bool operator==( U const & u, basic_string_span<T> const & r ) gsl_noexcept
-{
-    const basic_string_span< typename std11::add_const<T>::type > l( u );
+    template <class T,
+              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
+    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator==(
+        U const &u, basic_string_span<T> const &r) gsl_noexcept {
+        const basic_string_span<typename std11::add_const<T>::type> l(u);
 
-    return l.size() == r.size()
-        && std::equal( l.begin(), l.end(), r.begin() );
-}
+        return l.size() == r.size() &&
+               std::equal(l.begin(), l.end(), r.begin());
+    }
 
-template< class T, class U
-    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
->
-gsl_SUPPRESS_MSGSL_WARNING(stl.1)
-inline gsl_constexpr14 bool operator<( U const & u, basic_string_span<T> const & r ) gsl_noexcept
-{
-    const basic_string_span< typename std11::add_const<T>::type > l( u );
+    template <class T,
+              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
+    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator<(
+        U const &u, basic_string_span<T> const &r) gsl_noexcept {
+        const basic_string_span<typename std11::add_const<T>::type> l(u);
 
-    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
-}
+        return std::lexicographical_compare(l.begin(), l.end(), r.begin(),
+                                            r.end());
+    }
 #endif
 
-#else //gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
+#else // gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
 
-template< class T >
-gsl_SUPPRESS_MSGSL_WARNING(stl.1)
-inline gsl_constexpr14 bool operator==( basic_string_span<T> const & l, basic_string_span<T> const & r ) gsl_noexcept
-{
-    return l.size() == r.size()
-        && std::equal( l.begin(), l.end(), r.begin() );
-}
+    template <class T>
+    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator==(
+        basic_string_span<T> const &l, basic_string_span<T> const &r)
+        gsl_noexcept {
+        return l.size() == r.size() &&
+               std::equal(l.begin(), l.end(), r.begin());
+    }
 
-template< class T >
-gsl_SUPPRESS_MSGSL_WARNING(stl.1)
-inline gsl_constexpr14 bool operator<( basic_string_span<T> const & l, basic_string_span<T> const & r ) gsl_noexcept
-{
-    return std::lexicographical_compare( l.begin(), l.end(), r.begin(), r.end() );
-}
+    template <class T>
+    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator<(
+        basic_string_span<T> const &l, basic_string_span<T> const &r)
+        gsl_noexcept {
+        return std::lexicographical_compare(l.begin(), l.end(), r.begin(),
+                                            r.end());
+    }
 
 #endif // gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
 
-template< class T, class U >
-inline gsl_constexpr14 bool operator!=( basic_string_span<T> const & l, U const & r ) gsl_noexcept
-{
-    return !( l == r );
-}
+    template <class T, class U>
+    inline gsl_constexpr14 bool operator!=(basic_string_span<T> const &l,
+                                           U const &r) gsl_noexcept {
+        return !(l == r);
+    }
 
-template< class T, class U >
-inline gsl_constexpr14 bool operator<=( basic_string_span<T> const & l, U const & r ) gsl_noexcept
-{
-#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) || ! gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
-    return !( r < l );
+    template <class T, class U>
+    inline gsl_constexpr14 bool operator<=(basic_string_span<T> const &l,
+                                           U const &r) gsl_noexcept {
+#if gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) ||                                 \
+    !gsl_CONFIG(ALLOWS_NONSTRICT_SPAN_COMPARISON)
+        return !(r < l);
 #else
-    basic_string_span< typename std11::add_const<T>::type > rr( r );
-    return !( rr < l );
+        basic_string_span<typename std11::add_const<T>::type> rr(r);
+        return !(rr < l);
 #endif
-}
+    }
 
-template< class T, class U >
-inline gsl_constexpr14 bool operator>( basic_string_span<T> const & l, U const & r ) gsl_noexcept
-{
-#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) || ! gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
-    return ( r < l );
+    template <class T, class U>
+    inline gsl_constexpr14 bool operator>(basic_string_span<T> const &l,
+                                          U const &r) gsl_noexcept {
+#if gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) ||                                 \
+    !gsl_CONFIG(ALLOWS_NONSTRICT_SPAN_COMPARISON)
+        return (r < l);
 #else
-    basic_string_span< typename std11::add_const<T>::type > rr( r );
-    return ( rr < l );
+        basic_string_span<typename std11::add_const<T>::type> rr(r);
+        return (rr < l);
 #endif
-}
+    }
 
-template< class T, class U >
-inline gsl_constexpr14 bool operator>=( basic_string_span<T> const & l, U const & r ) gsl_noexcept
-{
-    return !( l < r );
-}
+    template <class T, class U>
+    inline gsl_constexpr14 bool operator>=(basic_string_span<T> const &l,
+                                           U const &r) gsl_noexcept {
+        return !(l < r);
+    }
 
-#if gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
+#if gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG)
 
-template< class T, class U
-    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
->
-inline gsl_constexpr14 bool operator!=( U const & l, basic_string_span<T> const & r ) gsl_noexcept
-{
-    return !( l == r );
-}
+    template <class T,
+              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
+    inline gsl_constexpr14 bool operator!=(
+        U const &l, basic_string_span<T> const &r) gsl_noexcept {
+        return !(l == r);
+    }
 
-template< class T, class U
-    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
->
-inline gsl_constexpr14 bool operator<=( U const & l, basic_string_span<T> const & r ) gsl_noexcept
-{
-    return !( r < l );
-}
+    template <class T,
+              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
+    inline gsl_constexpr14 bool operator<=(
+        U const &l, basic_string_span<T> const &r) gsl_noexcept {
+        return !(r < l);
+    }
 
-template< class T, class U
-    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
->
-inline gsl_constexpr14 bool operator>( U const & l, basic_string_span<T> const & r ) gsl_noexcept
-{
-    return ( r < l );
-}
+    template <class T,
+              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
+    inline gsl_constexpr14 bool operator>(
+        U const &l, basic_string_span<T> const &r) gsl_noexcept {
+        return (r < l);
+    }
 
-template< class T, class U
-    gsl_ENABLE_IF_(( !detail::is_basic_string_span<U>::value ))
->
-inline gsl_constexpr14 bool operator>=( U const & l, basic_string_span<T> const & r ) gsl_noexcept
-{
-    return !( l < r );
-}
+    template <class T,
+              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
+    inline gsl_constexpr14 bool operator>=(
+        U const &l, basic_string_span<T> const &r) gsl_noexcept {
+        return !(l < r);
+    }
 
 #endif // gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
 
-// convert basic_string_span to byte span:
+    // convert basic_string_span to byte span:
 
-template< class T >
-gsl_api inline span< const byte > as_bytes( basic_string_span<T> spn ) gsl_noexcept
-{
-    return span< const byte >( reinterpret_cast<const byte *>( spn.data() ), spn.size_bytes() ); // NOLINT
-}
+    template <class T>
+    gsl_api inline span<const byte> as_bytes(basic_string_span<T> spn)
+        gsl_noexcept {
+        return span<const byte>(reinterpret_cast<const byte *>(spn.data()),
+                                spn.size_bytes()); // NOLINT
+    }
 
-//
-// String types:
-//
+    //
+    // String types:
+    //
 
-typedef char * zstring;
-typedef const char * czstring;
+    typedef char *zstring;
+    typedef const char *czstring;
 
-#if gsl_HAVE( WCHAR )
-typedef wchar_t * wzstring;
-typedef const wchar_t * cwzstring;
+#if gsl_HAVE(WCHAR)
+    typedef wchar_t *wzstring;
+    typedef const wchar_t *cwzstring;
 #endif
 
-typedef basic_string_span< char > string_span;
-typedef basic_string_span< char const > cstring_span;
+    typedef basic_string_span<char> string_span;
+    typedef basic_string_span<char const> cstring_span;
 
-#if gsl_HAVE( WCHAR )
-typedef basic_string_span< wchar_t > wstring_span;
-typedef basic_string_span< wchar_t const > cwstring_span;
+#if gsl_HAVE(WCHAR)
+    typedef basic_string_span<wchar_t> wstring_span;
+    typedef basic_string_span<wchar_t const> cwstring_span;
 #endif
 
-// to_string() allow (explicit) conversions from string_span to string
+    // to_string() allow (explicit) conversions from string_span to string
 
 #if 0
 
@@ -3791,227 +3710,227 @@ inline std::basic_string< typename std::remove_const<T>::type > to_string( basic
 
 #else
 
-inline std::string to_string( string_span const & spn )
-{
-    return std::string( spn.data(), spn.length() );
-}
+    inline std::string to_string(string_span const &spn) {
+        return std::string(spn.data(), spn.length());
+    }
 
-inline std::string to_string( cstring_span const & spn )
-{
-    return std::string( spn.data(), spn.length() );
-}
+    inline std::string to_string(cstring_span const &spn) {
+        return std::string(spn.data(), spn.length());
+    }
 
-#if gsl_HAVE( WCHAR )
+#if gsl_HAVE(WCHAR)
 
-inline std::wstring to_string( wstring_span const & spn )
-{
-    return std::wstring( spn.data(), spn.length() );
-}
+    inline std::wstring to_string(wstring_span const &spn) {
+        return std::wstring(spn.data(), spn.length());
+    }
 
-inline std::wstring to_string( cwstring_span const & spn )
-{
-    return std::wstring( spn.data(), spn.length() );
-}
+    inline std::wstring to_string(cwstring_span const &spn) {
+        return std::wstring(spn.data(), spn.length());
+    }
 
 #endif // gsl_HAVE( WCHAR )
 #endif // to_string()
 
-//
-// Stream output for string_span types
-//
+    //
+    // Stream output for string_span types
+    //
 
-namespace detail {
+    namespace detail {
 
-template< class Stream >
-void write_padding( Stream & os, std::streamsize n )
-{
-    for ( std::streamsize i = 0; i < n; ++i )
-        os.rdbuf()->sputc( os.fill() );
-}
+    template <class Stream> void write_padding(Stream &os, std::streamsize n) {
+        for (std::streamsize i = 0; i < n; ++i)
+            os.rdbuf()->sputc(os.fill());
+    }
 
-template< class Stream, class Span >
-Stream & write_to_stream( Stream & os, Span const & spn )
-{
-    typename Stream::sentry sentry( os );
+    template <class Stream, class Span>
+    Stream &write_to_stream(Stream &os, Span const &spn) {
+        typename Stream::sentry sentry(os);
 
-    if ( !os )
-        return os;
+        if (!os)
+            return os;
 
-    const std::streamsize length = narrow<std::streamsize>( spn.length() );
+        const std::streamsize length = narrow<std::streamsize>(spn.length());
 
-    // Whether, and how, to pad
-    const bool pad = ( length < os.width() );
-    const bool left_pad = pad && ( os.flags() & std::ios_base::adjustfield ) == std::ios_base::right;
+        // Whether, and how, to pad
+        const bool pad = (length < os.width());
+        const bool left_pad =
+            pad &&
+            (os.flags() & std::ios_base::adjustfield) == std::ios_base::right;
 
-    if ( left_pad )
-        write_padding( os, os.width() - length );
+        if (left_pad)
+            write_padding(os, os.width() - length);
 
-    // Write span characters
-    os.rdbuf()->sputn( spn.begin(), length );
+        // Write span characters
+        os.rdbuf()->sputn(spn.begin(), length);
 
-    if ( pad && !left_pad )
-        write_padding( os, os.width() - length );
+        if (pad && !left_pad)
+            write_padding(os, os.width() - length);
 
-    // Reset output stream width
-    os.width(0);
+        // Reset output stream width
+        os.width(0);
 
-    return os;
-}
+        return os;
+    }
 
-} // namespace detail
+    } // namespace detail
 
-template< typename Traits >
-std::basic_ostream< char, Traits > & operator<<( std::basic_ostream< char, Traits > & os, string_span const & spn )
-{
-    return detail::write_to_stream( os, spn );
-}
+    template <typename Traits>
+    std::basic_ostream<char, Traits> &operator<<(
+        std::basic_ostream<char, Traits> &os, string_span const &spn) {
+        return detail::write_to_stream(os, spn);
+    }
 
-template< typename Traits >
-std::basic_ostream< char, Traits > & operator<<( std::basic_ostream< char, Traits > & os, cstring_span const & spn )
-{
-    return detail::write_to_stream( os, spn );
-}
+    template <typename Traits>
+    std::basic_ostream<char, Traits> &operator<<(
+        std::basic_ostream<char, Traits> &os, cstring_span const &spn) {
+        return detail::write_to_stream(os, spn);
+    }
 
-#if gsl_HAVE( WCHAR )
+#if gsl_HAVE(WCHAR)
 
-template< typename Traits >
-std::basic_ostream< wchar_t, Traits > & operator<<( std::basic_ostream< wchar_t, Traits > & os, wstring_span const & spn )
-{
-    return detail::write_to_stream( os, spn );
-}
+    template <typename Traits>
+    std::basic_ostream<wchar_t, Traits> &operator<<(
+        std::basic_ostream<wchar_t, Traits> &os, wstring_span const &spn) {
+        return detail::write_to_stream(os, spn);
+    }
 
-template< typename Traits >
-std::basic_ostream< wchar_t, Traits > & operator<<( std::basic_ostream< wchar_t, Traits > & os, cwstring_span const & spn )
-{
-    return detail::write_to_stream( os, spn );
-}
+    template <typename Traits>
+    std::basic_ostream<wchar_t, Traits> &operator<<(
+        std::basic_ostream<wchar_t, Traits> &os, cwstring_span const &spn) {
+        return detail::write_to_stream(os, spn);
+    }
 
 #endif // gsl_HAVE( WCHAR )
 
-//
-// ensure_sentinel()
-//
-// Provides a way to obtain a span from a contiguous sequence
-// that ends with a (non-inclusive) sentinel value.
-//
-// Will fail-fast if sentinel cannot be found before max elements are examined.
-//
-namespace detail {
+    //
+    // ensure_sentinel()
+    //
+    // Provides a way to obtain a span from a contiguous sequence
+    // that ends with a (non-inclusive) sentinel value.
+    //
+    // Will fail-fast if sentinel cannot be found before max elements are
+    // examined.
+    //
+    namespace detail {
 
-template< class T, class SizeType, const T Sentinel >
-gsl_api static span<T> ensure_sentinel( T * seq, SizeType max = (std::numeric_limits<SizeType>::max)() )
-{
-    typedef T * pointer;
+    template <class T, class SizeType, const T Sentinel>
+    gsl_api static span<T>
+    ensure_sentinel(T *seq,
+                    SizeType max = (std::numeric_limits<SizeType>::max)()) {
+        typedef T *pointer;
 
-    gsl_SUPPRESS_MSVC_WARNING( 26429, "f.23: symbol 'cur' is never tested for nullness, it can be marked as not_null" )
-    pointer cur = seq;
+        gsl_SUPPRESS_MSVC_WARNING(
+            26429, "f.23: symbol 'cur' is never tested for nullness, it can be "
+                   "marked as not_null") pointer cur = seq;
 
-    while ( static_cast<SizeType>( cur - seq ) < max && *cur != Sentinel )
-        ++cur;
+        while (static_cast<SizeType>(cur - seq) < max && *cur != Sentinel)
+            ++cur;
 
-    gsl_Expects( *cur == Sentinel );
+        gsl_Expects(*cur == Sentinel);
 
-    return span<T>( seq, narrow_cast< typename span<T>::index_type >( cur - seq ) );
-}
-} // namespace detail
+        return span<T>(seq,
+                       narrow_cast<typename span<T>::index_type>(cur - seq));
+    }
+    } // namespace detail
 
-//
-// ensure_z - creates a string_span for a czstring or cwzstring.
-// Will fail fast if a null-terminator cannot be found before
-// the limit of size_type.
-//
+    //
+    // ensure_z - creates a string_span for a czstring or cwzstring.
+    // Will fail fast if a null-terminator cannot be found before
+    // the limit of size_type.
+    //
 
-template< class T >
-gsl_api inline span<T> ensure_z( T * const & sz, size_t max = (std::numeric_limits<size_t>::max)() )
-{
-    return detail::ensure_sentinel<T, size_t, 0>( sz, max );
-}
+    template <class T>
+    gsl_api inline span<T> ensure_z(
+        T *const &sz, size_t max = (std::numeric_limits<size_t>::max)()) {
+        return detail::ensure_sentinel<T, size_t, 0>(sz, max);
+    }
 
-template< class T, size_t N >
-gsl_api inline span<T> ensure_z( T (&sz)[N] )
-{
-    return ::gsl::ensure_z( gsl_ADDRESSOF( sz[0] ), N );
-}
+    template <class T, size_t N> gsl_api inline span<T> ensure_z(T(&sz)[N]) {
+        return ::gsl::ensure_z(gsl_ADDRESSOF(sz[0]), N);
+    }
 
-# if gsl_HAVE( TYPE_TRAITS )
+#if gsl_HAVE(TYPE_TRAITS)
 
-template< class Container >
-inline span< typename std::remove_pointer<typename Container::pointer>::type >
-ensure_z( Container & cont )
-{
-    return ::gsl::ensure_z( cont.data(), cont.length() );
-}
-# endif
+    template <class Container>
+    inline span<typename std::remove_pointer<typename Container::pointer>::type>
+    ensure_z(Container & cont) {
+        return ::gsl::ensure_z(cont.data(), cont.length());
+    }
+#endif
 
-//
-// basic_zstring_span<> - A view of contiguous null-terminated characters, replace (*,len).
-//
+    //
+    // basic_zstring_span<> - A view of contiguous null-terminated characters,
+    // replace (*,len).
+    //
 
-template <typename T>
-class basic_zstring_span
-{
-public:
-    typedef T element_type;
-    typedef span<T> span_type;
+    template <typename T> class basic_zstring_span {
+      public:
+        typedef T element_type;
+        typedef span<T> span_type;
 
-    typedef typename span_type::index_type index_type;
-    typedef typename span_type::difference_type difference_type;
+        typedef typename span_type::index_type index_type;
+        typedef typename span_type::difference_type difference_type;
 
-    typedef element_type * czstring_type;
-    typedef basic_string_span<element_type> string_span_type;
+        typedef element_type *czstring_type;
+        typedef basic_string_span<element_type> string_span_type;
 
-    gsl_api gsl_constexpr14 basic_zstring_span( span_type s )
-        : span_( s )
-    {
-        // expects a zero-terminated span
-        gsl_Expects( s[s.size() - 1] == '\0');
-    }
+        gsl_api gsl_constexpr14 basic_zstring_span(span_type s) : span_(s) {
+            // expects a zero-terminated span
+            gsl_Expects(s[s.size() - 1] == '\0');
+        }
 
-#if gsl_HAVE( IS_DEFAULT )
-    gsl_constexpr basic_zstring_span( basic_zstring_span const & other ) = default;
-    gsl_constexpr basic_zstring_span( basic_zstring_span &&      other ) = default;
-    gsl_constexpr14 basic_zstring_span & operator=( basic_zstring_span const & other ) = default;
-    gsl_constexpr14 basic_zstring_span & operator=( basic_zstring_span &&      other ) = default;
+#if gsl_HAVE(IS_DEFAULT)
+        gsl_constexpr
+        basic_zstring_span(basic_zstring_span const &other) = default;
+        gsl_constexpr basic_zstring_span(basic_zstring_span &&other) = default;
+        gsl_constexpr14 basic_zstring_span &
+        operator=(basic_zstring_span const &other) = default;
+        gsl_constexpr14 basic_zstring_span &
+        operator=(basic_zstring_span &&other) = default;
 #else
-    gsl_api gsl_constexpr basic_zstring_span( basic_zstring_span const & other) : span_ ( other.span_ ) {}
-    gsl_api gsl_constexpr basic_zstring_span & operator=( basic_zstring_span const & other ) { span_ = other.span_; return *this; }
+        gsl_api gsl_constexpr
+        basic_zstring_span(basic_zstring_span const &other)
+            : span_(other.span_) {}
+        gsl_api gsl_constexpr basic_zstring_span &
+        operator=(basic_zstring_span const &other) {
+            span_ = other.span_;
+            return *this;
+        }
 #endif
 
-    gsl_api gsl_constexpr bool empty() const gsl_noexcept
-    {
-        return span_.size() == 0;
-    }
+        gsl_api gsl_constexpr bool empty() const gsl_noexcept {
+            return span_.size() == 0;
+        }
 
-    gsl_api gsl_constexpr string_span_type as_string_span() const gsl_noexcept
-    {
-        return string_span_type( span_.data(), span_.size() > 1 ? span_.size() - 1 : 0 );
-    }
+        gsl_api gsl_constexpr string_span_type
+        as_string_span() const gsl_noexcept {
+            return string_span_type(span_.data(),
+                                    span_.size() > 1 ? span_.size() - 1 : 0);
+        }
 
-    /*gsl_api*/ // currently disabled due to an apparent NVCC bug
-    gsl_constexpr string_span_type ensure_z() const
-    {
-        return ::gsl::ensure_z(span_.data(), span_.size());
-    }
+        /*gsl_api*/ // currently disabled due to an apparent NVCC bug
+        gsl_constexpr string_span_type ensure_z() const {
+            return ::gsl::ensure_z(span_.data(), span_.size());
+        }
 
-    gsl_api gsl_constexpr czstring_type assume_z() const gsl_noexcept
-    {
-        return span_.data();
-    }
+        gsl_api gsl_constexpr czstring_type assume_z() const gsl_noexcept {
+            return span_.data();
+        }
 
-private:
-    span_type span_;
-};
+      private:
+        span_type span_;
+    };
 
-//
-// zString types:
-//
+    //
+    // zString types:
+    //
 
-typedef basic_zstring_span< char > zstring_span;
-typedef basic_zstring_span< char const > czstring_span;
+    typedef basic_zstring_span<char> zstring_span;
+    typedef basic_zstring_span<char const> czstring_span;
 
-#if gsl_HAVE( WCHAR )
-typedef basic_zstring_span< wchar_t > wzstring_span;
-typedef basic_zstring_span< wchar_t const > cwzstring_span;
+#if gsl_HAVE(WCHAR)
+    typedef basic_zstring_span<wchar_t> wzstring_span;
+    typedef basic_zstring_span<wchar_t const> cwzstring_span;
 #endif
 
 } // namespace gsl
@@ -4020,13 +3939,10 @@ typedef basic_zstring_span< wchar_t const > cwzstring_span;
 
 namespace std {
 
-template<>
-struct hash< ::gsl::byte >
-{
-public:
-    gsl_constexpr std::size_t operator()( ::gsl::byte v ) const gsl_noexcept
-    {
-        return ::gsl::to_integer<std::size_t>( v );
+template <> struct hash<::gsl::byte> {
+  public:
+    gsl_constexpr std::size_t operator()(::gsl::byte v) const gsl_noexcept {
+        return ::gsl::to_integer<std::size_t>(v);
     }
 };
 
@@ -4038,11 +3954,13 @@ struct hash< ::gsl::byte >
 
 // gsl_lite namespace:
 
-// gsl-lite currently keeps all symbols in the namespace `gsl`. The `gsl_lite` namespace contains all the symbols in the
-// `gsl` namespace, plus some extensions that are not specified in the Core Guidelines.
+// gsl-lite currently keeps all symbols in the namespace `gsl`. The `gsl_lite`
+// namespace contains all the symbols in the `gsl` namespace, plus some
+// extensions that are not specified in the Core Guidelines.
 //
-// Going forward, we want to support coexistence of gsl-lite with M-GSL, so we want to encourage using the `gsl_lite`
-// namespace when consuming gsl-lite. Typical use in library code would be:
+// Going forward, we want to support coexistence of gsl-lite with M-GSL, so we
+// want to encourage using the `gsl_lite` namespace when consuming gsl-lite.
+// Typical use in library code would be:
 //
 //     #include <gsl-lite/gsl-lite.hpp> // instead of <gsl/gsl-lite.hpp>
 //
@@ -4054,12 +3972,13 @@ struct hash< ::gsl::byte >
 //         }
 //     } // namespace foo
 //
-// In a future version, the new <gsl-lite/gsl-lite.hpp> header will only define the `gsl_lite` namespace and no
-// unprefixed `Expects()` and `Ensures()` macros to avoid collision with M-GSL. To ensure backward compatibility, the
-// old header <gsl/gsl-lite.hpp> will keep defining the `gsl` namespace and the `Expects()` and `Ensures()` macros.
+// In a future version, the new <gsl-lite/gsl-lite.hpp> header will only define
+// the `gsl_lite` namespace and no unprefixed `Expects()` and `Ensures()` macros
+// to avoid collision with M-GSL. To ensure backward compatibility, the old
+// header <gsl/gsl-lite.hpp> will keep defining the `gsl` namespace and the
+// `Expects()` and `Ensures()` macros.
 
-namespace gsl_lite
-{
+namespace gsl_lite {
 
 namespace std11 = ::gsl::std11;
 namespace std14 = ::gsl::std14;
@@ -4071,10 +3990,10 @@ using namespace std14;
 using namespace std17;
 using namespace std20;
 
-#if gsl_HAVE( SHARED_PTR )
-using std::unique_ptr;
-using std::shared_ptr;
+#if gsl_HAVE(SHARED_PTR)
 using std::make_shared;
+using std::shared_ptr;
+using std::unique_ptr;
 #endif
 
 using ::gsl::index;
@@ -4088,61 +4007,60 @@ typedef gsl_CONFIG_INDEX_TYPE stride;
 // Integer type for pointer, iterator, or index differences.
 typedef gsl_CONFIG_INDEX_TYPE diff;
 
-#if  gsl_HAVE( ALIAS_TEMPLATE )
+#if gsl_HAVE(ALIAS_TEMPLATE)
 using ::gsl::owner;
 #endif
 
 using ::gsl::fail_fast;
 
 using ::gsl::finally;
-#if gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
-using ::gsl::on_return;
+#if gsl_FEATURE(EXPERIMENTAL_RETURN_GUARD)
 using ::gsl::on_error;
+using ::gsl::on_return;
 #endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
 
-using ::gsl::narrow_cast;
-using ::gsl::narrowing_error;
 using ::gsl::narrow;
+using ::gsl::narrow_cast;
 using ::gsl::narrow_failfast;
-
+using ::gsl::narrowing_error;
 
 using ::gsl::at;
 
-using ::gsl::not_null;
 using ::gsl::make_not_null;
+using ::gsl::not_null;
 
 using ::gsl::byte;
 
-using ::gsl::with_container_t;
 using ::gsl::with_container;
+using ::gsl::with_container_t;
 
-using ::gsl::span;
-using ::gsl::make_span;
-using ::gsl::byte_span;
-using ::gsl::copy;
 using ::gsl::as_bytes;
 using ::gsl::as_writable_bytes;
-#if ! gsl_DEPRECATE_TO_LEVEL( 6 )
+using ::gsl::byte_span;
+using ::gsl::copy;
+using ::gsl::make_span;
+using ::gsl::span;
+#if !gsl_DEPRECATE_TO_LEVEL(6)
 using ::gsl::as_writeable_bytes;
 #endif
 
 using ::gsl::basic_string_span;
-using ::gsl::string_span;
 using ::gsl::cstring_span;
+using ::gsl::string_span;
 
 using ::gsl::basic_zstring_span;
-using ::gsl::zstring_span;
 using ::gsl::czstring_span;
+using ::gsl::zstring_span;
 
-using ::gsl::zstring;
 using ::gsl::czstring;
+using ::gsl::zstring;
 
-#if gsl_HAVE( WCHAR )
-using ::gsl::wzstring;
+#if gsl_HAVE(WCHAR)
 using ::gsl::cwzstring;
+using ::gsl::wzstring;
 
-using ::gsl::wzstring_span;
 using ::gsl::cwzstring_span;
+using ::gsl::wzstring_span;
 #endif // gsl_HAVE( WCHAR )
 
 } // namespace gsl_lite
@@ -4153,4 +4071,4 @@ gsl_RESTORE_MSVC_WARNINGS()
 
 #endif // GSL_GSL_LITE_HPP_INCLUDED
 
-// end of file
+    // end of file
diff --git a/modules/cpu/src/runtime/hardware_context.cpp b/modules/cpu/src/runtime/hardware_context.cpp
index d128bb67e5..3fb14685e4 100644
--- a/modules/cpu/src/runtime/hardware_context.cpp
+++ b/modules/cpu/src/runtime/hardware_context.cpp
@@ -5,11 +5,9 @@
 using namespace nncase::runtime::cpu;
 std::unique_ptr<hardware_context_impl> hardware_context::impl_;
 
-class condition_variable
-{
-public:
-    condition_variable()
-    {
+class condition_variable {
+  public:
+    condition_variable() {
         pthread_cond_init(&cond, NULL);
         pthread_mutex_init(&mutex, NULL);
     }
@@ -17,47 +15,37 @@ class condition_variable
     pthread_mutex_t mutex;
     pthread_cond_t cond;
 
-    ~condition_variable()
-    {
+    ~condition_variable() {
         pthread_mutex_destroy(&mutex);
         pthread_cond_destroy(&cond);
     }
 };
 
-struct hardware_context_impl
-{
-public:
-    hardware_context_impl()
-    {
+struct hardware_context_impl {
+  public:
+    hardware_context_impl() {
         global_cond = condition_variable();
         pthread_mutex_init(&global_mutex, NULL);
 
-        for (size_t i = 0; i < BLOCKS; i++)
-        {
+        for (size_t i = 0; i < BLOCKS; i++) {
             pthread_mutex_init(&block_mutexs[i], NULL);
             block_conds[i] = condition_variable();
-            for (size_t j = 0; j < CORES; j++)
-            {
+            for (size_t j = 0; j < CORES; j++) {
                 block_visited[i][j] = false;
                 global_visited[i][j] = false;
             }
         }
     }
 
-    void reset_block_visited(int bid)
-    {
-        for (size_t i = 0; i < CORES; i++)
-        {
+    void reset_block_visited(int bid) {
+        for (size_t i = 0; i < CORES; i++) {
             block_visited[bid][i] = false;
         }
     }
 
-    void reset_global_visited()
-    {
-        for (size_t i = 0; i < BLOCKS; i++)
-        {
-            for (size_t j = 0; j < CORES; j++)
-            {
+    void reset_global_visited() {
+        for (size_t i = 0; i < BLOCKS; i++) {
+            for (size_t j = 0; j < CORES; j++) {
                 global_visited[i][j] = false;
             }
         }
@@ -70,75 +58,60 @@ struct hardware_context_impl
     condition_variable block_conds[BLOCKS];
     bool block_visited[BLOCKS][CORES];
 
-    ~hardware_context_impl()
-    {
+    ~hardware_context_impl() {
         pthread_mutex_destroy(&global_mutex);
-        for (size_t i = 0; i < BLOCKS; i++)
-        {
+        for (size_t i = 0; i < BLOCKS; i++) {
             pthread_mutex_destroy(&block_mutexs[i]);
         }
     }
 };
 
-void hardware_context::init()
-{
+void hardware_context::init() {
     impl_ = std::make_unique<hardware_context_impl>();
 }
 
-void hardware_context::lock_block(int bid)
-{
+void hardware_context::lock_block(int bid) {
     pthread_mutex_lock(&impl_->block_mutexs[bid]);
 }
 
-void hardware_context::unlock_block(int bid)
-{
+void hardware_context::unlock_block(int bid) {
     pthread_mutex_unlock(&impl_->block_mutexs[bid]);
 }
 
-int hardware_context::mark_block_visit(int bid, int tid)
-{
+int hardware_context::mark_block_visit(int bid, int tid) {
     impl_->block_visited[bid][tid] = true;
     int visited = 0;
-    for (size_t i = 0; i < CORES; i++)
-    {
+    for (size_t i = 0; i < CORES; i++) {
         visited += impl_->block_visited[bid][i] == true ? 1 : 0;
     }
     return visited;
 }
 
 void hardware_context::wait_block_sync(int bid, int visited,
-    std::function<void()> callable)
-{
+                                       std::function<void()> callable) {
     pthread_mutex_lock(&impl_->block_conds[bid].mutex);
-    if (visited == CORES)
-    {
+    if (visited == CORES) {
         callable();
         impl_->reset_block_visited(bid);
         pthread_cond_broadcast(&impl_->block_conds[bid].cond);
-    }
-    else
-    {
+    } else {
         pthread_cond_wait(&impl_->block_conds[bid].cond,
-            &impl_->block_conds[bid].mutex);
+                          &impl_->block_conds[bid].mutex);
     }
     pthread_mutex_unlock(&impl_->block_conds[bid].mutex);
 }
 
 void hardware_context::lock_all() { pthread_mutex_lock(&impl_->global_mutex); }
 
-void hardware_context::unlock_all()
-{
+void hardware_context::unlock_all() {
     pthread_mutex_unlock(&impl_->global_mutex);
 }
 
-int hardware_context::mark_all_visit(int bid, int tid)
-{
+int hardware_context::mark_all_visit(int bid, int tid) {
     impl_->global_visited[bid][tid] = true;
     int visited = 0;
-    for (size_t i = 0; i < BLOCKS; i++)
-    {
-        for (size_t j = 0; j < CORES; j++)
-        {
+    for (size_t i = 0; i < BLOCKS; i++) {
+        for (size_t j = 0; j < CORES; j++) {
             visited += impl_->global_visited[i][j] == true ? 1 : 0;
         }
     }
@@ -146,17 +119,13 @@ int hardware_context::mark_all_visit(int bid, int tid)
 }
 
 void hardware_context::wait_all_sync(int visited,
-    std::function<void()> callable)
-{
+                                     std::function<void()> callable) {
     pthread_mutex_lock(&impl_->global_cond.mutex);
-    if (visited == BLOCKS * CORES)
-    {
+    if (visited == BLOCKS * CORES) {
         callable();
         impl_->reset_global_visited();
         pthread_cond_broadcast(&impl_->global_cond.cond);
-    }
-    else
-    {
+    } else {
         pthread_cond_wait(&impl_->global_cond.cond, &impl_->global_cond.mutex);
     }
     pthread_mutex_unlock(&impl_->global_cond.mutex);
diff --git a/modules/cpu/src/runtime/hardware_context.h b/modules/cpu/src/runtime/hardware_context.h
index d217430c57..1882d74080 100644
--- a/modules/cpu/src/runtime/hardware_context.h
+++ b/modules/cpu/src/runtime/hardware_context.h
@@ -7,8 +7,7 @@
 struct hardware_context_impl;
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
-namespace hardware_context
-{
+namespace hardware_context {
 void init();
 
 void lock_block(int bid);
@@ -23,5 +22,5 @@ void wait_all_sync(
     int visited, std::function<void()> callable = []() -> void {});
 
 extern std::unique_ptr<hardware_context_impl> impl_;
-}
+} // namespace hardware_context
 END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/io_utils.h b/modules/cpu/src/runtime/io_utils.h
index 836cd8e73c..6e6ef7c6f5 100644
--- a/modules/cpu/src/runtime/io_utils.h
+++ b/modules/cpu/src/runtime/io_utils.h
@@ -1,7 +1,7 @@
 #pragma once
+#include "gsl-lite.hpp"
 #include <filesystem>
 #include <fstream>
-#include "gsl-lite.hpp"
 #include <vector>
 
 inline std::vector<uint8_t> read_stream(std::istream &stream) {
diff --git a/modules/cpu/src/runtime/method_table_def.h b/modules/cpu/src/runtime/method_table_def.h
index a67f676e67..207352b638 100644
--- a/modules/cpu/src/runtime/method_table_def.h
+++ b/modules/cpu/src/runtime/method_table_def.h
@@ -69,9 +69,9 @@ typedef struct nncase_method_table {
     void *(*thread_end)();
 
     // rvv impl
-    void (*matmul_unit_impl)(const float *input_a, const float *input_b, float *output,
-                      size_t size_m, size_t size_k, size_t size_n, size_t lda,
-                      size_t ldb, size_t ldc);
+    void (*matmul_unit_impl)(const float *input_a, const float *input_b,
+                             float *output, size_t size_m, size_t size_k,
+                             size_t size_n, size_t lda, size_t ldb, size_t ldc);
 } nncase_mt_t;
 
 typedef struct buffer {
diff --git a/modules/cpu/src/runtime/runtime_utils.h b/modules/cpu/src/runtime/runtime_utils.h
index 70b62857e3..7865c4f4fc 100644
--- a/modules/cpu/src/runtime/runtime_utils.h
+++ b/modules/cpu/src/runtime/runtime_utils.h
@@ -1,35 +1,29 @@
 #pragma once
 
+#include "gsl-lite.hpp"
 #include <array>
 #include <cassert>
 #include <cmath>
 #include <cstddef>
-#include "gsl-lite.hpp"
 #include <iostream>
 #include <linux/limits.h>
+#include <nncase/runtime/cpu/compiler_defs.h>
 #include <numeric>
 #include <vector>
-#include <nncase/runtime/cpu/compiler_defs.h>
-
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
-inline void create_thread(pthread_t &pt, void *param_, void *(*call)(void *))
-{
+inline void create_thread(pthread_t &pt, void *param_, void *(*call)(void *)) {
     void *(*new_call)(void *) = call; // + (intptr_t)buf;
     int ret = pthread_create(&pt, NULL, new_call, param_);
-    if (ret != 0)
-    {
+    if (ret != 0) {
         printf("thread create failed\n");
     }
 }
 
-inline void join_thread(pthread_t &pt)
-{
-    pthread_join(pt, NULL);
-}
+inline void join_thread(pthread_t &pt) { pthread_join(pt, NULL); }
 
-inline void rt_assert([[maybe_unused]] bool condition, [[maybe_unused]] char *message)
-{
+inline void rt_assert([[maybe_unused]] bool condition,
+                      [[maybe_unused]] char *message) {
     assert(condition && message);
 }
 END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/shared_memory.h b/modules/cpu/src/runtime/shared_memory.h
index 6663d8e675..3d20b85426 100644
--- a/modules/cpu/src/runtime/shared_memory.h
+++ b/modules/cpu/src/runtime/shared_memory.h
@@ -13,9 +13,9 @@
  * limitations under the License.
  */
 #pragma once
+#include "gsl-lite.hpp"
 #include <filesystem>
 #include <nncase/runtime/cpu/compiler_defs.h>
-#include "gsl-lite.hpp"
 
 #ifdef WIN32
 #include <Windows.h>
diff --git a/tests/onnx_test_runner.py b/tests/onnx_test_runner.py
index 06fb2e0483..97be07a2fd 100644
--- a/tests/onnx_test_runner.py
+++ b/tests/onnx_test_runner.py
@@ -46,11 +46,12 @@ def run(self, model_file):
         if self.case_dir != os.path.dirname(model_file):
             new_file = os.path.join(self.case_dir, 'test.onnx')
             shutil.copy(model_file, new_file)
-            for tensor in external_data_helper._get_all_tensors(onnx.load(model_file, load_external_data = False)):
+            for tensor in external_data_helper._get_all_tensors(onnx.load(model_file, load_external_data=False)):
                 if external_data_helper.uses_external_data(tensor):
                     info = external_data_helper.ExternalDataInfo(tensor)
                     file_location = external_data_helper._sanitize_path(info.location)
-                    external_data_file_path = os.path.join(os.path.dirname(model_file), file_location)
+                    external_data_file_path = os.path.join(
+                        os.path.dirname(model_file), file_location)
                     shutil.copy(external_data_file_path, self.case_dir)
             model_file = new_file
 

From b3a3b31557115888ea948913cd905059ba398745 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 19 Sep 2023 15:23:46 +0800
Subject: [PATCH 194/308] fix build

---
 modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs |  7 ++++---
 .../Nncase.Modules.CPU/CodeGen/LinkableFunction.cs    |  6 +++---
 modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs  | 11 ++++++-----
 modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs    |  4 ++--
 modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs   | 11 +++++------
 src/Nncase.Importer/Onnx/OnnxImporter.cs              |  1 +
 src/Nncase.Passes/Rules/ShapeExpr/GatherToGetItem.cs  |  6 +++---
 7 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
index d1f55bc233..916435759f 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
@@ -15,7 +15,7 @@ namespace Nncase.CodeGen.CPU;
 internal class FunctionBuilder : IDisposable
 {
     private readonly uint _id;
-    private readonly MemoryStream _textContent = new MemoryStream();
+    private readonly SectionManager _sectionManager;
     private readonly BinaryWriter _textWriter;
     private readonly BinaryWriter _rdataWriter;
 
@@ -59,7 +59,8 @@ private unsafe struct DescHeader
     public FunctionBuilder(uint id, BinaryWriter rdataWriter)
     {
         _id = id;
-        _textWriter = new BinaryWriter(_textContent, Encoding.UTF8, leaveOpen: true);
+        _sectionManager = new();
+        _textWriter = _sectionManager.GetWriter(WellknownSectionNames.Text);
         _rdataWriter = rdataWriter;
     }
 
@@ -84,7 +85,7 @@ public unsafe LinkableFunction Build(TIR.PrimFunction function)
             _rdataWriter.Write(bytes);
         }
 
-        return new LinkableFunction(_id, function, functionCSource);
+        return new LinkableFunction(_id, function, functionCSource, _sectionManager.GetContent(WellknownSectionNames.Text));
     }
 
     public void Dispose()
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
index d1934086f2..5f51530941 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
@@ -8,13 +8,13 @@ namespace Nncase.CodeGen.CPU;
 
 internal sealed class LinkableFunction : ILinkableFunction
 {
-    public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, FunctionCSource funcCSource)
+    public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, FunctionCSource funcCSource, Stream text)
     {
         Id = id;
         SourceFunction = sourceFunction;
         PrimFunction = sourceFunction;
         FunctionCSource = funcCSource;
-        Text = Array.Empty<byte>();
+        Text = text;
         Sections = Array.Empty<ILinkedSection>();
     }
 
@@ -26,7 +26,7 @@ public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, FunctionCSourc
 
     public FunctionCSource FunctionCSource { get; }
 
-    public byte[] Text { get; }
+    public Stream Text { get; }
 
     public IEnumerable<FunctionRef> FunctionRefs => Enumerable.Empty<FunctionRef>();
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
index c6121cba2b..3abd00897a 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
@@ -16,12 +16,12 @@ internal sealed class LinkableModule : ILinkableModule
 {
     private const int _textAlignment = 8;
 
-    private readonly byte[] _rdata;
+    private readonly Stream _rdata;
 
     private readonly IReadOnlyList<LinkableFunction> _functions;
     private readonly CompileOptions _options;
 
-    public LinkableModule(byte[] rdata, IReadOnlyList<LinkableFunction> functions, CompileOptions options)
+    public LinkableModule(Stream rdata, IReadOnlyList<LinkableFunction> functions, CompileOptions options)
     {
         _rdata = rdata;
         _functions = functions;
@@ -96,7 +96,8 @@ public ILinkedModule Link(ILinkContext linkContext)
             // }
         }
 
-        var text = new List<byte>();
+        var manager = new SectionManager();
+        var textWriter = manager.GetWriter(WellknownSectionNames.Text);
         var linkedFunctions = new List<LinkedFunction>();
         int offset = 0;
         foreach (var func in _functions)
@@ -105,12 +106,12 @@ public ILinkedModule Link(ILinkContext linkContext)
             var elfPath = CompileCSource(dumpPath);
 
             var func_text = File.ReadAllBytes(elfPath);
-            text.AddRange(func_text);
+            textWriter.Write(func_text);
             linkedFunctions.Add(new LinkedFunction(func.Id, func.SourceFunction, (uint)offset, (uint)func_text.Length, func.Sections));
             offset += func_text.Length;
         }
 
-        return new LinkedModule(linkedFunctions, text.ToArray(), _rdata);
+        return new LinkedModule(linkedFunctions, manager.GetContent(WellknownSectionNames.Text)!, _rdata);
     }
 
     // private string LinkCSources()
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
index c32350936f..ddda156d4b 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
@@ -12,10 +12,10 @@ namespace Nncase.CodeGen.CPU;
 
 internal sealed class LinkedModule : ILinkedModule
 {
-    public LinkedModule(IReadOnlyList<ILinkedFunction> functions, byte[] text, byte[] rdata)
+    public LinkedModule(IReadOnlyList<ILinkedFunction> functions, Stream text, Stream rdata)
     {
         Functions = functions;
-        Sections = new[] { new LinkedSection(text, ".text", 0, 8, (uint)text.Length), new LinkedSection(rdata, ".rdata", 0, 8, (uint)rdata.Length) };
+        Sections = new[] { new LinkedSection(text, WellknownSectionNames.Text, 0, 8, (uint)text.Length), new LinkedSection(rdata, WellknownSectionNames.Rdata, 0, 8, (uint)rdata.Length) };
     }
 
     public string ModuleKind => Targets.CPUTarget.Kind;
diff --git a/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
index 36dd625463..46bda204cb 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
@@ -10,14 +10,15 @@ namespace Nncase.CodeGen.CPU;
 /// <summary>
 /// K230CoreModule builder.
 /// </summary>
-public sealed class ModuleBuilder : IModuleBuilder, IDisposable
+public sealed class ModuleBuilder : IModuleBuilder
 {
-    private readonly MemoryStream _rdataContent = new MemoryStream();
+    private readonly SectionManager _sectionManager;
     private readonly BinaryWriter _rdataWriter;
 
     public ModuleBuilder(CompileOptions options)
     {
-        _rdataWriter = new BinaryWriter(_rdataContent, Encoding.UTF8, leaveOpen: true);
+        _sectionManager = new();
+        _rdataWriter = _sectionManager.GetWriter(WellknownSectionNames.Rdata);
         CompileOptions = options;
     }
 
@@ -32,8 +33,6 @@ public ILinkableModule Build(IReadOnlyList<BaseFunction> functions)
         var linkableFunctions = functions.OfType<TIR.PrimFunction>().Select((f, i) => new FunctionBuilder((uint)i, _rdataWriter).Build(f)).ToArray();
         _rdataWriter.Flush();
 
-        return new LinkableModule(_rdataContent.ToArray(), linkableFunctions, CompileOptions);
+        return new LinkableModule(_sectionManager.GetContent(WellknownSectionNames.Rdata)!, linkableFunctions, CompileOptions);
     }
-
-    public void Dispose() => ((IDisposable)_rdataContent).Dispose();
 }
diff --git a/src/Nncase.Importer/Onnx/OnnxImporter.cs b/src/Nncase.Importer/Onnx/OnnxImporter.cs
index 3004d86822..d9e8c2d14d 100644
--- a/src/Nncase.Importer/Onnx/OnnxImporter.cs
+++ b/src/Nncase.Importer/Onnx/OnnxImporter.cs
@@ -52,6 +52,7 @@ protected override (IEnumerable<Var> Inputs, Dictionary<Var, Expr[]> VarMap) Cre
     {
         var bucketOptions = CompileSession.CompileOptions.ShapeBucketOptions;
         _fixVarMap = bucketOptions.FixVarMap;
+        _fixVarMap.Add("N", 384);
 
         _constTensors = _graph.Initializer
             .ToDictionary(tensor => tensor.Name, tensor => tensor);
diff --git a/src/Nncase.Passes/Rules/ShapeExpr/GatherToGetItem.cs b/src/Nncase.Passes/Rules/ShapeExpr/GatherToGetItem.cs
index 2a1453f3c9..c2273e5f31 100644
--- a/src/Nncase.Passes/Rules/ShapeExpr/GatherToGetItem.cs
+++ b/src/Nncase.Passes/Rules/ShapeExpr/GatherToGetItem.cs
@@ -14,10 +14,10 @@ namespace Nncase.Passes.Rules.ShapeExpr;
 public sealed partial class GatherToGetItem : RewriteRule<Pattern>
 {
     // (Gather(input, 0, 0) -> GetItem(input)
-    public override Pattern Pattern => IsGather(
-        IsWildcard("input"), IsTensorConst("axis"), IsTensorConst("index") with { TypePattern = IsScalar() });
+    public override Pattern Pattern => IsGather("gather", 0,
+        IsWildcard("input"), IsTensorConst("index") with { TypePattern = IsScalar() });
 
-    private Expr? GetReplace(Expr input, int axis, int index)
+    private Expr? GetReplace(Expr input, int index)
     {
         return input[index];
     }

From 4a806d7628570a5a2f56f1f7038c66b39b01191d Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Tue, 19 Sep 2023 07:26:32 +0000
Subject: [PATCH 195/308] Apply code-format changes

---
 modules/cpu/src/runtime/gsl-lite.hpp | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/modules/cpu/src/runtime/gsl-lite.hpp b/modules/cpu/src/runtime/gsl-lite.hpp
index 084210f03f..bcddfb1832 100644
--- a/modules/cpu/src/runtime/gsl-lite.hpp
+++ b/modules/cpu/src/runtime/gsl-lite.hpp
@@ -733,9 +733,11 @@
 
 #if gsl_HAVE(TYPE_TRAITS)
 #include <type_traits> // for enable_if<>,
-    // add_const<>, add_pointer<>, common_type<>, make_signed<>, remove_cv<>, remove_const<>, remove_volatile<>, remove_reference<>, remove_cvref<>, remove_pointer<>, underlying_type<>,
-    // is_assignable<>, is_constructible<>, is_const<>, is_convertible<>, is_integral<>, is_pointer<>, is_signed<>,
-    // integral_constant<>, declval()
+// add_const<>, add_pointer<>, common_type<>, make_signed<>, remove_cv<>,
+// remove_const<>, remove_volatile<>, remove_reference<>, remove_cvref<>,
+// remove_pointer<>, underlying_type<>, is_assignable<>, is_constructible<>,
+// is_const<>, is_convertible<>, is_integral<>, is_pointer<>, is_signed<>,
+// integral_constant<>, declval()
 #elif gsl_HAVE(TR1_TYPE_TRAITS)
 #include <tr1/type_traits> // for add_const<>, remove_cv<>, remove_const<>, remove_volatile<>, remove_reference<>, integral_constant<>
 #endif
@@ -1975,9 +1977,9 @@ gsl_DISABLE_MSVC_WARNINGS(
        // DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN(
        // gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN(
        // gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-        // If type_traits are not available, then we can't distinguish
-        // `is_convertible<>` and `is_constructible<>`, so we unconditionally
-        // permit implicit construction.
+       // If type_traits are not available, then we can't distinguish
+       // `is_convertible<>` and `is_constructible<>`, so we unconditionally
+       // permit implicit construction.
         template <class U>
         gsl_constexpr14 not_null(U other) : data_(T(std::move(other))) {
             gsl_Expects(data_.ptr_ != gsl_nullptr);
@@ -2027,9 +2029,9 @@ gsl_DISABLE_MSVC_WARNINGS(
        // DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN(
        // gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN(
        // gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-        // If type_traits are not available, then we can't distinguish
-        // `is_convertible<>` and `is_constructible<>`, so we unconditionally
-        // permit implicit construction.
+       // If type_traits are not available, then we can't distinguish
+       // `is_convertible<>` and `is_constructible<>`, so we unconditionally
+       // permit implicit construction.
         template <class U>
         gsl_constexpr14 not_null(not_null<U> other)
             : data_(T(std::move(other.data_.ptr_))) {

From 43e00ae28ce3d5b934cc7cd89ba652dfab3f44c9 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 19 Sep 2023 18:45:01 +0800
Subject: [PATCH 196/308] add codegen of transpose

---
 .../CodeGen/CSourceConvertVisitor.cs          |  3 ++
 .../Evaluator/XPU/Transpose.cs                | 15 ++++++
 .../Evaluator/XPU/XPUModule.cs                |  1 +
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  5 ++
 .../Nncase.Modules.CPU/IR/XPU/Transpose.cs    | 13 +++++
 .../Passes/Tile/SingleCPUFusionConverter.cs   |  8 ++++
 src/Nncase.Core/IR/Tensors/Transpose.cs       |  2 +-
 src/Nncase.Evaluator/Tensors/Transpose.cs     | 47 +++++++++++++++++--
 .../Targets/UnitTestCPUTargetTiling.cs        | 31 +++++++++++-
 9 files changed, 119 insertions(+), 6 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Transpose.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Transpose.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index caf9fdede0..c800c19584 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -340,6 +340,9 @@ protected override CSymbol VisitCall(Call expr)
                 case IR.XPU.Softmax softmax:
                     IndentScope.Writer.Write($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {softmax.Axis})");
                     break;
+                case IR.XPU.Transpose transpose:
+                    IndentScope.Writer.Write($"transpose({Visit(args[0]).Name}, {Visit(args[1]).Name}, {{{string.Join(",", transpose.Perm.Select(p => p.ToString()))}}})");
+                    break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
             }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Transpose.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Transpose.cs
new file mode 100644
index 0000000000..cf74d2698b
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Transpose.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class TransposeEvaluator : ITypeInferencer<Transpose>
+{
+    public IRType Visit(ITypeInferenceContext context, Transpose target)
+    {
+        return TupleType.Void;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 44f4616018..04b5e62101 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -25,5 +25,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<ConcatEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<SliceEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<SoftmaxEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<TransposeEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 4cdbdb3aea..d16259a692 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -58,4 +58,9 @@ public static Call Softmax(int axis, Expr input, Expr output)
     {
         return new Call(new IR.XPU.Softmax(axis), input, output);
     }
+
+    public static Call Transpose(int[] perm, Expr input, Expr output)
+    {
+        return new Call(new IR.XPU.Transpose(perm), input, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Transpose.cs b/modules/Nncase.Modules.CPU/IR/XPU/Transpose.cs
new file mode 100644
index 0000000000..48e26d5f69
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Transpose.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Transpose : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(Transpose), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(Transpose), 1, "output");
+
+    public IRArray<int> Perm { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 74aa5a8330..2fc362afa4 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -280,6 +280,9 @@ protected override Unit VisitLeafCall(Call expr)
                         case Softmax softmax:
                             GenerateSoftmax(softmax, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), arguments, ret);
                             break;
+                        case Transpose transpose:
+                            GenerateTranspose(transpose, ((TensorConst)expr.Arguments[1]).Value.ToArray<int>(), arguments, ret);
+                            break;
                         default:
                             throw new NotSupportedException();
                     }
@@ -357,6 +360,11 @@ private void GenerateSoftmax(Softmax softmax, int axis, Buffer[] arguments, Buff
             _mainBody.Add(IR.F.XPU.Softmax(axis, arguments[0], ret));
         }
 
+        private void GenerateTranspose(Transpose transpose, int[] perm, Buffer[] arguments, Buffer ret)
+        {
+            _mainBody.Add(IR.F.XPU.Transpose(perm, arguments[0], ret));
+        }
+
 #if false
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
diff --git a/src/Nncase.Core/IR/Tensors/Transpose.cs b/src/Nncase.Core/IR/Tensors/Transpose.cs
index 896d279c29..211dda9a54 100644
--- a/src/Nncase.Core/IR/Tensors/Transpose.cs
+++ b/src/Nncase.Core/IR/Tensors/Transpose.cs
@@ -15,7 +15,7 @@ public sealed partial class Transpose : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Transpose), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Transpose), 0, "input", ParameterKind.Input);
 
     /// <summary>
     /// Gets perm.
diff --git a/src/Nncase.Evaluator/Tensors/Transpose.cs b/src/Nncase.Evaluator/Tensors/Transpose.cs
index 77e74d07f1..350133289b 100644
--- a/src/Nncase.Evaluator/Tensors/Transpose.cs
+++ b/src/Nncase.Evaluator/Tensors/Transpose.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using DryIoc.ImTools;
 using Nncase.CostModel;
 using Nncase.IR;
 using Nncase.IR.Tensors;
@@ -64,15 +65,21 @@ public IValue Visit(IEvaluateContext context, Transpose tr)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Transpose target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Transpose.Input);
-        return Visit(context, target, input);
+        var input = context.CheckArgumentType<IRType>(target, Transpose.Input);
+
+        return input switch
+        {
+            DistributedType d => Visit(context, target, d),
+            TensorType t => Visit(context, target, t),
+            _ => new InvalidType(input.GetType().ToString()),
+        };
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Transpose target)
     {
-        var inputType = context.GetArgumentType<TensorType>(target, Transpose.Input);
-        var outputType = context.GetReturnType<TensorType>();
+        var inputType = context.GetArgumentType<IRType>(target, Transpose.Input);
+        var outputType = context.GetReturnType<IRType>();
 
         return new()
         {
@@ -102,4 +109,36 @@ private IRType Visit(ITypeInferenceContext context, Transpose target, TensorType
         var permExpr = context.GetArgument(target, Transpose.Perm);
         return TypeInference.TransposeType(input, permExpr);
     }
+
+    private IRType Visit(ITypeInferenceContext context, Transpose target, DistributedType input)
+    {
+        if (Visit(context, target, input.TensorType) is not TensorType tensorType)
+        {
+            throw new InvalidOperationException();
+        }
+
+        var permExpr = context.GetArgument(target, Transpose.Perm);
+        if (permExpr is TensorConst permValue)
+        {
+            var perm = permValue.Value.ToArray<int>();
+            var ndsbp = new SBP[input.Placement.Rank];
+
+            for (int i = 0; i < input.Placement.Rank; i++)
+            {
+                switch (input.NdSBP[i])
+                {
+                    case SBPSplit { Axis: int ix }:
+                        ndsbp[i] = SBP.S(perm.IndexOf(ix));
+                        break;
+                    default:
+                        ndsbp[i] = input.NdSBP[i];
+                        break;
+                }
+            }
+
+            return new DistributedType(tensorType, ndsbp, input.Placement);
+        }
+
+        return new InvalidType(input.ToString());
+    }
 }
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index d0005a6ff8..a188825ea5 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -44,7 +44,8 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseGather))]
     // [ClassData(typeof(TilingCaseSoftmax))]
     // [ClassData(typeof(TilingCaseSlice))]
-    [ClassData(typeof(TilingCaseConcat))]
+    [ClassData(typeof(TilingCaseTranspose))]
+    // [ClassData(typeof(TilingCaseConcat))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -431,3 +432,31 @@ public TilingCaseSoftmax()
         Add(main, new[] { input_tensor, output });
     }
 }
+
+internal sealed class TilingCaseTranspose : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseTranspose()
+    {
+        var shape = new[] { 1, 1, 64, 128 };
+        var in_a = new Var("in_a", new TensorType(DataTypes.Float32, shape));
+        var perm = new[] { 0, 2, 3, 1 };
+
+        Fusion fusion;
+        Var fin_a;
+        {
+            fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, shape));
+            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Transpose()), fin_a, perm);
+            fusion = new Fusion("cpu", v1, fin_a);
+        }
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin_a, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        var main = new Function("transpose", new Call(fusion, in_a), new[] { in_a });
+        Add(main, new[] { input_tensor, output });
+    }
+}

From 2581225d480898ecf8da61b3f0a734151920ba22 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 19 Sep 2023 20:04:36 +0800
Subject: [PATCH 197/308] add reshape

---
 .../CodeGen/CSourceConvertVisitor.cs          | 25 +++++-
 .../Evaluator/XPU/ReShape.cs                  | 12 +++
 .../Evaluator/XPU/TDMALoad.cs                 |  2 +-
 .../Evaluator/XPU/TDMAStore.cs                |  2 +-
 .../Evaluator/XPU/XPUModule.cs                |  1 +
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   | 10 ++-
 modules/Nncase.Modules.CPU/IR/XPU/ReShape.cs  | 11 +++
 .../Passes/Rules/MHAFusion.cs                 |  8 +-
 .../Passes/Tile/SingleCPUFusionConverter.cs   | 42 +++++++--
 src/Nncase.Compiler/Compiler.cs               |  1 +
 src/Nncase.Core/IR/Tensors/Concat.cs          |  3 +
 src/Nncase.Core/IR/Tensors/Gather.cs          |  3 +
 src/Nncase.Core/IR/Tensors/Reshape.cs         |  2 +-
 src/Nncase.Evaluator/Tensors/Boxing.cs        |  7 ++
 src/Nncase.Evaluator/Tensors/Reshape.cs       | 86 ++++++++++++++++++-
 src/Nncase.Importer/Onnx/OnnxImporter.cs      |  2 +-
 .../Rules/ShapeExpr/GatherToGetItem.cs        |  3 +-
 .../Targets/UnitTestCPUTargetTiling.cs        | 59 ++++++++++++-
 18 files changed, 255 insertions(+), 24 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/ReShape.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/ReShape.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index c800c19584..a179c5f1cc 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -242,10 +242,28 @@ protected override CSymbol VisitCall(Call expr)
             switch (xpuOp)
             {
                 case IR.XPU.TDMALoad load:
-                    IndentScope.Writer.Write($"tdma_load_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{((TensorType)args[0].CheckedType).ToSlicing(load.NdSbp, load.Placement)})");
+                    if (args.Length == 1)
+                    {
+                        var tensorType = (TensorType)args[0].CheckedType;
+                        IndentScope.Writer.Write($"tdma_boxing_load_sync({Visit(args[0]).Name}, {{{string.Join(',', tensorType.Shape)}}}, {tensorType.ToSlicing(load.NdSbp, load.Placement)[1..^1]})");
+                    }
+                    else
+                    {
+                        IndentScope.Writer.Write($"tdma_load_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{((TensorType)args[0].CheckedType).ToSlicing(load.NdSbp, load.Placement)})");
+                    }
+
                     break;
                 case IR.XPU.TDMAStore store:
-                    IndentScope.Writer.Write($"tdma_store_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{((TensorType)args[0].CheckedType).ToSlicing(store.NdSbp, store.Placement)})");
+                    if (args.Length == 1)
+                    {
+                        var tensorType = (TensorType)args[0].CheckedType;
+                        IndentScope.Writer.Write($"tdma_boxing_store_sync({Visit(args[0]).Name}, {{{string.Join(',', tensorType.Shape)}}}, {tensorType.ToSlicing(store.NdSbp, store.Placement)[1..^1]})");
+                    }
+                    else
+                    {
+                        IndentScope.Writer.Write($"tdma_store_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{((TensorType)args[0].CheckedType).ToSlicing(store.NdSbp, store.Placement)})");
+                    }
+
                     break;
                 case IR.XPU.Unary unary:
                     IndentScope.Writer.Write($"unary({Visit(args[0]).Name}, {Visit(args[1]).Name}, unary_op_t::{unary.UnaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
@@ -343,6 +361,9 @@ protected override CSymbol VisitCall(Call expr)
                 case IR.XPU.Transpose transpose:
                     IndentScope.Writer.Write($"transpose({Visit(args[0]).Name}, {Visit(args[1]).Name}, {{{string.Join(",", transpose.Perm.Select(p => p.ToString()))}}})");
                     break;
+                case IR.XPU.ReShape reshape:
+                    IndentScope.Writer.Write($"__tensor_copy_sync(std::move({Visit(args[1]).Name}),std::move(view({Visit(args[0]).Name},{{{args[1].CheckedShape.ToString()[1..^1]}}})))");
+                    break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
             }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/ReShape.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/ReShape.cs
new file mode 100644
index 0000000000..826d95257e
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/ReShape.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class ReShapeEvaluator : ITypeInferencer<ReShape>
+{
+    public IRType Visit(ITypeInferenceContext context, ReShape target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs
index e97789d522..d432fd678e 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs
@@ -11,7 +11,7 @@ public class TDMALoadEvaluator : ITypeInferencer<TDMALoad>
     public IRType Visit(ITypeInferenceContext context, TDMALoad target)
     {
         _ = context.CheckArgumentType<TensorType>(target, TDMALoad.Dest);
-        _ = context.CheckArgumentType<TensorType>(target, TDMALoad.Src);
+        _ = context.CheckArgumentType<IRType>(target, TDMALoad.Src);
         return TupleType.Void;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs
index 027aa2a88f..af78b1e0e0 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs
@@ -11,7 +11,7 @@ public sealed class TDMAStoreEvaluator : ITypeInferencer<TDMAStore>
     public IRType Visit(ITypeInferenceContext context, TDMAStore target)
     {
         _ = context.CheckArgumentType<TensorType>(target, TDMAStore.Src);
-        _ = context.CheckArgumentType<TensorType>(target, TDMAStore.Dest);
+        _ = context.CheckArgumentType<IRType>(target, TDMAStore.Dest);
         return TupleType.Void;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 04b5e62101..ff790c9ac9 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -26,5 +26,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<SliceEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<SoftmaxEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<TransposeEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<ReShapeEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index d16259a692..d6c7f748bf 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -52,7 +52,10 @@ public static Call Concat(int axis, Expr[] inputs, Expr output)
         return new Call(new Concat(axis), inputs.Concat(new[] { output }).ToArray());
     }
 
-    public static Expr Slice(TIR.Buffer input, TIR.Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType) => new Call(new Slice(distributedType), input, output, begins, ends, axes);
+    public static Expr Slice(TIR.Buffer input, TIR.Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType)
+    {
+        return new Call(new Slice(distributedType), input, output, begins, ends, axes);
+    }
 
     public static Call Softmax(int axis, Expr input, Expr output)
     {
@@ -63,4 +66,9 @@ public static Call Transpose(int[] perm, Expr input, Expr output)
     {
         return new Call(new IR.XPU.Transpose(perm), input, output);
     }
+
+    public static Call ReShape(Expr input, Expr output)
+    {
+        return new Call(new IR.XPU.ReShape(), input, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/ReShape.cs b/modules/Nncase.Modules.CPU/IR/XPU/ReShape.cs
new file mode 100644
index 0000000000..92d6a585ad
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/ReShape.cs
@@ -0,0 +1,11 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class ReShape : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(ReShape), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(ReShape), 1, "output");
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index 68d073b8c0..c9fbef25b2 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -140,7 +140,7 @@ private static Pattern CreatePattern()
         var v9 = IsTensorConst("v9");
         var v10 = IsWildcard("position_ids");
 
-        var v11 = IsCall("v11", IsOp<Gather>(), IsVArgs(v8, v9, v10));
+        var v11 = IsCall("v11", IsOp<Gather>(_ => true), IsVArgs(v8, v10));
         var v12 = IsTensorConst("v12");
         var v13 = IsCall("v13", IsOp<Reshape>(), IsVArgs(v11, v12));
         var v14 = IsCall("v14", IsOp<Binary>(), IsVArgs(v7, v13));
@@ -155,9 +155,9 @@ private static Pattern CreatePattern()
         var v23 = IsTuple("v23", IsVArgs(v20, v22));
 
         var v24 = IsTensorConst("v24");
-        var v25 = IsCall("v25", IsOp<Concat>(), IsVArgs(v23, v24));
+        var v25 = IsCall("v25", IsOp<Concat>(_ => true), IsVArgs(v23));
         var v26 = IsTensorConst("v26");
-        var v27 = IsCall("v27", IsOp<Gather>(), IsVArgs(v26, v9, v10));
+        var v27 = IsCall("v27", IsOp<Gather>(_ => true), IsVArgs(v26, v10));
         var v28 = IsCall("v28", IsOp<Reshape>(), IsVArgs(v27, v12));
         var v29 = IsCall("v29", IsOp<Binary>(), IsVArgs(v25, v28));
         var v30 = IsCall("v30", IsOp<Binary>(), IsVArgs(v14, v29));
@@ -171,7 +171,7 @@ private static Pattern CreatePattern()
         var v38 = IsCall("v38", IsOp<Slice>(), IsVArgs(v34, v21, v15, v17, v18));
         var v39 = IsTuple("v39", IsVArgs(v37, v38));
 
-        var v40 = IsCall("v40", IsOp<Concat>(), IsVArgs(v39, v24));
+        var v40 = IsCall("v40", IsOp<Concat>(_ => true), IsVArgs(v39));
         var v41 = IsCall("v41", IsOp<Binary>(), IsVArgs(v40, v28));
         var v42 = IsCall("v42", IsOp<Binary>(), IsVArgs(v35, v41));
         var v43 = IsTensorConst("v43");
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 2fc362afa4..37468e2031 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -203,16 +203,29 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
             calls.Add((valid, call));
             if (!valid)
             {
-                var broadcastArgs = args.Zip(target.Parameters).Select(t => t.Second.ParameterKind == ParameterKind.Input ? DistributedUtility.GetPartialCandidateBoxings(t.First) : Array.Empty<Expr>()).ToArray();
-
-                if (!broadcastArgs.All(bargs => bargs.Count == 0))
+                if (target is CPUKernelOp { Target: Op })
                 {
-                    calls.AddRange(broadcastArgs.Select((bargs, i) => bargs.Any() ? bargs : bargs.Concat(new[] { args[i] })).
-                        CartesianProduct().
-                        Select(bargs => bargs.ToArray()).
-                        Select(bargs => new Call(target, bargs)).
+                    // the reshape need force boxing.
+                    var newShape = ((TensorConst)args[1]).Value.ToArray<int>();
+                    var inType = (DistributedType)args[0].CheckedType;
+                    var tensorType = inType.TensorType with { Shape = newShape };
+                    calls.AddRange(DistributedUtility.GetLeafCandidateNDSBPs(tensorType, inType.Placement).
+                        Select(ndsbp => IR.F.Tensors.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))).
                         Select(c => (c.InferenceType(), c)));
                 }
+                else
+                {
+                    var broadcastArgs = args.Zip(target.Parameters).Select(t => t.Second.ParameterKind == ParameterKind.Input ? DistributedUtility.GetPartialCandidateBoxings(t.First) : Array.Empty<Expr>()).ToArray();
+
+                    if (!broadcastArgs.All(bargs => bargs.Count == 0))
+                    {
+                        calls.AddRange(broadcastArgs.Select((bargs, i) => bargs.Any() ? bargs : bargs.Concat(new[] { args[i] })).
+                            CartesianProduct().
+                            Select(bargs => bargs.ToArray()).
+                            Select(bargs => new Call(target, bargs)).
+                            Select(c => (c.InferenceType(), c)));
+                    }
+                }
             }
 
             return calls;
@@ -283,6 +296,9 @@ protected override Unit VisitLeafCall(Call expr)
                         case Transpose transpose:
                             GenerateTranspose(transpose, ((TensorConst)expr.Arguments[1]).Value.ToArray<int>(), arguments, ret);
                             break;
+                        case Reshape reshape:
+                            GenerateReshape(reshape, arguments[0], ret);
+                            break;
                         default:
                             throw new NotSupportedException();
                     }
@@ -298,6 +314,11 @@ protected override Unit VisitLeafCall(Call expr)
             return default;
         }
 
+        private void GenerateReshape(Reshape reshape, Buffer input, Buffer ret)
+        {
+            _mainBody.Add(IR.F.XPU.ReShape(input, ret));
+        }
+
         private void GenerateConcat(Concat concat, Buffer[] inputs, Buffer ret)
         {
             _mainBody.Add(IR.F.XPU.Concat(concat.Axis, inputs, ret));
@@ -323,6 +344,13 @@ private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call
                         _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSBP, distTensorType.Placement));
                     }
 
+                    break;
+                case (DistributedType inType, DistributedType outType):
+                    {
+                        _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], None.Default, inType.NdSBP, inType.Placement));
+                        _mainBody.Add(IR.F.XPU.TDMALoad(ret, None.Default, outType.NdSBP, outType.Placement));
+                    }
+
                     break;
                 default:
                     throw new NotSupportedException();
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index d1e1751815..53ca97ea13 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -107,6 +107,7 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.Neutral.FoldLayerNormPattern2>();
             p.Add<Passes.Rules.Neutral.FoldLayerNormPattern3>();
             p.Add<Passes.Rules.Neutral.FoldLayerNormPattern4>();
+            p.Add<Passes.Rules.Neutral.FoldLayerNormPattern5>();
             p.Add<Passes.Rules.Neutral.FoldGeluWithScale>();
             p.Add<Passes.Rules.Neutral.FoldGeneralGelu>();
             p.Add<Passes.Rules.Neutral.FoldSwishPattern1>();
diff --git a/src/Nncase.Core/IR/Tensors/Concat.cs b/src/Nncase.Core/IR/Tensors/Concat.cs
index 3578d66fce..cbe4861bc3 100644
--- a/src/Nncase.Core/IR/Tensors/Concat.cs
+++ b/src/Nncase.Core/IR/Tensors/Concat.cs
@@ -26,4 +26,7 @@ public sealed partial class Concat : Op
     /// Gets axis.
     /// </summary>
     public int Axis { get; }
+
+    /// <inheritdoc/>
+    public override string DisplayProperty() => $"Axis: {Axis}";
 }
diff --git a/src/Nncase.Core/IR/Tensors/Gather.cs b/src/Nncase.Core/IR/Tensors/Gather.cs
index 5ac52f4888..012a0de053 100644
--- a/src/Nncase.Core/IR/Tensors/Gather.cs
+++ b/src/Nncase.Core/IR/Tensors/Gather.cs
@@ -33,4 +33,7 @@ public sealed partial class Gather : Op
     /// Gets axis.
     /// </summary>
     public int Axis { get; }
+
+    /// <inheritdoc/>
+    public override string DisplayProperty() => $"Axis: {Axis}";
 }
diff --git a/src/Nncase.Core/IR/Tensors/Reshape.cs b/src/Nncase.Core/IR/Tensors/Reshape.cs
index 2db6d16b89..571fa457e6 100644
--- a/src/Nncase.Core/IR/Tensors/Reshape.cs
+++ b/src/Nncase.Core/IR/Tensors/Reshape.cs
@@ -22,7 +22,7 @@ public sealed partial class Reshape : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Reshape), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Reshape), 0, "input", ParameterKind.Input);
 
     /// <summary>
     /// Gets shape.
diff --git a/src/Nncase.Evaluator/Tensors/Boxing.cs b/src/Nncase.Evaluator/Tensors/Boxing.cs
index a36db02da7..98d25da586 100644
--- a/src/Nncase.Evaluator/Tensors/Boxing.cs
+++ b/src/Nncase.Evaluator/Tensors/Boxing.cs
@@ -116,6 +116,13 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
                     }
                 }
 
+                break;
+            case (DistributedType a, DistributedType b) when a.TensorType != b.TensorType && a.Placement == b.Placement:
+                cost = new Cost()
+                {
+                    [CostFactorNames.MemoryStore] = (UInt128)((float)CostUtility.GetMemoryAccess(a) / DistributedUtility.GetDividedTensorEfficiency(a, _burstLength)),
+                    [CostFactorNames.MemoryLoad] = (UInt128)((float)CostUtility.GetMemoryAccess(b) / DistributedUtility.GetDividedTensorEfficiency(b, _burstLength)),
+                };
                 break;
             case (DistributedType a, DistributedType b) when a == b:
                 throw new InvalidOperationException($"the boxing inType == outType");
diff --git a/src/Nncase.Evaluator/Tensors/Reshape.cs b/src/Nncase.Evaluator/Tensors/Reshape.cs
index 38c4d150ee..a619073b36 100644
--- a/src/Nncase.Evaluator/Tensors/Reshape.cs
+++ b/src/Nncase.Evaluator/Tensors/Reshape.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Linq;
-using DryIoc.ImTools;
 using NetFabric.Hyperlinq;
 using Nncase.CostModel;
 using Nncase.IR;
@@ -34,8 +33,12 @@ public IValue Visit(IEvaluateContext context, Reshape reshape)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Reshape target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Reshape.Input);
-        return Visit(context, target, input);
+        var input = context.CheckArgumentType<IRType>(target, Reshape.Input);
+        return input switch
+        {
+            TensorType tensorType => Visit(context, target, tensorType),
+            DistributedType distributedType => Visit(context, target, distributedType),
+        };
     }
 
     public Cost Visit(ICostEvaluateContext context, Reshape target)
@@ -121,4 +124,81 @@ private IRType Visit(ITypeInferenceContext context, Reshape target, TensorType i
         var outShape = ReshapeTo(targetType);
         return input with { Shape = outShape };
     }
+
+    private IRType Visit(ITypeInferenceContext context, Reshape target, DistributedType inputType)
+    {
+        var outType = Visit(context, target, inputType.TensorType);
+        if (outType is not TensorType outTensorType)
+        {
+            return outType;
+        }
+
+        var invalid = new InvalidType(inputType.ToString());
+        if (outTensorType.Shape.IsUnranked)
+        {
+            return invalid;
+        }
+
+        var newShape = outTensorType.Shape.ToValueArray();
+        var oldShape = inputType.TensorType.Shape.ToValueArray();
+
+        // check is unsequeeze/sequeeze
+        if (Enumerable.SequenceEqual(oldShape.Where(i => i != 1).ToArray(), newShape.Where(i => i != 1).ToArray()))
+        {
+            if (oldShape.Length < newShape.Length)
+            {
+                var upAxis = 0;
+                foreach (var axis in Enumerable.Range(0, oldShape.Rank + 1))
+                {
+                    var oldShapeList = oldShape.ToList();
+                    oldShapeList.Insert(axis, 1);
+                    if (Enumerable.SequenceEqual(oldShapeList, newShape))
+                    {
+                        upAxis = axis;
+                        break;
+                    }
+                }
+
+                var ndsbp = new SBP[inputType.Placement.Rank];
+                for (int i = 0; i < inputType.Placement.Rank; i++)
+                {
+                    ndsbp[i] = inputType.NdSBP[i] switch
+                    {
+                        SBPSplit { Axis: int sx } => sx >= upAxis ? SBPSplit.S(sx + 1) : SBPSplit.S(sx),
+                        SBP sbp => sbp,
+                    };
+                }
+
+                return inputType with { TensorType = outTensorType, NdSBP = new(ndsbp) };
+            }
+            else if (oldShape.Length > newShape.Length)
+            {
+                var downAxis = 0;
+                foreach (var axis in Enumerable.Range(0, oldShape.Rank + 1))
+                {
+                    var oldShapeList = oldShape.ToList();
+                    oldShapeList.RemoveAt(axis);
+                    if (Enumerable.SequenceEqual(oldShapeList, newShape))
+                    {
+                        downAxis = axis;
+                        break;
+                    }
+                }
+
+                var ndsbp = new SBP[inputType.Placement.Rank];
+                for (int i = 0; i < inputType.Placement.Rank; i++)
+                {
+                    ndsbp[i] = inputType.NdSBP[i] switch
+                    {
+                        SBPSplit { Axis: int sx } => sx >= downAxis ? SBPSplit.S(sx - 1) : SBPSplit.S(sx),
+                        SBP sbp => sbp,
+                    };
+                }
+
+                return inputType with { TensorType = outTensorType, NdSBP = new(ndsbp) };
+            }
+        }
+
+        return invalid;
+    }
 }
diff --git a/src/Nncase.Importer/Onnx/OnnxImporter.cs b/src/Nncase.Importer/Onnx/OnnxImporter.cs
index d9e8c2d14d..01003a3a03 100644
--- a/src/Nncase.Importer/Onnx/OnnxImporter.cs
+++ b/src/Nncase.Importer/Onnx/OnnxImporter.cs
@@ -52,8 +52,8 @@ protected override (IEnumerable<Var> Inputs, Dictionary<Var, Expr[]> VarMap) Cre
     {
         var bucketOptions = CompileSession.CompileOptions.ShapeBucketOptions;
         _fixVarMap = bucketOptions.FixVarMap;
-        _fixVarMap.Add("N", 384);
 
+        // _fixVarMap.Add("N", 384);
         _constTensors = _graph.Initializer
             .ToDictionary(tensor => tensor.Name, tensor => tensor);
 
diff --git a/src/Nncase.Passes/Rules/ShapeExpr/GatherToGetItem.cs b/src/Nncase.Passes/Rules/ShapeExpr/GatherToGetItem.cs
index c2273e5f31..ec379be4a4 100644
--- a/src/Nncase.Passes/Rules/ShapeExpr/GatherToGetItem.cs
+++ b/src/Nncase.Passes/Rules/ShapeExpr/GatherToGetItem.cs
@@ -14,8 +14,7 @@ namespace Nncase.Passes.Rules.ShapeExpr;
 public sealed partial class GatherToGetItem : RewriteRule<Pattern>
 {
     // (Gather(input, 0, 0) -> GetItem(input)
-    public override Pattern Pattern => IsGather("gather", 0,
-        IsWildcard("input"), IsTensorConst("index") with { TypePattern = IsScalar() });
+    public override Pattern Pattern => IsGather("gather", 0, IsWildcard("input"), IsTensorConst("index") with { TypePattern = IsScalar() });
 
     private Expr? GetReplace(Expr input, int index)
     {
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index a188825ea5..30a8fe649f 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -44,8 +44,8 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseGather))]
     // [ClassData(typeof(TilingCaseSoftmax))]
     // [ClassData(typeof(TilingCaseSlice))]
-    [ClassData(typeof(TilingCaseTranspose))]
     // [ClassData(typeof(TilingCaseConcat))]
+    [ClassData(typeof(TilingCaseTranspose))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -457,6 +457,63 @@ public TilingCaseTranspose()
         var output = fusion.Body.Evaluate(feedDict).AsTensor();
 
         var main = new Function("transpose", new Call(fusion, in_a), new[] { in_a });
+    }
+}
+
+internal sealed class TilingCaseReshape1 : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseReshape1()
+    {
+        var inputShape = new[] { 1, 384, 128 };
+        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+        var newShape = new[] { 1, 1, 384, 128 };
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Reshape()), fin, newShape);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("reshape1", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}
+
+internal sealed class TilingCaseReshape2 : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseReshape2()
+    {
+        var inputShape = new[] { 1, 384, 64, 128 };
+        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+        var newShape = new[] { 1, 384, 8192 };
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Reshape()), fin, newShape);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("reshape2", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
         Add(main, new[] { input_tensor, output });
     }
 }

From c81a287f068b77eae6967bf25caaababb9ec5887 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 20 Sep 2023 14:38:02 +0800
Subject: [PATCH 198/308] pass reshape2

---
 .../CodeGen/CSourceConvertVisitor.cs          | 18 +++++-
 modules/cpu/src/runtime/cmodel/include/tdma.h | 58 +++++++++++++++++++
 .../Targets/UnitTestCPUTargetTiling.cs        |  4 +-
 3 files changed, 77 insertions(+), 3 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index a179c5f1cc..1a2ec5086c 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -245,7 +245,14 @@ protected override CSymbol VisitCall(Call expr)
                     if (args.Length == 1)
                     {
                         var tensorType = (TensorType)args[0].CheckedType;
-                        IndentScope.Writer.Write($"tdma_boxing_load_sync({Visit(args[0]).Name}, {{{string.Join(',', tensorType.Shape)}}}, {tensorType.ToSlicing(load.NdSbp, load.Placement)[1..^1]})");
+                        var splitAxisAndScale = load.NdSbp.Select((sbp, i) => sbp is SBPSplit s ? (s.Axis, load.Placement.Hierarchy[i]) : (0, 1)).ToArray();
+                        var fullShape = tensorType.Shape.ToValueArray();
+                        foreach (var s in splitAxisAndScale)
+                        {
+                            fullShape[s.Item1] *= s.Item2;
+                        }
+
+                        IndentScope.Writer.Write($"tdma_boxing_load_sync({Visit(args[0]).Name}, {{{string.Join(',', fullShape)}}}, {tensorType.ToSlicing(load.NdSbp, load.Placement)[1..^1]}, ctx)");
                     }
                     else
                     {
@@ -257,7 +264,14 @@ protected override CSymbol VisitCall(Call expr)
                     if (args.Length == 1)
                     {
                         var tensorType = (TensorType)args[0].CheckedType;
-                        IndentScope.Writer.Write($"tdma_boxing_store_sync({Visit(args[0]).Name}, {{{string.Join(',', tensorType.Shape)}}}, {tensorType.ToSlicing(store.NdSbp, store.Placement)[1..^1]})");
+                        var splitAxisAndScale = store.NdSbp.Select((sbp, i) => sbp is SBPSplit s ? (s.Axis, store.Placement.Hierarchy[i]) : (0, 1)).ToArray();
+                        var fullShape = tensorType.Shape.ToValueArray();
+                        foreach (var s in splitAxisAndScale)
+                        {
+                            fullShape[s.Item1] *= s.Item2;
+                        }
+
+                        IndentScope.Writer.Write($"tdma_boxing_store_sync({Visit(args[0]).Name}, {{{string.Join(',', fullShape)}}}, {tensorType.ToSlicing(store.NdSbp, store.Placement)[1..^1]}, ctx)");
                     }
                     else
                     {
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 0446b2af90..b3e45db2f4 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -260,6 +260,64 @@ void tdma_store_async(tensor<T, SrcLoc> &src, tensor<T, loc_t::device> &&dest) {
                        std::forward<tensor<T, SrcLoc>>(src));
 }
 
+template <class T>
+void boxing_store_sync_visit_func(int visited,
+                                  [[maybe_unused]] thread_context &ctx,
+                                  tensor<T, loc_t::local> &src,
+                                  dims_t global_dims, dims_t starts,
+                                  dims_t dims) {
+    T *global_span = nullptr;
+    if (visited == 1) {
+        if (global_hardware_ctx.global_var != nullptr) {
+            runtime_util->rt_assert(false,
+                                    (char *)"the global var has been used!");
+        }
+        global_span =
+            (T *)runtime_util->malloc(sizeof(T) * compute_size(global_dims));
+        global_hardware_ctx.global_var = global_span;
+    }
+
+    tensor<T> global_tensor =
+        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
+                                 compute_size(global_dims)),
+                  global_dims);
+    __tensor_copy_sync<T, loc_t::local, loc_t::local>(
+        std::move(global_tensor(starts, dims)), std::move(src));
+}
+
+template <class T>
+void boxing_load_sync_visit_func([[maybe_unused]] int visited,
+                                 [[maybe_unused]] thread_context &ctx,
+                                 tensor<T, loc_t::local> &dest,
+                                 dims_t global_dims, dims_t starts,
+                                 dims_t dims) {
+    T *global_span = nullptr;
+    tensor<T> global_tensor =
+        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
+                                 compute_size(global_dims)),
+                  global_dims);
+    __tensor_copy_sync<T, loc_t::local, loc_t::local>(
+        std::move(dest), std::move(global_tensor(starts, dims)));
+}
+
+template <class T, loc_t DestLoc>
+void tdma_boxing_load_sync(tensor<T, DestLoc> &dest, dims_t global_dims,
+                           dims_t starts, dims_t dims, thread_context &ctx) {
+    __tdma_all_sync_apply_macro(boxing_load_sync_visit_func, ([]() -> void {
+                                    runtime_util->free(
+                                        global_hardware_ctx.global_var);
+                                    global_hardware_ctx.global_var = nullptr;
+                                }),
+                                ctx, dest, global_dims, starts, dims)
+}
+
+template <class T, loc_t SrcLoc>
+void tdma_boxing_store_sync(tensor<T, SrcLoc> &src, dims_t global_dims,
+                            dims_t starts, dims_t dims, thread_context &ctx) {
+    __tdma_all_sync_apply_macro(boxing_store_sync_visit_func, ([]() -> void {}),
+                                ctx, src, global_dims, starts, dims)
+}
+
 template <class T> void tdma_fill_async(tensor<T, loc_t::local> &src, T value) {
     apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
           [&](gsl::span<const size_t> index) -> void {
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 30a8fe649f..af52b1baca 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -45,7 +45,9 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseSoftmax))]
     // [ClassData(typeof(TilingCaseSlice))]
     // [ClassData(typeof(TilingCaseConcat))]
-    [ClassData(typeof(TilingCaseTranspose))]
+    // [ClassData(typeof(TilingCaseTranspose))]
+    // [ClassData(typeof(TilingCaseReshape1))]
+    [ClassData(typeof(TilingCaseReshape2))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);

From c7df643632f2e9706db96e85e431c0b31abd7d68 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 20 Sep 2023 18:31:54 +0800
Subject: [PATCH 199/308] update stackvm

---
 .../Evaluator/CPU}/Boxing.cs                  |    4 +-
 .../Evaluator/CPU/CPUModule.cs                |    1 +
 .../Nncase.Modules.CPU/IR/CPU}/Boxing.cs      |    2 +-
 .../Nncase.Modules.CPU/IR/CPU/Functional.cs   |   10 +
 .../Passes/Tile/SingleCPUFusionConverter.cs   |   59 +-
 .../CodeGen/StackVM/CodeGenVisitor.g.cs       |   14 +-
 .../CodeGen/StackVM/StackVMEmitter.g.cs       |   11 +-
 .../nncase/kernels/stackvm/tensor_ops.h       |  636 ++----
 .../nncase/runtime/stackvm/op_reader.h        | 1955 ++++++++++-------
 .../include/nncase/runtime/stackvm/opcode.h   | 1398 +++++++-----
 src/Native/src/kernels/stackvm/tensor_ops.cpp |   11 +-
 src/Native/src/runtime/stackvm/op_reader.cpp  |   96 +-
 src/Native/src/runtime/stackvm/ops/tensor.cpp |  628 ++----
 .../runtime/stackvm/runtime_function_ops.h    |    9 +-
 src/Nncase.Core/DistributedUtility.cs         |   47 -
 src/Nncase.Core/IR/Tensors/Functional.cs      |   10 -
 src/Nncase.Evaluator/Tensors/TensorsModule.cs |    1 -
 .../CodeGen/UnitTestStackVMEmitter.cs         |    6 +-
 src/Nncase.Tests/Core/UnitTestExpression.cs   |    4 +-
 src/Nncase.Tests/Distributed/UnitTestCost.cs  |    2 +-
 20 files changed, 2406 insertions(+), 2498 deletions(-)
 rename {src/Nncase.Evaluator/Tensors => modules/Nncase.Modules.CPU/Evaluator/CPU}/Boxing.cs (99%)
 rename {src/Nncase.Core/IR/Tensors => modules/Nncase.Modules.CPU/IR/CPU}/Boxing.cs (96%)

diff --git a/src/Nncase.Evaluator/Tensors/Boxing.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
similarity index 99%
rename from src/Nncase.Evaluator/Tensors/Boxing.cs
rename to modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
index 98d25da586..cae49e26cf 100644
--- a/src/Nncase.Evaluator/Tensors/Boxing.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
@@ -6,9 +6,9 @@
 using System.Linq;
 using Nncase.CostModel;
 using Nncase.IR;
-using Nncase.IR.Tensors;
+using Nncase.IR.CPU;
 
-namespace Nncase.Evaluator.Tensors;
+namespace Nncase.Evaluator.CPU;
 
 public sealed class BoxingEvaluator : ITypeInferencer<Boxing>, ICostEvaluator<Boxing>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
index aa01122091..b86978fd5d 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
@@ -14,5 +14,6 @@ internal class CPUModule : IApplicationPart
     public void ConfigureServices(IRegistrator registrator)
     {
         registrator.RegisterManyInterface<CPUKernelOpEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<BoxingEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/src/Nncase.Core/IR/Tensors/Boxing.cs b/modules/Nncase.Modules.CPU/IR/CPU/Boxing.cs
similarity index 96%
rename from src/Nncase.Core/IR/Tensors/Boxing.cs
rename to modules/Nncase.Modules.CPU/IR/CPU/Boxing.cs
index 04496b8263..d86c10bdaf 100644
--- a/src/Nncase.Core/IR/Tensors/Boxing.cs
+++ b/modules/Nncase.Modules.CPU/IR/CPU/Boxing.cs
@@ -9,7 +9,7 @@
 using System.Threading.Tasks;
 using Nncase.PatternMatch;
 
-namespace Nncase.IR.Tensors;
+namespace Nncase.IR.CPU;
 
 /// <summary>
 /// Boxing expression.
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
index 41d4ffa744..3451b2df3a 100644
--- a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
@@ -22,4 +22,14 @@ public static Call CPUKernel(Op target, params Expr[] inputs)
     {
         return new Call(new CPUKernelOp(target), inputs);
     }
+
+    public static Call Boxing(Expr input, IRType type)
+    {
+        if (input.CheckedType == type)
+        {
+            throw new NotSupportedException();
+        }
+
+        return new Call(new Boxing(type), input);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 37468e2031..32fb83df39 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -24,6 +24,8 @@
 using Range = Nncase.TIR.Range;
 using Tuple = Nncase.IR.Tuple;
 
+[assembly: InternalsVisibleTo("Nncase.Tests")]
+
 namespace Nncase.Passes.Tile;
 
 /// <summary>
@@ -86,6 +88,53 @@ public TIR.PrimFunction Convert(Fusion fusion)
         return T.PrimFunc(newFusion.Name, newFusion.ModuleKind, visitor.InputBuffers.Concat(visitor.OutputBuffers).ToArray()).Body(primBody.ToArray()).Build();
     }
 
+    public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement placement)
+    {
+        return DistributedUtility.GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).Select(ndsbp => IR.F.CPU.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).ToArray();
+    }
+
+    /// <summary>
+    /// when input expression sbp is partial, get the new candidate boxings.
+    /// </summary>
+    /// <param name="expr">input expression.</param>
+    /// <returns>the boxings.</returns>
+    /// <exception cref="NotSupportedException">when expr is tuple.</exception>
+    public static IReadOnlyList<Expr> GetPartialCandidateBoxings(Expr expr)
+    {
+        if (expr is IR.Tuple tuple)
+        {
+            var candidates = tuple.Fields.ToArray().
+                Select(GetPartialCandidateBoxings).
+                CartesianProduct();
+            return candidates.Any() ? candidates.
+                Select(fs => new IR.Tuple(fs.ToArray())).
+                ToArray() : Array.Empty<Expr>();
+        }
+
+        var type = (DistributedType)expr.CheckedType;
+        var tensorType = type.TensorType;
+        var candidateNdsbps = new List<SBP>[type.Placement.Rank];
+        for (int i = 0; i < type.Placement.Rank; i++)
+        {
+            candidateNdsbps[i] = new List<SBP>();
+            if (type.NdSBP[i] is SBPPartialSum)
+            {
+                candidateNdsbps[i].Add(SBP.B);
+                for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
+                {
+                    if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && DistributedUtility.IsDivisible(s, type.Placement.Hierarchy[i]))
+                    {
+                        candidateNdsbps[i].Add(SBP.S(axis));
+                    }
+                }
+            }
+        }
+
+        return candidateNdsbps.CartesianProduct().
+            Select(ndsbp => new DistributedType(tensorType, new IRArray<SBP>(ndsbp), type.Placement)).
+            Select(disttype => IR.F.CPU.Boxing(expr, disttype)).ToArray();
+    }
+
     private sealed class DistributeConvertVisitor : ExprVisitor<IReadOnlyList<Expr>, Unit>
     {
         private readonly Dictionary<Expr, List<Expr>> _stagesMap;
@@ -104,7 +153,7 @@ public DistributeConvertVisitor(TileOptions tileOptions)
         public IReadOnlyList<Expr> Convert(Expr body, out IReadOnlyDictionary<Expr, List<Expr>> stagesMap)
         {
             stagesMap = _stagesMap;
-            return Visit(body).Select(newbody => IR.F.Tensors.Boxing(newbody, body.CheckedType)).ToArray();
+            return Visit(body).Select(newbody => IR.F.CPU.Boxing(newbody, body.CheckedType)).ToArray();
         }
 
         protected override IReadOnlyList<Expr> DefaultVisitLeaf(Expr expr)
@@ -162,7 +211,7 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
                 var tensorType = (TensorType)oldArg.CheckedType;
                 boxingArgs.Add(info.ParameterKind switch
                 {
-                    ParameterKind.Input => DistributedUtility.GetLeafCandidateNDSBPs(tensorType, Placement).Select(ndsbp => IR.F.Tensors.Boxing(newArgs[0], new DistributedType(tensorType, ndsbp, Placement))).ToList(),
+                    ParameterKind.Input => DistributedUtility.GetLeafCandidateNDSBPs(tensorType, Placement).Select(ndsbp => IR.F.CPU.Boxing(newArgs[0], new DistributedType(tensorType, ndsbp, Placement))).ToList(),
                     ParameterKind.Attribute => new Expr[] { newArgs[0] },
                     _ => throw new ArgumentOutOfRangeException(info.ParameterKind.ToString()),
                 });
@@ -184,7 +233,7 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
 
         private IReadOnlyList<Expr> GetLeafArgCandidates(ParameterKind parameterKind, Expr expr) => (parameterKind, expr) switch
         {
-            (ParameterKind.Input, Expr e) when e is Const or Var => DistributedUtility.GetLeafCandidateBoxings(e, Placement),
+            (ParameterKind.Input, Expr e) when e is Const or Var => GetLeafCandidateBoxings(e, Placement),
             (ParameterKind.Input, Expr e) when e is IR.Tuple tp => tp.Fields.ToArray().Select(f => GetLeafArgCandidates(parameterKind, f)).CartesianProduct().Select(e => new IR.Tuple(e.ToArray())).ToArray(),
             (ParameterKind.Attribute, Expr e) when e is Const or Var => new[] { e },
             (_, Expr arg) => ExprMemo[arg],
@@ -210,12 +259,12 @@ protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
                     var inType = (DistributedType)args[0].CheckedType;
                     var tensorType = inType.TensorType with { Shape = newShape };
                     calls.AddRange(DistributedUtility.GetLeafCandidateNDSBPs(tensorType, inType.Placement).
-                        Select(ndsbp => IR.F.Tensors.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))).
+                        Select(ndsbp => IR.F.CPU.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))).
                         Select(c => (c.InferenceType(), c)));
                 }
                 else
                 {
-                    var broadcastArgs = args.Zip(target.Parameters).Select(t => t.Second.ParameterKind == ParameterKind.Input ? DistributedUtility.GetPartialCandidateBoxings(t.First) : Array.Empty<Expr>()).ToArray();
+                    var broadcastArgs = args.Zip(target.Parameters).Select(t => t.Second.ParameterKind == ParameterKind.Input ? GetPartialCandidateBoxings(t.First) : Array.Empty<Expr>()).ToArray();
 
                     if (!broadcastArgs.All(bargs => bargs.Count == 0))
                     {
diff --git a/modules/Nncase.Modules.StackVM/CodeGen/StackVM/CodeGenVisitor.g.cs b/modules/Nncase.Modules.StackVM/CodeGen/StackVM/CodeGenVisitor.g.cs
index ee69381088..314930a8a9 100644
--- a/modules/Nncase.Modules.StackVM/CodeGen/StackVM/CodeGenVisitor.g.cs
+++ b/modules/Nncase.Modules.StackVM/CodeGen/StackVM/CodeGenVisitor.g.cs
@@ -1,6 +1,6 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
-/* This file is generated by tools/stackvm_gen/IsaGen at 2023/9/5 19:40:30 +08:00. */
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:08 AM +00:00. */
 
 using System;
 using System.Collections.Generic;
@@ -59,7 +59,7 @@ private void EmitTensorCall(Op op)
                 Emitter.T.L2Normalization();
                 break;
             case IR.NN.LayerNorm top:
-                Emitter.T.LayerNorm(top.Axis, top.Epsilon);
+                Emitter.T.LayerNorm(top.Axis, top.Epsilon, top.UseMean);
                 break;
             case IR.NN.LeakyRelu top:
                 Emitter.T.LeakyRelu();
@@ -176,7 +176,7 @@ private void EmitTensorCall(Op op)
                 Emitter.T.Cast(top.NewType, top.CastMode);
                 break;
             case IR.Tensors.Concat top:
-                Emitter.T.Concat();
+                Emitter.T.Concat(top.Axis);
                 break;
             case IR.Tensors.ConstantOfShape top:
                 Emitter.T.ConstantOfShape();
@@ -191,7 +191,7 @@ private void EmitTensorCall(Op op)
                 Emitter.T.Flatten();
                 break;
             case IR.Tensors.Gather top:
-                Emitter.T.Gather();
+                Emitter.T.Gather(top.Axis);
                 break;
             case IR.Tensors.GatherElements top:
                 Emitter.T.GatherElements();
@@ -205,9 +205,6 @@ private void EmitTensorCall(Op op)
             case IR.Tensors.IndexOf top:
                 Emitter.T.IndexOf();
                 break;
-            case IR.RNN.LSTM top:
-                Emitter.T.LSTM(top.Direction, top.Layout, top.Activations);
-                break;
             case IR.Tensors.Prod top:
                 Emitter.T.Prod();
                 break;
@@ -289,6 +286,9 @@ private void EmitTensorCall(Op op)
             case IR.ShapeExpr.UnsqueezeShape top:
                 Emitter.T.UnsqueezeShape();
                 break;
+            case IR.RNN.LSTM top:
+                Emitter.T.LSTM(top.Direction, top.Layout, top.Activations);
+                break;
             case IR.Random.Normal top:
                 Emitter.T.Normal(top.Type);
                 break;
diff --git a/modules/Nncase.Modules.StackVM/CodeGen/StackVM/StackVMEmitter.g.cs b/modules/Nncase.Modules.StackVM/CodeGen/StackVM/StackVMEmitter.g.cs
index 6e2184c5ea..b6512a344c 100644
--- a/modules/Nncase.Modules.StackVM/CodeGen/StackVM/StackVMEmitter.g.cs
+++ b/modules/Nncase.Modules.StackVM/CodeGen/StackVM/StackVMEmitter.g.cs
@@ -1,6 +1,6 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
-/* This file is generated by tools/stackvm_gen/IsaGen at 2023/9/5 19:40:30 +08:00. */
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:08 AM +00:00. */
 
 using System;
 using System.Collections.Generic;
@@ -723,10 +723,11 @@ public void Compare(CompareOp compareOp)
         }
 
         ///<summary>.</summary>
-        public void Concat()
+        public void Concat(int axis)
         {
             _emitter.Write((byte)100);
             _emitter.Write((ushort)11);
+            _emitter.Write(axis);
         }
 
         ///<summary>.</summary>
@@ -841,10 +842,11 @@ public void Flatten()
         }
 
         ///<summary>.</summary>
-        public void Gather()
+        public void Gather(int axis)
         {
             _emitter.Write((byte)100);
             _emitter.Write((ushort)27);
+            _emitter.Write(axis);
         }
 
         ///<summary>.</summary>
@@ -925,12 +927,13 @@ public void L2Normalization()
         }
 
         ///<summary>.</summary>
-        public void LayerNorm(int axis, float epsilon)
+        public void LayerNorm(int axis, float epsilon, bool useMean)
         {
             _emitter.Write((byte)100);
             _emitter.Write((ushort)39);
             _emitter.Write(axis);
             _emitter.Write(epsilon);
+            _emitter.Write(useMean);
         }
 
         ///<summary>.</summary>
diff --git a/src/Native/include/nncase/kernels/stackvm/tensor_ops.h b/src/Native/include/nncase/kernels/stackvm/tensor_ops.h
index e918f22f25..27c0766226 100644
--- a/src/Native/include/nncase/kernels/stackvm/tensor_ops.h
+++ b/src/Native/include/nncase/kernels/stackvm/tensor_ops.h
@@ -1,5 +1,4 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 2023/9/5 19:40:29
- * +08:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -26,449 +25,194 @@
 
 BEGIN_NS_NNCASE_KERNELS_MODULE(stackvm)
 
-NNCASE_API result<value_t>
-batch_normalization(value_t input, value_t scale, value_t bias,
-                    value_t input_mean, value_t input_var, value_t epsilon,
-                    value_t momentum, value_t output = nullptr,
-                    kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-batch_to_space(value_t input, value_t block_shape, value_t crops,
-               value_t output = nullptr,
-               kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-binary(runtime::stackvm::binary_op_t binary_op, value_t lhs, value_t rhs,
-       value_t output = nullptr,
-       kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-bitcast(prim_type_t type, prim_type_t new_type, value_t input,
-        value_t new_shape, value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-broadcast(value_t input, value_t shape, value_t output = nullptr,
-          kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-broadcast_shape(value_t inputs, value_t output = nullptr,
-                kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-bucket_pad(value_t input, value_t shape, value_t output = nullptr,
-           kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-cast(typecode_t new_type, runtime::stackvm::cast_mode_t cast_mode,
-     value_t input, value_t output = nullptr,
-     kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-celu(value_t input, value_t alpha, value_t output = nullptr,
-     kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-clamp(value_t input, value_t min, value_t max, value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-compare(runtime::stackvm::compare_op_t compare_op, value_t lhs, value_t rhs,
-        value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-concat(value_t input, value_t axis, value_t output = nullptr,
-       kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-condition(bool can_fold_const_call, value_t predicate, value_t value,
-          value_t output = nullptr,
-          kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-constant_of_shape(value_t shape, value_t value, value_t output = nullptr,
-                  kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-conv2d(runtime::stackvm::pad_mode_t pad_mode, value_t input, value_t weights,
-       value_t bias, value_t stride, value_t padding, value_t dilation,
-       value_t groups, value_t fused_clamp, value_t output = nullptr,
-       kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-conv2d_shape(value_t input, value_t weights, value_t padding, value_t stride,
-             value_t dilation, value_t groups, value_t output = nullptr,
-             kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-conv2d_transpose(runtime::stackvm::pad_mode_t pad_mode, value_t input,
-                 value_t weights, value_t bias, value_t output_shape,
-                 value_t stride, value_t padding, value_t output_padding,
-                 value_t dilation, value_t groups, value_t fused_clamp,
-                 value_t output = nullptr,
-                 kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-conv2d_transpose_shape(value_t input, value_t weights, value_t stride,
-                       value_t dilation, value_t padding,
-                       value_t output_padding, value_t groups,
-                       value_t output = nullptr,
-                       kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-cum_sum(value_t input, value_t axis, value_t exclusive, value_t reverse,
-        value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-dequantize(typecode_t target_type, value_t input, value_t dequant_param,
-           value_t output = nullptr,
-           kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-elu(value_t input, value_t alpha, value_t output = nullptr,
-    kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-erf(value_t input, value_t output = nullptr,
-    kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-expand(value_t input, value_t shape, value_t output = nullptr,
-       kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-fake_dequantize(typecode_t target_type, value_t input, value_t dequant_param,
-                value_t output = nullptr,
-                kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-fake_quantize(typecode_t target_type, value_t input, value_t quant_param,
-              value_t output = nullptr,
-              kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-fix_shape(value_t input, value_t shape, value_t output = nullptr,
-          kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-flatten(value_t input, value_t axis, value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-gather(value_t input, value_t axis, value_t index, value_t output = nullptr,
-       kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-gather_elements(value_t input, value_t axis, value_t indices,
-                value_t output = nullptr,
-                kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-gather_nd(value_t input, value_t batch_dims, value_t index,
-          value_t output = nullptr,
-          kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-gelu(value_t input, value_t alpha, value_t output = nullptr,
-     kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-get_item(value_t input, value_t index, value_t output = nullptr,
-         kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-get_paddings(value_t input_shape, value_t weights_shape, value_t strides,
-             value_t dilations, value_t same, value_t lower,
-             value_t output = nullptr,
-             kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-hard_sigmoid(value_t input, value_t alpha, value_t beta,
-             value_t output = nullptr,
-             kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-hard_swish(value_t input, value_t output = nullptr,
-           kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-hardmax(value_t input, value_t axis, value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-index_of(value_t input, value_t value, value_t output = nullptr,
-         kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-instance_normalization(value_t input, value_t scale, value_t bias,
-                       value_t epsilon, value_t output = nullptr,
-                       kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-l2_normalization(value_t input, value_t output = nullptr,
-                 kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-layer_norm(int32_t axis, float epsilon, value_t input, value_t scale,
-           value_t bias, value_t output = nullptr,
-           kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-leaky_relu(value_t input, value_t alpha, value_t output = nullptr,
-           kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-log_softmax(value_t input, value_t axis, value_t output = nullptr,
-            kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-lp_normalization(value_t input, value_t axis, value_t p,
-                 value_t output = nullptr,
-                 kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-lrn(value_t input, value_t alpha, value_t beta, value_t bias, value_t size,
-    value_t output = nullptr,
-    kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-lstm(runtime::stackvm::lstmdirection_t direction,
-     runtime::stackvm::lstmlayout_t layout,
-     std::vector<std::string> activations, value_t x, value_t w, value_t r,
-     value_t b, value_t sequence_lens, value_t initial_h, value_t initial_c,
-     value_t p, value_t activation_alpha, value_t activation_beta, value_t clip,
-     value_t hidden_size, value_t input_forget, value_t output_size,
-     value_t output = nullptr,
-     kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-mat_mul(value_t lhs, value_t rhs, value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-mat_mul_shape(value_t lhs, value_t rhs, value_t output = nullptr,
-              kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-normal(typecode_t type, value_t mean, value_t scale, value_t seed,
-       value_t shape, value_t output = nullptr,
-       kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-normal_like(typecode_t type, value_t input, value_t mean, value_t scale,
-            value_t seed, value_t output = nullptr,
-            kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-one_hot(runtime::stackvm::one_hot_mode_t one_hot_mode, value_t indices,
-        value_t depth, value_t values, value_t axis, value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-pad(runtime::stackvm::pad_mode_t pad_mode, value_t input, value_t pads,
-    value_t value, value_t output = nullptr,
-    kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-prelu(value_t input, value_t slope, value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-prod(value_t input, value_t output = nullptr,
-     kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-quant_param_of(runtime::stackvm::quant_mode_t quant_mode, value_t range,
-               value_t bits, value_t output = nullptr,
-               kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-quantize(typecode_t target_type, value_t input, value_t quant_param,
-         value_t output = nullptr,
-         kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-range(value_t begin, value_t end, value_t step, value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-range_of(bool is_range_of_weight, value_t input, value_t output = nullptr,
-         kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-rank(value_t input, value_t output = nullptr,
-     kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-reduce(runtime::stackvm::reduce_op_t reduce_op, value_t input, value_t axis,
-       value_t init_value, value_t keep_dims, value_t output = nullptr,
-       kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-reduce_arg(runtime::stackvm::reduce_arg_op_t reduce_arg_op,
-           typecode_t dest_type, value_t input, value_t axis, value_t keep_dims,
-           value_t select_last_index, value_t output = nullptr,
-           kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-reduce_window2d(runtime::stackvm::reduce_op_t reduce_op, value_t input,
-                value_t init_value, value_t filter, value_t stride,
-                value_t padding, value_t dilation, value_t ceil_mode,
-                value_t count_include_pad, value_t output = nullptr,
-                kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-relu(value_t input, value_t output = nullptr,
-     kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-relu6(value_t input, value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-require(std::string message, bool can_fold_const_call, value_t predicate,
-        value_t value, value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-reshape(value_t input, value_t shape, value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-reshape_shape(value_t input_shape, value_t shape, value_t output = nullptr,
-              kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> resize_image(
-    runtime::stackvm::image_resize_mode_t resize_mode,
-    runtime::stackvm::image_resize_transformation_mode_t transformation_mode,
-    runtime::stackvm::image_resize_nearest_mode_t nearest_mode,
-    bool is_tfresize, value_t input, value_t roi, value_t new_size,
-    value_t cubic_coeff_a, value_t exclude_outside, value_t extrapolation_value,
-    value_t output = nullptr,
-    kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-reverse_sequence(value_t input, value_t seq_lens, value_t batch_axis,
-                 value_t time_axis, value_t output = nullptr,
-                 kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-scatter_nd(value_t input, value_t indices, value_t updates,
-           value_t output = nullptr,
-           kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-select(value_t predicate, value_t true_value, value_t false_value,
-       value_t output = nullptr,
-       kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-selu(value_t input, value_t alpha, value_t gamma, value_t output = nullptr,
-     kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-shape_of(value_t input, value_t output = nullptr,
-         kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-sigmoid(value_t input, value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-size_of(value_t input, value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-slice(value_t input, value_t begins, value_t ends, value_t axes,
-      value_t strides, value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-softmax(value_t input, value_t axis, value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-softplus(value_t input, value_t output = nullptr,
-         kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-softsign(value_t input, value_t output = nullptr,
-         kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-space_to_batch(value_t input, value_t block_shape, value_t paddings,
-               value_t output = nullptr,
-               kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-split(value_t input, value_t axis, value_t sections, value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-squeeze(value_t input, value_t dim, value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-squeeze_shape(value_t input_shape, value_t dim, value_t output = nullptr,
-              kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-stack(value_t inputs, value_t axis, value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-swish(value_t input, value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-tile(value_t input, value_t repeats, value_t output = nullptr,
-     kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-top_k(value_t x, value_t k, value_t axis, value_t largest, value_t sorted,
-      value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-transpose(value_t input, value_t perm, value_t output = nullptr,
-          kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-transpose_shape(value_t input_shape, value_t perm, value_t output = nullptr,
-                kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-trilu(value_t input, value_t k, value_t upper, value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-unary(runtime::stackvm::unary_op_t unary_op, value_t input,
-      value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-uniform(typecode_t type, value_t high, value_t low, value_t seed, value_t shape,
-        value_t output = nullptr,
-        kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-uniform_like(typecode_t type, value_t input, value_t high, value_t low,
-             value_t seed, value_t output = nullptr,
-             kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-unsqueeze(value_t input, value_t dim, value_t output = nullptr,
-          kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-unsqueeze_shape(value_t input_shape, value_t dim, value_t output = nullptr,
-                kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t>
-where(bool is_tf_where, value_t cond, value_t x, value_t y,
-      value_t output = nullptr,
-      kernel_context &context = default_kernel_context());
+NNCASE_API result<value_t> batch_normalization(value_t input, value_t scale, value_t bias, value_t input_mean, value_t input_var, value_t epsilon, value_t momentum, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> batch_to_space(value_t input, value_t block_shape, value_t crops, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> binary(runtime::stackvm::binary_op_t binary_op, value_t lhs, value_t rhs, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> bitcast(prim_type_t type, prim_type_t new_type, value_t input, value_t new_shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> broadcast(value_t input, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> broadcast_shape(value_t inputs, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> bucket_pad(value_t input, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> cast(typecode_t new_type, runtime::stackvm::cast_mode_t cast_mode, value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> celu(value_t input, value_t alpha, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> clamp(value_t input, value_t min, value_t max, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> compare(runtime::stackvm::compare_op_t compare_op, value_t lhs, value_t rhs, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> concat(int32_t axis, value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> condition(bool can_fold_const_call, value_t predicate, value_t value, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> constant_of_shape(value_t shape, value_t value, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> conv2d(runtime::stackvm::pad_mode_t pad_mode, value_t input, value_t weights, value_t bias, value_t stride, value_t padding, value_t dilation, value_t groups, value_t fused_clamp, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> conv2d_shape(value_t input, value_t weights, value_t padding, value_t stride, value_t dilation, value_t groups, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> conv2d_transpose(runtime::stackvm::pad_mode_t pad_mode, value_t input, value_t weights, value_t bias, value_t output_shape, value_t stride, value_t padding, value_t output_padding, value_t dilation, value_t groups, value_t fused_clamp, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> conv2d_transpose_shape(value_t input, value_t weights, value_t stride, value_t dilation, value_t padding, value_t output_padding, value_t groups, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> cum_sum(value_t input, value_t axis, value_t exclusive, value_t reverse, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> dequantize(typecode_t target_type, value_t input, value_t dequant_param, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> elu(value_t input, value_t alpha, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> erf(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> expand(value_t input, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> fake_dequantize(typecode_t target_type, value_t input, value_t dequant_param, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> fake_quantize(typecode_t target_type, value_t input, value_t quant_param, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> fix_shape(value_t input, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> flatten(value_t input, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> gather(int32_t axis, value_t input, value_t index, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> gather_elements(value_t input, value_t axis, value_t indices, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> gather_nd(value_t input, value_t batch_dims, value_t index, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> gelu(value_t input, value_t alpha, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> get_item(value_t input, value_t index, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> get_paddings(value_t input_shape, value_t weights_shape, value_t strides, value_t dilations, value_t same, value_t lower, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> hard_sigmoid(value_t input, value_t alpha, value_t beta, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> hard_swish(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> hardmax(value_t input, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> index_of(value_t input, value_t value, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> instance_normalization(value_t input, value_t scale, value_t bias, value_t epsilon, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> l2_normalization(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> layer_norm(int32_t axis, float epsilon, bool use_mean, value_t input, value_t scale, value_t bias, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> leaky_relu(value_t input, value_t alpha, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> log_softmax(value_t input, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> lp_normalization(value_t input, value_t axis, value_t p, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> lrn(value_t input, value_t alpha, value_t beta, value_t bias, value_t size, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> lstm(runtime::stackvm::lstmdirection_t direction, runtime::stackvm::lstmlayout_t layout, std::vector<std::string> activations, value_t x, value_t w, value_t r, value_t b, value_t sequence_lens, value_t initial_h, value_t initial_c, value_t p, value_t activation_alpha, value_t activation_beta, value_t clip, value_t hidden_size, value_t input_forget, value_t output_size, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> mat_mul(value_t lhs, value_t rhs, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> mat_mul_shape(value_t lhs, value_t rhs, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> normal(typecode_t type, value_t mean, value_t scale, value_t seed, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> normal_like(typecode_t type, value_t input, value_t mean, value_t scale, value_t seed, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> one_hot(runtime::stackvm::one_hot_mode_t one_hot_mode, value_t indices, value_t depth, value_t values, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> pad(runtime::stackvm::pad_mode_t pad_mode, value_t input, value_t pads, value_t value, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> prelu(value_t input, value_t slope, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> prod(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> quant_param_of(runtime::stackvm::quant_mode_t quant_mode, value_t range, value_t bits, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> quantize(typecode_t target_type, value_t input, value_t quant_param, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> range(value_t begin, value_t end, value_t step, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> range_of(bool is_range_of_weight, value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> rank(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> reduce(runtime::stackvm::reduce_op_t reduce_op, value_t input, value_t axis, value_t init_value, value_t keep_dims, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> reduce_arg(runtime::stackvm::reduce_arg_op_t reduce_arg_op, typecode_t dest_type, value_t input, value_t axis, value_t keep_dims, value_t select_last_index, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> reduce_window2d(runtime::stackvm::reduce_op_t reduce_op, value_t input, value_t init_value, value_t filter, value_t stride, value_t padding, value_t dilation, value_t ceil_mode, value_t count_include_pad, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> relu(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> relu6(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> require(std::string message, bool can_fold_const_call, value_t predicate, value_t value, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> reshape(value_t input, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> reshape_shape(value_t input_shape, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> resize_image(runtime::stackvm::image_resize_mode_t resize_mode, runtime::stackvm::image_resize_transformation_mode_t transformation_mode, runtime::stackvm::image_resize_nearest_mode_t nearest_mode, bool is_tfresize, value_t input, value_t roi, value_t new_size, value_t cubic_coeff_a, value_t exclude_outside, value_t extrapolation_value, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> reverse_sequence(value_t input, value_t seq_lens, value_t batch_axis, value_t time_axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> scatter_nd(value_t input, value_t indices, value_t updates, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> select(value_t predicate, value_t true_value, value_t false_value, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> selu(value_t input, value_t alpha, value_t gamma, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> shape_of(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> sigmoid(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> size_of(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> slice(value_t input, value_t begins, value_t ends, value_t axes, value_t strides, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> softmax(value_t input, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> softplus(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> softsign(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> space_to_batch(value_t input, value_t block_shape, value_t paddings, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> split(value_t input, value_t axis, value_t sections, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> squeeze(value_t input, value_t dim, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> squeeze_shape(value_t input_shape, value_t dim, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> stack(value_t inputs, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> swish(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> tile(value_t input, value_t repeats, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> top_k(value_t x, value_t k, value_t axis, value_t largest, value_t sorted, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> transpose(value_t input, value_t perm, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> transpose_shape(value_t input_shape, value_t perm, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> trilu(value_t input, value_t k, value_t upper, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> unary(runtime::stackvm::unary_op_t unary_op, value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> uniform(typecode_t type, value_t high, value_t low, value_t seed, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> uniform_like(typecode_t type, value_t input, value_t high, value_t low, value_t seed, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> unsqueeze(value_t input, value_t dim, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> unsqueeze_shape(value_t input_shape, value_t dim, value_t output = nullptr, kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> where(bool is_tf_where, value_t cond, value_t x, value_t y, value_t output = nullptr, kernel_context &context = default_kernel_context());
 
 END_NS_NNCASE_KERNELS_MODULE
diff --git a/src/Native/include/nncase/runtime/stackvm/op_reader.h b/src/Native/include/nncase/runtime/stackvm/op_reader.h
index 80372463e4..a7ec8bee9f 100644
--- a/src/Native/include/nncase/runtime/stackvm/op_reader.h
+++ b/src/Native/include/nncase/runtime/stackvm/op_reader.h
@@ -1,5 +1,4 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 2023/9/5 19:40:29
- * +08:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -23,48 +22,67 @@
 
 BEGIN_NS_NNCASE_RT_MODULE(stackvm)
 
-template <opcode_t Op> struct op_reader;
+template <opcode_t Op>
+struct op_reader;
 
-template <> struct op_reader<opcode_t::NOP> {
-    nop_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::NOP>
+{
+    nop_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         nop_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::BR> {
-    br_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::BR>
+{
+    br_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         br_op_t op;
         op.target = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::BR_TRUE> {
-    br_true_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::BR_TRUE>
+{
+    br_true_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         br_true_op_t op;
         op.target = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::BR_FALSE> {
-    br_false_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::BR_FALSE>
+{
+    br_false_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         br_false_op_t op;
         op.target = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::RET> {
-    ret_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::RET>
+{
+    ret_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ret_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CALL> {
-    call_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CALL>
+{
+    call_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         call_op_t op;
         op.args = reader.read_unaligned<uint16_t>();
         op.target = reader.read_unaligned<int32_t>();
@@ -72,16 +90,22 @@ template <> struct op_reader<opcode_t::CALL> {
     }
 };
 
-template <> struct op_reader<opcode_t::ECALL> {
-    ecall_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::ECALL>
+{
+    ecall_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ecall_op_t op;
         op.args = reader.read_unaligned<uint16_t>();
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::EXTCALL> {
-    extcall_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::EXTCALL>
+{
+    extcall_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         extcall_op_t op;
         op.args = reader.read_unaligned<uint16_t>();
         op.is_prim_func = reader.read_unaligned<bool>();
@@ -89,8 +113,11 @@ template <> struct op_reader<opcode_t::EXTCALL> {
     }
 };
 
-template <> struct op_reader<opcode_t::CUSCALL> {
-    cuscall_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CUSCALL>
+{
+    cuscall_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         cuscall_op_t op;
         op.registered_name = reader.read_string();
         op.fields_span = reader.read_span(reader.read_unaligned<uint32_t>());
@@ -99,171 +126,243 @@ template <> struct op_reader<opcode_t::CUSCALL> {
     }
 };
 
-template <> struct op_reader<opcode_t::THROW> {
-    throw_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::THROW>
+{
+    throw_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         throw_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::BREAK> {
-    break_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::BREAK>
+{
+    break_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         break_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDC_I4> {
-    ldc_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDC_I4>
+{
+    ldc_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldc_i4_op_t op;
         op.imm = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDNULL> {
-    ldnull_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDNULL>
+{
+    ldnull_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldnull_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDC_I4_0> {
-    ldc_i4_0_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDC_I4_0>
+{
+    ldc_i4_0_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldc_i4_0_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDC_I4_1> {
-    ldc_i4_1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDC_I4_1>
+{
+    ldc_i4_1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldc_i4_1_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDC_R4> {
-    ldc_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDC_R4>
+{
+    ldc_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldc_r4_op_t op;
         op.imm = reader.read_unaligned<float>();
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDIND_I1> {
-    ldind_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDIND_I1>
+{
+    ldind_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldind_i1_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDIND_I2> {
-    ldind_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDIND_I2>
+{
+    ldind_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldind_i2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDIND_I4> {
-    ldind_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDIND_I4>
+{
+    ldind_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldind_i4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDIND_I> {
-    ldind_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDIND_I>
+{
+    ldind_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldind_i_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDIND_U1> {
-    ldind_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDIND_U1>
+{
+    ldind_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldind_u1_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDIND_U2> {
-    ldind_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDIND_U2>
+{
+    ldind_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldind_u2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDIND_U4> {
-    ldind_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDIND_U4>
+{
+    ldind_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldind_u4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDIND_U> {
-    ldind_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDIND_U>
+{
+    ldind_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldind_u_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDIND_BR2> {
-    ldind_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDIND_BR2>
+{
+    ldind_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldind_br2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDIND_R4> {
-    ldind_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDIND_R4>
+{
+    ldind_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldind_r4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STIND_I1> {
-    stind_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STIND_I1>
+{
+    stind_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stind_i1_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STIND_I2> {
-    stind_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STIND_I2>
+{
+    stind_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stind_i2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STIND_I4> {
-    stind_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STIND_I4>
+{
+    stind_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stind_i4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STIND_I> {
-    stind_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STIND_I>
+{
+    stind_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stind_i_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STIND_BR2> {
-    stind_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STIND_BR2>
+{
+    stind_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stind_br2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STIND_R4> {
-    stind_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STIND_R4>
+{
+    stind_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stind_r4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LEA_GP> {
-    lea_gp_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LEA_GP>
+{
+    lea_gp_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         lea_gp_op_t op;
         op.gpid = reader.read_unaligned<uint8_t>();
         op.offset = reader.read_unaligned<int32_t>();
@@ -271,507 +370,718 @@ template <> struct op_reader<opcode_t::LEA_GP> {
     }
 };
 
-template <> struct op_reader<opcode_t::LDELEM_I1> {
-    ldelem_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDELEM_I1>
+{
+    ldelem_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldelem_i1_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDELEM_I2> {
-    ldelem_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDELEM_I2>
+{
+    ldelem_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldelem_i2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDELEM_I4> {
-    ldelem_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDELEM_I4>
+{
+    ldelem_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldelem_i4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDELEM_I> {
-    ldelem_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDELEM_I>
+{
+    ldelem_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldelem_i_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDELEM_U1> {
-    ldelem_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDELEM_U1>
+{
+    ldelem_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldelem_u1_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDELEM_U2> {
-    ldelem_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDELEM_U2>
+{
+    ldelem_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldelem_u2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDELEM_U4> {
-    ldelem_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDELEM_U4>
+{
+    ldelem_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldelem_u4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDELEM_U> {
-    ldelem_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDELEM_U>
+{
+    ldelem_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldelem_u_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDELEM_BR2> {
-    ldelem_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDELEM_BR2>
+{
+    ldelem_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldelem_br2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDELEM_R4> {
-    ldelem_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDELEM_R4>
+{
+    ldelem_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldelem_r4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STELEM_I1> {
-    stelem_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STELEM_I1>
+{
+    stelem_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stelem_i1_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STELEM_I2> {
-    stelem_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STELEM_I2>
+{
+    stelem_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stelem_i2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STELEM_I4> {
-    stelem_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STELEM_I4>
+{
+    stelem_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stelem_i4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STELEM_I> {
-    stelem_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STELEM_I>
+{
+    stelem_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stelem_i_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STELEM_BR2> {
-    stelem_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STELEM_BR2>
+{
+    stelem_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stelem_br2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STELEM_R4> {
-    stelem_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STELEM_R4>
+{
+    stelem_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stelem_r4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDARG> {
-    ldarg_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDARG>
+{
+    ldarg_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldarg_op_t op;
         op.index = reader.read_unaligned<uint16_t>();
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDARG_0> {
-    ldarg_0_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDARG_0>
+{
+    ldarg_0_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldarg_0_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDARG_1> {
-    ldarg_1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDARG_1>
+{
+    ldarg_1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldarg_1_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDARG_2> {
-    ldarg_2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDARG_2>
+{
+    ldarg_2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldarg_2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDARG_3> {
-    ldarg_3_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDARG_3>
+{
+    ldarg_3_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldarg_3_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDARG_4> {
-    ldarg_4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDARG_4>
+{
+    ldarg_4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldarg_4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDARG_5> {
-    ldarg_5_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDARG_5>
+{
+    ldarg_5_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldarg_5_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDTUPLE_ELEM> {
-    ldtuple_elem_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDTUPLE_ELEM>
+{
+    ldtuple_elem_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldtuple_elem_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDTUPLE> {
-    ldtuple_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDTUPLE>
+{
+    ldtuple_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldtuple_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDDATATYPE> {
-    lddatatype_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDDATATYPE>
+{
+    lddatatype_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         lddatatype_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDTENSOR> {
-    ldtensor_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDTENSOR>
+{
+    ldtensor_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldtensor_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDLOCAL> {
-    ldlocal_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDLOCAL>
+{
+    ldlocal_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldlocal_op_t op;
         op.index = reader.read_unaligned<uint16_t>();
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::STLOCAL> {
-    stlocal_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::STLOCAL>
+{
+    stlocal_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         stlocal_op_t op;
         op.index = reader.read_unaligned<uint16_t>();
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::LDSCALAR> {
-    ldscalar_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::LDSCALAR>
+{
+    ldscalar_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ldscalar_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::DUP> {
-    dup_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::DUP>
+{
+    dup_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         dup_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::POP> {
-    pop_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::POP>
+{
+    pop_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         pop_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::NEG> {
-    neg_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::NEG>
+{
+    neg_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         neg_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::ADD> {
-    add_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::ADD>
+{
+    add_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         add_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::SUB> {
-    sub_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::SUB>
+{
+    sub_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         sub_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::MUL> {
-    mul_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::MUL>
+{
+    mul_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         mul_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::DIV> {
-    div_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::DIV>
+{
+    div_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         div_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::DIV_U> {
-    div_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::DIV_U>
+{
+    div_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         div_u_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::REM> {
-    rem_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::REM>
+{
+    rem_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         rem_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::REM_U> {
-    rem_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::REM_U>
+{
+    rem_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         rem_u_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::AND> {
-    and_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::AND>
+{
+    and_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         and_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::OR> {
-    or_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::OR>
+{
+    or_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         or_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::XOR> {
-    xor_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::XOR>
+{
+    xor_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         xor_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::NOT> {
-    not_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::NOT>
+{
+    not_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         not_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::SHL> {
-    shl_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::SHL>
+{
+    shl_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         shl_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::SHR> {
-    shr_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::SHR>
+{
+    shr_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         shr_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::SHR_U> {
-    shr_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::SHR_U>
+{
+    shr_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         shr_u_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CLT> {
-    clt_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CLT>
+{
+    clt_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         clt_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CLT_U> {
-    clt_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CLT_U>
+{
+    clt_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         clt_u_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CLE> {
-    cle_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CLE>
+{
+    cle_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         cle_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CLE_U> {
-    cle_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CLE_U>
+{
+    cle_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         cle_u_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CEQ> {
-    ceq_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CEQ>
+{
+    ceq_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         ceq_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CGE> {
-    cge_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CGE>
+{
+    cge_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         cge_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CGE_U> {
-    cge_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CGE_U>
+{
+    cge_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         cge_u_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CGT> {
-    cgt_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CGT>
+{
+    cgt_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         cgt_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CGT_U> {
-    cgt_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CGT_U>
+{
+    cgt_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         cgt_u_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CNE> {
-    cne_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CNE>
+{
+    cne_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         cne_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CONV_I1> {
-    conv_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CONV_I1>
+{
+    conv_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         conv_i1_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CONV_I2> {
-    conv_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CONV_I2>
+{
+    conv_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         conv_i2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CONV_I4> {
-    conv_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CONV_I4>
+{
+    conv_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         conv_i4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CONV_I> {
-    conv_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CONV_I>
+{
+    conv_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         conv_i_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CONV_U1> {
-    conv_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CONV_U1>
+{
+    conv_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         conv_u1_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CONV_U2> {
-    conv_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CONV_U2>
+{
+    conv_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         conv_u2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CONV_U4> {
-    conv_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CONV_U4>
+{
+    conv_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         conv_u4_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CONV_U> {
-    conv_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CONV_U>
+{
+    conv_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         conv_u_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CONV_BR2> {
-    conv_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CONV_BR2>
+{
+    conv_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         conv_br2_op_t op;
         return op;
     }
 };
 
-template <> struct op_reader<opcode_t::CONV_R4> {
-    conv_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct op_reader<opcode_t::CONV_R4>
+{
+    conv_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         conv_r4_op_t op;
         return op;
     }
 };
 
-template <tensor_function_t Op> struct tensor_op_reader;
+template <tensor_function_t Op>
+struct tensor_op_reader;
 
-template <> struct tensor_op_reader<tensor_function_t::batch_normalization> {
-    tensor_batch_normalization_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::batch_normalization>
+{
+    tensor_batch_normalization_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_batch_normalization_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::batch_to_space> {
-    tensor_batch_to_space_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::batch_to_space>
+{
+    tensor_batch_to_space_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_batch_to_space_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::binary> {
-    tensor_binary_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::binary>
+{
+    tensor_binary_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_binary_op_t op;
-        op.binary_op =
-            static_cast<binary_op_t>(reader.read_unaligned<uint8_t>());
+        op.binary_op = static_cast<binary_op_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::bitcast> {
-    tensor_bitcast_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::bitcast>
+{
+    tensor_bitcast_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_bitcast_op_t op;
         op.type = reader.read_unaligned<prim_type_t>();
         op.new_type = reader.read_unaligned<prim_type_t>();
@@ -779,478 +1089,629 @@ template <> struct tensor_op_reader<tensor_function_t::bitcast> {
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::broadcast> {
-    tensor_broadcast_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::broadcast>
+{
+    tensor_broadcast_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_broadcast_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::broadcast_shape> {
-    tensor_broadcast_shape_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::broadcast_shape>
+{
+    tensor_broadcast_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_broadcast_shape_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::bucket_pad> {
-    tensor_bucket_pad_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::bucket_pad>
+{
+    tensor_bucket_pad_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_bucket_pad_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::cast> {
-    tensor_cast_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::cast>
+{
+    tensor_cast_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_cast_op_t op;
         op.new_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
-        op.cast_mode =
-            static_cast<cast_mode_t>(reader.read_unaligned<uint32_t>());
+        op.cast_mode = static_cast<cast_mode_t>(reader.read_unaligned<uint32_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::celu> {
-    tensor_celu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::celu>
+{
+    tensor_celu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_celu_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::clamp> {
-    tensor_clamp_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::clamp>
+{
+    tensor_clamp_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_clamp_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::compare> {
-    tensor_compare_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::compare>
+{
+    tensor_compare_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_compare_op_t op;
-        op.compare_op =
-            static_cast<compare_op_t>(reader.read_unaligned<uint8_t>());
+        op.compare_op = static_cast<compare_op_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::concat> {
-    tensor_concat_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::concat>
+{
+    tensor_concat_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_concat_op_t op;
+        op.axis = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::condition> {
-    tensor_condition_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::condition>
+{
+    tensor_condition_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_condition_op_t op;
         op.can_fold_const_call = reader.read_unaligned<bool>();
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::constant_of_shape> {
-    tensor_constant_of_shape_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::constant_of_shape>
+{
+    tensor_constant_of_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_constant_of_shape_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::conv2d> {
-    tensor_conv2d_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::conv2d>
+{
+    tensor_conv2d_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_conv2d_op_t op;
         op.pad_mode = static_cast<pad_mode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::conv2d_shape> {
-    tensor_conv2d_shape_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::conv2d_shape>
+{
+    tensor_conv2d_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_conv2d_shape_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::conv2d_transpose> {
-    tensor_conv2d_transpose_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::conv2d_transpose>
+{
+    tensor_conv2d_transpose_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_conv2d_transpose_op_t op;
         op.pad_mode = static_cast<pad_mode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::conv2d_transpose_shape> {
-    tensor_conv2d_transpose_shape_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::conv2d_transpose_shape>
+{
+    tensor_conv2d_transpose_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_conv2d_transpose_shape_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::cum_sum> {
-    tensor_cum_sum_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::cum_sum>
+{
+    tensor_cum_sum_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_cum_sum_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::dequantize> {
-    tensor_dequantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::dequantize>
+{
+    tensor_dequantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_dequantize_op_t op;
-        op.target_type =
-            static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
+        op.target_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::elu> {
-    tensor_elu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::elu>
+{
+    tensor_elu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_elu_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::erf> {
-    tensor_erf_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::erf>
+{
+    tensor_erf_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_erf_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::expand> {
-    tensor_expand_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::expand>
+{
+    tensor_expand_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_expand_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::fake_dequantize> {
-    tensor_fake_dequantize_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::fake_dequantize>
+{
+    tensor_fake_dequantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_fake_dequantize_op_t op;
-        op.target_type =
-            static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
+        op.target_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::fake_quantize> {
-    tensor_fake_quantize_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::fake_quantize>
+{
+    tensor_fake_quantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_fake_quantize_op_t op;
-        op.target_type =
-            static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
+        op.target_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::fix_shape> {
-    tensor_fix_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::fix_shape>
+{
+    tensor_fix_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_fix_shape_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::flatten> {
-    tensor_flatten_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::flatten>
+{
+    tensor_flatten_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_flatten_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::gather> {
-    tensor_gather_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::gather>
+{
+    tensor_gather_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_gather_op_t op;
+        op.axis = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::gather_elements> {
-    tensor_gather_elements_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::gather_elements>
+{
+    tensor_gather_elements_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_gather_elements_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::gather_nd> {
-    tensor_gather_nd_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::gather_nd>
+{
+    tensor_gather_nd_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_gather_nd_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::gelu> {
-    tensor_gelu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::gelu>
+{
+    tensor_gelu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_gelu_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::get_item> {
-    tensor_get_item_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::get_item>
+{
+    tensor_get_item_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_get_item_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::get_paddings> {
-    tensor_get_paddings_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::get_paddings>
+{
+    tensor_get_paddings_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_get_paddings_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::hard_sigmoid> {
-    tensor_hard_sigmoid_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::hard_sigmoid>
+{
+    tensor_hard_sigmoid_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_hard_sigmoid_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::hard_swish> {
-    tensor_hard_swish_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::hard_swish>
+{
+    tensor_hard_swish_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_hard_swish_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::hardmax> {
-    tensor_hardmax_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::hardmax>
+{
+    tensor_hardmax_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_hardmax_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::index_of> {
-    tensor_index_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::index_of>
+{
+    tensor_index_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_index_of_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::instance_normalization> {
-    tensor_instance_normalization_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::instance_normalization>
+{
+    tensor_instance_normalization_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_instance_normalization_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::l2_normalization> {
-    tensor_l2_normalization_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::l2_normalization>
+{
+    tensor_l2_normalization_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_l2_normalization_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::layer_norm> {
-    tensor_layer_norm_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::layer_norm>
+{
+    tensor_layer_norm_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_layer_norm_op_t op;
         op.axis = reader.read_unaligned<int32_t>();
         op.epsilon = reader.read_unaligned<float>();
+        op.use_mean = reader.read_unaligned<bool>();
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::leaky_relu> {
-    tensor_leaky_relu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::leaky_relu>
+{
+    tensor_leaky_relu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_leaky_relu_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::log_softmax> {
-    tensor_log_softmax_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::log_softmax>
+{
+    tensor_log_softmax_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_log_softmax_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::lp_normalization> {
-    tensor_lp_normalization_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::lp_normalization>
+{
+    tensor_lp_normalization_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_lp_normalization_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::lrn> {
-    tensor_lrn_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::lrn>
+{
+    tensor_lrn_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_lrn_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::lstm> {
-    tensor_lstm_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::lstm>
+{
+    tensor_lstm_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_lstm_op_t op;
-        op.direction =
-            static_cast<lstmdirection_t>(reader.read_unaligned<uint32_t>());
-        op.layout =
-            static_cast<lstmlayout_t>(reader.read_unaligned<uint32_t>());
+        op.direction = static_cast<lstmdirection_t>(reader.read_unaligned<uint32_t>());
+        op.layout = static_cast<lstmlayout_t>(reader.read_unaligned<uint32_t>());
         op.activations = reader.read_string_array();
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::mat_mul> {
-    tensor_mat_mul_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::mat_mul>
+{
+    tensor_mat_mul_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_mat_mul_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::mat_mul_shape> {
-    tensor_mat_mul_shape_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::mat_mul_shape>
+{
+    tensor_mat_mul_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_mat_mul_shape_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::normal> {
-    tensor_normal_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::normal>
+{
+    tensor_normal_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_normal_op_t op;
         op.type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::normal_like> {
-    tensor_normal_like_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::normal_like>
+{
+    tensor_normal_like_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_normal_like_op_t op;
         op.type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::one_hot> {
-    tensor_one_hot_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::one_hot>
+{
+    tensor_one_hot_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_one_hot_op_t op;
-        op.one_hot_mode =
-            static_cast<one_hot_mode_t>(reader.read_unaligned<uint8_t>());
+        op.one_hot_mode = static_cast<one_hot_mode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::pad> {
-    tensor_pad_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::pad>
+{
+    tensor_pad_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_pad_op_t op;
         op.pad_mode = static_cast<pad_mode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::prelu> {
-    tensor_prelu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::prelu>
+{
+    tensor_prelu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_prelu_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::prod> {
-    tensor_prod_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::prod>
+{
+    tensor_prod_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_prod_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::quant_param_of> {
-    tensor_quant_param_of_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::quant_param_of>
+{
+    tensor_quant_param_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_quant_param_of_op_t op;
-        op.quant_mode =
-            static_cast<quant_mode_t>(reader.read_unaligned<uint32_t>());
+        op.quant_mode = static_cast<quant_mode_t>(reader.read_unaligned<uint32_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::quantize> {
-    tensor_quantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::quantize>
+{
+    tensor_quantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_quantize_op_t op;
-        op.target_type =
-            static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
+        op.target_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::range> {
-    tensor_range_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::range>
+{
+    tensor_range_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_range_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::range_of> {
-    tensor_range_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::range_of>
+{
+    tensor_range_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_range_of_op_t op;
         op.is_range_of_weight = reader.read_unaligned<bool>();
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::rank> {
-    tensor_rank_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::rank>
+{
+    tensor_rank_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_rank_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::reduce> {
-    tensor_reduce_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::reduce>
+{
+    tensor_reduce_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_reduce_op_t op;
-        op.reduce_op =
-            static_cast<reduce_op_t>(reader.read_unaligned<uint8_t>());
+        op.reduce_op = static_cast<reduce_op_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::reduce_arg> {
-    tensor_reduce_arg_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::reduce_arg>
+{
+    tensor_reduce_arg_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_reduce_arg_op_t op;
-        op.reduce_arg_op =
-            static_cast<reduce_arg_op_t>(reader.read_unaligned<uint8_t>());
-        op.dest_type =
-            static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
+        op.reduce_arg_op = static_cast<reduce_arg_op_t>(reader.read_unaligned<uint8_t>());
+        op.dest_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::reduce_window2d> {
-    tensor_reduce_window2d_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::reduce_window2d>
+{
+    tensor_reduce_window2d_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_reduce_window2d_op_t op;
-        op.reduce_op =
-            static_cast<reduce_op_t>(reader.read_unaligned<uint8_t>());
+        op.reduce_op = static_cast<reduce_op_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::relu> {
-    tensor_relu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::relu>
+{
+    tensor_relu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_relu_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::relu6> {
-    tensor_relu6_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::relu6>
+{
+    tensor_relu6_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_relu6_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::require> {
-    tensor_require_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::require>
+{
+    tensor_require_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_require_op_t op;
         op.message = reader.read_string();
         op.can_fold_const_call = reader.read_unaligned<bool>();
@@ -1258,635 +1719,427 @@ template <> struct tensor_op_reader<tensor_function_t::require> {
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::reshape> {
-    tensor_reshape_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::reshape>
+{
+    tensor_reshape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_reshape_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::reshape_shape> {
-    tensor_reshape_shape_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::reshape_shape>
+{
+    tensor_reshape_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_reshape_shape_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::resize_image> {
-    tensor_resize_image_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::resize_image>
+{
+    tensor_resize_image_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_resize_image_op_t op;
-        op.resize_mode =
-            static_cast<image_resize_mode_t>(reader.read_unaligned<uint8_t>());
-        op.transformation_mode =
-            static_cast<image_resize_transformation_mode_t>(
-                reader.read_unaligned<uint32_t>());
-        op.nearest_mode = static_cast<image_resize_nearest_mode_t>(
-            reader.read_unaligned<uint32_t>());
+        op.resize_mode = static_cast<image_resize_mode_t>(reader.read_unaligned<uint8_t>());
+        op.transformation_mode = static_cast<image_resize_transformation_mode_t>(reader.read_unaligned<uint32_t>());
+        op.nearest_mode = static_cast<image_resize_nearest_mode_t>(reader.read_unaligned<uint32_t>());
         op.is_tfresize = reader.read_unaligned<bool>();
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::reverse_sequence> {
-    tensor_reverse_sequence_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::reverse_sequence>
+{
+    tensor_reverse_sequence_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_reverse_sequence_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::scatter_nd> {
-    tensor_scatter_nd_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::scatter_nd>
+{
+    tensor_scatter_nd_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_scatter_nd_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::select> {
-    tensor_select_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::select>
+{
+    tensor_select_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_select_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::selu> {
-    tensor_selu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::selu>
+{
+    tensor_selu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_selu_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::shape_of> {
-    tensor_shape_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::shape_of>
+{
+    tensor_shape_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_shape_of_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::sigmoid> {
-    tensor_sigmoid_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::sigmoid>
+{
+    tensor_sigmoid_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_sigmoid_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::size_of> {
-    tensor_size_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::size_of>
+{
+    tensor_size_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_size_of_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::slice> {
-    tensor_slice_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::slice>
+{
+    tensor_slice_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_slice_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::softmax> {
-    tensor_softmax_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::softmax>
+{
+    tensor_softmax_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_softmax_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::softplus> {
-    tensor_softplus_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::softplus>
+{
+    tensor_softplus_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_softplus_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::softsign> {
-    tensor_softsign_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::softsign>
+{
+    tensor_softsign_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_softsign_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::space_to_batch> {
-    tensor_space_to_batch_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::space_to_batch>
+{
+    tensor_space_to_batch_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_space_to_batch_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::split> {
-    tensor_split_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::split>
+{
+    tensor_split_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_split_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::squeeze> {
-    tensor_squeeze_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::squeeze>
+{
+    tensor_squeeze_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_squeeze_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::squeeze_shape> {
-    tensor_squeeze_shape_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::squeeze_shape>
+{
+    tensor_squeeze_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_squeeze_shape_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::stack> {
-    tensor_stack_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::stack>
+{
+    tensor_stack_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_stack_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::swish> {
-    tensor_swish_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::swish>
+{
+    tensor_swish_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_swish_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::tile> {
-    tensor_tile_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::tile>
+{
+    tensor_tile_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_tile_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::top_k> {
-    tensor_top_k_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::top_k>
+{
+    tensor_top_k_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_top_k_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::transpose> {
-    tensor_transpose_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::transpose>
+{
+    tensor_transpose_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_transpose_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::transpose_shape> {
-    tensor_transpose_shape_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::transpose_shape>
+{
+    tensor_transpose_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_transpose_shape_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::trilu> {
-    tensor_trilu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::trilu>
+{
+    tensor_trilu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_trilu_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::unary> {
-    tensor_unary_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::unary>
+{
+    tensor_unary_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_unary_op_t op;
         op.unary_op = static_cast<unary_op_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::uniform> {
-    tensor_uniform_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::uniform>
+{
+    tensor_uniform_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_uniform_op_t op;
         op.type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::uniform_like> {
-    tensor_uniform_like_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::uniform_like>
+{
+    tensor_uniform_like_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_uniform_like_op_t op;
         op.type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::unsqueeze> {
-    tensor_unsqueeze_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::unsqueeze>
+{
+    tensor_unsqueeze_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_unsqueeze_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::unsqueeze_shape> {
-    tensor_unsqueeze_shape_op_t
-    operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::unsqueeze_shape>
+{
+    tensor_unsqueeze_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_unsqueeze_shape_op_t op;
         return op;
     }
 };
 
-template <> struct tensor_op_reader<tensor_function_t::where> {
-    tensor_where_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
+template <>
+struct tensor_op_reader<tensor_function_t::where>
+{
+    tensor_where_op_t operator()(NNCASE_UNUSED span_reader &reader) const
+    {
         tensor_where_op_t op;
         op.is_tf_where = reader.read_unaligned<bool>();
         return op;
     }
 };
 
-class NNCASE_API tensor_op_visitor {
-  public:
-    result<void> visit(tensor_function_t tensor_funct,
-                       span_reader &reader) noexcept;
-
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_batch_normalization_op_t &op) noexcept {
-        return default_visit(tensor_function_t::batch_normalization, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_batch_to_space_op_t &op) noexcept {
-        return default_visit(tensor_function_t::batch_to_space, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_binary_op_t &op) noexcept {
-        return default_visit(tensor_function_t::binary, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_bitcast_op_t &op) noexcept {
-        return default_visit(tensor_function_t::bitcast, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_broadcast_op_t &op) noexcept {
-        return default_visit(tensor_function_t::broadcast, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_broadcast_shape_op_t &op) noexcept {
-        return default_visit(tensor_function_t::broadcast_shape, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_bucket_pad_op_t &op) noexcept {
-        return default_visit(tensor_function_t::bucket_pad, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_cast_op_t &op) noexcept {
-        return default_visit(tensor_function_t::cast, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_celu_op_t &op) noexcept {
-        return default_visit(tensor_function_t::celu, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_clamp_op_t &op) noexcept {
-        return default_visit(tensor_function_t::clamp, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_compare_op_t &op) noexcept {
-        return default_visit(tensor_function_t::compare, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_concat_op_t &op) noexcept {
-        return default_visit(tensor_function_t::concat, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_condition_op_t &op) noexcept {
-        return default_visit(tensor_function_t::condition, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_constant_of_shape_op_t &op) noexcept {
-        return default_visit(tensor_function_t::constant_of_shape, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_conv2d_op_t &op) noexcept {
-        return default_visit(tensor_function_t::conv2d, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_conv2d_shape_op_t &op) noexcept {
-        return default_visit(tensor_function_t::conv2d_shape, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_conv2d_transpose_op_t &op) noexcept {
-        return default_visit(tensor_function_t::conv2d_transpose, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_conv2d_transpose_shape_op_t &op) noexcept {
-        return default_visit(tensor_function_t::conv2d_transpose_shape, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_cum_sum_op_t &op) noexcept {
-        return default_visit(tensor_function_t::cum_sum, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_dequantize_op_t &op) noexcept {
-        return default_visit(tensor_function_t::dequantize, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_elu_op_t &op) noexcept {
-        return default_visit(tensor_function_t::elu, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_erf_op_t &op) noexcept {
-        return default_visit(tensor_function_t::erf, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_expand_op_t &op) noexcept {
-        return default_visit(tensor_function_t::expand, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_fake_dequantize_op_t &op) noexcept {
-        return default_visit(tensor_function_t::fake_dequantize, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_fake_quantize_op_t &op) noexcept {
-        return default_visit(tensor_function_t::fake_quantize, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_fix_shape_op_t &op) noexcept {
-        return default_visit(tensor_function_t::fix_shape, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_flatten_op_t &op) noexcept {
-        return default_visit(tensor_function_t::flatten, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_gather_op_t &op) noexcept {
-        return default_visit(tensor_function_t::gather, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_gather_elements_op_t &op) noexcept {
-        return default_visit(tensor_function_t::gather_elements, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_gather_nd_op_t &op) noexcept {
-        return default_visit(tensor_function_t::gather_nd, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_gelu_op_t &op) noexcept {
-        return default_visit(tensor_function_t::gelu, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_get_item_op_t &op) noexcept {
-        return default_visit(tensor_function_t::get_item, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_get_paddings_op_t &op) noexcept {
-        return default_visit(tensor_function_t::get_paddings, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_hard_sigmoid_op_t &op) noexcept {
-        return default_visit(tensor_function_t::hard_sigmoid, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_hard_swish_op_t &op) noexcept {
-        return default_visit(tensor_function_t::hard_swish, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_hardmax_op_t &op) noexcept {
-        return default_visit(tensor_function_t::hardmax, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_index_of_op_t &op) noexcept {
-        return default_visit(tensor_function_t::index_of, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_instance_normalization_op_t &op) noexcept {
-        return default_visit(tensor_function_t::instance_normalization, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_l2_normalization_op_t &op) noexcept {
-        return default_visit(tensor_function_t::l2_normalization, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_layer_norm_op_t &op) noexcept {
-        return default_visit(tensor_function_t::layer_norm, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_leaky_relu_op_t &op) noexcept {
-        return default_visit(tensor_function_t::leaky_relu, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_log_softmax_op_t &op) noexcept {
-        return default_visit(tensor_function_t::log_softmax, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_lp_normalization_op_t &op) noexcept {
-        return default_visit(tensor_function_t::lp_normalization, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_lrn_op_t &op) noexcept {
-        return default_visit(tensor_function_t::lrn, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_lstm_op_t &op) noexcept {
-        return default_visit(tensor_function_t::lstm, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_mat_mul_op_t &op) noexcept {
-        return default_visit(tensor_function_t::mat_mul, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_mat_mul_shape_op_t &op) noexcept {
-        return default_visit(tensor_function_t::mat_mul_shape, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_normal_op_t &op) noexcept {
-        return default_visit(tensor_function_t::normal, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_normal_like_op_t &op) noexcept {
-        return default_visit(tensor_function_t::normal_like, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_one_hot_op_t &op) noexcept {
-        return default_visit(tensor_function_t::one_hot, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_pad_op_t &op) noexcept {
-        return default_visit(tensor_function_t::pad, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_prelu_op_t &op) noexcept {
-        return default_visit(tensor_function_t::prelu, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_prod_op_t &op) noexcept {
-        return default_visit(tensor_function_t::prod, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_quant_param_of_op_t &op) noexcept {
-        return default_visit(tensor_function_t::quant_param_of, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_quantize_op_t &op) noexcept {
-        return default_visit(tensor_function_t::quantize, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_range_op_t &op) noexcept {
-        return default_visit(tensor_function_t::range, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_range_of_op_t &op) noexcept {
-        return default_visit(tensor_function_t::range_of, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_rank_op_t &op) noexcept {
-        return default_visit(tensor_function_t::rank, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_reduce_op_t &op) noexcept {
-        return default_visit(tensor_function_t::reduce, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_reduce_arg_op_t &op) noexcept {
-        return default_visit(tensor_function_t::reduce_arg, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_reduce_window2d_op_t &op) noexcept {
-        return default_visit(tensor_function_t::reduce_window2d, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_relu_op_t &op) noexcept {
-        return default_visit(tensor_function_t::relu, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_relu6_op_t &op) noexcept {
-        return default_visit(tensor_function_t::relu6, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_require_op_t &op) noexcept {
-        return default_visit(tensor_function_t::require, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_reshape_op_t &op) noexcept {
-        return default_visit(tensor_function_t::reshape, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_reshape_shape_op_t &op) noexcept {
-        return default_visit(tensor_function_t::reshape_shape, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_resize_image_op_t &op) noexcept {
-        return default_visit(tensor_function_t::resize_image, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_reverse_sequence_op_t &op) noexcept {
-        return default_visit(tensor_function_t::reverse_sequence, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_scatter_nd_op_t &op) noexcept {
-        return default_visit(tensor_function_t::scatter_nd, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_select_op_t &op) noexcept {
-        return default_visit(tensor_function_t::select, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_selu_op_t &op) noexcept {
-        return default_visit(tensor_function_t::selu, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_shape_of_op_t &op) noexcept {
-        return default_visit(tensor_function_t::shape_of, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_sigmoid_op_t &op) noexcept {
-        return default_visit(tensor_function_t::sigmoid, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_size_of_op_t &op) noexcept {
-        return default_visit(tensor_function_t::size_of, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_slice_op_t &op) noexcept {
-        return default_visit(tensor_function_t::slice, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_softmax_op_t &op) noexcept {
-        return default_visit(tensor_function_t::softmax, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_softplus_op_t &op) noexcept {
-        return default_visit(tensor_function_t::softplus, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_softsign_op_t &op) noexcept {
-        return default_visit(tensor_function_t::softsign, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_space_to_batch_op_t &op) noexcept {
-        return default_visit(tensor_function_t::space_to_batch, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_split_op_t &op) noexcept {
-        return default_visit(tensor_function_t::split, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_squeeze_op_t &op) noexcept {
-        return default_visit(tensor_function_t::squeeze, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_squeeze_shape_op_t &op) noexcept {
-        return default_visit(tensor_function_t::squeeze_shape, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_stack_op_t &op) noexcept {
-        return default_visit(tensor_function_t::stack, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_swish_op_t &op) noexcept {
-        return default_visit(tensor_function_t::swish, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_tile_op_t &op) noexcept {
-        return default_visit(tensor_function_t::tile, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_top_k_op_t &op) noexcept {
-        return default_visit(tensor_function_t::top_k, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_transpose_op_t &op) noexcept {
-        return default_visit(tensor_function_t::transpose, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_transpose_shape_op_t &op) noexcept {
-        return default_visit(tensor_function_t::transpose_shape, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_trilu_op_t &op) noexcept {
-        return default_visit(tensor_function_t::trilu, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_unary_op_t &op) noexcept {
-        return default_visit(tensor_function_t::unary, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_uniform_op_t &op) noexcept {
-        return default_visit(tensor_function_t::uniform, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_uniform_like_op_t &op) noexcept {
-        return default_visit(tensor_function_t::uniform_like, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_unsqueeze_op_t &op) noexcept {
-        return default_visit(tensor_function_t::unsqueeze, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_unsqueeze_shape_op_t &op) noexcept {
-        return default_visit(tensor_function_t::unsqueeze_shape, &op);
-    }
-    virtual result<void>
-    visit(NNCASE_UNUSED const tensor_where_op_t &op) noexcept {
-        return default_visit(tensor_function_t::where, &op);
-    }
-
-  protected:
-    virtual result<void>
-    default_visit(NNCASE_UNUSED tensor_function_t tensor_funct,
-                  NNCASE_UNUSED const void *op) noexcept {
-        return err(std::errc::not_supported);
-    }
+class NNCASE_API tensor_op_visitor
+{
+public:
+    result<void> visit(tensor_function_t tensor_funct, span_reader &reader) noexcept;
+
+    virtual result<void> visit(NNCASE_UNUSED const tensor_batch_normalization_op_t &op) noexcept { return default_visit(tensor_function_t::batch_normalization, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_batch_to_space_op_t &op) noexcept { return default_visit(tensor_function_t::batch_to_space, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_binary_op_t &op) noexcept { return default_visit(tensor_function_t::binary, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_bitcast_op_t &op) noexcept { return default_visit(tensor_function_t::bitcast, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_broadcast_op_t &op) noexcept { return default_visit(tensor_function_t::broadcast, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_broadcast_shape_op_t &op) noexcept { return default_visit(tensor_function_t::broadcast_shape, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_bucket_pad_op_t &op) noexcept { return default_visit(tensor_function_t::bucket_pad, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_cast_op_t &op) noexcept { return default_visit(tensor_function_t::cast, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_celu_op_t &op) noexcept { return default_visit(tensor_function_t::celu, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_clamp_op_t &op) noexcept { return default_visit(tensor_function_t::clamp, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_compare_op_t &op) noexcept { return default_visit(tensor_function_t::compare, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_concat_op_t &op) noexcept { return default_visit(tensor_function_t::concat, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_condition_op_t &op) noexcept { return default_visit(tensor_function_t::condition, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_constant_of_shape_op_t &op) noexcept { return default_visit(tensor_function_t::constant_of_shape, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_conv2d_op_t &op) noexcept { return default_visit(tensor_function_t::conv2d, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_conv2d_shape_op_t &op) noexcept { return default_visit(tensor_function_t::conv2d_shape, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_conv2d_transpose_op_t &op) noexcept { return default_visit(tensor_function_t::conv2d_transpose, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_conv2d_transpose_shape_op_t &op) noexcept { return default_visit(tensor_function_t::conv2d_transpose_shape, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_cum_sum_op_t &op) noexcept { return default_visit(tensor_function_t::cum_sum, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_dequantize_op_t &op) noexcept { return default_visit(tensor_function_t::dequantize, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_elu_op_t &op) noexcept { return default_visit(tensor_function_t::elu, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_erf_op_t &op) noexcept { return default_visit(tensor_function_t::erf, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_expand_op_t &op) noexcept { return default_visit(tensor_function_t::expand, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_fake_dequantize_op_t &op) noexcept { return default_visit(tensor_function_t::fake_dequantize, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_fake_quantize_op_t &op) noexcept { return default_visit(tensor_function_t::fake_quantize, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_fix_shape_op_t &op) noexcept { return default_visit(tensor_function_t::fix_shape, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_flatten_op_t &op) noexcept { return default_visit(tensor_function_t::flatten, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_gather_op_t &op) noexcept { return default_visit(tensor_function_t::gather, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_gather_elements_op_t &op) noexcept { return default_visit(tensor_function_t::gather_elements, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_gather_nd_op_t &op) noexcept { return default_visit(tensor_function_t::gather_nd, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_gelu_op_t &op) noexcept { return default_visit(tensor_function_t::gelu, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_get_item_op_t &op) noexcept { return default_visit(tensor_function_t::get_item, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_get_paddings_op_t &op) noexcept { return default_visit(tensor_function_t::get_paddings, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_hard_sigmoid_op_t &op) noexcept { return default_visit(tensor_function_t::hard_sigmoid, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_hard_swish_op_t &op) noexcept { return default_visit(tensor_function_t::hard_swish, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_hardmax_op_t &op) noexcept { return default_visit(tensor_function_t::hardmax, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_index_of_op_t &op) noexcept { return default_visit(tensor_function_t::index_of, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_instance_normalization_op_t &op) noexcept { return default_visit(tensor_function_t::instance_normalization, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_l2_normalization_op_t &op) noexcept { return default_visit(tensor_function_t::l2_normalization, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_layer_norm_op_t &op) noexcept { return default_visit(tensor_function_t::layer_norm, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_leaky_relu_op_t &op) noexcept { return default_visit(tensor_function_t::leaky_relu, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_log_softmax_op_t &op) noexcept { return default_visit(tensor_function_t::log_softmax, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_lp_normalization_op_t &op) noexcept { return default_visit(tensor_function_t::lp_normalization, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_lrn_op_t &op) noexcept { return default_visit(tensor_function_t::lrn, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_lstm_op_t &op) noexcept { return default_visit(tensor_function_t::lstm, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_mat_mul_op_t &op) noexcept { return default_visit(tensor_function_t::mat_mul, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_mat_mul_shape_op_t &op) noexcept { return default_visit(tensor_function_t::mat_mul_shape, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_normal_op_t &op) noexcept { return default_visit(tensor_function_t::normal, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_normal_like_op_t &op) noexcept { return default_visit(tensor_function_t::normal_like, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_one_hot_op_t &op) noexcept { return default_visit(tensor_function_t::one_hot, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_pad_op_t &op) noexcept { return default_visit(tensor_function_t::pad, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_prelu_op_t &op) noexcept { return default_visit(tensor_function_t::prelu, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_prod_op_t &op) noexcept { return default_visit(tensor_function_t::prod, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_quant_param_of_op_t &op) noexcept { return default_visit(tensor_function_t::quant_param_of, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_quantize_op_t &op) noexcept { return default_visit(tensor_function_t::quantize, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_range_op_t &op) noexcept { return default_visit(tensor_function_t::range, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_range_of_op_t &op) noexcept { return default_visit(tensor_function_t::range_of, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_rank_op_t &op) noexcept { return default_visit(tensor_function_t::rank, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_reduce_op_t &op) noexcept { return default_visit(tensor_function_t::reduce, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_reduce_arg_op_t &op) noexcept { return default_visit(tensor_function_t::reduce_arg, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_reduce_window2d_op_t &op) noexcept { return default_visit(tensor_function_t::reduce_window2d, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_relu_op_t &op) noexcept { return default_visit(tensor_function_t::relu, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_relu6_op_t &op) noexcept { return default_visit(tensor_function_t::relu6, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_require_op_t &op) noexcept { return default_visit(tensor_function_t::require, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_reshape_op_t &op) noexcept { return default_visit(tensor_function_t::reshape, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_reshape_shape_op_t &op) noexcept { return default_visit(tensor_function_t::reshape_shape, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_resize_image_op_t &op) noexcept { return default_visit(tensor_function_t::resize_image, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_reverse_sequence_op_t &op) noexcept { return default_visit(tensor_function_t::reverse_sequence, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_scatter_nd_op_t &op) noexcept { return default_visit(tensor_function_t::scatter_nd, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_select_op_t &op) noexcept { return default_visit(tensor_function_t::select, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_selu_op_t &op) noexcept { return default_visit(tensor_function_t::selu, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_shape_of_op_t &op) noexcept { return default_visit(tensor_function_t::shape_of, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_sigmoid_op_t &op) noexcept { return default_visit(tensor_function_t::sigmoid, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_size_of_op_t &op) noexcept { return default_visit(tensor_function_t::size_of, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_slice_op_t &op) noexcept { return default_visit(tensor_function_t::slice, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_softmax_op_t &op) noexcept { return default_visit(tensor_function_t::softmax, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_softplus_op_t &op) noexcept { return default_visit(tensor_function_t::softplus, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_softsign_op_t &op) noexcept { return default_visit(tensor_function_t::softsign, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_space_to_batch_op_t &op) noexcept { return default_visit(tensor_function_t::space_to_batch, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_split_op_t &op) noexcept { return default_visit(tensor_function_t::split, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_squeeze_op_t &op) noexcept { return default_visit(tensor_function_t::squeeze, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_squeeze_shape_op_t &op) noexcept { return default_visit(tensor_function_t::squeeze_shape, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_stack_op_t &op) noexcept { return default_visit(tensor_function_t::stack, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_swish_op_t &op) noexcept { return default_visit(tensor_function_t::swish, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_tile_op_t &op) noexcept { return default_visit(tensor_function_t::tile, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_top_k_op_t &op) noexcept { return default_visit(tensor_function_t::top_k, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_transpose_op_t &op) noexcept { return default_visit(tensor_function_t::transpose, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_transpose_shape_op_t &op) noexcept { return default_visit(tensor_function_t::transpose_shape, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_trilu_op_t &op) noexcept { return default_visit(tensor_function_t::trilu, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_unary_op_t &op) noexcept { return default_visit(tensor_function_t::unary, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_uniform_op_t &op) noexcept { return default_visit(tensor_function_t::uniform, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_uniform_like_op_t &op) noexcept { return default_visit(tensor_function_t::uniform_like, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_unsqueeze_op_t &op) noexcept { return default_visit(tensor_function_t::unsqueeze, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_unsqueeze_shape_op_t &op) noexcept { return default_visit(tensor_function_t::unsqueeze_shape, &op); }
+    virtual result<void> visit(NNCASE_UNUSED const tensor_where_op_t &op) noexcept { return default_visit(tensor_function_t::where, &op); }
+
+protected:
+    virtual result<void> default_visit(NNCASE_UNUSED tensor_function_t tensor_funct, NNCASE_UNUSED const void *op) noexcept { return err(std::errc::not_supported); }
 };
 
 END_NS_NNCASE_RT_MODULE
diff --git a/src/Native/include/nncase/runtime/stackvm/opcode.h b/src/Native/include/nncase/runtime/stackvm/opcode.h
index 5c17c82894..6bf7ac71c1 100644
--- a/src/Native/include/nncase/runtime/stackvm/opcode.h
+++ b/src/Native/include/nncase/runtime/stackvm/opcode.h
@@ -1,5 +1,4 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 2023/9/5 19:40:29
- * +08:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -23,7 +22,8 @@ BEGIN_NS_NNCASE_RT_MODULE(stackvm)
 
 // Enums
 
-enum class opcode_t : uint8_t {
+enum class opcode_t : uint8_t
+{
     NOP = 0,
     LDNULL = 1,
     LDC_I4 = 2,
@@ -127,7 +127,8 @@ enum class opcode_t : uint8_t {
     TENSOR = 100,
 };
 
-enum class tensor_function_t : uint16_t {
+enum class tensor_function_t : uint16_t
+{
     batch_normalization = 0,
     batch_to_space = 1,
     celu = 8,
@@ -190,7 +191,6 @@ enum class tensor_function_t : uint16_t {
     gather_nd = 29,
     get_item = 31,
     index_of = 36,
-    lstm = 44,
     prod = 52,
     range = 55,
     rank = 57,
@@ -218,6 +218,7 @@ enum class tensor_function_t : uint16_t {
     squeeze_shape = 81,
     transpose_shape = 87,
     unsqueeze_shape = 93,
+    lstm = 44,
     normal = 47,
     normal_like = 48,
     uniform = 90,
@@ -225,7 +226,8 @@ enum class tensor_function_t : uint16_t {
     resize_image = 66,
 };
 
-enum class binary_op_t : uint8_t {
+enum class binary_op_t : uint8_t
+{
     add = 0,
     sub = 1,
     mul = 2,
@@ -244,14 +246,16 @@ enum class binary_op_t : uint8_t {
     right_shift = 15,
 };
 
-enum class cast_mode_t : int32_t {
+enum class cast_mode_t : int32_t
+{
     kdefault = 0,
     exact = 1,
     check_overflow = 2,
     reinterpret = 3,
 };
 
-enum class compare_op_t : uint8_t {
+enum class compare_op_t : uint8_t
+{
     equal = 0,
     not_equal = 1,
     lower_than = 2,
@@ -260,36 +264,42 @@ enum class compare_op_t : uint8_t {
     greater_or_equal = 5,
 };
 
-enum class pad_mode_t : uint8_t {
+enum class pad_mode_t : uint8_t
+{
     constant = 0,
     reflect = 1,
     symmetric = 2,
     edge = 3,
 };
 
-enum class lstmdirection_t : int32_t {
+enum class lstmdirection_t : int32_t
+{
     forward = 0,
     reverse = 1,
     bidirectional = 2,
 };
 
-enum class lstmlayout_t : int32_t {
+enum class lstmlayout_t : int32_t
+{
     zero = 0,
     one = 1,
 };
 
-enum class one_hot_mode_t : uint8_t {
+enum class one_hot_mode_t : uint8_t
+{
     normal = 0,
     process_neg = 1,
 };
 
-enum class quant_mode_t : int32_t {
+enum class quant_mode_t : int32_t
+{
     unsigned_mode = 0,
     signed_symmetric_mode = 1,
     signed_asymmetric_mode = 2,
 };
 
-enum class reduce_op_t : uint8_t {
+enum class reduce_op_t : uint8_t
+{
     mean = 0,
     min = 1,
     max = 2,
@@ -297,17 +307,20 @@ enum class reduce_op_t : uint8_t {
     prod = 4,
 };
 
-enum class reduce_arg_op_t : uint8_t {
+enum class reduce_arg_op_t : uint8_t
+{
     arg_min = 0,
     arg_max = 1,
 };
 
-enum class image_resize_mode_t : uint8_t {
+enum class image_resize_mode_t : uint8_t
+{
     bilinear = 0,
     nearest_neighbor = 1,
 };
 
-enum class image_resize_transformation_mode_t : int32_t {
+enum class image_resize_transformation_mode_t : int32_t
+{
     half_pixel = 0,
     pytorch_half_pixel = 1,
     align_corners = 2,
@@ -315,14 +328,16 @@ enum class image_resize_transformation_mode_t : int32_t {
     tfcrop_and_resize = 4,
 };
 
-enum class image_resize_nearest_mode_t : int32_t {
+enum class image_resize_nearest_mode_t : int32_t
+{
     round_prefer_floor = 0,
     round_prefer_ceil = 1,
     floor = 2,
     ceil = 3,
 };
 
-enum class unary_op_t : uint8_t {
+enum class unary_op_t : uint8_t
+{
     abs = 0,
     acos = 1,
     acosh = 2,
@@ -349,895 +364,1058 @@ enum class unary_op_t : uint8_t {
 
 // Instructions
 
-struct nop_op_t {};
+struct nop_op_t
+{
+};
 
-struct br_op_t {
+struct br_op_t
+{
     int32_t target;
 };
 
-struct br_true_op_t {
+struct br_true_op_t
+{
     int32_t target;
 };
 
-struct br_false_op_t {
+struct br_false_op_t
+{
     int32_t target;
 };
 
-struct ret_op_t {};
+struct ret_op_t
+{
+};
 
-struct call_op_t {
+struct call_op_t
+{
     uint16_t args;
     int32_t target;
 };
 
-struct ecall_op_t {
+struct ecall_op_t
+{
     uint16_t args;
 };
 
-struct extcall_op_t {
+struct extcall_op_t
+{
     uint16_t args;
     bool is_prim_func;
 };
 
-struct cuscall_op_t {
+struct cuscall_op_t
+{
     std::string registered_name;
     gsl::span<const gsl::byte> fields_span;
     uint16_t args;
 };
 
-struct throw_op_t {};
+struct throw_op_t
+{
+};
 
-struct break_op_t {};
+struct break_op_t
+{
+};
 
-struct ldc_i4_op_t {
+struct ldc_i4_op_t
+{
     int32_t imm;
 };
 
-struct ldnull_op_t {};
+struct ldnull_op_t
+{
+};
 
-struct ldc_i4_0_op_t {};
+struct ldc_i4_0_op_t
+{
+};
 
-struct ldc_i4_1_op_t {};
+struct ldc_i4_1_op_t
+{
+};
 
-struct ldc_r4_op_t {
+struct ldc_r4_op_t
+{
     float imm;
 };
 
-struct ldind_i1_op_t {};
+struct ldind_i1_op_t
+{
+};
 
-struct ldind_i2_op_t {};
+struct ldind_i2_op_t
+{
+};
 
-struct ldind_i4_op_t {};
+struct ldind_i4_op_t
+{
+};
 
-struct ldind_i_op_t {};
+struct ldind_i_op_t
+{
+};
 
-struct ldind_u1_op_t {};
+struct ldind_u1_op_t
+{
+};
 
-struct ldind_u2_op_t {};
+struct ldind_u2_op_t
+{
+};
 
-struct ldind_u4_op_t {};
+struct ldind_u4_op_t
+{
+};
 
-struct ldind_u_op_t {};
+struct ldind_u_op_t
+{
+};
 
-struct ldind_br2_op_t {};
+struct ldind_br2_op_t
+{
+};
 
-struct ldind_r4_op_t {};
+struct ldind_r4_op_t
+{
+};
 
-struct stind_i1_op_t {};
+struct stind_i1_op_t
+{
+};
 
-struct stind_i2_op_t {};
+struct stind_i2_op_t
+{
+};
 
-struct stind_i4_op_t {};
+struct stind_i4_op_t
+{
+};
 
-struct stind_i_op_t {};
+struct stind_i_op_t
+{
+};
 
-struct stind_br2_op_t {};
+struct stind_br2_op_t
+{
+};
 
-struct stind_r4_op_t {};
+struct stind_r4_op_t
+{
+};
 
-struct lea_gp_op_t {
+struct lea_gp_op_t
+{
     uint8_t gpid;
     int32_t offset;
 };
 
-struct ldelem_i1_op_t {};
+struct ldelem_i1_op_t
+{
+};
 
-struct ldelem_i2_op_t {};
+struct ldelem_i2_op_t
+{
+};
 
-struct ldelem_i4_op_t {};
+struct ldelem_i4_op_t
+{
+};
 
-struct ldelem_i_op_t {};
+struct ldelem_i_op_t
+{
+};
 
-struct ldelem_u1_op_t {};
+struct ldelem_u1_op_t
+{
+};
 
-struct ldelem_u2_op_t {};
+struct ldelem_u2_op_t
+{
+};
 
-struct ldelem_u4_op_t {};
+struct ldelem_u4_op_t
+{
+};
 
-struct ldelem_u_op_t {};
+struct ldelem_u_op_t
+{
+};
 
-struct ldelem_br2_op_t {};
+struct ldelem_br2_op_t
+{
+};
 
-struct ldelem_r4_op_t {};
+struct ldelem_r4_op_t
+{
+};
 
-struct stelem_i1_op_t {};
+struct stelem_i1_op_t
+{
+};
 
-struct stelem_i2_op_t {};
+struct stelem_i2_op_t
+{
+};
 
-struct stelem_i4_op_t {};
+struct stelem_i4_op_t
+{
+};
 
-struct stelem_i_op_t {};
+struct stelem_i_op_t
+{
+};
 
-struct stelem_br2_op_t {};
+struct stelem_br2_op_t
+{
+};
 
-struct stelem_r4_op_t {};
+struct stelem_r4_op_t
+{
+};
 
-struct ldarg_op_t {
+struct ldarg_op_t
+{
     uint16_t index;
 };
 
-struct ldarg_0_op_t {};
+struct ldarg_0_op_t
+{
+};
 
-struct ldarg_1_op_t {};
+struct ldarg_1_op_t
+{
+};
 
-struct ldarg_2_op_t {};
+struct ldarg_2_op_t
+{
+};
 
-struct ldarg_3_op_t {};
+struct ldarg_3_op_t
+{
+};
 
-struct ldarg_4_op_t {};
+struct ldarg_4_op_t
+{
+};
 
-struct ldarg_5_op_t {};
+struct ldarg_5_op_t
+{
+};
 
-struct ldtuple_elem_op_t {};
+struct ldtuple_elem_op_t
+{
+};
 
-struct ldtuple_op_t {};
+struct ldtuple_op_t
+{
+};
 
-struct lddatatype_op_t {};
+struct lddatatype_op_t
+{
+};
 
-struct ldtensor_op_t {};
+struct ldtensor_op_t
+{
+};
 
-struct ldlocal_op_t {
+struct ldlocal_op_t
+{
     uint16_t index;
 };
 
-struct stlocal_op_t {
+struct stlocal_op_t
+{
     uint16_t index;
 };
 
-struct ldscalar_op_t {};
+struct ldscalar_op_t
+{
+};
 
-struct dup_op_t {};
+struct dup_op_t
+{
+};
 
-struct pop_op_t {};
+struct pop_op_t
+{
+};
 
-struct neg_op_t {};
+struct neg_op_t
+{
+};
 
-struct add_op_t {};
+struct add_op_t
+{
+};
 
-struct sub_op_t {};
+struct sub_op_t
+{
+};
 
-struct mul_op_t {};
+struct mul_op_t
+{
+};
 
-struct div_op_t {};
+struct div_op_t
+{
+};
 
-struct div_u_op_t {};
+struct div_u_op_t
+{
+};
 
-struct rem_op_t {};
+struct rem_op_t
+{
+};
 
-struct rem_u_op_t {};
+struct rem_u_op_t
+{
+};
 
-struct and_op_t {};
+struct and_op_t
+{
+};
 
-struct or_op_t {};
+struct or_op_t
+{
+};
 
-struct xor_op_t {};
+struct xor_op_t
+{
+};
 
-struct not_op_t {};
+struct not_op_t
+{
+};
 
-struct shl_op_t {};
+struct shl_op_t
+{
+};
 
-struct shr_op_t {};
+struct shr_op_t
+{
+};
 
-struct shr_u_op_t {};
+struct shr_u_op_t
+{
+};
 
-struct clt_op_t {};
+struct clt_op_t
+{
+};
 
-struct clt_u_op_t {};
+struct clt_u_op_t
+{
+};
 
-struct cle_op_t {};
+struct cle_op_t
+{
+};
 
-struct cle_u_op_t {};
+struct cle_u_op_t
+{
+};
 
-struct ceq_op_t {};
+struct ceq_op_t
+{
+};
 
-struct cge_op_t {};
+struct cge_op_t
+{
+};
 
-struct cge_u_op_t {};
+struct cge_u_op_t
+{
+};
 
-struct cgt_op_t {};
+struct cgt_op_t
+{
+};
 
-struct cgt_u_op_t {};
+struct cgt_u_op_t
+{
+};
 
-struct cne_op_t {};
+struct cne_op_t
+{
+};
 
-struct conv_i1_op_t {};
+struct conv_i1_op_t
+{
+};
 
-struct conv_i2_op_t {};
+struct conv_i2_op_t
+{
+};
 
-struct conv_i4_op_t {};
+struct conv_i4_op_t
+{
+};
 
-struct conv_i_op_t {};
+struct conv_i_op_t
+{
+};
 
-struct conv_u1_op_t {};
+struct conv_u1_op_t
+{
+};
 
-struct conv_u2_op_t {};
+struct conv_u2_op_t
+{
+};
 
-struct conv_u4_op_t {};
+struct conv_u4_op_t
+{
+};
 
-struct conv_u_op_t {};
+struct conv_u_op_t
+{
+};
 
-struct conv_br2_op_t {};
+struct conv_br2_op_t
+{
+};
 
-struct conv_r4_op_t {};
+struct conv_r4_op_t
+{
+};
 
 // Tensor instructions
 
-struct tensor_batch_normalization_op_t {};
+struct tensor_batch_normalization_op_t
+{
+};
 
-struct tensor_batch_to_space_op_t {};
+struct tensor_batch_to_space_op_t
+{
+};
 
-struct tensor_binary_op_t {
+struct tensor_binary_op_t
+{
     binary_op_t binary_op;
 };
 
-struct tensor_bitcast_op_t {
+struct tensor_bitcast_op_t
+{
     prim_type_t type;
     prim_type_t new_type;
 };
 
-struct tensor_broadcast_op_t {};
+struct tensor_broadcast_op_t
+{
+};
 
-struct tensor_broadcast_shape_op_t {};
+struct tensor_broadcast_shape_op_t
+{
+};
 
-struct tensor_bucket_pad_op_t {};
+struct tensor_bucket_pad_op_t
+{
+};
 
-struct tensor_cast_op_t {
+struct tensor_cast_op_t
+{
     typecode_t new_type;
     cast_mode_t cast_mode;
 };
 
-struct tensor_celu_op_t {};
+struct tensor_celu_op_t
+{
+};
 
-struct tensor_clamp_op_t {};
+struct tensor_clamp_op_t
+{
+};
 
-struct tensor_compare_op_t {
+struct tensor_compare_op_t
+{
     compare_op_t compare_op;
 };
 
-struct tensor_concat_op_t {};
+struct tensor_concat_op_t
+{
+    int32_t axis;
+};
 
-struct tensor_condition_op_t {
+struct tensor_condition_op_t
+{
     bool can_fold_const_call;
 };
 
-struct tensor_constant_of_shape_op_t {};
+struct tensor_constant_of_shape_op_t
+{
+};
 
-struct tensor_conv2d_op_t {
+struct tensor_conv2d_op_t
+{
     pad_mode_t pad_mode;
 };
 
-struct tensor_conv2d_shape_op_t {};
+struct tensor_conv2d_shape_op_t
+{
+};
 
-struct tensor_conv2d_transpose_op_t {
+struct tensor_conv2d_transpose_op_t
+{
     pad_mode_t pad_mode;
 };
 
-struct tensor_conv2d_transpose_shape_op_t {};
+struct tensor_conv2d_transpose_shape_op_t
+{
+};
 
-struct tensor_cum_sum_op_t {};
+struct tensor_cum_sum_op_t
+{
+};
 
-struct tensor_dequantize_op_t {
+struct tensor_dequantize_op_t
+{
     typecode_t target_type;
 };
 
-struct tensor_elu_op_t {};
+struct tensor_elu_op_t
+{
+};
 
-struct tensor_erf_op_t {};
+struct tensor_erf_op_t
+{
+};
 
-struct tensor_expand_op_t {};
+struct tensor_expand_op_t
+{
+};
 
-struct tensor_fake_dequantize_op_t {
+struct tensor_fake_dequantize_op_t
+{
     typecode_t target_type;
 };
 
-struct tensor_fake_quantize_op_t {
+struct tensor_fake_quantize_op_t
+{
     typecode_t target_type;
 };
 
-struct tensor_fix_shape_op_t {};
+struct tensor_fix_shape_op_t
+{
+};
 
-struct tensor_flatten_op_t {};
+struct tensor_flatten_op_t
+{
+};
 
-struct tensor_gather_op_t {};
+struct tensor_gather_op_t
+{
+    int32_t axis;
+};
 
-struct tensor_gather_elements_op_t {};
+struct tensor_gather_elements_op_t
+{
+};
 
-struct tensor_gather_nd_op_t {};
+struct tensor_gather_nd_op_t
+{
+};
 
-struct tensor_gelu_op_t {};
+struct tensor_gelu_op_t
+{
+};
 
-struct tensor_get_item_op_t {};
+struct tensor_get_item_op_t
+{
+};
 
-struct tensor_get_paddings_op_t {};
+struct tensor_get_paddings_op_t
+{
+};
 
-struct tensor_hard_sigmoid_op_t {};
+struct tensor_hard_sigmoid_op_t
+{
+};
 
-struct tensor_hard_swish_op_t {};
+struct tensor_hard_swish_op_t
+{
+};
 
-struct tensor_hardmax_op_t {};
+struct tensor_hardmax_op_t
+{
+};
 
-struct tensor_index_of_op_t {};
+struct tensor_index_of_op_t
+{
+};
 
-struct tensor_instance_normalization_op_t {};
+struct tensor_instance_normalization_op_t
+{
+};
 
-struct tensor_l2_normalization_op_t {};
+struct tensor_l2_normalization_op_t
+{
+};
 
-struct tensor_layer_norm_op_t {
+struct tensor_layer_norm_op_t
+{
     int32_t axis;
     float epsilon;
+    bool use_mean;
 };
 
-struct tensor_leaky_relu_op_t {};
+struct tensor_leaky_relu_op_t
+{
+};
 
-struct tensor_log_softmax_op_t {};
+struct tensor_log_softmax_op_t
+{
+};
 
-struct tensor_lp_normalization_op_t {};
+struct tensor_lp_normalization_op_t
+{
+};
 
-struct tensor_lrn_op_t {};
+struct tensor_lrn_op_t
+{
+};
 
-struct tensor_lstm_op_t {
+struct tensor_lstm_op_t
+{
     lstmdirection_t direction;
     lstmlayout_t layout;
     std::vector<std::string> activations;
 };
 
-struct tensor_mat_mul_op_t {};
+struct tensor_mat_mul_op_t
+{
+};
 
-struct tensor_mat_mul_shape_op_t {};
+struct tensor_mat_mul_shape_op_t
+{
+};
 
-struct tensor_normal_op_t {
+struct tensor_normal_op_t
+{
     typecode_t type;
 };
 
-struct tensor_normal_like_op_t {
+struct tensor_normal_like_op_t
+{
     typecode_t type;
 };
 
-struct tensor_one_hot_op_t {
+struct tensor_one_hot_op_t
+{
     one_hot_mode_t one_hot_mode;
 };
 
-struct tensor_pad_op_t {
+struct tensor_pad_op_t
+{
     pad_mode_t pad_mode;
 };
 
-struct tensor_prelu_op_t {};
+struct tensor_prelu_op_t
+{
+};
 
-struct tensor_prod_op_t {};
+struct tensor_prod_op_t
+{
+};
 
-struct tensor_quant_param_of_op_t {
+struct tensor_quant_param_of_op_t
+{
     quant_mode_t quant_mode;
 };
 
-struct tensor_quantize_op_t {
+struct tensor_quantize_op_t
+{
     typecode_t target_type;
 };
 
-struct tensor_range_op_t {};
+struct tensor_range_op_t
+{
+};
 
-struct tensor_range_of_op_t {
+struct tensor_range_of_op_t
+{
     bool is_range_of_weight;
 };
 
-struct tensor_rank_op_t {};
+struct tensor_rank_op_t
+{
+};
 
-struct tensor_reduce_op_t {
+struct tensor_reduce_op_t
+{
     reduce_op_t reduce_op;
 };
 
-struct tensor_reduce_arg_op_t {
+struct tensor_reduce_arg_op_t
+{
     reduce_arg_op_t reduce_arg_op;
     typecode_t dest_type;
 };
 
-struct tensor_reduce_window2d_op_t {
+struct tensor_reduce_window2d_op_t
+{
     reduce_op_t reduce_op;
 };
 
-struct tensor_relu_op_t {};
+struct tensor_relu_op_t
+{
+};
 
-struct tensor_relu6_op_t {};
+struct tensor_relu6_op_t
+{
+};
 
-struct tensor_require_op_t {
+struct tensor_require_op_t
+{
     std::string message;
     bool can_fold_const_call;
 };
 
-struct tensor_reshape_op_t {};
+struct tensor_reshape_op_t
+{
+};
 
-struct tensor_reshape_shape_op_t {};
+struct tensor_reshape_shape_op_t
+{
+};
 
-struct tensor_resize_image_op_t {
+struct tensor_resize_image_op_t
+{
     image_resize_mode_t resize_mode;
     image_resize_transformation_mode_t transformation_mode;
     image_resize_nearest_mode_t nearest_mode;
     bool is_tfresize;
 };
 
-struct tensor_reverse_sequence_op_t {};
+struct tensor_reverse_sequence_op_t
+{
+};
 
-struct tensor_scatter_nd_op_t {};
+struct tensor_scatter_nd_op_t
+{
+};
 
-struct tensor_select_op_t {};
+struct tensor_select_op_t
+{
+};
 
-struct tensor_selu_op_t {};
+struct tensor_selu_op_t
+{
+};
 
-struct tensor_shape_of_op_t {};
+struct tensor_shape_of_op_t
+{
+};
 
-struct tensor_sigmoid_op_t {};
+struct tensor_sigmoid_op_t
+{
+};
 
-struct tensor_size_of_op_t {};
+struct tensor_size_of_op_t
+{
+};
 
-struct tensor_slice_op_t {};
+struct tensor_slice_op_t
+{
+};
 
-struct tensor_softmax_op_t {};
+struct tensor_softmax_op_t
+{
+};
 
-struct tensor_softplus_op_t {};
+struct tensor_softplus_op_t
+{
+};
 
-struct tensor_softsign_op_t {};
+struct tensor_softsign_op_t
+{
+};
 
-struct tensor_space_to_batch_op_t {};
+struct tensor_space_to_batch_op_t
+{
+};
 
-struct tensor_split_op_t {};
+struct tensor_split_op_t
+{
+};
 
-struct tensor_squeeze_op_t {};
+struct tensor_squeeze_op_t
+{
+};
 
-struct tensor_squeeze_shape_op_t {};
+struct tensor_squeeze_shape_op_t
+{
+};
 
-struct tensor_stack_op_t {};
+struct tensor_stack_op_t
+{
+};
 
-struct tensor_swish_op_t {};
+struct tensor_swish_op_t
+{
+};
 
-struct tensor_tile_op_t {};
+struct tensor_tile_op_t
+{
+};
 
-struct tensor_top_k_op_t {};
+struct tensor_top_k_op_t
+{
+};
 
-struct tensor_transpose_op_t {};
+struct tensor_transpose_op_t
+{
+};
 
-struct tensor_transpose_shape_op_t {};
+struct tensor_transpose_shape_op_t
+{
+};
 
-struct tensor_trilu_op_t {};
+struct tensor_trilu_op_t
+{
+};
 
-struct tensor_unary_op_t {
+struct tensor_unary_op_t
+{
     unary_op_t unary_op;
 };
 
-struct tensor_uniform_op_t {
+struct tensor_uniform_op_t
+{
     typecode_t type;
 };
 
-struct tensor_uniform_like_op_t {
+struct tensor_uniform_like_op_t
+{
     typecode_t type;
 };
 
-struct tensor_unsqueeze_op_t {};
+struct tensor_unsqueeze_op_t
+{
+};
 
-struct tensor_unsqueeze_shape_op_t {};
+struct tensor_unsqueeze_shape_op_t
+{
+};
 
-struct tensor_where_op_t {
+struct tensor_where_op_t
+{
     bool is_tf_where;
 };
 
-inline std::string to_string(tensor_function_t tensor_funct) {
-    switch (tensor_funct) {
-    case tensor_function_t::batch_normalization:
-        return "batch_normalization";
-    case tensor_function_t::batch_to_space:
-        return "batch_to_space";
-    case tensor_function_t::celu:
-        return "celu";
-    case tensor_function_t::conv2d:
-        return "conv2d";
-    case tensor_function_t::conv2d_transpose:
-        return "conv2d_transpose";
-    case tensor_function_t::elu:
-        return "elu";
-    case tensor_function_t::erf:
-        return "erf";
-    case tensor_function_t::gelu:
-        return "gelu";
-    case tensor_function_t::hardmax:
-        return "hardmax";
-    case tensor_function_t::hard_sigmoid:
-        return "hard_sigmoid";
-    case tensor_function_t::hard_swish:
-        return "hard_swish";
-    case tensor_function_t::instance_normalization:
-        return "instance_normalization";
-    case tensor_function_t::l2_normalization:
-        return "l2_normalization";
-    case tensor_function_t::layer_norm:
-        return "layer_norm";
-    case tensor_function_t::leaky_relu:
-        return "leaky_relu";
-    case tensor_function_t::log_softmax:
-        return "log_softmax";
-    case tensor_function_t::lp_normalization:
-        return "lp_normalization";
-    case tensor_function_t::lrn:
-        return "lrn";
-    case tensor_function_t::one_hot:
-        return "one_hot";
-    case tensor_function_t::pad:
-        return "pad";
-    case tensor_function_t::prelu:
-        return "prelu";
-    case tensor_function_t::reduce_window2d:
-        return "reduce_window2d";
-    case tensor_function_t::relu:
-        return "relu";
-    case tensor_function_t::relu6:
-        return "relu6";
-    case tensor_function_t::selu:
-        return "selu";
-    case tensor_function_t::sigmoid:
-        return "sigmoid";
-    case tensor_function_t::softmax:
-        return "softmax";
-    case tensor_function_t::softplus:
-        return "softplus";
-    case tensor_function_t::softsign:
-        return "softsign";
-    case tensor_function_t::space_to_batch:
-        return "space_to_batch";
-    case tensor_function_t::swish:
-        return "swish";
-    case tensor_function_t::binary:
-        return "binary";
-    case tensor_function_t::clamp:
-        return "clamp";
-    case tensor_function_t::compare:
-        return "compare";
-    case tensor_function_t::condition:
-        return "condition";
-    case tensor_function_t::cum_sum:
-        return "cum_sum";
-    case tensor_function_t::dequantize:
-        return "dequantize";
-    case tensor_function_t::fake_dequantize:
-        return "fake_dequantize";
-    case tensor_function_t::fake_quantize:
-        return "fake_quantize";
-    case tensor_function_t::mat_mul:
-        return "mat_mul";
-    case tensor_function_t::quantize:
-        return "quantize";
-    case tensor_function_t::quant_param_of:
-        return "quant_param_of";
-    case tensor_function_t::range_of:
-        return "range_of";
-    case tensor_function_t::reduce:
-        return "reduce";
-    case tensor_function_t::reduce_arg:
-        return "reduce_arg";
-    case tensor_function_t::require:
-        return "require";
-    case tensor_function_t::select:
-        return "select";
-    case tensor_function_t::unary:
-        return "unary";
-    case tensor_function_t::bitcast:
-        return "bitcast";
-    case tensor_function_t::broadcast:
-        return "broadcast";
-    case tensor_function_t::bucket_pad:
-        return "bucket_pad";
-    case tensor_function_t::cast:
-        return "cast";
-    case tensor_function_t::concat:
-        return "concat";
-    case tensor_function_t::constant_of_shape:
-        return "constant_of_shape";
-    case tensor_function_t::expand:
-        return "expand";
-    case tensor_function_t::fix_shape:
-        return "fix_shape";
-    case tensor_function_t::flatten:
-        return "flatten";
-    case tensor_function_t::gather:
-        return "gather";
-    case tensor_function_t::gather_elements:
-        return "gather_elements";
-    case tensor_function_t::gather_nd:
-        return "gather_nd";
-    case tensor_function_t::get_item:
-        return "get_item";
-    case tensor_function_t::index_of:
-        return "index_of";
-    case tensor_function_t::lstm:
-        return "lstm";
-    case tensor_function_t::prod:
-        return "prod";
-    case tensor_function_t::range:
-        return "range";
-    case tensor_function_t::rank:
-        return "rank";
-    case tensor_function_t::reshape:
-        return "reshape";
-    case tensor_function_t::reverse_sequence:
-        return "reverse_sequence";
-    case tensor_function_t::scatter_nd:
-        return "scatter_nd";
-    case tensor_function_t::shape_of:
-        return "shape_of";
-    case tensor_function_t::size_of:
-        return "size_of";
-    case tensor_function_t::slice:
-        return "slice";
-    case tensor_function_t::split:
-        return "split";
-    case tensor_function_t::squeeze:
-        return "squeeze";
-    case tensor_function_t::stack:
-        return "stack";
-    case tensor_function_t::tile:
-        return "tile";
-    case tensor_function_t::top_k:
-        return "top_k";
-    case tensor_function_t::transpose:
-        return "transpose";
-    case tensor_function_t::trilu:
-        return "trilu";
-    case tensor_function_t::unsqueeze:
-        return "unsqueeze";
-    case tensor_function_t::where:
-        return "where";
-    case tensor_function_t::broadcast_shape:
-        return "broadcast_shape";
-    case tensor_function_t::conv2d_shape:
-        return "conv2d_shape";
-    case tensor_function_t::conv2d_transpose_shape:
-        return "conv2d_transpose_shape";
-    case tensor_function_t::get_paddings:
-        return "get_paddings";
-    case tensor_function_t::mat_mul_shape:
-        return "mat_mul_shape";
-    case tensor_function_t::reshape_shape:
-        return "reshape_shape";
-    case tensor_function_t::squeeze_shape:
-        return "squeeze_shape";
-    case tensor_function_t::transpose_shape:
-        return "transpose_shape";
-    case tensor_function_t::unsqueeze_shape:
-        return "unsqueeze_shape";
-    case tensor_function_t::normal:
-        return "normal";
-    case tensor_function_t::normal_like:
-        return "normal_like";
-    case tensor_function_t::uniform:
-        return "uniform";
-    case tensor_function_t::uniform_like:
-        return "uniform_like";
-    case tensor_function_t::resize_image:
-        return "resize_image";
+
+
+
+inline std::string to_string(tensor_function_t tensor_funct)
+{
+    switch(tensor_funct)
+    {
+        case tensor_function_t::batch_normalization: return "batch_normalization";
+        case tensor_function_t::batch_to_space: return "batch_to_space";
+        case tensor_function_t::celu: return "celu";
+        case tensor_function_t::conv2d: return "conv2d";
+        case tensor_function_t::conv2d_transpose: return "conv2d_transpose";
+        case tensor_function_t::elu: return "elu";
+        case tensor_function_t::erf: return "erf";
+        case tensor_function_t::gelu: return "gelu";
+        case tensor_function_t::hardmax: return "hardmax";
+        case tensor_function_t::hard_sigmoid: return "hard_sigmoid";
+        case tensor_function_t::hard_swish: return "hard_swish";
+        case tensor_function_t::instance_normalization: return "instance_normalization";
+        case tensor_function_t::l2_normalization: return "l2_normalization";
+        case tensor_function_t::layer_norm: return "layer_norm";
+        case tensor_function_t::leaky_relu: return "leaky_relu";
+        case tensor_function_t::log_softmax: return "log_softmax";
+        case tensor_function_t::lp_normalization: return "lp_normalization";
+        case tensor_function_t::lrn: return "lrn";
+        case tensor_function_t::one_hot: return "one_hot";
+        case tensor_function_t::pad: return "pad";
+        case tensor_function_t::prelu: return "prelu";
+        case tensor_function_t::reduce_window2d: return "reduce_window2d";
+        case tensor_function_t::relu: return "relu";
+        case tensor_function_t::relu6: return "relu6";
+        case tensor_function_t::selu: return "selu";
+        case tensor_function_t::sigmoid: return "sigmoid";
+        case tensor_function_t::softmax: return "softmax";
+        case tensor_function_t::softplus: return "softplus";
+        case tensor_function_t::softsign: return "softsign";
+        case tensor_function_t::space_to_batch: return "space_to_batch";
+        case tensor_function_t::swish: return "swish";
+        case tensor_function_t::binary: return "binary";
+        case tensor_function_t::clamp: return "clamp";
+        case tensor_function_t::compare: return "compare";
+        case tensor_function_t::condition: return "condition";
+        case tensor_function_t::cum_sum: return "cum_sum";
+        case tensor_function_t::dequantize: return "dequantize";
+        case tensor_function_t::fake_dequantize: return "fake_dequantize";
+        case tensor_function_t::fake_quantize: return "fake_quantize";
+        case tensor_function_t::mat_mul: return "mat_mul";
+        case tensor_function_t::quantize: return "quantize";
+        case tensor_function_t::quant_param_of: return "quant_param_of";
+        case tensor_function_t::range_of: return "range_of";
+        case tensor_function_t::reduce: return "reduce";
+        case tensor_function_t::reduce_arg: return "reduce_arg";
+        case tensor_function_t::require: return "require";
+        case tensor_function_t::select: return "select";
+        case tensor_function_t::unary: return "unary";
+        case tensor_function_t::bitcast: return "bitcast";
+        case tensor_function_t::broadcast: return "broadcast";
+        case tensor_function_t::bucket_pad: return "bucket_pad";
+        case tensor_function_t::cast: return "cast";
+        case tensor_function_t::concat: return "concat";
+        case tensor_function_t::constant_of_shape: return "constant_of_shape";
+        case tensor_function_t::expand: return "expand";
+        case tensor_function_t::fix_shape: return "fix_shape";
+        case tensor_function_t::flatten: return "flatten";
+        case tensor_function_t::gather: return "gather";
+        case tensor_function_t::gather_elements: return "gather_elements";
+        case tensor_function_t::gather_nd: return "gather_nd";
+        case tensor_function_t::get_item: return "get_item";
+        case tensor_function_t::index_of: return "index_of";
+        case tensor_function_t::prod: return "prod";
+        case tensor_function_t::range: return "range";
+        case tensor_function_t::rank: return "rank";
+        case tensor_function_t::reshape: return "reshape";
+        case tensor_function_t::reverse_sequence: return "reverse_sequence";
+        case tensor_function_t::scatter_nd: return "scatter_nd";
+        case tensor_function_t::shape_of: return "shape_of";
+        case tensor_function_t::size_of: return "size_of";
+        case tensor_function_t::slice: return "slice";
+        case tensor_function_t::split: return "split";
+        case tensor_function_t::squeeze: return "squeeze";
+        case tensor_function_t::stack: return "stack";
+        case tensor_function_t::tile: return "tile";
+        case tensor_function_t::top_k: return "top_k";
+        case tensor_function_t::transpose: return "transpose";
+        case tensor_function_t::trilu: return "trilu";
+        case tensor_function_t::unsqueeze: return "unsqueeze";
+        case tensor_function_t::where: return "where";
+        case tensor_function_t::broadcast_shape: return "broadcast_shape";
+        case tensor_function_t::conv2d_shape: return "conv2d_shape";
+        case tensor_function_t::conv2d_transpose_shape: return "conv2d_transpose_shape";
+        case tensor_function_t::get_paddings: return "get_paddings";
+        case tensor_function_t::mat_mul_shape: return "mat_mul_shape";
+        case tensor_function_t::reshape_shape: return "reshape_shape";
+        case tensor_function_t::squeeze_shape: return "squeeze_shape";
+        case tensor_function_t::transpose_shape: return "transpose_shape";
+        case tensor_function_t::unsqueeze_shape: return "unsqueeze_shape";
+        case tensor_function_t::lstm: return "lstm";
+        case tensor_function_t::normal: return "normal";
+        case tensor_function_t::normal_like: return "normal_like";
+        case tensor_function_t::uniform: return "uniform";
+        case tensor_function_t::uniform_like: return "uniform_like";
+        case tensor_function_t::resize_image: return "resize_image";
     }
     return "unknown tensor_function_t";
 }
 
-inline std::string to_string(opcode_t code) {
-    switch (code) {
-    case opcode_t::NOP:
-        return "NOP";
-    case opcode_t::LDNULL:
-        return "LDNULL";
-    case opcode_t::LDC_I4:
-        return "LDC_I4";
-    case opcode_t::LDC_I4_0:
-        return "LDC_I4_0";
-    case opcode_t::LDC_I4_1:
-        return "LDC_I4_1";
-    case opcode_t::LDC_R4:
-        return "LDC_R4";
-    case opcode_t::LDIND_I1:
-        return "LDIND_I1";
-    case opcode_t::LDIND_I2:
-        return "LDIND_I2";
-    case opcode_t::LDIND_I4:
-        return "LDIND_I4";
-    case opcode_t::LDIND_I:
-        return "LDIND_I";
-    case opcode_t::LDIND_U1:
-        return "LDIND_U1";
-    case opcode_t::LDIND_U2:
-        return "LDIND_U2";
-    case opcode_t::LDIND_U4:
-        return "LDIND_U4";
-    case opcode_t::LDIND_U:
-        return "LDIND_U";
-    case opcode_t::LDIND_BR2:
-        return "LDIND_BR2";
-    case opcode_t::LDIND_R4:
-        return "LDIND_R4";
-    case opcode_t::STIND_I1:
-        return "STIND_I1";
-    case opcode_t::STIND_I2:
-        return "STIND_I2";
-    case opcode_t::STIND_I4:
-        return "STIND_I4";
-    case opcode_t::STIND_I:
-        return "STIND_I";
-    case opcode_t::STIND_BR2:
-        return "STIND_BR2";
-    case opcode_t::STIND_R4:
-        return "STIND_R4";
-    case opcode_t::LEA_GP:
-        return "LEA_GP";
-    case opcode_t::LDELEM_I1:
-        return "LDELEM_I1";
-    case opcode_t::LDELEM_I2:
-        return "LDELEM_I2";
-    case opcode_t::LDELEM_I4:
-        return "LDELEM_I4";
-    case opcode_t::LDELEM_I:
-        return "LDELEM_I";
-    case opcode_t::LDELEM_U1:
-        return "LDELEM_U1";
-    case opcode_t::LDELEM_U2:
-        return "LDELEM_U2";
-    case opcode_t::LDELEM_U4:
-        return "LDELEM_U4";
-    case opcode_t::LDELEM_U:
-        return "LDELEM_U";
-    case opcode_t::LDELEM_BR2:
-        return "LDELEM_BR2";
-    case opcode_t::LDELEM_R4:
-        return "LDELEM_R4";
-    case opcode_t::STELEM_I1:
-        return "STELEM_I1";
-    case opcode_t::STELEM_I2:
-        return "STELEM_I2";
-    case opcode_t::STELEM_I4:
-        return "STELEM_I4";
-    case opcode_t::STELEM_I:
-        return "STELEM_I";
-    case opcode_t::STELEM_BR2:
-        return "STELEM_BR2";
-    case opcode_t::STELEM_R4:
-        return "STELEM_R4";
-    case opcode_t::LDARG:
-        return "LDARG";
-    case opcode_t::LDARG_0:
-        return "LDARG_0";
-    case opcode_t::LDARG_1:
-        return "LDARG_1";
-    case opcode_t::LDARG_2:
-        return "LDARG_2";
-    case opcode_t::LDARG_3:
-        return "LDARG_3";
-    case opcode_t::LDARG_4:
-        return "LDARG_4";
-    case opcode_t::LDARG_5:
-        return "LDARG_5";
-    case opcode_t::DUP:
-        return "DUP";
-    case opcode_t::POP:
-        return "POP";
-    case opcode_t::LDLOCAL:
-        return "LDLOCAL";
-    case opcode_t::STLOCAL:
-        return "STLOCAL";
-    case opcode_t::LDTUPLE_ELEM:
-        return "LDTUPLE_ELEM";
-    case opcode_t::LDTUPLE:
-        return "LDTUPLE";
-    case opcode_t::LDDATATYPE:
-        return "LDDATATYPE";
-    case opcode_t::LDTENSOR:
-        return "LDTENSOR";
-    case opcode_t::LDSCALAR:
-        return "LDSCALAR";
-    case opcode_t::NEG:
-        return "NEG";
-    case opcode_t::ADD:
-        return "ADD";
-    case opcode_t::SUB:
-        return "SUB";
-    case opcode_t::MUL:
-        return "MUL";
-    case opcode_t::DIV:
-        return "DIV";
-    case opcode_t::DIV_U:
-        return "DIV_U";
-    case opcode_t::REM:
-        return "REM";
-    case opcode_t::REM_U:
-        return "REM_U";
-    case opcode_t::AND:
-        return "AND";
-    case opcode_t::OR:
-        return "OR";
-    case opcode_t::XOR:
-        return "XOR";
-    case opcode_t::NOT:
-        return "NOT";
-    case opcode_t::SHL:
-        return "SHL";
-    case opcode_t::SHR:
-        return "SHR";
-    case opcode_t::SHR_U:
-        return "SHR_U";
-    case opcode_t::CLT:
-        return "CLT";
-    case opcode_t::CLT_U:
-        return "CLT_U";
-    case opcode_t::CLE:
-        return "CLE";
-    case opcode_t::CLE_U:
-        return "CLE_U";
-    case opcode_t::CEQ:
-        return "CEQ";
-    case opcode_t::CGE:
-        return "CGE";
-    case opcode_t::CGE_U:
-        return "CGE_U";
-    case opcode_t::CGT:
-        return "CGT";
-    case opcode_t::CGT_U:
-        return "CGT_U";
-    case opcode_t::CNE:
-        return "CNE";
-    case opcode_t::CONV_I1:
-        return "CONV_I1";
-    case opcode_t::CONV_I2:
-        return "CONV_I2";
-    case opcode_t::CONV_I4:
-        return "CONV_I4";
-    case opcode_t::CONV_I:
-        return "CONV_I";
-    case opcode_t::CONV_U1:
-        return "CONV_U1";
-    case opcode_t::CONV_U2:
-        return "CONV_U2";
-    case opcode_t::CONV_U4:
-        return "CONV_U4";
-    case opcode_t::CONV_U:
-        return "CONV_U";
-    case opcode_t::CONV_BR2:
-        return "CONV_BR2";
-    case opcode_t::CONV_R4:
-        return "CONV_R4";
-    case opcode_t::BR:
-        return "BR";
-    case opcode_t::BR_TRUE:
-        return "BR_TRUE";
-    case opcode_t::BR_FALSE:
-        return "BR_FALSE";
-    case opcode_t::RET:
-        return "RET";
-    case opcode_t::CALL:
-        return "CALL";
-    case opcode_t::ECALL:
-        return "ECALL";
-    case opcode_t::EXTCALL:
-        return "EXTCALL";
-    case opcode_t::CUSCALL:
-        return "CUSCALL";
-    case opcode_t::THROW:
-        return "THROW";
-    case opcode_t::BREAK:
-        return "BREAK";
-    case opcode_t::TENSOR:
-        return "TENSOR";
+inline std::string to_string(opcode_t code)
+{
+    switch(code)
+    {
+      case opcode_t::NOP: return "NOP";
+      case opcode_t::LDNULL: return "LDNULL";
+      case opcode_t::LDC_I4: return "LDC_I4";
+      case opcode_t::LDC_I4_0: return "LDC_I4_0";
+      case opcode_t::LDC_I4_1: return "LDC_I4_1";
+      case opcode_t::LDC_R4: return "LDC_R4";
+      case opcode_t::LDIND_I1: return "LDIND_I1";
+      case opcode_t::LDIND_I2: return "LDIND_I2";
+      case opcode_t::LDIND_I4: return "LDIND_I4";
+      case opcode_t::LDIND_I: return "LDIND_I";
+      case opcode_t::LDIND_U1: return "LDIND_U1";
+      case opcode_t::LDIND_U2: return "LDIND_U2";
+      case opcode_t::LDIND_U4: return "LDIND_U4";
+      case opcode_t::LDIND_U: return "LDIND_U";
+      case opcode_t::LDIND_BR2: return "LDIND_BR2";
+      case opcode_t::LDIND_R4: return "LDIND_R4";
+      case opcode_t::STIND_I1: return "STIND_I1";
+      case opcode_t::STIND_I2: return "STIND_I2";
+      case opcode_t::STIND_I4: return "STIND_I4";
+      case opcode_t::STIND_I: return "STIND_I";
+      case opcode_t::STIND_BR2: return "STIND_BR2";
+      case opcode_t::STIND_R4: return "STIND_R4";
+      case opcode_t::LEA_GP: return "LEA_GP";
+      case opcode_t::LDELEM_I1: return "LDELEM_I1";
+      case opcode_t::LDELEM_I2: return "LDELEM_I2";
+      case opcode_t::LDELEM_I4: return "LDELEM_I4";
+      case opcode_t::LDELEM_I: return "LDELEM_I";
+      case opcode_t::LDELEM_U1: return "LDELEM_U1";
+      case opcode_t::LDELEM_U2: return "LDELEM_U2";
+      case opcode_t::LDELEM_U4: return "LDELEM_U4";
+      case opcode_t::LDELEM_U: return "LDELEM_U";
+      case opcode_t::LDELEM_BR2: return "LDELEM_BR2";
+      case opcode_t::LDELEM_R4: return "LDELEM_R4";
+      case opcode_t::STELEM_I1: return "STELEM_I1";
+      case opcode_t::STELEM_I2: return "STELEM_I2";
+      case opcode_t::STELEM_I4: return "STELEM_I4";
+      case opcode_t::STELEM_I: return "STELEM_I";
+      case opcode_t::STELEM_BR2: return "STELEM_BR2";
+      case opcode_t::STELEM_R4: return "STELEM_R4";
+      case opcode_t::LDARG: return "LDARG";
+      case opcode_t::LDARG_0: return "LDARG_0";
+      case opcode_t::LDARG_1: return "LDARG_1";
+      case opcode_t::LDARG_2: return "LDARG_2";
+      case opcode_t::LDARG_3: return "LDARG_3";
+      case opcode_t::LDARG_4: return "LDARG_4";
+      case opcode_t::LDARG_5: return "LDARG_5";
+      case opcode_t::DUP: return "DUP";
+      case opcode_t::POP: return "POP";
+      case opcode_t::LDLOCAL: return "LDLOCAL";
+      case opcode_t::STLOCAL: return "STLOCAL";
+      case opcode_t::LDTUPLE_ELEM: return "LDTUPLE_ELEM";
+      case opcode_t::LDTUPLE: return "LDTUPLE";
+      case opcode_t::LDDATATYPE: return "LDDATATYPE";
+      case opcode_t::LDTENSOR: return "LDTENSOR";
+      case opcode_t::LDSCALAR: return "LDSCALAR";
+      case opcode_t::NEG: return "NEG";
+      case opcode_t::ADD: return "ADD";
+      case opcode_t::SUB: return "SUB";
+      case opcode_t::MUL: return "MUL";
+      case opcode_t::DIV: return "DIV";
+      case opcode_t::DIV_U: return "DIV_U";
+      case opcode_t::REM: return "REM";
+      case opcode_t::REM_U: return "REM_U";
+      case opcode_t::AND: return "AND";
+      case opcode_t::OR: return "OR";
+      case opcode_t::XOR: return "XOR";
+      case opcode_t::NOT: return "NOT";
+      case opcode_t::SHL: return "SHL";
+      case opcode_t::SHR: return "SHR";
+      case opcode_t::SHR_U: return "SHR_U";
+      case opcode_t::CLT: return "CLT";
+      case opcode_t::CLT_U: return "CLT_U";
+      case opcode_t::CLE: return "CLE";
+      case opcode_t::CLE_U: return "CLE_U";
+      case opcode_t::CEQ: return "CEQ";
+      case opcode_t::CGE: return "CGE";
+      case opcode_t::CGE_U: return "CGE_U";
+      case opcode_t::CGT: return "CGT";
+      case opcode_t::CGT_U: return "CGT_U";
+      case opcode_t::CNE: return "CNE";
+      case opcode_t::CONV_I1: return "CONV_I1";
+      case opcode_t::CONV_I2: return "CONV_I2";
+      case opcode_t::CONV_I4: return "CONV_I4";
+      case opcode_t::CONV_I: return "CONV_I";
+      case opcode_t::CONV_U1: return "CONV_U1";
+      case opcode_t::CONV_U2: return "CONV_U2";
+      case opcode_t::CONV_U4: return "CONV_U4";
+      case opcode_t::CONV_U: return "CONV_U";
+      case opcode_t::CONV_BR2: return "CONV_BR2";
+      case opcode_t::CONV_R4: return "CONV_R4";
+      case opcode_t::BR: return "BR";
+      case opcode_t::BR_TRUE: return "BR_TRUE";
+      case opcode_t::BR_FALSE: return "BR_FALSE";
+      case opcode_t::RET: return "RET";
+      case opcode_t::CALL: return "CALL";
+      case opcode_t::ECALL: return "ECALL";
+      case opcode_t::EXTCALL: return "EXTCALL";
+      case opcode_t::CUSCALL: return "CUSCALL";
+      case opcode_t::THROW: return "THROW";
+      case opcode_t::BREAK: return "BREAK";
+      case opcode_t::TENSOR: return "TENSOR";
     }
     return "unknown opcode_t";
 }
diff --git a/src/Native/src/kernels/stackvm/tensor_ops.cpp b/src/Native/src/kernels/stackvm/tensor_ops.cpp
index 5357771fb5..22b504adc2 100644
--- a/src/Native/src/kernels/stackvm/tensor_ops.cpp
+++ b/src/Native/src/kernels/stackvm/tensor_ops.cpp
@@ -48,7 +48,7 @@ result<value_t> nncase::kernels::stackvm::batch_normalization(
 }
 
 result<value_t> nncase::kernels::stackvm::layer_norm(
-    int32_t axis, float epsilon, value_t input, value_t scale, value_t bias,
+    int32_t axis, float epsilon, [[maybe_unused]] bool use_mean, value_t input, value_t scale, value_t bias,
     value_t output, [[maybe_unused]] kernel_context &context) {
     try_f32_input(input_mem, input);
     try_f32_input(scale_mem, scale);
@@ -118,7 +118,7 @@ nncase::kernels::stackvm::clamp(value_t input, value_t min, value_t max,
     KERNEL_FINISH;
 }
 
-result<value_t> nncase::kernels::stackvm::concat(value_t input, value_t axis,
+result<value_t> nncase::kernels::stackvm::concat(int32_t axis, value_t input,
                                                  value_t output,
                                                  kernel_context &context) {
     try_tuple_input(inputs_mem, input);
@@ -126,7 +126,7 @@ result<value_t> nncase::kernels::stackvm::concat(value_t input, value_t axis,
     try_var(strides, get_strides(input_tuple));
     try_tuple_field0(input0, input_tuple);
     auto dtype = input0->dtype();
-    try_positive_axis_with_rank(axis_value, axis, input0->shape().size());
+    auto axis_value = positive_index(axis, input0->shape().size());
     auto out_shape = concat_infer_shape(shapes, axis_value);
     try_output(out_mem, output, dtype, out_shape);
     auto concat_dims = dims_t();
@@ -285,14 +285,15 @@ nncase::kernels::stackvm::flatten(value_t input, value_t axis, value_t output,
     KERNEL_FINISH;
 }
 
-result<value_t> nncase::kernels::stackvm::gather(value_t input, value_t axis,
+result<value_t> nncase::kernels::stackvm::gather(int32_t axis, value_t input,
                                                  value_t index, value_t output,
                                                  kernel_context &context) {
     try_input(input_mem, input);
     try_input(index_mem, index);
     auto dtype = input_tensor->dtype();
     try_var(typecode, to_typecode(dtype));
-    try_positive_axis(axis_value, axis, input_tensor);
+    // try_positive_axis(axis_value, axis, input_tensor);
+    auto axis_value = positive_index(axis, input_tensor->shape().size());
     auto out_shape = gather_infer_shape(input_tensor->shape(),
                                         index_tensor->shape(), axis_value);
     try_output(out_mem, output, dtype, out_shape);
diff --git a/src/Native/src/runtime/stackvm/op_reader.cpp b/src/Native/src/runtime/stackvm/op_reader.cpp
index 901f0f6125..fcdf55117c 100644
--- a/src/Native/src/runtime/stackvm/op_reader.cpp
+++ b/src/Native/src/runtime/stackvm/op_reader.cpp
@@ -1,5 +1,4 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 2023/9/5 19:40:29
- * +08:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -21,15 +20,14 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace nncase::runtime::stackvm;
 
-result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
-                                      span_reader &reader) noexcept {
-    switch (tensor_funct) {
+result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reader &reader) noexcept
+{
+     switch (tensor_funct)
+     {
     case tensor_function_t::batch_normalization:
-        return visit(
-            tensor_op_reader<tensor_function_t::batch_normalization>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::batch_normalization>()(reader));
     case tensor_function_t::batch_to_space:
-        return visit(
-            tensor_op_reader<tensor_function_t::batch_to_space>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::batch_to_space>()(reader));
     case tensor_function_t::binary:
         return visit(tensor_op_reader<tensor_function_t::binary>()(reader));
     case tensor_function_t::bitcast:
@@ -37,8 +35,7 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::broadcast:
         return visit(tensor_op_reader<tensor_function_t::broadcast>()(reader));
     case tensor_function_t::broadcast_shape:
-        return visit(
-            tensor_op_reader<tensor_function_t::broadcast_shape>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::broadcast_shape>()(reader));
     case tensor_function_t::bucket_pad:
         return visit(tensor_op_reader<tensor_function_t::bucket_pad>()(reader));
     case tensor_function_t::cast:
@@ -54,20 +51,15 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::condition:
         return visit(tensor_op_reader<tensor_function_t::condition>()(reader));
     case tensor_function_t::constant_of_shape:
-        return visit(
-            tensor_op_reader<tensor_function_t::constant_of_shape>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::constant_of_shape>()(reader));
     case tensor_function_t::conv2d:
         return visit(tensor_op_reader<tensor_function_t::conv2d>()(reader));
     case tensor_function_t::conv2d_shape:
-        return visit(
-            tensor_op_reader<tensor_function_t::conv2d_shape>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::conv2d_shape>()(reader));
     case tensor_function_t::conv2d_transpose:
-        return visit(
-            tensor_op_reader<tensor_function_t::conv2d_transpose>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::conv2d_transpose>()(reader));
     case tensor_function_t::conv2d_transpose_shape:
-        return visit(
-            tensor_op_reader<tensor_function_t::conv2d_transpose_shape>()(
-                reader));
+        return visit(tensor_op_reader<tensor_function_t::conv2d_transpose_shape>()(reader));
     case tensor_function_t::cum_sum:
         return visit(tensor_op_reader<tensor_function_t::cum_sum>()(reader));
     case tensor_function_t::dequantize:
@@ -79,11 +71,9 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::expand:
         return visit(tensor_op_reader<tensor_function_t::expand>()(reader));
     case tensor_function_t::fake_dequantize:
-        return visit(
-            tensor_op_reader<tensor_function_t::fake_dequantize>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::fake_dequantize>()(reader));
     case tensor_function_t::fake_quantize:
-        return visit(
-            tensor_op_reader<tensor_function_t::fake_quantize>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::fake_quantize>()(reader));
     case tensor_function_t::fix_shape:
         return visit(tensor_op_reader<tensor_function_t::fix_shape>()(reader));
     case tensor_function_t::flatten:
@@ -91,8 +81,7 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::gather:
         return visit(tensor_op_reader<tensor_function_t::gather>()(reader));
     case tensor_function_t::gather_elements:
-        return visit(
-            tensor_op_reader<tensor_function_t::gather_elements>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::gather_elements>()(reader));
     case tensor_function_t::gather_nd:
         return visit(tensor_op_reader<tensor_function_t::gather_nd>()(reader));
     case tensor_function_t::gelu:
@@ -100,11 +89,9 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::get_item:
         return visit(tensor_op_reader<tensor_function_t::get_item>()(reader));
     case tensor_function_t::get_paddings:
-        return visit(
-            tensor_op_reader<tensor_function_t::get_paddings>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::get_paddings>()(reader));
     case tensor_function_t::hard_sigmoid:
-        return visit(
-            tensor_op_reader<tensor_function_t::hard_sigmoid>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::hard_sigmoid>()(reader));
     case tensor_function_t::hard_swish:
         return visit(tensor_op_reader<tensor_function_t::hard_swish>()(reader));
     case tensor_function_t::hardmax:
@@ -112,22 +99,17 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::index_of:
         return visit(tensor_op_reader<tensor_function_t::index_of>()(reader));
     case tensor_function_t::instance_normalization:
-        return visit(
-            tensor_op_reader<tensor_function_t::instance_normalization>()(
-                reader));
+        return visit(tensor_op_reader<tensor_function_t::instance_normalization>()(reader));
     case tensor_function_t::l2_normalization:
-        return visit(
-            tensor_op_reader<tensor_function_t::l2_normalization>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::l2_normalization>()(reader));
     case tensor_function_t::layer_norm:
         return visit(tensor_op_reader<tensor_function_t::layer_norm>()(reader));
     case tensor_function_t::leaky_relu:
         return visit(tensor_op_reader<tensor_function_t::leaky_relu>()(reader));
     case tensor_function_t::log_softmax:
-        return visit(
-            tensor_op_reader<tensor_function_t::log_softmax>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::log_softmax>()(reader));
     case tensor_function_t::lp_normalization:
-        return visit(
-            tensor_op_reader<tensor_function_t::lp_normalization>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::lp_normalization>()(reader));
     case tensor_function_t::lrn:
         return visit(tensor_op_reader<tensor_function_t::lrn>()(reader));
     case tensor_function_t::lstm:
@@ -135,13 +117,11 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::mat_mul:
         return visit(tensor_op_reader<tensor_function_t::mat_mul>()(reader));
     case tensor_function_t::mat_mul_shape:
-        return visit(
-            tensor_op_reader<tensor_function_t::mat_mul_shape>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::mat_mul_shape>()(reader));
     case tensor_function_t::normal:
         return visit(tensor_op_reader<tensor_function_t::normal>()(reader));
     case tensor_function_t::normal_like:
-        return visit(
-            tensor_op_reader<tensor_function_t::normal_like>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::normal_like>()(reader));
     case tensor_function_t::one_hot:
         return visit(tensor_op_reader<tensor_function_t::one_hot>()(reader));
     case tensor_function_t::pad:
@@ -151,8 +131,7 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::prod:
         return visit(tensor_op_reader<tensor_function_t::prod>()(reader));
     case tensor_function_t::quant_param_of:
-        return visit(
-            tensor_op_reader<tensor_function_t::quant_param_of>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::quant_param_of>()(reader));
     case tensor_function_t::quantize:
         return visit(tensor_op_reader<tensor_function_t::quantize>()(reader));
     case tensor_function_t::range:
@@ -166,8 +145,7 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::reduce_arg:
         return visit(tensor_op_reader<tensor_function_t::reduce_arg>()(reader));
     case tensor_function_t::reduce_window2d:
-        return visit(
-            tensor_op_reader<tensor_function_t::reduce_window2d>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::reduce_window2d>()(reader));
     case tensor_function_t::relu:
         return visit(tensor_op_reader<tensor_function_t::relu>()(reader));
     case tensor_function_t::relu6:
@@ -177,14 +155,11 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::reshape:
         return visit(tensor_op_reader<tensor_function_t::reshape>()(reader));
     case tensor_function_t::reshape_shape:
-        return visit(
-            tensor_op_reader<tensor_function_t::reshape_shape>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::reshape_shape>()(reader));
     case tensor_function_t::resize_image:
-        return visit(
-            tensor_op_reader<tensor_function_t::resize_image>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::resize_image>()(reader));
     case tensor_function_t::reverse_sequence:
-        return visit(
-            tensor_op_reader<tensor_function_t::reverse_sequence>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::reverse_sequence>()(reader));
     case tensor_function_t::scatter_nd:
         return visit(tensor_op_reader<tensor_function_t::scatter_nd>()(reader));
     case tensor_function_t::select:
@@ -206,15 +181,13 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::softsign:
         return visit(tensor_op_reader<tensor_function_t::softsign>()(reader));
     case tensor_function_t::space_to_batch:
-        return visit(
-            tensor_op_reader<tensor_function_t::space_to_batch>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::space_to_batch>()(reader));
     case tensor_function_t::split:
         return visit(tensor_op_reader<tensor_function_t::split>()(reader));
     case tensor_function_t::squeeze:
         return visit(tensor_op_reader<tensor_function_t::squeeze>()(reader));
     case tensor_function_t::squeeze_shape:
-        return visit(
-            tensor_op_reader<tensor_function_t::squeeze_shape>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::squeeze_shape>()(reader));
     case tensor_function_t::stack:
         return visit(tensor_op_reader<tensor_function_t::stack>()(reader));
     case tensor_function_t::swish:
@@ -226,8 +199,7 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::transpose:
         return visit(tensor_op_reader<tensor_function_t::transpose>()(reader));
     case tensor_function_t::transpose_shape:
-        return visit(
-            tensor_op_reader<tensor_function_t::transpose_shape>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::transpose_shape>()(reader));
     case tensor_function_t::trilu:
         return visit(tensor_op_reader<tensor_function_t::trilu>()(reader));
     case tensor_function_t::unary:
@@ -235,13 +207,11 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
     case tensor_function_t::uniform:
         return visit(tensor_op_reader<tensor_function_t::uniform>()(reader));
     case tensor_function_t::uniform_like:
-        return visit(
-            tensor_op_reader<tensor_function_t::uniform_like>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::uniform_like>()(reader));
     case tensor_function_t::unsqueeze:
         return visit(tensor_op_reader<tensor_function_t::unsqueeze>()(reader));
     case tensor_function_t::unsqueeze_shape:
-        return visit(
-            tensor_op_reader<tensor_function_t::unsqueeze_shape>()(reader));
+        return visit(tensor_op_reader<tensor_function_t::unsqueeze_shape>()(reader));
     case tensor_function_t::where:
         return visit(tensor_op_reader<tensor_function_t::where>()(reader));
     default:
diff --git a/src/Native/src/runtime/stackvm/ops/tensor.cpp b/src/Native/src/runtime/stackvm/ops/tensor.cpp
index 6f09a7084c..0893e73e59 100644
--- a/src/Native/src/runtime/stackvm/ops/tensor.cpp
+++ b/src/Native/src/runtime/stackvm/ops/tensor.cpp
@@ -1,5 +1,4 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 2023/9/5 19:40:29
- * +08:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:08 AM +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -24,8 +23,8 @@ using namespace nncase::runtime;
 using namespace nncase::runtime::stackvm;
 
 #ifdef NNCASE_DUMP_MANAGER
-#define dump_op(op)                                                            \
-    auto dump_manager = module().interp().dump_manager();                      \
+#define dump_op(op) \
+    auto dump_manager = module().interp().dump_manager(); \
     dump_manager->dump_op(op)
 #define dump_input(var) dump_manager->dump_input(var, #var)
 #define dump_output(var) dump_manager->dump_output(var)
@@ -35,8 +34,8 @@ using namespace nncase::runtime::stackvm;
 #define dump_output(var)
 #endif
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_batch_normalization_op_t &op) noexcept {
+
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_batch_normalization_op_t &op) noexcept {
     dump_op("batch_normalization");
     try_var(input, pop_value());
     dump_input(input);
@@ -52,16 +51,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(epsilon);
     try_var(momentum, pop_value());
     dump_input(momentum);
-    try_var(output, kernels::stackvm::batch_normalization(
-                        input, scale, bias, input_mean, input_var, epsilon,
-                        momentum, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::batch_normalization(input, scale, bias, input_mean, input_var, epsilon, momentum, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_batch_to_space_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_batch_to_space_op_t &op) noexcept {
     dump_op("batch_to_space");
     try_var(input, pop_value());
     dump_input(input);
@@ -69,111 +65,93 @@ result<void> stackvm_runtime_function::visit(
     dump_input(block_shape);
     try_var(crops, pop_value());
     dump_input(crops);
-    try_var(output,
-            kernels::stackvm::batch_to_space(input, block_shape, crops, nullptr,
-                                             module().kernel_context()));
+    try_var(output, kernels::stackvm::batch_to_space(input, block_shape, crops, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_binary_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_binary_op_t &op) noexcept {
     dump_op("binary");
     try_var(lhs, pop_value());
     dump_input(lhs);
     try_var(rhs, pop_value());
     dump_input(rhs);
-    try_var(output, kernels::stackvm::binary(op.binary_op, lhs, rhs, nullptr,
-                                             module().kernel_context()));
+    try_var(output, kernels::stackvm::binary(op.binary_op, lhs, rhs, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_bitcast_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_bitcast_op_t &op) noexcept {
     dump_op("bitcast");
     try_var(input, pop_value());
     dump_input(input);
     try_var(new_shape, pop_value());
     dump_input(new_shape);
-    try_var(output,
-            kernels::stackvm::bitcast(op.type, op.new_type, input, new_shape,
-                                      nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::bitcast(op.type, op.new_type, input, new_shape, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_broadcast_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_broadcast_op_t &op) noexcept {
     dump_op("broadcast");
     try_var(input, pop_value());
     dump_input(input);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::broadcast(input, shape, nullptr,
-                                                module().kernel_context()));
+    try_var(output, kernels::stackvm::broadcast(input, shape, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_broadcast_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_broadcast_shape_op_t &op) noexcept {
     dump_op("broadcast_shape");
     try_var(inputs, pop_value());
     dump_input(inputs);
-    try_var(output, kernels::stackvm::broadcast_shape(
-                        inputs, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::broadcast_shape(inputs, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_bucket_pad_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_bucket_pad_op_t &op) noexcept {
     dump_op("bucket_pad");
     try_var(input, pop_value());
     dump_input(input);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::bucket_pad(input, shape, nullptr,
-                                                 module().kernel_context()));
+    try_var(output, kernels::stackvm::bucket_pad(input, shape, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_cast_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_cast_op_t &op) noexcept {
     dump_op("cast");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::cast(op.new_type, op.cast_mode, input,
-                                           nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::cast(op.new_type, op.cast_mode, input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_celu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_celu_op_t &op) noexcept {
     dump_op("celu");
     try_var(input, pop_value());
     dump_input(input);
     try_var(alpha, pop_value());
     dump_input(alpha);
-    try_var(output, kernels::stackvm::celu(input, alpha, nullptr,
-                                           module().kernel_context()));
+    try_var(output, kernels::stackvm::celu(input, alpha, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_clamp_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_clamp_op_t &op) noexcept {
     dump_op("clamp");
     try_var(input, pop_value());
     dump_input(input);
@@ -181,72 +159,59 @@ result<void> stackvm_runtime_function::visit(
     dump_input(min);
     try_var(max, pop_value());
     dump_input(max);
-    try_var(output, kernels::stackvm::clamp(input, min, max, nullptr,
-                                            module().kernel_context()));
+    try_var(output, kernels::stackvm::clamp(input, min, max, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_compare_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_compare_op_t &op) noexcept {
     dump_op("compare");
     try_var(lhs, pop_value());
     dump_input(lhs);
     try_var(rhs, pop_value());
     dump_input(rhs);
-    try_var(output, kernels::stackvm::compare(op.compare_op, lhs, rhs, nullptr,
-                                              module().kernel_context()));
+    try_var(output, kernels::stackvm::compare(op.compare_op, lhs, rhs, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_concat_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_concat_op_t &op) noexcept {
     dump_op("concat");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(axis, pop_value());
-    dump_input(axis);
-    try_var(output, kernels::stackvm::concat(input, axis, nullptr,
-                                             module().kernel_context()));
+    try_var(output, kernels::stackvm::concat(op.axis, input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_condition_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_condition_op_t &op) noexcept {
     dump_op("condition");
     try_var(predicate, pop_value());
     dump_input(predicate);
     try_var(value, pop_value());
     dump_input(value);
-    try_var(output, kernels::stackvm::condition(op.can_fold_const_call,
-                                                predicate, value, nullptr,
-                                                module().kernel_context()));
+    try_var(output, kernels::stackvm::condition(op.can_fold_const_call, predicate, value, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_constant_of_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_constant_of_shape_op_t &op) noexcept {
     dump_op("constant_of_shape");
     try_var(shape, pop_value());
     dump_input(shape);
     try_var(value, pop_value());
     dump_input(value);
-    try_var(output, kernels::stackvm::constant_of_shape(
-                        shape, value, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::constant_of_shape(shape, value, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_conv2d_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2d_op_t &op) noexcept {
     dump_op("conv2d");
     try_var(input, pop_value());
     dump_input(input);
@@ -264,17 +229,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(groups);
     try_var(fused_clamp, pop_value());
     dump_input(fused_clamp);
-    try_var(output,
-            kernels::stackvm::conv2d(op.pad_mode, input, weights, bias, stride,
-                                     padding, dilation, groups, fused_clamp,
-                                     nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::conv2d(op.pad_mode, input, weights, bias, stride, padding, dilation, groups, fused_clamp, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_conv2d_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2d_shape_op_t &op) noexcept {
     dump_op("conv2d_shape");
     try_var(input, pop_value());
     dump_input(input);
@@ -288,16 +249,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(dilation);
     try_var(groups, pop_value());
     dump_input(groups);
-    try_var(output, kernels::stackvm::conv2d_shape(
-                        input, weights, padding, stride, dilation, groups,
-                        nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::conv2d_shape(input, weights, padding, stride, dilation, groups, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_conv2d_transpose_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2d_transpose_op_t &op) noexcept {
     dump_op("conv2d_transpose");
     try_var(input, pop_value());
     dump_input(input);
@@ -319,17 +277,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(groups);
     try_var(fused_clamp, pop_value());
     dump_input(fused_clamp);
-    try_var(output, kernels::stackvm::conv2d_transpose(
-                        op.pad_mode, input, weights, bias, output_shape, stride,
-                        padding, output_padding, dilation, groups, fused_clamp,
-                        nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::conv2d_transpose(op.pad_mode, input, weights, bias, output_shape, stride, padding, output_padding, dilation, groups, fused_clamp, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_conv2d_transpose_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2d_transpose_shape_op_t &op) noexcept {
     dump_op("conv2d_transpose_shape");
     try_var(input, pop_value());
     dump_input(input);
@@ -345,17 +299,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(output_padding);
     try_var(groups, pop_value());
     dump_input(groups);
-    try_var(output,
-            kernels::stackvm::conv2d_transpose_shape(
-                input, weights, stride, dilation, padding, output_padding,
-                groups, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::conv2d_transpose_shape(input, weights, stride, dilation, padding, output_padding, groups, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_cum_sum_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_cum_sum_op_t &op) noexcept {
     dump_op("cum_sum");
     try_var(input, pop_value());
     dump_input(input);
@@ -365,145 +315,119 @@ result<void> stackvm_runtime_function::visit(
     dump_input(exclusive);
     try_var(reverse, pop_value());
     dump_input(reverse);
-    try_var(output,
-            kernels::stackvm::cum_sum(input, axis, exclusive, reverse, nullptr,
-                                      module().kernel_context()));
+    try_var(output, kernels::stackvm::cum_sum(input, axis, exclusive, reverse, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_dequantize_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_dequantize_op_t &op) noexcept {
     dump_op("dequantize");
     try_var(input, pop_value());
     dump_input(input);
     try_var(dequant_param, pop_value());
     dump_input(dequant_param);
-    try_var(output,
-            kernels::stackvm::dequantize(op.target_type, input, dequant_param,
-                                         nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::dequantize(op.target_type, input, dequant_param, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_elu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_elu_op_t &op) noexcept {
     dump_op("elu");
     try_var(input, pop_value());
     dump_input(input);
     try_var(alpha, pop_value());
     dump_input(alpha);
-    try_var(output, kernels::stackvm::elu(input, alpha, nullptr,
-                                          module().kernel_context()));
+    try_var(output, kernels::stackvm::elu(input, alpha, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_erf_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_erf_op_t &op) noexcept {
     dump_op("erf");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output,
-            kernels::stackvm::erf(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::erf(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_expand_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_expand_op_t &op) noexcept {
     dump_op("expand");
     try_var(input, pop_value());
     dump_input(input);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::expand(input, shape, nullptr,
-                                             module().kernel_context()));
+    try_var(output, kernels::stackvm::expand(input, shape, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_fake_dequantize_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_fake_dequantize_op_t &op) noexcept {
     dump_op("fake_dequantize");
     try_var(input, pop_value());
     dump_input(input);
     try_var(dequant_param, pop_value());
     dump_input(dequant_param);
-    try_var(output, kernels::stackvm::fake_dequantize(
-                        op.target_type, input, dequant_param, nullptr,
-                        module().kernel_context()));
+    try_var(output, kernels::stackvm::fake_dequantize(op.target_type, input, dequant_param, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_fake_quantize_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_fake_quantize_op_t &op) noexcept {
     dump_op("fake_quantize");
     try_var(input, pop_value());
     dump_input(input);
     try_var(quant_param, pop_value());
     dump_input(quant_param);
-    try_var(output, kernels::stackvm::fake_quantize(op.target_type, input,
-                                                    quant_param, nullptr,
-                                                    module().kernel_context()));
+    try_var(output, kernels::stackvm::fake_quantize(op.target_type, input, quant_param, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_fix_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_fix_shape_op_t &op) noexcept {
     dump_op("fix_shape");
     try_var(input, pop_value());
     dump_input(input);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::fix_shape(input, shape, nullptr,
-                                                module().kernel_context()));
+    try_var(output, kernels::stackvm::fix_shape(input, shape, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_flatten_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_flatten_op_t &op) noexcept {
     dump_op("flatten");
     try_var(input, pop_value());
     dump_input(input);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::flatten(input, axis, nullptr,
-                                              module().kernel_context()));
+    try_var(output, kernels::stackvm::flatten(input, axis, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_gather_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_gather_op_t &op) noexcept {
     dump_op("gather");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(axis, pop_value());
-    dump_input(axis);
     try_var(index, pop_value());
     dump_input(index);
-    try_var(output, kernels::stackvm::gather(input, axis, index, nullptr,
-                                             module().kernel_context()));
+    try_var(output, kernels::stackvm::gather(op.axis, input, index, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_gather_elements_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_gather_elements_op_t &op) noexcept {
     dump_op("gather_elements");
     try_var(input, pop_value());
     dump_input(input);
@@ -511,16 +435,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(axis);
     try_var(indices, pop_value());
     dump_input(indices);
-    try_var(output,
-            kernels::stackvm::gather_elements(input, axis, indices, nullptr,
-                                              module().kernel_context()));
+    try_var(output, kernels::stackvm::gather_elements(input, axis, indices, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_gather_nd_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_gather_nd_op_t &op) noexcept {
     dump_op("gather_nd");
     try_var(input, pop_value());
     dump_input(input);
@@ -528,44 +449,37 @@ result<void> stackvm_runtime_function::visit(
     dump_input(batch_dims);
     try_var(index, pop_value());
     dump_input(index);
-    try_var(output,
-            kernels::stackvm::gather_nd(input, batch_dims, index, nullptr,
-                                        module().kernel_context()));
+    try_var(output, kernels::stackvm::gather_nd(input, batch_dims, index, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_gelu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_gelu_op_t &op) noexcept {
     dump_op("gelu");
     try_var(input, pop_value());
     dump_input(input);
     try_var(alpha, pop_value());
     dump_input(alpha);
-    try_var(output, kernels::stackvm::gelu(input, alpha, nullptr,
-                                           module().kernel_context()));
+    try_var(output, kernels::stackvm::gelu(input, alpha, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_get_item_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_get_item_op_t &op) noexcept {
     dump_op("get_item");
     try_var(input, pop_value());
     dump_input(input);
     try_var(index, pop_value());
     dump_input(index);
-    try_var(output, kernels::stackvm::get_item(input, index, nullptr,
-                                               module().kernel_context()));
+    try_var(output, kernels::stackvm::get_item(input, index, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_get_paddings_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_get_paddings_op_t &op) noexcept {
     dump_op("get_paddings");
     try_var(input_shape, pop_value());
     dump_input(input_shape);
@@ -579,16 +493,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(same);
     try_var(lower, pop_value());
     dump_input(lower);
-    try_var(output, kernels::stackvm::get_paddings(
-                        input_shape, weights_shape, strides, dilations, same,
-                        lower, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::get_paddings(input_shape, weights_shape, strides, dilations, same, lower, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_hard_sigmoid_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_hard_sigmoid_op_t &op) noexcept {
     dump_op("hard_sigmoid");
     try_var(input, pop_value());
     dump_input(input);
@@ -596,55 +507,47 @@ result<void> stackvm_runtime_function::visit(
     dump_input(alpha);
     try_var(beta, pop_value());
     dump_input(beta);
-    try_var(output, kernels::stackvm::hard_sigmoid(input, alpha, beta, nullptr,
-                                                   module().kernel_context()));
+    try_var(output, kernels::stackvm::hard_sigmoid(input, alpha, beta, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_hard_swish_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_hard_swish_op_t &op) noexcept {
     dump_op("hard_swish");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::hard_swish(input, nullptr,
-                                                 module().kernel_context()));
+    try_var(output, kernels::stackvm::hard_swish(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_hardmax_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_hardmax_op_t &op) noexcept {
     dump_op("hardmax");
     try_var(input, pop_value());
     dump_input(input);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::hardmax(input, axis, nullptr,
-                                              module().kernel_context()));
+    try_var(output, kernels::stackvm::hardmax(input, axis, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_index_of_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_index_of_op_t &op) noexcept {
     dump_op("index_of");
     try_var(input, pop_value());
     dump_input(input);
     try_var(value, pop_value());
     dump_input(value);
-    try_var(output, kernels::stackvm::index_of(input, value, nullptr,
-                                               module().kernel_context()));
+    try_var(output, kernels::stackvm::index_of(input, value, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_instance_normalization_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_instance_normalization_op_t &op) noexcept {
     dump_op("instance_normalization");
     try_var(input, pop_value());
     dump_input(input);
@@ -654,28 +557,23 @@ result<void> stackvm_runtime_function::visit(
     dump_input(bias);
     try_var(epsilon, pop_value());
     dump_input(epsilon);
-    try_var(output, kernels::stackvm::instance_normalization(
-                        input, scale, bias, epsilon, nullptr,
-                        module().kernel_context()));
+    try_var(output, kernels::stackvm::instance_normalization(input, scale, bias, epsilon, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_l2_normalization_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_l2_normalization_op_t &op) noexcept {
     dump_op("l2_normalization");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::l2_normalization(
-                        input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::l2_normalization(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_layer_norm_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_layer_norm_op_t &op) noexcept {
     dump_op("layer_norm");
     try_var(input, pop_value());
     dump_input(input);
@@ -683,44 +581,37 @@ result<void> stackvm_runtime_function::visit(
     dump_input(scale);
     try_var(bias, pop_value());
     dump_input(bias);
-    try_var(output, kernels::stackvm::layer_norm(op.axis, op.epsilon, input,
-                                                 scale, bias, nullptr,
-                                                 module().kernel_context()));
+    try_var(output, kernels::stackvm::layer_norm(op.axis, op.epsilon, op.use_mean, input, scale, bias, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_leaky_relu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_leaky_relu_op_t &op) noexcept {
     dump_op("leaky_relu");
     try_var(input, pop_value());
     dump_input(input);
     try_var(alpha, pop_value());
     dump_input(alpha);
-    try_var(output, kernels::stackvm::leaky_relu(input, alpha, nullptr,
-                                                 module().kernel_context()));
+    try_var(output, kernels::stackvm::leaky_relu(input, alpha, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_log_softmax_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_log_softmax_op_t &op) noexcept {
     dump_op("log_softmax");
     try_var(input, pop_value());
     dump_input(input);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::log_softmax(input, axis, nullptr,
-                                                  module().kernel_context()));
+    try_var(output, kernels::stackvm::log_softmax(input, axis, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_lp_normalization_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_lp_normalization_op_t &op) noexcept {
     dump_op("lp_normalization");
     try_var(input, pop_value());
     dump_input(input);
@@ -728,15 +619,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(axis);
     try_var(p, pop_value());
     dump_input(p);
-    try_var(output, kernels::stackvm::lp_normalization(
-                        input, axis, p, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::lp_normalization(input, axis, p, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_lrn_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_lrn_op_t &op) noexcept {
     dump_op("lrn");
     try_var(input, pop_value());
     dump_input(input);
@@ -748,15 +637,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(bias);
     try_var(size, pop_value());
     dump_input(size);
-    try_var(output, kernels::stackvm::lrn(input, alpha, beta, bias, size,
-                                          nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::lrn(input, alpha, beta, bias, size, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_lstm_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_lstm_op_t &op) noexcept {
     dump_op("lstm");
     try_var(x, pop_value());
     dump_input(x);
@@ -786,47 +673,37 @@ result<void> stackvm_runtime_function::visit(
     dump_input(input_forget);
     try_var(output_size, pop_value());
     dump_input(output_size);
-    try_var(output,
-            kernels::stackvm::lstm(op.direction, op.layout, op.activations, x,
-                                   w, r, b, sequence_lens, initial_h, initial_c,
-                                   p, activation_alpha, activation_beta, clip,
-                                   hidden_size, input_forget, output_size,
-                                   nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::lstm(op.direction, op.layout, op.activations, x, w, r, b, sequence_lens, initial_h, initial_c, p, activation_alpha, activation_beta, clip, hidden_size, input_forget, output_size, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_mat_mul_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_mat_mul_op_t &op) noexcept {
     dump_op("mat_mul");
     try_var(lhs, pop_value());
     dump_input(lhs);
     try_var(rhs, pop_value());
     dump_input(rhs);
-    try_var(output, kernels::stackvm::mat_mul(lhs, rhs, nullptr,
-                                              module().kernel_context()));
+    try_var(output, kernels::stackvm::mat_mul(lhs, rhs, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_mat_mul_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_mat_mul_shape_op_t &op) noexcept {
     dump_op("mat_mul_shape");
     try_var(lhs, pop_value());
     dump_input(lhs);
     try_var(rhs, pop_value());
     dump_input(rhs);
-    try_var(output, kernels::stackvm::mat_mul_shape(lhs, rhs, nullptr,
-                                                    module().kernel_context()));
+    try_var(output, kernels::stackvm::mat_mul_shape(lhs, rhs, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_normal_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_normal_op_t &op) noexcept {
     dump_op("normal");
     try_var(mean, pop_value());
     dump_input(mean);
@@ -836,16 +713,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(seed);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output,
-            kernels::stackvm::normal(op.type, mean, scale, seed, shape, nullptr,
-                                     module().kernel_context()));
+    try_var(output, kernels::stackvm::normal(op.type, mean, scale, seed, shape, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_normal_like_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_normal_like_op_t &op) noexcept {
     dump_op("normal_like");
     try_var(input, pop_value());
     dump_input(input);
@@ -855,16 +729,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(scale);
     try_var(seed, pop_value());
     dump_input(seed);
-    try_var(output,
-            kernels::stackvm::normal_like(op.type, input, mean, scale, seed,
-                                          nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::normal_like(op.type, input, mean, scale, seed, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_one_hot_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_one_hot_op_t &op) noexcept {
     dump_op("one_hot");
     try_var(indices, pop_value());
     dump_input(indices);
@@ -874,16 +745,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(values);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::one_hot(op.one_hot_mode, indices, depth,
-                                              values, axis, nullptr,
-                                              module().kernel_context()));
+    try_var(output, kernels::stackvm::one_hot(op.one_hot_mode, indices, depth, values, axis, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_pad_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_pad_op_t &op) noexcept {
     dump_op("pad");
     try_var(input, pop_value());
     dump_input(input);
@@ -891,71 +759,59 @@ result<void> stackvm_runtime_function::visit(
     dump_input(pads);
     try_var(value, pop_value());
     dump_input(value);
-    try_var(output, kernels::stackvm::pad(op.pad_mode, input, pads, value,
-                                          nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::pad(op.pad_mode, input, pads, value, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_prelu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_prelu_op_t &op) noexcept {
     dump_op("prelu");
     try_var(input, pop_value());
     dump_input(input);
     try_var(slope, pop_value());
     dump_input(slope);
-    try_var(output, kernels::stackvm::prelu(input, slope, nullptr,
-                                            module().kernel_context()));
+    try_var(output, kernels::stackvm::prelu(input, slope, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_prod_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_prod_op_t &op) noexcept {
     dump_op("prod");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output,
-            kernels::stackvm::prod(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::prod(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_quant_param_of_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_quant_param_of_op_t &op) noexcept {
     dump_op("quant_param_of");
     try_var(range, pop_value());
     dump_input(range);
     try_var(bits, pop_value());
     dump_input(bits);
-    try_var(output, kernels::stackvm::quant_param_of(
-                        op.quant_mode, range, bits, nullptr,
-                        module().kernel_context()));
+    try_var(output, kernels::stackvm::quant_param_of(op.quant_mode, range, bits, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_quantize_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_quantize_op_t &op) noexcept {
     dump_op("quantize");
     try_var(input, pop_value());
     dump_input(input);
     try_var(quant_param, pop_value());
     dump_input(quant_param);
-    try_var(output,
-            kernels::stackvm::quantize(op.target_type, input, quant_param,
-                                       nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::quantize(op.target_type, input, quant_param, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_range_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_range_op_t &op) noexcept {
     dump_op("range");
     try_var(begin, pop_value());
     dump_input(begin);
@@ -963,40 +819,33 @@ result<void> stackvm_runtime_function::visit(
     dump_input(end);
     try_var(step, pop_value());
     dump_input(step);
-    try_var(output, kernels::stackvm::range(begin, end, step, nullptr,
-                                            module().kernel_context()));
+    try_var(output, kernels::stackvm::range(begin, end, step, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_range_of_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_range_of_op_t &op) noexcept {
     dump_op("range_of");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output,
-            kernels::stackvm::range_of(op.is_range_of_weight, input, nullptr,
-                                       module().kernel_context()));
+    try_var(output, kernels::stackvm::range_of(op.is_range_of_weight, input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_rank_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_rank_op_t &op) noexcept {
     dump_op("rank");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output,
-            kernels::stackvm::rank(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::rank(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_reduce_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reduce_op_t &op) noexcept {
     dump_op("reduce");
     try_var(input, pop_value());
     dump_input(input);
@@ -1006,16 +855,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(init_value);
     try_var(keep_dims, pop_value());
     dump_input(keep_dims);
-    try_var(output, kernels::stackvm::reduce(op.reduce_op, input, axis,
-                                             init_value, keep_dims, nullptr,
-                                             module().kernel_context()));
+    try_var(output, kernels::stackvm::reduce(op.reduce_op, input, axis, init_value, keep_dims, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_reduce_arg_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reduce_arg_op_t &op) noexcept {
     dump_op("reduce_arg");
     try_var(input, pop_value());
     dump_input(input);
@@ -1025,16 +871,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(keep_dims);
     try_var(select_last_index, pop_value());
     dump_input(select_last_index);
-    try_var(output, kernels::stackvm::reduce_arg(
-                        op.reduce_arg_op, op.dest_type, input, axis, keep_dims,
-                        select_last_index, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::reduce_arg(op.reduce_arg_op, op.dest_type, input, axis, keep_dims, select_last_index, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_reduce_window2d_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reduce_window2d_op_t &op) noexcept {
     dump_op("reduce_window2d");
     try_var(input, pop_value());
     dump_input(input);
@@ -1052,84 +895,69 @@ result<void> stackvm_runtime_function::visit(
     dump_input(ceil_mode);
     try_var(count_include_pad, pop_value());
     dump_input(count_include_pad);
-    try_var(output, kernels::stackvm::reduce_window2d(
-                        op.reduce_op, input, init_value, filter, stride,
-                        padding, dilation, ceil_mode, count_include_pad,
-                        nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::reduce_window2d(op.reduce_op, input, init_value, filter, stride, padding, dilation, ceil_mode, count_include_pad, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_relu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_relu_op_t &op) noexcept {
     dump_op("relu");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output,
-            kernels::stackvm::relu(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::relu(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_relu6_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_relu6_op_t &op) noexcept {
     dump_op("relu6");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output,
-            kernels::stackvm::relu6(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::relu6(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_require_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_require_op_t &op) noexcept {
     dump_op("require");
     try_var(predicate, pop_value());
     dump_input(predicate);
     try_var(value, pop_value());
     dump_input(value);
-    try_var(output, kernels::stackvm::require(
-                        op.message, op.can_fold_const_call, predicate, value,
-                        nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::require(op.message, op.can_fold_const_call, predicate, value, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_reshape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reshape_op_t &op) noexcept {
     dump_op("reshape");
     try_var(input, pop_value());
     dump_input(input);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::reshape(input, shape, nullptr,
-                                              module().kernel_context()));
+    try_var(output, kernels::stackvm::reshape(input, shape, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_reshape_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reshape_shape_op_t &op) noexcept {
     dump_op("reshape_shape");
     try_var(input_shape, pop_value());
     dump_input(input_shape);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::reshape_shape(input_shape, shape, nullptr,
-                                                    module().kernel_context()));
+    try_var(output, kernels::stackvm::reshape_shape(input_shape, shape, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_resize_image_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_resize_image_op_t &op) noexcept {
     dump_op("resize_image");
     try_var(input, pop_value());
     dump_input(input);
@@ -1143,18 +971,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(exclude_outside);
     try_var(extrapolation_value, pop_value());
     dump_input(extrapolation_value);
-    try_var(output, kernels::stackvm::resize_image(
-                        op.resize_mode, op.transformation_mode, op.nearest_mode,
-                        op.is_tfresize, input, roi, new_size, cubic_coeff_a,
-                        exclude_outside, extrapolation_value, nullptr,
-                        module().kernel_context()));
+    try_var(output, kernels::stackvm::resize_image(op.resize_mode, op.transformation_mode, op.nearest_mode, op.is_tfresize, input, roi, new_size, cubic_coeff_a, exclude_outside, extrapolation_value, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_reverse_sequence_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reverse_sequence_op_t &op) noexcept {
     dump_op("reverse_sequence");
     try_var(input, pop_value());
     dump_input(input);
@@ -1164,16 +987,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(batch_axis);
     try_var(time_axis, pop_value());
     dump_input(time_axis);
-    try_var(output, kernels::stackvm::reverse_sequence(
-                        input, seq_lens, batch_axis, time_axis, nullptr,
-                        module().kernel_context()));
+    try_var(output, kernels::stackvm::reverse_sequence(input, seq_lens, batch_axis, time_axis, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_scatter_nd_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_scatter_nd_op_t &op) noexcept {
     dump_op("scatter_nd");
     try_var(input, pop_value());
     dump_input(input);
@@ -1181,16 +1001,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(indices);
     try_var(updates, pop_value());
     dump_input(updates);
-    try_var(output,
-            kernels::stackvm::scatter_nd(input, indices, updates, nullptr,
-                                         module().kernel_context()));
+    try_var(output, kernels::stackvm::scatter_nd(input, indices, updates, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_select_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_select_op_t &op) noexcept {
     dump_op("select");
     try_var(predicate, pop_value());
     dump_input(predicate);
@@ -1198,16 +1015,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(true_value);
     try_var(false_value, pop_value());
     dump_input(false_value);
-    try_var(output,
-            kernels::stackvm::select(predicate, true_value, false_value,
-                                     nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::select(predicate, true_value, false_value, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_selu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_selu_op_t &op) noexcept {
     dump_op("selu");
     try_var(input, pop_value());
     dump_input(input);
@@ -1215,51 +1029,43 @@ result<void> stackvm_runtime_function::visit(
     dump_input(alpha);
     try_var(gamma, pop_value());
     dump_input(gamma);
-    try_var(output, kernels::stackvm::selu(input, alpha, gamma, nullptr,
-                                           module().kernel_context()));
+    try_var(output, kernels::stackvm::selu(input, alpha, gamma, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_shape_of_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_shape_of_op_t &op) noexcept {
     dump_op("shape_of");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::shape_of(input, nullptr,
-                                               module().kernel_context()));
+    try_var(output, kernels::stackvm::shape_of(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_sigmoid_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_sigmoid_op_t &op) noexcept {
     dump_op("sigmoid");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::sigmoid(input, nullptr,
-                                              module().kernel_context()));
+    try_var(output, kernels::stackvm::sigmoid(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_size_of_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_size_of_op_t &op) noexcept {
     dump_op("size_of");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::size_of(input, nullptr,
-                                              module().kernel_context()));
+    try_var(output, kernels::stackvm::size_of(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_slice_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_slice_op_t &op) noexcept {
     dump_op("slice");
     try_var(input, pop_value());
     dump_input(input);
@@ -1271,54 +1077,45 @@ result<void> stackvm_runtime_function::visit(
     dump_input(axes);
     try_var(strides, pop_value());
     dump_input(strides);
-    try_var(output,
-            kernels::stackvm::slice(input, begins, ends, axes, strides, nullptr,
-                                    module().kernel_context()));
+    try_var(output, kernels::stackvm::slice(input, begins, ends, axes, strides, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_softmax_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_softmax_op_t &op) noexcept {
     dump_op("softmax");
     try_var(input, pop_value());
     dump_input(input);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::softmax(input, axis, nullptr,
-                                              module().kernel_context()));
+    try_var(output, kernels::stackvm::softmax(input, axis, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_softplus_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_softplus_op_t &op) noexcept {
     dump_op("softplus");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::softplus(input, nullptr,
-                                               module().kernel_context()));
+    try_var(output, kernels::stackvm::softplus(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_softsign_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_softsign_op_t &op) noexcept {
     dump_op("softsign");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::softsign(input, nullptr,
-                                               module().kernel_context()));
+    try_var(output, kernels::stackvm::softsign(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_space_to_batch_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_space_to_batch_op_t &op) noexcept {
     dump_op("space_to_batch");
     try_var(input, pop_value());
     dump_input(input);
@@ -1326,16 +1123,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(block_shape);
     try_var(paddings, pop_value());
     dump_input(paddings);
-    try_var(output, kernels::stackvm::space_to_batch(
-                        input, block_shape, paddings, nullptr,
-                        module().kernel_context()));
+    try_var(output, kernels::stackvm::space_to_batch(input, block_shape, paddings, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_split_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_split_op_t &op) noexcept {
     dump_op("split");
     try_var(input, pop_value());
     dump_input(input);
@@ -1343,83 +1137,71 @@ result<void> stackvm_runtime_function::visit(
     dump_input(axis);
     try_var(sections, pop_value());
     dump_input(sections);
-    try_var(output, kernels::stackvm::split(input, axis, sections, nullptr,
-                                            module().kernel_context()));
+    try_var(output, kernels::stackvm::split(input, axis, sections, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_squeeze_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_squeeze_op_t &op) noexcept {
     dump_op("squeeze");
     try_var(input, pop_value());
     dump_input(input);
     try_var(dim, pop_value());
     dump_input(dim);
-    try_var(output, kernels::stackvm::squeeze(input, dim, nullptr,
-                                              module().kernel_context()));
+    try_var(output, kernels::stackvm::squeeze(input, dim, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_squeeze_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_squeeze_shape_op_t &op) noexcept {
     dump_op("squeeze_shape");
     try_var(input_shape, pop_value());
     dump_input(input_shape);
     try_var(dim, pop_value());
     dump_input(dim);
-    try_var(output, kernels::stackvm::squeeze_shape(input_shape, dim, nullptr,
-                                                    module().kernel_context()));
+    try_var(output, kernels::stackvm::squeeze_shape(input_shape, dim, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_stack_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_stack_op_t &op) noexcept {
     dump_op("stack");
     try_var(inputs, pop_value());
     dump_input(inputs);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::stack(inputs, axis, nullptr,
-                                            module().kernel_context()));
+    try_var(output, kernels::stackvm::stack(inputs, axis, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_swish_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_swish_op_t &op) noexcept {
     dump_op("swish");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output,
-            kernels::stackvm::swish(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::swish(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_tile_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_tile_op_t &op) noexcept {
     dump_op("tile");
     try_var(input, pop_value());
     dump_input(input);
     try_var(repeats, pop_value());
     dump_input(repeats);
-    try_var(output, kernels::stackvm::tile(input, repeats, nullptr,
-                                           module().kernel_context()));
+    try_var(output, kernels::stackvm::tile(input, repeats, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_top_k_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_top_k_op_t &op) noexcept {
     dump_op("top_k");
     try_var(x, pop_value());
     dump_input(x);
@@ -1431,44 +1213,37 @@ result<void> stackvm_runtime_function::visit(
     dump_input(largest);
     try_var(sorted, pop_value());
     dump_input(sorted);
-    try_var(output,
-            kernels::stackvm::top_k(x, k, axis, largest, sorted, nullptr,
-                                    module().kernel_context()));
+    try_var(output, kernels::stackvm::top_k(x, k, axis, largest, sorted, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_transpose_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_transpose_op_t &op) noexcept {
     dump_op("transpose");
     try_var(input, pop_value());
     dump_input(input);
     try_var(perm, pop_value());
     dump_input(perm);
-    try_var(output, kernels::stackvm::transpose(input, perm, nullptr,
-                                                module().kernel_context()));
+    try_var(output, kernels::stackvm::transpose(input, perm, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_transpose_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_transpose_shape_op_t &op) noexcept {
     dump_op("transpose_shape");
     try_var(input_shape, pop_value());
     dump_input(input_shape);
     try_var(perm, pop_value());
     dump_input(perm);
-    try_var(output, kernels::stackvm::transpose_shape(
-                        input_shape, perm, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::transpose_shape(input_shape, perm, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_trilu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_trilu_op_t &op) noexcept {
     dump_op("trilu");
     try_var(input, pop_value());
     dump_input(input);
@@ -1476,27 +1251,23 @@ result<void> stackvm_runtime_function::visit(
     dump_input(k);
     try_var(upper, pop_value());
     dump_input(upper);
-    try_var(output, kernels::stackvm::trilu(input, k, upper, nullptr,
-                                            module().kernel_context()));
+    try_var(output, kernels::stackvm::trilu(input, k, upper, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_unary_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_unary_op_t &op) noexcept {
     dump_op("unary");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::unary(op.unary_op, input, nullptr,
-                                            module().kernel_context()));
+    try_var(output, kernels::stackvm::unary(op.unary_op, input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_uniform_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_uniform_op_t &op) noexcept {
     dump_op("uniform");
     try_var(high, pop_value());
     dump_input(high);
@@ -1506,16 +1277,13 @@ result<void> stackvm_runtime_function::visit(
     dump_input(seed);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output,
-            kernels::stackvm::uniform(op.type, high, low, seed, shape, nullptr,
-                                      module().kernel_context()));
+    try_var(output, kernels::stackvm::uniform(op.type, high, low, seed, shape, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_uniform_like_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_uniform_like_op_t &op) noexcept {
     dump_op("uniform_like");
     try_var(input, pop_value());
     dump_input(input);
@@ -1525,44 +1293,37 @@ result<void> stackvm_runtime_function::visit(
     dump_input(low);
     try_var(seed, pop_value());
     dump_input(seed);
-    try_var(output,
-            kernels::stackvm::uniform_like(op.type, input, high, low, seed,
-                                           nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::uniform_like(op.type, input, high, low, seed, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_unsqueeze_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_unsqueeze_op_t &op) noexcept {
     dump_op("unsqueeze");
     try_var(input, pop_value());
     dump_input(input);
     try_var(dim, pop_value());
     dump_input(dim);
-    try_var(output, kernels::stackvm::unsqueeze(input, dim, nullptr,
-                                                module().kernel_context()));
+    try_var(output, kernels::stackvm::unsqueeze(input, dim, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_unsqueeze_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_unsqueeze_shape_op_t &op) noexcept {
     dump_op("unsqueeze_shape");
     try_var(input_shape, pop_value());
     dump_input(input_shape);
     try_var(dim, pop_value());
     dump_input(dim);
-    try_var(output, kernels::stackvm::unsqueeze_shape(
-                        input_shape, dim, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::unsqueeze_shape(input_shape, dim, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit(
-    [[maybe_unused]] const tensor_where_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_where_op_t &op) noexcept {
     dump_op("where");
     try_var(cond, pop_value());
     dump_input(cond);
@@ -1570,8 +1331,7 @@ result<void> stackvm_runtime_function::visit(
     dump_input(x);
     try_var(y, pop_value());
     dump_input(y);
-    try_var(output, kernels::stackvm::where(op.is_tf_where, cond, x, y, nullptr,
-                                            module().kernel_context()));
+    try_var(output, kernels::stackvm::where(op.is_tf_where, cond, x, y, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
diff --git a/src/Native/src/runtime/stackvm/runtime_function_ops.h b/src/Native/src/runtime/stackvm/runtime_function_ops.h
index ae6944ef59..eee188a832 100644
--- a/src/Native/src/runtime/stackvm/runtime_function_ops.h
+++ b/src/Native/src/runtime/stackvm/runtime_function_ops.h
@@ -1,5 +1,4 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 2023/9/5 19:40:29
- * +08:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -33,8 +32,7 @@ result<void> visit(const tensor_constant_of_shape_op_t &op) noexcept override;
 result<void> visit(const tensor_conv2d_op_t &op) noexcept override;
 result<void> visit(const tensor_conv2d_shape_op_t &op) noexcept override;
 result<void> visit(const tensor_conv2d_transpose_op_t &op) noexcept override;
-result<void>
-visit(const tensor_conv2d_transpose_shape_op_t &op) noexcept override;
+result<void> visit(const tensor_conv2d_transpose_shape_op_t &op) noexcept override;
 result<void> visit(const tensor_cum_sum_op_t &op) noexcept override;
 result<void> visit(const tensor_dequantize_op_t &op) noexcept override;
 result<void> visit(const tensor_elu_op_t &op) noexcept override;
@@ -54,8 +52,7 @@ result<void> visit(const tensor_hard_sigmoid_op_t &op) noexcept override;
 result<void> visit(const tensor_hard_swish_op_t &op) noexcept override;
 result<void> visit(const tensor_hardmax_op_t &op) noexcept override;
 result<void> visit(const tensor_index_of_op_t &op) noexcept override;
-result<void>
-visit(const tensor_instance_normalization_op_t &op) noexcept override;
+result<void> visit(const tensor_instance_normalization_op_t &op) noexcept override;
 result<void> visit(const tensor_l2_normalization_op_t &op) noexcept override;
 result<void> visit(const tensor_layer_norm_op_t &op) noexcept override;
 result<void> visit(const tensor_leaky_relu_op_t &op) noexcept override;
diff --git a/src/Nncase.Core/DistributedUtility.cs b/src/Nncase.Core/DistributedUtility.cs
index 774bdc819a..6cdecf2c6a 100644
--- a/src/Nncase.Core/DistributedUtility.cs
+++ b/src/Nncase.Core/DistributedUtility.cs
@@ -33,53 +33,6 @@ public static IReadOnlyList<IRArray<SBP>> GetLeafCandidateNDSBPs(TensorType tens
            ToArray();
     }
 
-    public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement placement)
-    {
-        return GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).ToArray();
-    }
-
-    /// <summary>
-    /// when input expression sbp is partial, get the new candidate boxings.
-    /// </summary>
-    /// <param name="expr">input expression.</param>
-    /// <returns>the boxings.</returns>
-    /// <exception cref="NotSupportedException">when expr is tuple.</exception>
-    public static IReadOnlyList<Expr> GetPartialCandidateBoxings(Expr expr)
-    {
-        if (expr is IR.Tuple tuple)
-        {
-            var candidates = tuple.Fields.ToArray().
-                Select(GetPartialCandidateBoxings).
-                CartesianProduct();
-            return candidates.Any() ? candidates.
-                Select(fs => new IR.Tuple(fs.ToArray())).
-                ToArray() : Array.Empty<Expr>();
-        }
-
-        var type = (DistributedType)expr.CheckedType;
-        var tensorType = type.TensorType;
-        var candidateNdsbps = new List<SBP>[type.Placement.Rank];
-        for (int i = 0; i < type.Placement.Rank; i++)
-        {
-            candidateNdsbps[i] = new List<SBP>();
-            if (type.NdSBP[i] is SBPPartialSum)
-            {
-                candidateNdsbps[i].Add(SBP.B);
-                for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
-                {
-                    if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && IsDivisible(s, type.Placement.Hierarchy[i]))
-                    {
-                        candidateNdsbps[i].Add(SBP.S(axis));
-                    }
-                }
-            }
-        }
-
-        return candidateNdsbps.CartesianProduct().
-            Select(ndsbp => new DistributedType(tensorType, new IRArray<SBP>(ndsbp), type.Placement)).
-            Select(disttype => IR.F.Tensors.Boxing(expr, disttype)).ToArray();
-    }
-
     public static bool IsDistributable(TensorType tensorType, ReadOnlySpan<SBP> ndsbp, Placement placement, [MaybeNullWhen(false)] out TensorType distType)
     {
         distType = null;
diff --git a/src/Nncase.Core/IR/Tensors/Functional.cs b/src/Nncase.Core/IR/Tensors/Functional.cs
index 74973ca9ea..d20f69cbf5 100644
--- a/src/Nncase.Core/IR/Tensors/Functional.cs
+++ b/src/Nncase.Core/IR/Tensors/Functional.cs
@@ -70,16 +70,6 @@ public static Call Bitcast(PrimType type, Expr input, PrimType newType, Expr sha
     public static Call Cast(Expr input, DataType newType, CastMode castMode = CastMode.KDefault) =>
         new Call(new Cast(newType, castMode), input);
 
-    public static Call Boxing(Expr input, IRType type)
-    {
-        if (input.CheckedType == type)
-        {
-            throw new NotSupportedException();
-        }
-
-        return new Call(new Boxing(type), input);
-    }
-
     public static Call Concat(Expr input, int axis) => new Call(new Concat(axis), input);
 
     public static Call ConstantOfShape(Expr shape, Expr value) => new Call(new ConstantOfShape(), shape, value);
diff --git a/src/Nncase.Evaluator/Tensors/TensorsModule.cs b/src/Nncase.Evaluator/Tensors/TensorsModule.cs
index bb75b46c30..15e3446a23 100644
--- a/src/Nncase.Evaluator/Tensors/TensorsModule.cs
+++ b/src/Nncase.Evaluator/Tensors/TensorsModule.cs
@@ -16,7 +16,6 @@ internal class TensorsModule : IApplicationPart
     public void ConfigureServices(IRegistrator registrator)
     {
         registrator.RegisterManyInterface<BroadcastEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<BoxingEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<BitcastEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<CastEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<ConcatEvaluator>(reuse: Reuse.Singleton);
diff --git a/src/Nncase.Tests/CodeGen/UnitTestStackVMEmitter.cs b/src/Nncase.Tests/CodeGen/UnitTestStackVMEmitter.cs
index 2e1027f3c2..087cb54f9a 100644
--- a/src/Nncase.Tests/CodeGen/UnitTestStackVMEmitter.cs
+++ b/src/Nncase.Tests/CodeGen/UnitTestStackVMEmitter.cs
@@ -1002,7 +1002,7 @@ public void TestStackVMEmitterGConcat()
         var memoryStream = new MemoryStream();
         var stackVmEmitter = new StackVMEmitter(new BinaryWriter(memoryStream, Encoding.UTF8, true));
         var tensorEmitter = new StackVMEmitter.TensorEmitter(stackVmEmitter);
-        tensorEmitter.Concat();
+        tensorEmitter.Concat(0);
         var actual = memoryStream.ToArray();
         Assert.Equal(new byte[] { 100, actual[1], 0 }, actual);
     }
@@ -1156,7 +1156,7 @@ public void TestStackVMEmitterGGather()
         var memoryStream = new MemoryStream();
         var stackVmEmitter = new StackVMEmitter(new BinaryWriter(memoryStream, Encoding.UTF8, true));
         var tensorEmitter = new StackVMEmitter.TensorEmitter(stackVmEmitter);
-        tensorEmitter.Gather();
+        tensorEmitter.Gather(0);
         var actual = memoryStream.ToArray();
         Assert.Equal(new byte[] { 100, actual[1], 0 }, actual);
     }
@@ -1244,7 +1244,7 @@ public void TestStackVMEmitterGLayerNorm()
         var memoryStream = new MemoryStream();
         var stackVmEmitter = new StackVMEmitter(new BinaryWriter(memoryStream, Encoding.UTF8, true));
         var tensorEmitter = new StackVMEmitter.TensorEmitter(stackVmEmitter);
-        tensorEmitter.LayerNorm(-1, 0f);
+        tensorEmitter.LayerNorm(-1, 0f, false);
         var actual = memoryStream.ToArray();
         Assert.Equal(new byte[] { 100, actual[1], 0, 255, 255, 255, 255, 0, 0, 0, 0 }, actual);
     }
diff --git a/src/Nncase.Tests/Core/UnitTestExpression.cs b/src/Nncase.Tests/Core/UnitTestExpression.cs
index d5869529fd..6a9dc2b8b3 100644
--- a/src/Nncase.Tests/Core/UnitTestExpression.cs
+++ b/src/Nncase.Tests/Core/UnitTestExpression.cs
@@ -535,8 +535,8 @@ public void TestBoxingEqual()
         var b = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
 
         var input = new Var(ttype);
-        var ea = IR.F.Tensors.Boxing(input, a);
-        var eb = IR.F.Tensors.Boxing(input, b);
+        var ea = IR.F.CPU.Boxing(input, a);
+        var eb = IR.F.CPU.Boxing(input, b);
 
         Assert.Equal(ea.Target, eb.Target);
         Assert.StrictEqual(ea.Target, eb.Target);
diff --git a/src/Nncase.Tests/Distributed/UnitTestCost.cs b/src/Nncase.Tests/Distributed/UnitTestCost.cs
index d4e842ab38..975e379844 100644
--- a/src/Nncase.Tests/Distributed/UnitTestCost.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestCost.cs
@@ -31,7 +31,7 @@ public void TestPartialToBroadCastCost()
          })
         {
             var input0 = new Var(new DistributedType(tensorType, ndsbp, placement));
-            var candidates = DistributedUtility.GetPartialCandidateBoxings(input0);
+            var candidates = Nncase.Passes.Tile.SingleCPUFusionConverter.GetPartialCandidateBoxings(input0);
             foreach (var item in candidates)
             {
                 var cost = CompilerServices.EvaluateCost(item);

From dd377e6da40fe4fabf01b7fc1d4f0934b5d1d192 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 20 Sep 2023 18:45:20 +0800
Subject: [PATCH 200/308] merge

---
 .../Tile/AutoDistributedConvertVisitor.cs     | 245 ++++++++
 .../Passes/Tile/SingleCPUFusionConverter.cs   | 550 +-----------------
 .../Passes/Tile/TIRConvertVisitor.cs          | 307 ++++++++++
 src/Nncase.Core/DistributedUtility.cs         |  52 ++
 src/Nncase.Core/IR/NN/Activations.cs          |   2 +-
 .../Passes/EGraphExtractExtensions.cs         |   5 +-
 .../Passes/EGraphExtractors/Extractor.cs      |  15 +-
 .../Passes/EGraphExtractors/SatExtractor.cs   |   8 +-
 src/Nncase.EGraph/Passes/RewriteProvider.cs   |   2 +-
 src/Nncase.Evaluator/Math/Binary.cs           |   2 +-
 src/Nncase.Evaluator/NN/Activations.cs        |   6 +-
 src/Nncase.Evaluator/Tensors/Gather.cs        |   3 +
 src/Nncase.Passes/EGraphExtractPass.cs        |   2 +-
 .../Distributed/UnitTestTypeInfer.cs          |  42 ++
 .../Targets/UnitTestCPUTargetTiling.cs        |   4 +-
 15 files changed, 681 insertions(+), 564 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
new file mode 100644
index 0000000000..1f7d7b37fa
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
@@ -0,0 +1,245 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Reactive;
+using Nncase.IR;
+using Nncase.IR.CPU;
+using Nncase.IR.Tensors;
+
+namespace Nncase.Passes.Tile;
+
+internal sealed class AutoDistributedConvertVisitor : ExprVisitor<IReadOnlyList<Expr>, Unit>
+{
+    private readonly Dictionary<Expr, Expr> _originMap;
+
+    public AutoDistributedConvertVisitor(TileOptions tileOptions)
+    {
+        TileOptions = tileOptions;
+        Placement = new Placement(Placement.DeviceKind.CPU, tileOptions.Hierarchy, "bt");
+        _originMap = new Dictionary<Expr, Expr>(ReferenceEqualityComparer.Instance);
+    }
+
+    public TileOptions TileOptions { get; }
+
+    public Placement Placement { get; }
+
+    public Expr Convert(Expr body)
+    {
+        var equivalents = Visit(body).Select(newbody => IR.F.Tensors.Boxing(newbody, body.CheckedType)).ToArray();
+        var graph = new EGraph();
+        var bodyEclasses = equivalents.Select(graph.Add).ToArray();
+        foreach (var cls in bodyEclasses.Skip(1))
+        {
+            graph.Union(bodyEclasses[0], cls);
+        }
+
+        graph.Rebuild();
+        return graph.Extract(bodyEclasses[0], null, out _);
+    }
+
+    protected override IReadOnlyList<Expr> DefaultVisitLeaf(Expr expr)
+    {
+        return Array.Empty<Expr>();
+    }
+
+    protected override IReadOnlyList<Expr> VisitLeafTuple(IR.Tuple expr)
+    {
+        return UpdateEquivalents(expr.Fields.ToArray().Select(Visit).CartesianProduct().Select(e => new IR.Tuple(e.ToArray())).ToArray(), expr);
+    }
+
+    protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
+    {
+        if (expr.Target is not Op op)
+        {
+            throw new NotSupportedException("not support auto distributed call function");
+        }
+
+        var equivalArgs = op.Parameters.
+            Select(param => VisitLeafArgument(param.ParameterKind, expr.Arguments[param.Index])).ToArray();
+        var candidateEquivalCalls = equivalArgs.
+            CartesianProduct().
+            Select(args => args.ToArray()).
+            Select(args => BuildEquivalCalls(op, args)).
+            SelectMany(i => i).
+            ToArray();
+
+        if (candidateEquivalCalls.Any(t => t.Valid))
+        {
+            return UpdateEquivalents(Canonicalize(candidateEquivalCalls.Where(t => t.Valid).Select(t => t.Call)), expr);
+        }
+
+        var boxingArgs = op.Parameters.Select(param => param.ParameterKind switch
+            {
+                ParameterKind.Input => ExprMemo[expr.Arguments[param.Index]].Select(GetReBoxings).SelectMany(i => i),
+                ParameterKind.Attribute => ExprMemo[expr.Arguments[param.Index]],
+                _ => throw new NotSupportedException(),
+            }).ToArray();
+
+        var candidateBoxingCalls = boxingArgs.
+            CartesianProduct().
+            Select(args => args.ToArray()).
+            Select(args => new Call(op, args)).
+            Select<Call, (bool Valid, Call Call)>(c => (c.InferenceType(), c)).
+            ToArray();
+
+        if (candidateBoxingCalls.Any(t => t.Valid))
+        {
+            return UpdateEquivalents(Canonicalize(candidateBoxingCalls.Where(t => t.Valid).Select(t => t.Call)), expr);
+        }
+
+        throw new InvalidDataException("after reboxing still can't infer!");
+    }
+
+    private IReadOnlyList<Expr> VisitLeafArgument(ParameterKind parameterKind, Expr expr)
+    {
+        IReadOnlyList<Expr> equivalents;
+        if (!ExprMemo[expr].Any())
+        {
+            equivalents = (parameterKind, expr) switch
+            {
+                (ParameterKind.Input, Expr e) when e is Const or Var => DistributedUtility.GetLeafCandidateBoxings(e, Placement),
+                (ParameterKind.Input, Expr e) when e is IR.Tuple tp => tp.Fields.ToArray().Select(f => VisitLeafArgument(parameterKind, f)).CartesianProduct().Select(e => new IR.Tuple(e.ToArray())).ToArray(),
+                (ParameterKind.Attribute, Expr e) when e is Const or Var => new[] { e },
+                _ => throw new InvalidOperationException(),
+            };
+            ExprMemo[expr] = equivalents;
+            UpdateEquivalents(equivalents, expr);
+        }
+        else
+        {
+            equivalents = ExprMemo[expr];
+        }
+
+        return equivalents;
+    }
+
+    private IReadOnlyList<Expr> GetReBoxings(Expr expr)
+    {
+        if (expr is IR.Tuple tuple)
+        {
+            var candidates = tuple.Fields.ToArray().
+                Select(GetReBoxings).
+                CartesianProduct();
+            return candidates.Any() ? candidates.
+                Select(fs => new IR.Tuple(fs.ToArray())).
+                ToArray() : Array.Empty<Expr>();
+        }
+
+        var type = (DistributedType)expr.CheckedType;
+        var tensorType = type.TensorType;
+        var candidateNdsbps = new List<SBP>[type.Placement.Rank];
+        for (int i = 0; i < type.Placement.Rank; i++)
+        {
+            candidateNdsbps[i] = new List<SBP> { SBP.B };
+            for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
+            {
+                if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && DistributedUtility.IsDivisible(s, type.Placement.Hierarchy[i]))
+                {
+                    candidateNdsbps[i].Add(SBP.S(axis));
+                }
+            }
+        }
+
+        return candidateNdsbps.CartesianProduct().
+            Select(ndsbp => new IRArray<SBP>(ndsbp)).
+            Where(ndsbp => ndsbp != type.NdSBP).
+            Select(ndsbp => new DistributedType(tensorType, new IRArray<SBP>(ndsbp), type.Placement)).
+            Select(disttype => IR.F.Tensors.Boxing(expr, disttype)).ToArray();
+    }
+
+    private IEnumerable<(bool Valid, Call Call)> BuildEquivalCalls(Op target, Expr[] args)
+    {
+        if (!target.Parameters.Where(p => p.ParameterKind == ParameterKind.Input).All(p => IsDistributed(args[p.Index].CheckedType)))
+        {
+            throw new InvalidDataException();
+        }
+
+        var calls = new List<(bool, Call)>();
+        var call = new Call(target, args);
+        var valid = call.InferenceType();
+        calls.Add((valid, call));
+        if (!valid)
+        {
+            if (target is CPUKernelOp { Target: Reshape } || target is Reshape)
+            {
+                // the reshape need force boxing.
+                var newShape = ((TensorConst)args[1]).Value.ToArray<int>();
+                var inType = (DistributedType)args[0].CheckedType;
+                var tensorType = inType.TensorType with { Shape = newShape };
+                calls.AddRange(DistributedUtility.GetLeafCandidateNDSBPs(tensorType, inType.Placement).
+                    Select(ndsbp => IR.F.Tensors.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))).
+                    Select(c => (c.InferenceType(), c)));
+            }
+            else
+            {
+                // when args have partial, we need boxing args.
+                var broadcastArgs = args.Zip(target.Parameters).Select(t => t.Second.ParameterKind == ParameterKind.Input ? DistributedUtility.GetPartialCandidateBoxings(t.First) : Array.Empty<Expr>()).ToArray();
+
+                if (!broadcastArgs.All(bargs => bargs.Count == 0))
+                {
+                    calls.AddRange(broadcastArgs.Select((bargs, i) => bargs.Any() ? UpdateEquivalents(bargs, _originMap[args[i]]) : bargs.Concat(new[] { args[i] })).
+                        CartesianProduct().
+                        Select(bargs => bargs.ToArray()).
+                        Select(bargs => new Call(target, bargs)).
+                        Select(c => (c.InferenceType(), c)));
+                }
+            }
+        }
+
+        return calls;
+    }
+
+    private IReadOnlyList<Expr> Canonicalize(IEnumerable<Call> candidateEquivalCalls)
+    {
+        var equivalCalls = new List<Expr>();
+        foreach (var group in candidateEquivalCalls.GroupBy(c => c.CheckedType))
+        {
+            if (group.Count() > 1)
+            {
+                // extract group
+                var egrph = new EGraph();
+                var roots = group.Select(egrph.Add).ToArray();
+                foreach (var r in roots.Skip(1))
+                {
+                    egrph.Union(roots[0], r);
+                }
+
+                egrph.Rebuild();
+                var best = egrph.Extract(roots[0], null, out var picks);
+                foreach (var (enode, picked) in picks)
+                {
+                    if (!picked && _originMap.TryGetValue(enode.Expr, out var originExpr))
+                    {
+                        ExprMemo[originExpr] = ExprMemo[originExpr].Where(e => !ReferenceEquals(e, enode.Expr)).ToArray();
+                        _originMap.Remove(enode.Expr);
+                    }
+                }
+
+                equivalCalls.Add(best);
+            }
+            else
+            {
+                equivalCalls.Add(group.First());
+            }
+        }
+
+        return equivalCalls;
+    }
+
+    private bool IsDistributed(IRType type) => type switch
+    {
+        DistributedType => true,
+        TupleType t => t.All(IsDistributed),
+        _ => false,
+    };
+
+    private IReadOnlyList<Expr> UpdateEquivalents(IReadOnlyList<Expr> equivalents, Expr origin)
+    {
+        foreach (var item in equivalents)
+        {
+            _originMap[item] = origin;
+        }
+
+        return equivalents;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
index 32fb83df39..6b082fab48 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
@@ -1,30 +1,10 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
-using System.Reactive;
-using System.Runtime.CompilerServices;
-using DryIoc.FastExpressionCompiler.LightExpression;
 using NetFabric.Hyperlinq;
 using Nncase.Diagnostics;
 using Nncase.IR;
-using Nncase.IR.Buffers;
-using Nncase.IR.CPU;
-using Nncase.IR.F;
-using Nncase.IR.Math;
-using Nncase.IR.NN;
-using Nncase.IR.Tensors;
-using Nncase.Passes.Mutators;
-using Nncase.PatternMatch;
-using Nncase.Schedule;
-using Nncase.Targets;
 using Nncase.TIR;
-using Nncase.TIR.Builders;
-using Buffer = Nncase.TIR.Buffer;
-using MathF = Nncase.IR.F.Math;
-using Range = Nncase.TIR.Range;
-using Tuple = Nncase.IR.Tuple;
-
-[assembly: InternalsVisibleTo("Nncase.Tests")]
 
 namespace Nncase.Passes.Tile;
 
@@ -43,38 +23,8 @@ public SingleCPUFusionConverter(TileOptions tileOptions)
     public TIR.PrimFunction Convert(Fusion fusion)
     {
         // 1. convert to distribute graph
-        var distConverter = new DistributeConvertVisitor(TileOptions);
-        var candidatebodys = distConverter.Convert(fusion.Body, out var stagesMap);
-        var graph = new EGraph();
-        var bodyEclasses = candidatebodys.Select(graph.Add).ToArray();
-
-        // foreach (var (b, i) in candidatebodys.Select((b, i) => (b, i)))
-        // {
-        //     DumpScope.Current.DumpDotIR(b, "body_" + i.ToString(), "Distribute");
-        // }
-        // 2. union stages
-        foreach (var ((_, equivals), i) in stagesMap.Select((k, i) => (k, i)))
-        {
-            // foreach (var (b, j) in equivals.Select((b, j) => (b, j)))
-            // {
-            //     DumpScope.Current.DumpDotIR(b, $"eq_{i}_{j}", "Distribute");
-            // }
-            var equivalEclasses = equivals.Select(graph.Add).ToArray();
-
-            foreach (var cls in equivalEclasses.Skip(1))
-            {
-                graph.Union(equivalEclasses[0], cls);
-            }
-        }
-
-        // 3. union final body
-        foreach (var cls in bodyEclasses.Skip(1))
-        {
-            graph.Union(bodyEclasses[0], cls);
-        }
-
-        graph.Rebuild();
-        var body = graph.Extract(bodyEclasses[0], null);
+        var distConverter = new AutoDistributedConvertVisitor(TileOptions);
+        var body = distConverter.Convert(fusion.Body);
         var newFusion = fusion.With(body: body);
         if (DumpScope.Current.IsEnabled(DumpFlags.Tiling))
         {
@@ -83,502 +33,8 @@ public TIR.PrimFunction Convert(Fusion fusion)
 
         // 2. convert new fusion to prim func
         var primBody = new List<Expr>();
-        var visitor = new ConvertVisitor(primBody);
+        var visitor = new TIRConvertVisitor(primBody);
         visitor.Visit(newFusion);
         return T.PrimFunc(newFusion.Name, newFusion.ModuleKind, visitor.InputBuffers.Concat(visitor.OutputBuffers).ToArray()).Body(primBody.ToArray()).Build();
     }
-
-    public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement placement)
-    {
-        return DistributedUtility.GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).Select(ndsbp => IR.F.CPU.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).ToArray();
-    }
-
-    /// <summary>
-    /// when input expression sbp is partial, get the new candidate boxings.
-    /// </summary>
-    /// <param name="expr">input expression.</param>
-    /// <returns>the boxings.</returns>
-    /// <exception cref="NotSupportedException">when expr is tuple.</exception>
-    public static IReadOnlyList<Expr> GetPartialCandidateBoxings(Expr expr)
-    {
-        if (expr is IR.Tuple tuple)
-        {
-            var candidates = tuple.Fields.ToArray().
-                Select(GetPartialCandidateBoxings).
-                CartesianProduct();
-            return candidates.Any() ? candidates.
-                Select(fs => new IR.Tuple(fs.ToArray())).
-                ToArray() : Array.Empty<Expr>();
-        }
-
-        var type = (DistributedType)expr.CheckedType;
-        var tensorType = type.TensorType;
-        var candidateNdsbps = new List<SBP>[type.Placement.Rank];
-        for (int i = 0; i < type.Placement.Rank; i++)
-        {
-            candidateNdsbps[i] = new List<SBP>();
-            if (type.NdSBP[i] is SBPPartialSum)
-            {
-                candidateNdsbps[i].Add(SBP.B);
-                for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
-                {
-                    if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && DistributedUtility.IsDivisible(s, type.Placement.Hierarchy[i]))
-                    {
-                        candidateNdsbps[i].Add(SBP.S(axis));
-                    }
-                }
-            }
-        }
-
-        return candidateNdsbps.CartesianProduct().
-            Select(ndsbp => new DistributedType(tensorType, new IRArray<SBP>(ndsbp), type.Placement)).
-            Select(disttype => IR.F.CPU.Boxing(expr, disttype)).ToArray();
-    }
-
-    private sealed class DistributeConvertVisitor : ExprVisitor<IReadOnlyList<Expr>, Unit>
-    {
-        private readonly Dictionary<Expr, List<Expr>> _stagesMap;
-
-        public DistributeConvertVisitor(TileOptions tileOptions)
-        {
-            TileOptions = tileOptions;
-            Placement = new Placement(Placement.DeviceKind.CPU, tileOptions.Hierarchy, "bt");
-            _stagesMap = new Dictionary<Expr, List<Expr>>(ReferenceEqualityComparer.Instance);
-        }
-
-        public TileOptions TileOptions { get; }
-
-        public Placement Placement { get; }
-
-        public IReadOnlyList<Expr> Convert(Expr body, out IReadOnlyDictionary<Expr, List<Expr>> stagesMap)
-        {
-            stagesMap = _stagesMap;
-            return Visit(body).Select(newbody => IR.F.CPU.Boxing(newbody, body.CheckedType)).ToArray();
-        }
-
-        protected override IReadOnlyList<Expr> DefaultVisitLeaf(Expr expr)
-        {
-            return new[] { expr };
-        }
-
-        protected override IReadOnlyList<Expr> VisitLeafTuple(Tuple expr)
-        {
-            return expr.Fields.ToArray().Select(Visit).CartesianProduct().Select(e => new IR.Tuple(e.ToArray())).ToArray();
-        }
-
-        protected override IReadOnlyList<Expr> VisitLeafVar(Var expr)
-        {
-            return Array.Empty<Expr>();
-        }
-
-        protected override IReadOnlyList<Expr> VisitLeafConst(Const expr)
-        {
-            return Array.Empty<Expr>();
-        }
-
-        protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
-        {
-            if (expr.Target is not Op op)
-            {
-                throw new NotSupportedException("not support auto distributed call function");
-            }
-
-            var equivalArgs = op.Parameters.
-                Select(param => GetLeafArgCandidates(param.ParameterKind, expr.Arguments[param.Index])).ToArray();
-            var equivalCalls = equivalArgs.
-                CartesianProduct().
-                Select(args => args.ToArray()).
-                Select(args => BuildEqualityCalls(op, args)).
-                SelectMany(i => i).
-                ToArray();
-
-            if (equivalCalls.Any(t => t.Valid))
-            {
-                return equivalCalls.Where(t => t.Valid).Select(t => t.Call).ToArray();
-            }
-
-            var boxingArgs = new List<IReadOnlyList<Expr>>();
-            foreach (var (info, newArgs) in op.Parameters.Zip(equivalArgs))
-            {
-                var oldArg = expr.Arguments[info.Index];
-                if (!_stagesMap.TryGetValue(oldArg, out var equivals))
-                {
-                    equivals = new List<Expr>();
-                    _stagesMap.Add(oldArg, equivals);
-                }
-
-                equivals.AddRange(newArgs);
-                var tensorType = (TensorType)oldArg.CheckedType;
-                boxingArgs.Add(info.ParameterKind switch
-                {
-                    ParameterKind.Input => DistributedUtility.GetLeafCandidateNDSBPs(tensorType, Placement).Select(ndsbp => IR.F.CPU.Boxing(newArgs[0], new DistributedType(tensorType, ndsbp, Placement))).ToList(),
-                    ParameterKind.Attribute => new Expr[] { newArgs[0] },
-                    _ => throw new ArgumentOutOfRangeException(info.ParameterKind.ToString()),
-                });
-            }
-
-            equivalCalls = boxingArgs.CartesianProduct().
-                Select(Enumerable.ToArray<Expr>).
-                Select(args => BuildEqualityCalls(op, args)).
-                SelectMany(i => i).
-                ToArray();
-
-            if (!equivalCalls.Any(t => t.Valid))
-            {
-                throw new InvalidOperationException("after boxing still invalid!");
-            }
-
-            return equivalCalls.Where(t => t.Valid).Select(t => t.Call).ToArray();
-        }
-
-        private IReadOnlyList<Expr> GetLeafArgCandidates(ParameterKind parameterKind, Expr expr) => (parameterKind, expr) switch
-        {
-            (ParameterKind.Input, Expr e) when e is Const or Var => GetLeafCandidateBoxings(e, Placement),
-            (ParameterKind.Input, Expr e) when e is IR.Tuple tp => tp.Fields.ToArray().Select(f => GetLeafArgCandidates(parameterKind, f)).CartesianProduct().Select(e => new IR.Tuple(e.ToArray())).ToArray(),
-            (ParameterKind.Attribute, Expr e) when e is Const or Var => new[] { e },
-            (_, Expr arg) => ExprMemo[arg],
-        };
-
-        private IEnumerable<(bool Valid, Call Call)> BuildEqualityCalls(Op target, Expr[] args)
-        {
-            if (!target.Parameters.Where(p => p.ParameterKind == ParameterKind.Input).All(p => IsDistributed(args[p.Index].CheckedType)))
-            {
-                throw new InvalidDataException();
-            }
-
-            var calls = new List<(bool, Call)>();
-            var call = new Call(target, args);
-            var valid = call.InferenceType();
-            calls.Add((valid, call));
-            if (!valid)
-            {
-                if (target is CPUKernelOp { Target: Op })
-                {
-                    // the reshape need force boxing.
-                    var newShape = ((TensorConst)args[1]).Value.ToArray<int>();
-                    var inType = (DistributedType)args[0].CheckedType;
-                    var tensorType = inType.TensorType with { Shape = newShape };
-                    calls.AddRange(DistributedUtility.GetLeafCandidateNDSBPs(tensorType, inType.Placement).
-                        Select(ndsbp => IR.F.CPU.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))).
-                        Select(c => (c.InferenceType(), c)));
-                }
-                else
-                {
-                    var broadcastArgs = args.Zip(target.Parameters).Select(t => t.Second.ParameterKind == ParameterKind.Input ? GetPartialCandidateBoxings(t.First) : Array.Empty<Expr>()).ToArray();
-
-                    if (!broadcastArgs.All(bargs => bargs.Count == 0))
-                    {
-                        calls.AddRange(broadcastArgs.Select((bargs, i) => bargs.Any() ? bargs : bargs.Concat(new[] { args[i] })).
-                            CartesianProduct().
-                            Select(bargs => bargs.ToArray()).
-                            Select(bargs => new Call(target, bargs)).
-                            Select(c => (c.InferenceType(), c)));
-                    }
-                }
-            }
-
-            return calls;
-        }
-
-        private bool IsDistributed(IRType type) => type switch
-        {
-            DistributedType => true,
-            TupleType t => t.All(IsDistributed),
-            _ => false,
-        };
-    }
-
-    private sealed class ConvertVisitor : ExprVisitor<Unit, Unit>
-    {
-        private readonly Dictionary<Expr, TIR.Buffer> _buffersMap = new(ReferenceEqualityComparer.Instance);
-        private readonly List<Expr> _mainBody;
-
-        public ConvertVisitor(List<Expr> mainBody)
-        {
-            _mainBody = mainBody;
-        }
-
-        public Fusion VisitRootFusion => (Fusion)VisitRoot!;
-
-        public IEnumerable<TIR.Buffer> OutputBuffers => _buffersMap.Values.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Output));
-
-        public IEnumerable<TIR.Buffer> InputBuffers => _buffersMap.Values.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Input));
-
-        protected override Unit DefaultVisitLeaf(Expr expr)
-        {
-            return default;
-        }
-
-        protected override Unit VisitLeafCall(Call expr)
-        {
-            var arguments = expr.Arguments.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray();
-            var ret = AllocOrGetBuffer(expr);
-            switch (expr.Target)
-            {
-                case CPUKernelOp kernelOp:
-                    switch (kernelOp.Target)
-                    {
-                        case Unary unary:
-                            GenerateUnary(unary, arguments, ret);
-                            break;
-                        case Binary binary:
-                            GenerateBinary(binary, arguments, ret);
-                            break;
-                        case MatMul matmul:
-                            GenerateMatmul(matmul, arguments, ret);
-                            break;
-                        case LayerNorm layernorm:
-                            GenerateLayerNorm(layernorm, arguments, ret, (DistributedType)expr.Arguments[0].CheckedType);
-                            break;
-                        case Gather gather:
-                            GenerateGather(gather, arguments, ret);
-                            break;
-                        case Concat concat:
-                            GenerateConcat(concat, ((IR.Tuple)expr.Arguments[0]).Fields.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray(), ret);
-                            break;
-                        case Slice slice:
-                            GenerateSlice(slice, arguments[0], ret, expr.Arguments[1], expr.Arguments[2], expr.Arguments[3], (DistributedType)expr.CheckedType);
-                            break;
-                        case Softmax softmax:
-                            GenerateSoftmax(softmax, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), arguments, ret);
-                            break;
-                        case Transpose transpose:
-                            GenerateTranspose(transpose, ((TensorConst)expr.Arguments[1]).Value.ToArray<int>(), arguments, ret);
-                            break;
-                        case Reshape reshape:
-                            GenerateReshape(reshape, arguments[0], ret);
-                            break;
-                        default:
-                            throw new NotSupportedException();
-                    }
-
-                    break;
-                case Boxing boxing:
-                    GenerateBoxing(boxing, arguments, ret, expr);
-                    break;
-                default:
-                    throw new NotSupportedException();
-            }
-
-            return default;
-        }
-
-        private void GenerateReshape(Reshape reshape, Buffer input, Buffer ret)
-        {
-            _mainBody.Add(IR.F.XPU.ReShape(input, ret));
-        }
-
-        private void GenerateConcat(Concat concat, Buffer[] inputs, Buffer ret)
-        {
-            _mainBody.Add(IR.F.XPU.Concat(concat.Axis, inputs, ret));
-        }
-
-        private void GenerateSlice(Slice slice, Buffer input, Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType)
-        {
-            _mainBody.Add(IR.F.XPU.Slice(input, output, begins, ends, axes, distributedType));
-        }
-
-        private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call expr)
-        {
-            switch (expr.Arguments[0].CheckedType, boxing.NewType)
-            {
-                case (TensorType, DistributedType distTensorType):
-                    {
-                        _mainBody.Add(IR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSBP, distTensorType.Placement));
-                    }
-
-                    break;
-                case (DistributedType distTensorType, TensorType):
-                    {
-                        _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSBP, distTensorType.Placement));
-                    }
-
-                    break;
-                case (DistributedType inType, DistributedType outType):
-                    {
-                        _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], None.Default, inType.NdSBP, inType.Placement));
-                        _mainBody.Add(IR.F.XPU.TDMALoad(ret, None.Default, outType.NdSBP, outType.Placement));
-                    }
-
-                    break;
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
-        {
-            var input = arguments[IR.Math.Unary.Input.Index];
-            _mainBody.Add(IR.F.XPU.Unary(unary.UnaryOp, input, ret));
-        }
-
-        private void GenerateBinary(Binary binary, Buffer[] arguments, Buffer ret)
-        {
-            _mainBody.Add(IR.F.XPU.Binary(binary.BinaryOp, arguments[0], arguments[1], ret));
-        }
-
-        private void GenerateMatmul(MatMul matmul, Buffer[] arguments, Buffer ret)
-        {
-            _mainBody.Add(IR.F.XPU.Matmul(arguments[0], arguments[1], ret));
-        }
-
-        private void GenerateLayerNorm(LayerNorm layerNorm, Buffer[] arguments, Buffer ret, DistributedType distributedType)
-        {
-            _mainBody.Add(IR.F.XPU.LayerNorm(layerNorm.Axis, layerNorm.Epsilon, layerNorm.UseMean, arguments[0], arguments[1], arguments[2], ret, distributedType));
-        }
-
-        private void GenerateGather(Gather gahter, Buffer[] arguments, Buffer ret)
-        {
-            _mainBody.Add(IR.F.XPU.Gather(gahter.Axis, arguments[0], arguments[1], ret));
-        }
-
-        private void GenerateSoftmax(Softmax softmax, int axis, Buffer[] arguments, Buffer ret)
-        {
-            _mainBody.Add(IR.F.XPU.Softmax(axis, arguments[0], ret));
-        }
-
-        private void GenerateTranspose(Transpose transpose, int[] perm, Buffer[] arguments, Buffer ret)
-        {
-            _mainBody.Add(IR.F.XPU.Transpose(perm, arguments[0], ret));
-        }
-
-#if false
-        private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
-        {
-            var loops = Enumerable.Range(0, input.Rank).Select(i => (T.ForLoop(out var loopVar, (0, input.Dimensions[i]), i == 0 ? LoopMode.Parallel : LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
-            var loopVars = loops.Select(f => f.loopVar).ToArray();
-            Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Unary(unary.UnaryOp, T.BufferLoad(input, loopVars)));
-            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-            _mainBody.Add(T.Block(nameof(Unary)).Body(
-                T.MatchBuffer(arguments[0]),
-                T.MatchBuffer(ret),
-                final).Build());
-        }
-
-        private void GenerateMatMul(ReadOnlySpan<Buffer> arguments, Buffer ret, Call expr)
-        {
-            var lhs = arguments[0];
-            var rhs = arguments[1];
-            var loops = Enumerable.Range(0, lhs.Rank - 2).Select(i => (T.ForLoop(out var loopVar, (0, lhs.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
-            var loopVars = loops.Select(f => f.loopVar).ToArray();
-            var stmt = T.ForLoop(out var m, (0, lhs.Dimensions[^2]), LoopMode.Parallel).Body(
-                T.Serial(out var n, (0, rhs.Dimensions[^1])).Body(
-                    T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), 0f),
-                    T.Serial(out var k, (0, lhs.Dimensions[^1])).Body(
-                        T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), T.BufferLoad(ret, loopVars.Concat(new[] { m, n }).ToArray()) + (T.BufferLoad(lhs, loopVars.Concat(new[] { m, k }).ToArray()) * T.BufferLoad(rhs, loopVars.Concat(new[] { k, n }).ToArray())))))).
-                Build();
-            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-            // [m,k] @ [k, n]
-            var body = T.Block(nameof(MatMul)).Body(
-                T.MatchBuffer(arguments[0]),
-                T.MatchBuffer(arguments[1]),
-                T.MatchBuffer(ret),
-                final);
-            _mainBody.Add(body.Build());
-        }
-
-        private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffer ret, Call call)
-        {
-            var lhs = call.Arguments[Binary.Lhs.Index];
-            var rhs = call.Arguments[Binary.Rhs.Index];
-            var lhsBuffer = arguments[Binary.Lhs.Index];
-            var rhsBuffer = arguments[Binary.Rhs.Index];
-
-            var outShape = call.CheckedShape.ToValueArray();
-            var lhsShape = Enumerable.Repeat(1, outShape.Length).ToArray();
-            Array.Copy(lhs.CheckedShape.ToValueArray(), 0, lhsShape, lhsShape.Length - lhs.CheckedShape.Rank, lhs.CheckedShape.Rank);
-            var rhsShape = Enumerable.Repeat(1, outShape.Length).ToArray();
-            Array.Copy(rhs.CheckedShape.ToValueArray(), 0, rhsShape, rhsShape.Length - rhs.CheckedShape.Rank, rhs.CheckedShape.Rank);
-
-            var lhsScale = outShape.Zip(lhsShape).Select(s => s.First / s.Second).ToArray();
-            var rhsScale = outShape.Zip(rhsShape).Select(s => s.First / s.Second).ToArray();
-
-            var loops = Enumerable.Range(0, outShape.Length).Select(i => (T.ForLoop(out var loopVar, (0, outShape[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
-            var loopVars = loops.Select(f => f.loopVar).ToArray();
-            var lhsLoopVars = loopVars.Zip(lhsScale).Select(v => v.First / v.Second).ToArray();
-            var rhsLoopVars = loopVars.Zip(rhsScale).Select(v => v.First / v.Second).ToArray();
-            Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Binary(binary.BinaryOp, T.BufferLoad(lhsBuffer, lhsLoopVars), T.BufferLoad(rhsBuffer, rhsLoopVars)));
-            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-            var body = T.Block(nameof(Binary)).Body(
-                T.MatchBuffer(arguments[0]),
-                T.MatchBuffer(arguments[1]),
-                T.MatchBuffer(ret),
-                final);
-            _mainBody.Add(body.Build());
-        }
-#endif
-
-        private TIR.Buffer AllocOrGetBuffer(Expr expr)
-        {
-            var name = $"buffer_{_buffersMap.Keys.Count}";
-            if (!_buffersMap.TryGetValue(expr, out var buffer))
-            {
-                switch (expr)
-                {
-                    case Call c:
-                        var (type, loc) = GetTypeAndLocation(c.CheckedType);
-                        if (ReferenceEquals(c, VisitRootFusion.Body))
-                        {
-                            loc = MemoryLocation.Output;
-                        }
-
-                        buffer = T.AttachBuffer(type, loc, out _, out _, name);
-                        break;
-                    case Var v:
-                        buffer = T.AttachBuffer((TensorType)v.CheckedType, MemoryLocation.Input, out _, out _, name);
-                        break;
-                    case TensorConst c:
-                        buffer = T.AttachBuffer(c, out _, name);
-                        break;
-                    case IR.Tuple:
-                        return null!;
-                    default:
-                        throw new NotSupportedException();
-                }
-
-                _buffersMap.Add(expr, buffer);
-            }
-
-            return buffer;
-        }
-
-        private Tuple<TensorType, MemoryLocation> GetTypeAndLocation(IRType type)
-        {
-            MemoryLocation location = MemoryLocation.Data;
-            if (type is DistributedType distTensorType)
-            {
-                if (distTensorType.Placement.Rank == 2)
-                {
-                    location = MemoryLocation.L1Data;
-                }
-                else if (distTensorType.Placement.Rank == 1)
-                {
-                    location = MemoryLocation.L2Data;
-                }
-            }
-
-            TensorType tensorType;
-            if (type is DistributedType distTensor)
-            {
-                if (!DistributedUtility.IsDistributable(distTensor.TensorType, distTensor.NdSBP.ToArray(), distTensor.Placement, out var tType))
-                {
-                    throw new NotSupportedException();
-                }
-                else
-                {
-                    tensorType = tType;
-                }
-            }
-            else if (type is TensorType ttype)
-            {
-                tensorType = ttype;
-            }
-            else
-            {
-                throw new NotSupportedException();
-            }
-
-            return new Tuple<TensorType, MemoryLocation>(tensorType, location);
-        }
-    }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
new file mode 100644
index 0000000000..1071cbadfb
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -0,0 +1,307 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Reactive;
+using NetFabric.Hyperlinq;
+using Nncase.IR;
+using Nncase.IR.Math;
+using Nncase.IR.NN;
+using Nncase.IR.Tensors;
+using Nncase.TIR;
+using Buffer = Nncase.TIR.Buffer;
+
+namespace Nncase.Passes.Tile;
+
+public sealed class TIRConvertVisitor : ExprVisitor<Unit, Unit>
+{
+    private readonly Dictionary<Expr, TIR.Buffer> _buffersMap = new(ReferenceEqualityComparer.Instance);
+    private readonly List<Expr> _mainBody;
+
+    public TIRConvertVisitor(List<Expr> mainBody)
+    {
+        _mainBody = mainBody;
+    }
+
+    public Fusion VisitRootFusion => (Fusion)VisitRoot!;
+
+    public IEnumerable<TIR.Buffer> OutputBuffers => _buffersMap.Values.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Output));
+
+    public IEnumerable<TIR.Buffer> InputBuffers => _buffersMap.Values.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Input));
+
+    protected override Unit DefaultVisitLeaf(Expr expr)
+    {
+        return default;
+    }
+
+    protected override Unit VisitLeafCall(Call expr)
+    {
+        var arguments = expr.Arguments.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray();
+        var ret = AllocOrGetBuffer(expr);
+        switch (expr.Target)
+        {
+            case IR.CPU.CPUKernelOp kernelOp:
+                switch (kernelOp.Target)
+                {
+                    case Unary unary:
+                        GenerateUnary(unary, arguments, ret);
+                        break;
+                    case Binary binary:
+                        GenerateBinary(binary, arguments, ret);
+                        break;
+                    case MatMul matmul:
+                        GenerateMatmul(matmul, arguments, ret);
+                        break;
+                    case LayerNorm layernorm:
+                        GenerateLayerNorm(layernorm, arguments, ret, (DistributedType)expr.Arguments[0].CheckedType);
+                        break;
+                    case Gather gather:
+                        GenerateGather(gather, arguments, ret);
+                        break;
+                    case Concat concat:
+                        GenerateConcat(concat, ((IR.Tuple)expr.Arguments[0]).Fields.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray(), ret);
+                        break;
+                    case Slice slice:
+                        GenerateSlice(slice, arguments[0], ret, expr.Arguments[1], expr.Arguments[2], expr.Arguments[3], (DistributedType)expr.CheckedType);
+                        break;
+                    case Softmax softmax:
+                        GenerateSoftmax(softmax, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), arguments, ret);
+                        break;
+                    case Transpose transpose:
+                        GenerateTranspose(transpose, ((TensorConst)expr.Arguments[1]).Value.ToArray<int>(), arguments, ret);
+                        break;
+                    case Reshape reshape:
+                        GenerateReshape(reshape, arguments[0], ret);
+                        break;
+                    default:
+                        throw new NotSupportedException();
+                }
+
+                break;
+            case Boxing boxing:
+                GenerateBoxing(boxing, arguments, ret, expr);
+                break;
+            default:
+                throw new NotSupportedException();
+        }
+
+        return default;
+    }
+
+    private void GenerateReshape(Reshape reshape, Buffer input, Buffer ret)
+    {
+        _mainBody.Add(IR.F.XPU.ReShape(input, ret));
+    }
+
+    private void GenerateConcat(Concat concat, Buffer[] inputs, Buffer ret)
+    {
+        _mainBody.Add(IR.F.XPU.Concat(concat.Axis, inputs, ret));
+    }
+
+    private void GenerateSlice(Slice slice, Buffer input, Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType)
+    {
+        _mainBody.Add(IR.F.XPU.Slice(input, output, begins, ends, axes, distributedType));
+    }
+
+    private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call expr)
+    {
+        switch (expr.Arguments[0].CheckedType, boxing.NewType)
+        {
+            case (TensorType, DistributedType distTensorType):
+                {
+                    _mainBody.Add(IR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSBP, distTensorType.Placement));
+                }
+
+                break;
+            case (DistributedType distTensorType, TensorType):
+                {
+                    _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSBP, distTensorType.Placement));
+                }
+
+                break;
+            case (DistributedType inType, DistributedType outType):
+                {
+                    _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], None.Default, inType.NdSBP, inType.Placement));
+                    _mainBody.Add(IR.F.XPU.TDMALoad(ret, None.Default, outType.NdSBP, outType.Placement));
+                }
+
+                break;
+            default:
+                throw new NotSupportedException();
+        }
+    }
+
+    private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
+    {
+        var input = arguments[IR.Math.Unary.Input.Index];
+        _mainBody.Add(IR.F.XPU.Unary(unary.UnaryOp, input, ret));
+    }
+
+    private void GenerateBinary(Binary binary, Buffer[] arguments, Buffer ret)
+    {
+        _mainBody.Add(IR.F.XPU.Binary(binary.BinaryOp, arguments[0], arguments[1], ret));
+    }
+
+    private void GenerateMatmul(MatMul matmul, Buffer[] arguments, Buffer ret)
+    {
+        _mainBody.Add(IR.F.XPU.Matmul(arguments[0], arguments[1], ret));
+    }
+
+    private void GenerateLayerNorm(LayerNorm layerNorm, Buffer[] arguments, Buffer ret, DistributedType distributedType)
+    {
+        _mainBody.Add(IR.F.XPU.LayerNorm(layerNorm.Axis, layerNorm.Epsilon, layerNorm.UseMean, arguments[0], arguments[1], arguments[2], ret, distributedType));
+    }
+
+    private void GenerateGather(Gather gahter, Buffer[] arguments, Buffer ret)
+    {
+        _mainBody.Add(IR.F.XPU.Gather(gahter.Axis, arguments[0], arguments[1], ret));
+    }
+
+    private void GenerateSoftmax(Softmax softmax, int axis, Buffer[] arguments, Buffer ret)
+    {
+        _mainBody.Add(IR.F.XPU.Softmax(axis, arguments[0], ret));
+    }
+
+    private void GenerateTranspose(Transpose transpose, int[] perm, Buffer[] arguments, Buffer ret)
+    {
+        _mainBody.Add(IR.F.XPU.Transpose(perm, arguments[0], ret));
+    }
+
+#if false
+        private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
+        {
+            var loops = Enumerable.Range(0, input.Rank).Select(i => (T.ForLoop(out var loopVar, (0, input.Dimensions[i]), i == 0 ? LoopMode.Parallel : LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
+            var loopVars = loops.Select(f => f.loopVar).ToArray();
+            Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Unary(unary.UnaryOp, T.BufferLoad(input, loopVars)));
+            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
+            _mainBody.Add(T.Block(nameof(Unary)).Body(
+                T.MatchBuffer(arguments[0]),
+                T.MatchBuffer(ret),
+                final).Build());
+        }
+
+        private void GenerateMatMul(ReadOnlySpan<Buffer> arguments, Buffer ret, Call expr)
+        {
+            var lhs = arguments[0];
+            var rhs = arguments[1];
+            var loops = Enumerable.Range(0, lhs.Rank - 2).Select(i => (T.ForLoop(out var loopVar, (0, lhs.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
+            var loopVars = loops.Select(f => f.loopVar).ToArray();
+            var stmt = T.ForLoop(out var m, (0, lhs.Dimensions[^2]), LoopMode.Parallel).Body(
+                T.Serial(out var n, (0, rhs.Dimensions[^1])).Body(
+                    T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), 0f),
+                    T.Serial(out var k, (0, lhs.Dimensions[^1])).Body(
+                        T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), T.BufferLoad(ret, loopVars.Concat(new[] { m, n }).ToArray()) + (T.BufferLoad(lhs, loopVars.Concat(new[] { m, k }).ToArray()) * T.BufferLoad(rhs, loopVars.Concat(new[] { k, n }).ToArray())))))).
+                Build();
+            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
+            // [m,k] @ [k, n]
+            var body = T.Block(nameof(MatMul)).Body(
+                T.MatchBuffer(arguments[0]),
+                T.MatchBuffer(arguments[1]),
+                T.MatchBuffer(ret),
+                final);
+            _mainBody.Add(body.Build());
+        }
+
+        private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffer ret, Call call)
+        {
+            var lhs = call.Arguments[Binary.Lhs.Index];
+            var rhs = call.Arguments[Binary.Rhs.Index];
+            var lhsBuffer = arguments[Binary.Lhs.Index];
+            var rhsBuffer = arguments[Binary.Rhs.Index];
+
+            var outShape = call.CheckedShape.ToValueArray();
+            var lhsShape = Enumerable.Repeat(1, outShape.Length).ToArray();
+            Array.Copy(lhs.CheckedShape.ToValueArray(), 0, lhsShape, lhsShape.Length - lhs.CheckedShape.Rank, lhs.CheckedShape.Rank);
+            var rhsShape = Enumerable.Repeat(1, outShape.Length).ToArray();
+            Array.Copy(rhs.CheckedShape.ToValueArray(), 0, rhsShape, rhsShape.Length - rhs.CheckedShape.Rank, rhs.CheckedShape.Rank);
+
+            var lhsScale = outShape.Zip(lhsShape).Select(s => s.First / s.Second).ToArray();
+            var rhsScale = outShape.Zip(rhsShape).Select(s => s.First / s.Second).ToArray();
+
+            var loops = Enumerable.Range(0, outShape.Length).Select(i => (T.ForLoop(out var loopVar, (0, outShape[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
+            var loopVars = loops.Select(f => f.loopVar).ToArray();
+            var lhsLoopVars = loopVars.Zip(lhsScale).Select(v => v.First / v.Second).ToArray();
+            var rhsLoopVars = loopVars.Zip(rhsScale).Select(v => v.First / v.Second).ToArray();
+            Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Binary(binary.BinaryOp, T.BufferLoad(lhsBuffer, lhsLoopVars), T.BufferLoad(rhsBuffer, rhsLoopVars)));
+            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
+            var body = T.Block(nameof(Binary)).Body(
+                T.MatchBuffer(arguments[0]),
+                T.MatchBuffer(arguments[1]),
+                T.MatchBuffer(ret),
+                final);
+            _mainBody.Add(body.Build());
+        }
+#endif
+
+    private TIR.Buffer AllocOrGetBuffer(Expr expr)
+    {
+        var name = $"buffer_{_buffersMap.Keys.Count}";
+        if (!_buffersMap.TryGetValue(expr, out var buffer))
+        {
+            switch (expr)
+            {
+                case Call c:
+                    var (type, loc) = GetTypeAndLocation(c.CheckedType);
+                    if (ReferenceEquals(c, VisitRootFusion.Body))
+                    {
+                        loc = MemoryLocation.Output;
+                    }
+
+                    buffer = T.AttachBuffer(type, loc, out _, out _, name);
+                    break;
+                case Var v:
+                    buffer = T.AttachBuffer((TensorType)v.CheckedType, MemoryLocation.Input, out _, out _, name);
+                    break;
+                case TensorConst c:
+                    buffer = T.AttachBuffer(c, out _, name);
+                    break;
+                case IR.Tuple:
+                    return null!;
+                default:
+                    throw new NotSupportedException();
+            }
+
+            _buffersMap.Add(expr, buffer);
+        }
+
+        return buffer;
+    }
+
+    private Tuple<TensorType, MemoryLocation> GetTypeAndLocation(IRType type)
+    {
+        MemoryLocation location = MemoryLocation.Data;
+        if (type is DistributedType distTensorType)
+        {
+            if (distTensorType.Placement.Rank == 2)
+            {
+                location = MemoryLocation.L1Data;
+            }
+            else if (distTensorType.Placement.Rank == 1)
+            {
+                location = MemoryLocation.L2Data;
+            }
+        }
+
+        TensorType tensorType;
+        if (type is DistributedType distTensor)
+        {
+            if (!DistributedUtility.IsDistributable(distTensor.TensorType, distTensor.NdSBP.ToArray(), distTensor.Placement, out var tType))
+            {
+                throw new NotSupportedException();
+            }
+            else
+            {
+                tensorType = tType;
+            }
+        }
+        else if (type is TensorType ttype)
+        {
+            tensorType = ttype;
+        }
+        else
+        {
+            throw new NotSupportedException();
+        }
+
+        return new Tuple<TensorType, MemoryLocation>(tensorType, location);
+    }
+}
diff --git a/src/Nncase.Core/DistributedUtility.cs b/src/Nncase.Core/DistributedUtility.cs
index 6cdecf2c6a..64c52b7654 100644
--- a/src/Nncase.Core/DistributedUtility.cs
+++ b/src/Nncase.Core/DistributedUtility.cs
@@ -33,6 +33,58 @@ public static IReadOnlyList<IRArray<SBP>> GetLeafCandidateNDSBPs(TensorType tens
            ToArray();
     }
 
+    public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement placement)
+    {
+        return GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).ToArray();
+    }
+
+    /// <summary>
+    /// when input expression sbp is partial, get the new candidate boxings.
+    /// </summary>
+    /// <param name="expr">input expression.</param>
+    /// <returns>the boxings.</returns>
+    /// <exception cref="NotSupportedException">when expr is tuple.</exception>
+    public static IReadOnlyList<Expr> GetPartialCandidateBoxings(Expr expr)
+    {
+        if (expr is IR.Tuple tuple)
+        {
+            var candidates = tuple.Fields.ToArray().
+                Select(GetPartialCandidateBoxings).
+                CartesianProduct();
+            return candidates.Any() ? candidates.
+                Select(fs => new IR.Tuple(fs.ToArray())).
+                ToArray() : Array.Empty<Expr>();
+        }
+
+        var type = (DistributedType)expr.CheckedType;
+        if (!type.NdSBP.Any(sbp => sbp is SBPBroadCast))
+        {
+            return Array.Empty<Expr>();
+        }
+
+        var tensorType = type.TensorType;
+        var candidateNdsbps = new List<SBP>[type.Placement.Rank];
+        for (int i = 0; i < type.Placement.Rank; i++)
+        {
+            candidateNdsbps[i] = new List<SBP>();
+            if (type.NdSBP[i] is SBPPartialSum)
+            {
+                candidateNdsbps[i].Add(SBP.B);
+                for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
+                {
+                    if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && IsDivisible(s, type.Placement.Hierarchy[i]))
+                    {
+                        candidateNdsbps[i].Add(SBP.S(axis));
+                    }
+                }
+            }
+        }
+
+        return candidateNdsbps.CartesianProduct().
+            Select(ndsbp => new DistributedType(tensorType, new IRArray<SBP>(ndsbp), type.Placement)).
+            Select(disttype => IR.F.Tensors.Boxing(expr, disttype)).ToArray();
+    }
+
     public static bool IsDistributable(TensorType tensorType, ReadOnlySpan<SBP> ndsbp, Placement placement, [MaybeNullWhen(false)] out TensorType distType)
     {
         distType = null;
diff --git a/src/Nncase.Core/IR/NN/Activations.cs b/src/Nncase.Core/IR/NN/Activations.cs
index 46df70d241..523a4018d2 100644
--- a/src/Nncase.Core/IR/NN/Activations.cs
+++ b/src/Nncase.Core/IR/NN/Activations.cs
@@ -154,7 +154,7 @@ public sealed partial class Swish : ActivationOp
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Swish), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Swish), 0, "input", ParameterKind.Input);
 }
 
 /// <summary>
diff --git a/src/Nncase.EGraph/Passes/EGraphExtractExtensions.cs b/src/Nncase.EGraph/Passes/EGraphExtractExtensions.cs
index d522b3b6a4..7c0cfbdc26 100644
--- a/src/Nncase.EGraph/Passes/EGraphExtractExtensions.cs
+++ b/src/Nncase.EGraph/Passes/EGraphExtractExtensions.cs
@@ -26,8 +26,9 @@ public static class EGraphExtractExtensions
     /// <param name="eGraph">eGraph.</param>
     /// <param name="root">Root eclass.</param>
     /// <param name="basefunc_cost_evaluator">base func cost evaluator.</param>
+    /// <param name="picks">the picks.</param>
     /// <returns>Extracted root expression.</returns>
-    public static Expr Extract(this IEGraph eGraph, EClass root, Evaluator.IBaseFuncCostEvaluator? basefunc_cost_evaluator)
+    public static Expr Extract(this IEGraph eGraph, EClass root, Evaluator.IBaseFuncCostEvaluator? basefunc_cost_evaluator, out IReadOnlyDictionary<ENode, bool> picks)
     {
         // 1. set enode expr with more accuracy type.
         foreach (var eclass in eGraph.Classes)
@@ -50,7 +51,7 @@ public static Expr Extract(this IEGraph eGraph, EClass root, Evaluator.IBaseFunc
         //     EGraphPrinter.DumpEgraphAsDot(eGraph, costModel, root.Find(), fs);
         // }
         // return new EGraphExtractor(costModel).Extract(root.Find(), eGraph);
-        return new EGraphExtractors.SatExtractor(costModel).Extract(root.Find(), eGraph);
+        return new EGraphExtractors.SatExtractor(costModel).Extract(root.Find(), eGraph, out picks);
     }
 
     /// <summary>
diff --git a/src/Nncase.EGraph/Passes/EGraphExtractors/Extractor.cs b/src/Nncase.EGraph/Passes/EGraphExtractors/Extractor.cs
index c15dc50d83..fcf2abd729 100644
--- a/src/Nncase.EGraph/Passes/EGraphExtractors/Extractor.cs
+++ b/src/Nncase.EGraph/Passes/EGraphExtractors/Extractor.cs
@@ -17,7 +17,7 @@ namespace Nncase.Passes.EGraphExtractors;
 
 internal interface IExtractor
 {
-    Expr Extract(EClass root, IEGraph eGraph);
+    Expr Extract(EClass root, IEGraph eGraph, out IReadOnlyDictionary<ENode, bool> picks);
 }
 
 internal class Extractor : IExtractor
@@ -25,6 +25,7 @@ internal class Extractor : IExtractor
     private readonly EGraphCostModel _costModel;
     private readonly Dictionary<EClass, Expr> _eclassMemo = new();
     private readonly Dictionary<EClass, Expr> _markerEclassMemo = new();
+    private readonly Dictionary<ENode, bool> _picks = new();
     private StreamWriter? _dumpWriter;
 
     public Extractor(EGraphCostModel costModel)
@@ -32,7 +33,7 @@ public Extractor(EGraphCostModel costModel)
         _costModel = costModel;
     }
 
-    public Expr Extract(EClass root, IEGraph eGraph)
+    public Expr Extract(EClass root, IEGraph eGraph, out IReadOnlyDictionary<ENode, bool> picks)
     {
         _dumpWriter = DumpScope.Current.IsEnabled(DumpFlags.EGraphCost)
             ? new StreamWriter(DumpScope.Current.OpenFile($"{nameof(Extractor)}_Class_{root.Id}.txt"))
@@ -46,6 +47,15 @@ public Expr Extract(EClass root, IEGraph eGraph)
             _dumpWriter?.Dispose();
         }
 
+        foreach (var enode in eGraph.Nodes)
+        {
+            if (!_picks.ContainsKey(enode))
+            {
+                _picks[enode] = false;
+            }
+        }
+
+        picks = _picks;
         return _eclassMemo[root];
     }
 
@@ -132,6 +142,7 @@ private void Visit(EClass eclass)
                 _eclassMemo.Add(eclass, expr);
             }
 
+            _picks[minCostEnode] = true;
             stack.Pop();
         }
     }
diff --git a/src/Nncase.EGraph/Passes/EGraphExtractors/SatExtractor.cs b/src/Nncase.EGraph/Passes/EGraphExtractors/SatExtractor.cs
index 36cf26a0d3..038873173b 100644
--- a/src/Nncase.EGraph/Passes/EGraphExtractors/SatExtractor.cs
+++ b/src/Nncase.EGraph/Passes/EGraphExtractors/SatExtractor.cs
@@ -22,7 +22,7 @@ public SatExtractor(EGraphCostModel costModel)
         _costModel = costModel;
     }
 
-    public Expr Extract(EClass root, IEGraph eGraph)
+    public Expr Extract(EClass root, IEGraph eGraph, out IReadOnlyDictionary<ENode, bool> picks)
     {
         var cpmodel = new CpModel();
 
@@ -108,13 +108,13 @@ public Expr Extract(EClass root, IEGraph eGraph)
             throw new InvalidProgramException("SatExtract Failed!");
         }
 
-        var pick = eGraph.Nodes.ToDictionary(e => e, e => solver.BooleanValue(vars[e]));
+        picks = eGraph.Nodes.ToDictionary(e => e, e => solver.BooleanValue(vars[e]));
         using (var dumpStream = enableDump ? DumpScope.Current.OpenFile("Costs/Pick.dot") : Stream.Null)
         {
-            EGraphPrinter.DumpEgraphAsDot(eGraph, _costModel, pick, root.Find(), dumpStream);
+            EGraphPrinter.DumpEgraphAsDot(eGraph, _costModel, picks, root.Find(), dumpStream);
         }
 
-        return new SatExprBuildVisitor(pick).Visit(root);
+        return new SatExprBuildVisitor(picks).Visit(root);
     }
 
     private void EliminateAllCycles(EClass root, LinkedList<(EClass Class, ENode Node)> path, Dictionary<EClass, LinkedListNode<(EClass Class, ENode Node)>> pathMemo, Dictionary<ENode, bool> visited, CpModel cpModel, Dictionary<ENode, BoolVar> vars)
diff --git a/src/Nncase.EGraph/Passes/RewriteProvider.cs b/src/Nncase.EGraph/Passes/RewriteProvider.cs
index fa4558226a..76696663d4 100644
--- a/src/Nncase.EGraph/Passes/RewriteProvider.cs
+++ b/src/Nncase.EGraph/Passes/RewriteProvider.cs
@@ -36,7 +36,7 @@ public Expr ERewrite(Expr expr, IEnumerable<IRewriteRule> rules, RunPassContext
 
         var graph = new EGraph(expr);
         ERewrite(graph, rules, options);
-        var post = graph.Extract(graph.Root!, null);
+        var post = graph.Extract(graph.Root!, null, out _);
         return post;
     }
 
diff --git a/src/Nncase.Evaluator/Math/Binary.cs b/src/Nncase.Evaluator/Math/Binary.cs
index 96f5ce4f48..ac991e43cf 100755
--- a/src/Nncase.Evaluator/Math/Binary.cs
+++ b/src/Nncase.Evaluator/Math/Binary.cs
@@ -143,7 +143,7 @@ private IRType Visit(Binary target, DistributedType a, DistributedType b)
                 case (SBPSplit sa, SBPSplit sb):
                     if (sa != sb)
                     {
-                        return new InvalidType("lhs rhs sbp at {i} not equal");
+                        return new InvalidType($"lhs rhs sbp at {i} not equal");
                     }
 
                     ndsbp[i] = sa;
diff --git a/src/Nncase.Evaluator/NN/Activations.cs b/src/Nncase.Evaluator/NN/Activations.cs
index 002314c9fa..e49f167228 100644
--- a/src/Nncase.Evaluator/NN/Activations.cs
+++ b/src/Nncase.Evaluator/NN/Activations.cs
@@ -532,14 +532,14 @@ public IValue Visit(IEvaluateContext context, Swish swish)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Swish target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Swish.Input);
+        var input = context.CheckArgumentType<IRType>(target, Swish.Input);
         return Visit(input);
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Swish target)
     {
-        var outputType = context.GetReturnType<TensorType>();
+        var outputType = context.GetReturnType<IRType>();
         return new()
         {
             [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(outputType),
@@ -558,7 +558,7 @@ public Metric Visit(IMetricEvaluateContext context, Swish target)
         };
     }
 
-    private IRType Visit(TensorType input)
+    private IRType Visit(IRType input)
     {
         return input;
     }
diff --git a/src/Nncase.Evaluator/Tensors/Gather.cs b/src/Nncase.Evaluator/Tensors/Gather.cs
index fbfff9049f..2f4bd25d46 100644
--- a/src/Nncase.Evaluator/Tensors/Gather.cs
+++ b/src/Nncase.Evaluator/Tensors/Gather.cs
@@ -116,6 +116,9 @@ private IRType Visit(DistributedType input, int axis, DistributedType index)
                 case (SBPSplit { Axis: int ix }, SBPBroadCast):
                     ndsbp[i] = SBP.S(ix - axis + index.TensorType.Shape.Rank - 1);
                     break;
+                case (SBPBroadCast, SBPBroadCast):
+                    ndsbp[i] = SBP.B;
+                    break;
                 default:
                     return invalid;
             }
diff --git a/src/Nncase.Passes/EGraphExtractPass.cs b/src/Nncase.Passes/EGraphExtractPass.cs
index d4ebe21ebc..2c2baa12b8 100644
--- a/src/Nncase.Passes/EGraphExtractPass.cs
+++ b/src/Nncase.Passes/EGraphExtractPass.cs
@@ -24,7 +24,7 @@ public EGraphExtractPass(IBaseFuncCostEvaluator? costEvaluator = null)
 
     protected override Task<BaseFunction> RunCoreAsync(IEGraph input, RunPassContext context)
     {
-        var post = (BaseFunction)input.Extract(input.Root!, _costEvaluator);
+        var post = (BaseFunction)input.Extract(input.Root!, _costEvaluator, out _);
         IRHelpers.DCE(post);
         return Task.FromResult(post);
     }
diff --git a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
index c409d2f0fa..6bcd4ed9cc 100644
--- a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
@@ -74,7 +74,11 @@ public void TestInferMatmulProduct()
             Select(argTypes => argTypes.Select(type => new Var(type)).ToArray());
 
         int count = 0;
+#if DEBUG
         using (var f = Dumpper.OpenFile("types.txt"))
+#else
+        using (var f = new StreamWriter(MemoryStream.Null))
+#endif
         {
             using var wr = new StreamWriter(f);
             foreach (var args in candiateArgs)
@@ -92,6 +96,44 @@ public void TestInferMatmulProduct()
 
         Assert.Equal(64, count);
     }
+
+    [Fact]
+    public void TestInferGather()
+    {
+        var inputType = new TensorType(DataTypes.Float32, new[] { 384, 128 });
+        var indexType = new TensorType(DataTypes.Int64, new[] { 1, 384 });
+        var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+
+        var candiateArgs = new[] {
+            DistributedUtility.GetLeafCandidateNDSBPs(inputType, placement).Select(ndsbp => new DistributedType(inputType, ndsbp, placement)),
+            DistributedUtility.GetLeafCandidateNDSBPs(indexType, placement).Select(ndsbp => new DistributedType(indexType, ndsbp, placement)),
+            }.
+            CartesianProduct().
+            Select(argTypes => argTypes.Select(type => new Var(type)).ToArray());
+
+        int count = 0;
+#if DEBUG
+        using (var f = Dumpper.OpenFile("types.txt"))
+#else
+        using (var f = new StreamWriter(MemoryStream.Null))
+#endif
+        {
+            using var wr = new StreamWriter(f);
+            foreach (var args in candiateArgs)
+            {
+                var call = IR.F.Tensors.Gather(args[0], 0, args[1]);
+                call.InferenceType();
+                if (call.CheckedType is not InvalidType)
+                {
+                    count++;
+                }
+
+                wr.WriteLine($"{args[0].CheckedType} {args[1].CheckedType} => {call.CheckedType}");
+            }
+        }
+
+        Assert.Equal(9, count);
+    }
 }
 
 internal sealed class InferMatmulData : TheoryData<DistributedType, DistributedType, IRType>
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index af52b1baca..391dd55cb9 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -41,7 +41,7 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseMatmul))]
     // [ClassData(typeof(TilingCaseMatmulUnary))]
     // [ClassData(typeof(TilingCaseLayerNorm))]
-    // [ClassData(typeof(TilingCaseGather))]
+    [ClassData(typeof(TilingCaseGather))]
     // [ClassData(typeof(TilingCaseSoftmax))]
     // [ClassData(typeof(TilingCaseSlice))]
     // [ClassData(typeof(TilingCaseConcat))]
@@ -379,7 +379,7 @@ internal sealed class TilingCaseGather : TheoryData<Function, Tensor[]>
 {
     public TilingCaseGather()
     {
-        var inputShape = new[] { 32000, 8192 };
+        var inputShape = new[] { 384, 128 };
         var axisShape = new[] { 1, 384 };
         int axis = 0;
         var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));

From 350357e9dc9c626c00deb8a58ebeab3f8f2573cd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 21 Sep 2023 11:13:24 +0800
Subject: [PATCH 201/308] fix build

---
 .../CodeGen/CSourceConvertVisitor.cs          |  2 +-
 .../Evaluator/CPU/Boxing.cs                   |  1 +
 .../Tile/AutoDistributedConvertVisitor.cs     | 69 +++++++++++++++++--
 .../Passes/Tile/TIRConvertVisitor.cs          |  5 +-
 src/Nncase.Core/CostModel/Cost.cs             |  4 +-
 .../{ => Utilities}/DistributedUtility.cs     | 54 +--------------
 src/Nncase.Evaluator/Math/Unary.cs            |  4 +-
 src/Nncase.Evaluator/NN/LayerNorm.cs          |  2 +-
 .../Distributed/UnitTestConstruct.cs          |  2 +-
 src/Nncase.Tests/Distributed/UnitTestCost.cs  |  2 +-
 .../Distributed/UnitTestTypeInfer.cs          |  1 +
 .../Distributed/UnitTestUtilities.cs          |  1 +
 12 files changed, 77 insertions(+), 70 deletions(-)
 rename src/Nncase.Core/{ => Utilities}/DistributedUtility.cs (63%)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 1a2ec5086c..f61ff85a22 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -293,7 +293,7 @@ protected override CSymbol VisitCall(Call expr)
                     {
                         IndentScope.Writer.IndWrite($"{{\n");
 
-                        var dividedType = DistributedUtility.GetDividedTensorType(layernorm.DistType);
+                        var dividedType = Utilities.DistributedUtility.GetDividedTensorType(layernorm.DistType);
                         var sbpOnAxis = layernorm.DistType.NdSBP.Where(sbp => sbp is SBPSplit s && s.Axis >= layernorm.Axis).ToArray();
                         switch (sbpOnAxis.Length)
                         {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
index cae49e26cf..1e0ad2c6cc 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
@@ -7,6 +7,7 @@
 using Nncase.CostModel;
 using Nncase.IR;
 using Nncase.IR.CPU;
+using Nncase.Utilities;
 
 namespace Nncase.Evaluator.CPU;
 
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
index 1f7d7b37fa..08a3723d54 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
@@ -2,10 +2,13 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System.Reactive;
+using System.Runtime.CompilerServices;
 using Nncase.IR;
 using Nncase.IR.CPU;
 using Nncase.IR.Tensors;
 
+[assembly: InternalsVisibleTo("Nncase.Tests")]
+
 namespace Nncase.Passes.Tile;
 
 internal sealed class AutoDistributedConvertVisitor : ExprVisitor<IReadOnlyList<Expr>, Unit>
@@ -23,9 +26,61 @@ public AutoDistributedConvertVisitor(TileOptions tileOptions)
 
     public Placement Placement { get; }
 
+    public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement placement)
+    {
+        return Utilities.DistributedUtility.GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).Select(ndsbp => IR.F.CPU.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).ToArray();
+    }
+
+    /// <summary>
+    /// when input expression sbp is partial, get the new candidate boxings.
+    /// </summary>
+    /// <param name="expr">input expression.</param>
+    /// <returns>the boxings.</returns>
+    /// <exception cref="NotSupportedException">when expr is tuple.</exception>
+    public static IReadOnlyList<Expr> GetPartialCandidateBoxings(Expr expr)
+    {
+        if (expr is IR.Tuple tuple)
+        {
+            var candidates = tuple.Fields.ToArray().
+                Select(GetPartialCandidateBoxings).
+                CartesianProduct();
+            return candidates.Any() ? candidates.
+                Select(fs => new IR.Tuple(fs.ToArray())).
+                ToArray() : Array.Empty<Expr>();
+        }
+
+        var type = (DistributedType)expr.CheckedType;
+        if (!type.NdSBP.Any(sbp => sbp is SBPBroadCast))
+        {
+            return Array.Empty<Expr>();
+        }
+
+        var tensorType = type.TensorType;
+        var candidateNdsbps = new List<SBP>[type.Placement.Rank];
+        for (int i = 0; i < type.Placement.Rank; i++)
+        {
+            candidateNdsbps[i] = new List<SBP>();
+            if (type.NdSBP[i] is SBPPartialSum)
+            {
+                candidateNdsbps[i].Add(SBP.B);
+                for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
+                {
+                    if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && Utilities.DistributedUtility.IsDivisible(s, type.Placement.Hierarchy[i]))
+                    {
+                        candidateNdsbps[i].Add(SBP.S(axis));
+                    }
+                }
+            }
+        }
+
+        return candidateNdsbps.CartesianProduct().
+            Select(ndsbp => new DistributedType(tensorType, new IRArray<SBP>(ndsbp), type.Placement)).
+            Select(disttype => IR.F.CPU.Boxing(expr, disttype)).ToArray();
+    }
+
     public Expr Convert(Expr body)
     {
-        var equivalents = Visit(body).Select(newbody => IR.F.Tensors.Boxing(newbody, body.CheckedType)).ToArray();
+        var equivalents = Visit(body).Select(newbody => IR.F.CPU.Boxing(newbody, body.CheckedType)).ToArray();
         var graph = new EGraph();
         var bodyEclasses = equivalents.Select(graph.Add).ToArray();
         foreach (var cls in bodyEclasses.Skip(1))
@@ -97,7 +152,7 @@ private IReadOnlyList<Expr> VisitLeafArgument(ParameterKind parameterKind, Expr
         {
             equivalents = (parameterKind, expr) switch
             {
-                (ParameterKind.Input, Expr e) when e is Const or Var => DistributedUtility.GetLeafCandidateBoxings(e, Placement),
+                (ParameterKind.Input, Expr e) when e is Const or Var => GetLeafCandidateBoxings(e, Placement),
                 (ParameterKind.Input, Expr e) when e is IR.Tuple tp => tp.Fields.ToArray().Select(f => VisitLeafArgument(parameterKind, f)).CartesianProduct().Select(e => new IR.Tuple(e.ToArray())).ToArray(),
                 (ParameterKind.Attribute, Expr e) when e is Const or Var => new[] { e },
                 _ => throw new InvalidOperationException(),
@@ -133,7 +188,7 @@ private IReadOnlyList<Expr> GetReBoxings(Expr expr)
             candidateNdsbps[i] = new List<SBP> { SBP.B };
             for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
             {
-                if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && DistributedUtility.IsDivisible(s, type.Placement.Hierarchy[i]))
+                if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && Utilities.DistributedUtility.IsDivisible(s, type.Placement.Hierarchy[i]))
                 {
                     candidateNdsbps[i].Add(SBP.S(axis));
                 }
@@ -144,7 +199,7 @@ private IReadOnlyList<Expr> GetReBoxings(Expr expr)
             Select(ndsbp => new IRArray<SBP>(ndsbp)).
             Where(ndsbp => ndsbp != type.NdSBP).
             Select(ndsbp => new DistributedType(tensorType, new IRArray<SBP>(ndsbp), type.Placement)).
-            Select(disttype => IR.F.Tensors.Boxing(expr, disttype)).ToArray();
+            Select(disttype => IR.F.CPU.Boxing(expr, disttype)).ToArray();
     }
 
     private IEnumerable<(bool Valid, Call Call)> BuildEquivalCalls(Op target, Expr[] args)
@@ -166,14 +221,14 @@ private IReadOnlyList<Expr> GetReBoxings(Expr expr)
                 var newShape = ((TensorConst)args[1]).Value.ToArray<int>();
                 var inType = (DistributedType)args[0].CheckedType;
                 var tensorType = inType.TensorType with { Shape = newShape };
-                calls.AddRange(DistributedUtility.GetLeafCandidateNDSBPs(tensorType, inType.Placement).
-                    Select(ndsbp => IR.F.Tensors.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))).
+                calls.AddRange(Utilities.DistributedUtility.GetLeafCandidateNDSBPs(tensorType, inType.Placement).
+                    Select(ndsbp => IR.F.CPU.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))).
                     Select(c => (c.InferenceType(), c)));
             }
             else
             {
                 // when args have partial, we need boxing args.
-                var broadcastArgs = args.Zip(target.Parameters).Select(t => t.Second.ParameterKind == ParameterKind.Input ? DistributedUtility.GetPartialCandidateBoxings(t.First) : Array.Empty<Expr>()).ToArray();
+                var broadcastArgs = args.Zip(target.Parameters).Select(t => t.Second.ParameterKind == ParameterKind.Input ? GetPartialCandidateBoxings(t.First) : Array.Empty<Expr>()).ToArray();
 
                 if (!broadcastArgs.All(bargs => bargs.Count == 0))
                 {
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 1071cbadfb..ffb9631b1f 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -8,6 +8,7 @@
 using Nncase.IR.NN;
 using Nncase.IR.Tensors;
 using Nncase.TIR;
+using Nncase.Utilities;
 using Buffer = Nncase.TIR.Buffer;
 
 namespace Nncase.Passes.Tile;
@@ -77,7 +78,7 @@ protected override Unit VisitLeafCall(Call expr)
                 }
 
                 break;
-            case Boxing boxing:
+            case IR.CPU.Boxing boxing:
                 GenerateBoxing(boxing, arguments, ret, expr);
                 break;
             default:
@@ -102,7 +103,7 @@ private void GenerateSlice(Slice slice, Buffer input, Buffer output, Expr begins
         _mainBody.Add(IR.F.XPU.Slice(input, output, begins, ends, axes, distributedType));
     }
 
-    private void GenerateBoxing(Boxing boxing, Buffer[] arguments, Buffer ret, Call expr)
+    private void GenerateBoxing(IR.CPU.Boxing boxing, Buffer[] arguments, Buffer ret, Call expr)
     {
         switch (expr.Arguments[0].CheckedType, boxing.NewType)
         {
diff --git a/src/Nncase.Core/CostModel/Cost.cs b/src/Nncase.Core/CostModel/Cost.cs
index 4146bb5a86..e1835ad33a 100644
--- a/src/Nncase.Core/CostModel/Cost.cs
+++ b/src/Nncase.Core/CostModel/Cost.cs
@@ -204,7 +204,7 @@ public static UInt128 GetMemoryAccess(IRType type)
         {
             TensorType t => (UInt128)(t.Shape.Aggregate(1D, (acc, x) => acc * (x.IsFixed ? x.FixedValue : 1)) * t.DType.SizeInBytes),
             TupleType t => t.Fields.Sum(GetMemoryAccess),
-            DistributedType t => GetMemoryAccess(DistributedUtility.GetDividedTensorType(t)),
+            DistributedType t => GetMemoryAccess(Utilities.DistributedUtility.GetDividedTensorType(t)),
             _ => 0,
         };
     }
@@ -230,7 +230,7 @@ public static UInt128 GetCPUCycles(IRType type, double cyclesPerElement = 1)
         {
             TensorType t => (UInt128)(t.Shape.Aggregate(1D, (acc, x) => acc * (x.IsFixed ? x.FixedValue : 1)) * cyclesPerElement),
             TupleType t => t.Fields.Sum(GetMemoryAccess),
-            DistributedType t => GetCPUCycles(DistributedUtility.GetDividedTensorType(t)),
+            DistributedType t => GetCPUCycles(Utilities.DistributedUtility.GetDividedTensorType(t)),
             _ => 0,
         };
     }
diff --git a/src/Nncase.Core/DistributedUtility.cs b/src/Nncase.Core/Utilities/DistributedUtility.cs
similarity index 63%
rename from src/Nncase.Core/DistributedUtility.cs
rename to src/Nncase.Core/Utilities/DistributedUtility.cs
index 64c52b7654..bd899d45c4 100644
--- a/src/Nncase.Core/DistributedUtility.cs
+++ b/src/Nncase.Core/Utilities/DistributedUtility.cs
@@ -4,7 +4,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Nncase.IR;
 
-namespace Nncase;
+namespace Nncase.Utilities;
 
 public static class DistributedUtility
 {
@@ -33,58 +33,6 @@ public static IReadOnlyList<IRArray<SBP>> GetLeafCandidateNDSBPs(TensorType tens
            ToArray();
     }
 
-    public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement placement)
-    {
-        return GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).Select(ndsbp => IR.F.Tensors.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).ToArray();
-    }
-
-    /// <summary>
-    /// when input expression sbp is partial, get the new candidate boxings.
-    /// </summary>
-    /// <param name="expr">input expression.</param>
-    /// <returns>the boxings.</returns>
-    /// <exception cref="NotSupportedException">when expr is tuple.</exception>
-    public static IReadOnlyList<Expr> GetPartialCandidateBoxings(Expr expr)
-    {
-        if (expr is IR.Tuple tuple)
-        {
-            var candidates = tuple.Fields.ToArray().
-                Select(GetPartialCandidateBoxings).
-                CartesianProduct();
-            return candidates.Any() ? candidates.
-                Select(fs => new IR.Tuple(fs.ToArray())).
-                ToArray() : Array.Empty<Expr>();
-        }
-
-        var type = (DistributedType)expr.CheckedType;
-        if (!type.NdSBP.Any(sbp => sbp is SBPBroadCast))
-        {
-            return Array.Empty<Expr>();
-        }
-
-        var tensorType = type.TensorType;
-        var candidateNdsbps = new List<SBP>[type.Placement.Rank];
-        for (int i = 0; i < type.Placement.Rank; i++)
-        {
-            candidateNdsbps[i] = new List<SBP>();
-            if (type.NdSBP[i] is SBPPartialSum)
-            {
-                candidateNdsbps[i].Add(SBP.B);
-                for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
-                {
-                    if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && IsDivisible(s, type.Placement.Hierarchy[i]))
-                    {
-                        candidateNdsbps[i].Add(SBP.S(axis));
-                    }
-                }
-            }
-        }
-
-        return candidateNdsbps.CartesianProduct().
-            Select(ndsbp => new DistributedType(tensorType, new IRArray<SBP>(ndsbp), type.Placement)).
-            Select(disttype => IR.F.Tensors.Boxing(expr, disttype)).ToArray();
-    }
-
     public static bool IsDistributable(TensorType tensorType, ReadOnlySpan<SBP> ndsbp, Placement placement, [MaybeNullWhen(false)] out TensorType distType)
     {
         distType = null;
diff --git a/src/Nncase.Evaluator/Math/Unary.cs b/src/Nncase.Evaluator/Math/Unary.cs
index 5111e4a3b3..c5e7cdefa5 100644
--- a/src/Nncase.Evaluator/Math/Unary.cs
+++ b/src/Nncase.Evaluator/Math/Unary.cs
@@ -181,8 +181,8 @@ private IRType Visit(TensorType input)
 
     private Cost Visit(DistributedType inType, DistributedType outType, Unary target)
     {
-        var inPartType = DistributedUtility.GetDividedTensorType(inType);
-        var outPartType = DistributedUtility.GetDividedTensorType(outType);
+        var inPartType = Utilities.DistributedUtility.GetDividedTensorType(inType);
+        var outPartType = Utilities.DistributedUtility.GetDividedTensorType(outType);
         return new()
         {
             [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inPartType),
diff --git a/src/Nncase.Evaluator/NN/LayerNorm.cs b/src/Nncase.Evaluator/NN/LayerNorm.cs
index 7152fbaa57..b76300efbf 100644
--- a/src/Nncase.Evaluator/NN/LayerNorm.cs
+++ b/src/Nncase.Evaluator/NN/LayerNorm.cs
@@ -130,7 +130,7 @@ private IRType Visit(DistributedType input, DistributedType scale, DistributedTy
 
     private UInt128 GetRingReduceCommunicate(DistributedType distributedType, int[] axes)
     {
-        var ttype = DistributedUtility.GetDividedTensorType(distributedType);
+        var ttype = Utilities.DistributedUtility.GetDividedTensorType(distributedType);
         var splits = axes.Where(i => distributedType.NdSBP[i] is SBPSplit);
         if (!splits.Any())
         {
diff --git a/src/Nncase.Tests/Distributed/UnitTestConstruct.cs b/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
index 0ceefa4f5a..b17cd94b54 100644
--- a/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
@@ -4,12 +4,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection.Metadata;
-using Microsoft.Extensions.FileSystemGlobbing.Internal;
 using NetFabric.Hyperlinq;
 using Nncase.Diagnostics;
 using Nncase.IR;
 using Nncase.IR.Math;
 using Nncase.Passes;
+using Nncase.Utilities;
 using Xunit;
 
 namespace Nncase.Tests.DistributedTest;
diff --git a/src/Nncase.Tests/Distributed/UnitTestCost.cs b/src/Nncase.Tests/Distributed/UnitTestCost.cs
index 975e379844..096f571fda 100644
--- a/src/Nncase.Tests/Distributed/UnitTestCost.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestCost.cs
@@ -31,7 +31,7 @@ public void TestPartialToBroadCastCost()
          })
         {
             var input0 = new Var(new DistributedType(tensorType, ndsbp, placement));
-            var candidates = Nncase.Passes.Tile.SingleCPUFusionConverter.GetPartialCandidateBoxings(input0);
+            var candidates = Nncase.Passes.Tile.AutoDistributedConvertVisitor.GetPartialCandidateBoxings(input0);
             foreach (var item in candidates)
             {
                 var cost = CompilerServices.EvaluateCost(item);
diff --git a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
index 6bcd4ed9cc..bd31d8e2cd 100644
--- a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
@@ -7,6 +7,7 @@
 using Nncase.Diagnostics;
 using Nncase.IR;
 using Nncase.IR.Math;
+using Nncase.Utilities;
 using Xunit;
 
 namespace Nncase.Tests.DistributedTest;
diff --git a/src/Nncase.Tests/Distributed/UnitTestUtilities.cs b/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
index 88d324f147..3f1c27b65d 100644
--- a/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
@@ -6,6 +6,7 @@
 using NetFabric.Hyperlinq;
 using Nncase.Diagnostics;
 using Nncase.IR;
+using Nncase.Utilities;
 using Xunit;
 
 namespace Nncase.Tests.DistributedTest;

From 4677e839a7407d415faab6d95912719d32d23ff7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 21 Sep 2023 14:57:39 +0800
Subject: [PATCH 202/308] update compile

---
 .../CodeGen/CSourceConvertVisitor.cs          |  2 +-
 .../CodeGen/FunctionBuilder.cs                |  4 +-
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  2 +-
 modules/Nncase.Modules.CPU/IR/XPU/Unary.cs    |  2 +-
 .../Passes/Rules/MHAFusion.cs                 | 12 +++
 .../Passes/Tile/TIRConvertVisitor.cs          | 78 +++++++++----------
 src/Nncase.Cli/Commands/Compile.cs            | 45 +++++------
 src/Nncase.Core/Schedule/ScheduleTypes.cs     |  8 +-
 src/Nncase.Evaluator/Tensors/Reshape.cs       |  1 +
 src/Nncase.Importer/Onnx/OnnxImporter.cs      |  2 -
 src/Nncase.Passes/DDrBufferSchdeulePass.cs    | 24 +++---
 .../Targets/UnitTestCPUTargetTiling.cs        |  2 +-
 12 files changed, 93 insertions(+), 89 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index f61ff85a22..1e1a547941 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -280,7 +280,7 @@ protected override CSymbol VisitCall(Call expr)
 
                     break;
                 case IR.XPU.Unary unary:
-                    IndentScope.Writer.Write($"unary({Visit(args[0]).Name}, {Visit(args[1]).Name}, unary_op_t::{unary.UnaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
+                    IndentScope.Writer.Write($"unary({Visit(args[0]).Name}, {Visit(args[1]).Name}, unary_op_t::{unary.UnaryOp})");
                     break;
                 case IR.XPU.Binary binary:
                     IndentScope.Writer.Write($"binary({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, binary_op_t::{binary.BinaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
index 916435759f..e864a90077 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
@@ -75,13 +75,13 @@ public unsafe LinkableFunction Build(TIR.PrimFunction function)
         foreach (var (@const, range) in function.SchedResult.Rdatas)
         {
             var bytes = ((TensorConst)@const).Value.BytesBuffer;
-            var size = range.End.Value - range.Start.Value;
+            var size = range.Max - range.Min;
             if ((uint)bytes.Length != size)
             {
                 throw new InvalidDataException("The Buffer Szie Not Equal!");
             }
 
-            _rdataWriter.Position(range.Start.Value);
+            _rdataWriter.Position(range.Min);
             _rdataWriter.Write(bytes);
         }
 
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index d6c7f748bf..01bbaa1ecb 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -22,7 +22,7 @@ public static Call TDMAStore(Expr src, Expr dest, IRArray<SBP> ndsbp, Placement
         return new Call(new TDMAStore(ndsbp, placement), src, dest);
     }
 
-    public static Call Unary(UnaryOp unaryOp, Expr input, Expr output)
+    public static Call Unary(string unaryOp, Expr input, Expr output)
     {
         return new Call(new Unary(unaryOp), input, output);
     }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Unary.cs b/modules/Nncase.Modules.CPU/IR/XPU/Unary.cs
index 0b1876138d..ca431ca12e 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Unary.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Unary.cs
@@ -9,7 +9,7 @@ public sealed partial class Unary : XPUKernelOp
 
     public static readonly ParameterInfo Output = new(typeof(Unary), 1, "output");
 
-    public UnaryOp UnaryOp { get; }
+    public string UnaryOp { get; }
 
     /// <inheritdoc/>
     public override string DisplayProperty()
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index c9fbef25b2..56b4bfdcc0 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -33,6 +33,18 @@ public MHAMerger(IReadOnlyDictionary<Expr, Var> multiVarMap)
         _multiVarMap = multiVarMap;
     }
 
+    protected override Expr VisitLeafCall(Call expr, Unit context)
+    {
+        var target = Clone(expr.Target, context);
+        var arguments = CloneArray(expr.Arguments, context);
+        if (target is Binary)
+        {
+            arguments = arguments.Select(e => e switch { TensorConst { Value: Tensor { Shape.IsScalar: true } } tc => Const.FromTensor(Tensor.FromBytes(tc.ValueType.DType, tc.Value.BytesBuffer.ToArray(), new[] { 1 })), _ => e }).ToArray();
+        }
+
+        return expr.With(target: target, arguments: arguments);
+    }
+
     protected override Expr VisitLeafVar(Var expr, Unit context)
     {
         if (_multiVarMap.TryGetValue(expr, out var newVar))
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index ffb9631b1f..7fcc987fcd 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -38,45 +38,41 @@ protected override Unit VisitLeafCall(Call expr)
     {
         var arguments = expr.Arguments.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray();
         var ret = AllocOrGetBuffer(expr);
-        switch (expr.Target)
+        var op = expr.Target is IR.CPU.CPUKernelOp kop ? kop.Target : expr.Target;
+        switch (op)
         {
-            case IR.CPU.CPUKernelOp kernelOp:
-                switch (kernelOp.Target)
-                {
-                    case Unary unary:
-                        GenerateUnary(unary, arguments, ret);
-                        break;
-                    case Binary binary:
-                        GenerateBinary(binary, arguments, ret);
-                        break;
-                    case MatMul matmul:
-                        GenerateMatmul(matmul, arguments, ret);
-                        break;
-                    case LayerNorm layernorm:
-                        GenerateLayerNorm(layernorm, arguments, ret, (DistributedType)expr.Arguments[0].CheckedType);
-                        break;
-                    case Gather gather:
-                        GenerateGather(gather, arguments, ret);
-                        break;
-                    case Concat concat:
-                        GenerateConcat(concat, ((IR.Tuple)expr.Arguments[0]).Fields.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray(), ret);
-                        break;
-                    case Slice slice:
-                        GenerateSlice(slice, arguments[0], ret, expr.Arguments[1], expr.Arguments[2], expr.Arguments[3], (DistributedType)expr.CheckedType);
-                        break;
-                    case Softmax softmax:
-                        GenerateSoftmax(softmax, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), arguments, ret);
-                        break;
-                    case Transpose transpose:
-                        GenerateTranspose(transpose, ((TensorConst)expr.Arguments[1]).Value.ToArray<int>(), arguments, ret);
-                        break;
-                    case Reshape reshape:
-                        GenerateReshape(reshape, arguments[0], ret);
-                        break;
-                    default:
-                        throw new NotSupportedException();
-                }
-
+            case Unary unary:
+                GenerateUnary(unary.UnaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture), arguments, ret);
+                break;
+            case Binary binary:
+                GenerateBinary(binary, arguments, ret);
+                break;
+            case MatMul matmul:
+                GenerateMatmul(matmul, arguments, ret);
+                break;
+            case LayerNorm layernorm:
+                GenerateLayerNorm(layernorm, arguments, ret, (DistributedType)expr.Arguments[0].CheckedType);
+                break;
+            case Gather gather:
+                GenerateGather(gather, arguments, ret);
+                break;
+            case Concat concat:
+                GenerateConcat(concat, ((IR.Tuple)expr.Arguments[0]).Fields.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray(), ret);
+                break;
+            case Slice slice:
+                GenerateSlice(slice, arguments[0], ret, expr.Arguments[1], expr.Arguments[2], expr.Arguments[3], (DistributedType)expr.CheckedType);
+                break;
+            case Softmax softmax:
+                GenerateSoftmax(softmax, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), arguments, ret);
+                break;
+            case Transpose transpose:
+                GenerateTranspose(transpose, ((TensorConst)expr.Arguments[1]).Value.ToArray<int>(), arguments, ret);
+                break;
+            case Reshape or Unsqueeze:
+                GenerateReshape(arguments[0], ret);
+                break;
+            case Swish:
+                GenerateUnary("swish", arguments, ret);
                 break;
             case IR.CPU.Boxing boxing:
                 GenerateBoxing(boxing, arguments, ret, expr);
@@ -88,7 +84,7 @@ protected override Unit VisitLeafCall(Call expr)
         return default;
     }
 
-    private void GenerateReshape(Reshape reshape, Buffer input, Buffer ret)
+    private void GenerateReshape(Buffer input, Buffer ret)
     {
         _mainBody.Add(IR.F.XPU.ReShape(input, ret));
     }
@@ -131,10 +127,10 @@ private void GenerateBoxing(IR.CPU.Boxing boxing, Buffer[] arguments, Buffer ret
         }
     }
 
-    private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
+    private void GenerateUnary(string unaryOp, ReadOnlySpan<Buffer> arguments, Buffer ret)
     {
         var input = arguments[IR.Math.Unary.Input.Index];
-        _mainBody.Add(IR.F.XPU.Unary(unary.UnaryOp, input, ret));
+        _mainBody.Add(IR.F.XPU.Unary(unaryOp, input, ret));
     }
 
     private void GenerateBinary(Binary binary, Buffer[] arguments, Buffer ret)
diff --git a/src/Nncase.Cli/Commands/Compile.cs b/src/Nncase.Cli/Commands/Compile.cs
index 3110b7dcf7..9daed2ba2c 100644
--- a/src/Nncase.Cli/Commands/Compile.cs
+++ b/src/Nncase.Cli/Commands/Compile.cs
@@ -54,10 +54,9 @@ public Compile()
           aliases: new[] { "-i", "--input-format" },
           description: "input format, e.g. tflite",
           getDefaultValue: () => "tflite"));
-        AddOption(new Option<int>(
-          alias: "--dump-level",
-          description: $"dump ir to .il, default is {0}",
-          getDefaultValue: () => 0));
+        AddOption(new Option<IEnumerable<DumpFlags>>(
+          alias: "--dump-flags",
+          description: "dump ir flags. \n available value: None,ImportOps,PassIR,EGraphCost,Rewrite,Calibration,Evaluator,Compile,Tiling,Schedule,CodeGen."));
         AddOption(new Option<string>(
           alias: "--dump-dir",
           description: "dump to directory, default is .",
@@ -86,28 +85,19 @@ public Compile()
           alias: "--calib-method",
           description: $"model quant options, default is {Quantization.CalibMethod.Kld}",
           getDefaultValue: () => Quantization.CalibMethod.Kld));
+        AddOption(new Option<IEnumerable<(string, int)>>(
+          alias: "--fixed-vars",
+          description: $"dynamic shape fixed vars, default is empty. \nset by `n:123`",
+          parseArgument: result =>
+            {
+                return result.Tokens.
+                    Select(tk => tk.Value.Split(":").ToArray()).
+                    Select(tp => (tp[0].Trim(), int.Parse(tp[1].Trim())));
+            }));
 
         Handler = CommandHandler.Create<CliCompileOptions, IHost>(RunAsync);
     }
 
-    private static DumpFlags DumpLevelToFlags(int dumpLevel)
-    {
-        return dumpLevel switch
-        {
-            0 => DumpFlags.None,
-            1 => DumpLevelToFlags(0) | DumpFlags.Compile,
-            2 => DumpLevelToFlags(1) | DumpFlags.PassIR,
-            3 => DumpLevelToFlags(2) | DumpFlags.Rewrite,
-            4 => DumpLevelToFlags(3) | DumpFlags.EGraphCost,
-            5 => DumpLevelToFlags(4) | DumpFlags.Evaluator,
-            6 => DumpLevelToFlags(5) | DumpFlags.Calibration,
-            7 => DumpLevelToFlags(6) | DumpFlags.Tiling,
-            8 => DumpLevelToFlags(7) | DumpFlags.Schedule,
-            >= 9 => DumpLevelToFlags(8) | DumpFlags.CodeGen,
-            _ => throw new ArgumentOutOfRangeException(nameof(dumpLevel)),
-        };
-    }
-
     private async Task RunAsync(CliCompileOptions cliOptions, IHost host)
     {
         CompilerServices.Configure(host.Services);
@@ -117,7 +107,7 @@ private async Task RunAsync(CliCompileOptions cliOptions, IHost host)
         {
             InputFile = cliOptions.InputFile,
             InputFormat = cliOptions.InputFormat,
-            DumpFlags = DumpLevelToFlags(cliOptions.DumpLevel),
+            DumpFlags = cliOptions.DumpFlags.Aggregate(DumpFlags.None, (a, b) => a | b),
             DumpDir = cliOptions.DumpDir,
             QuantizeOptions = new()
             {
@@ -140,6 +130,11 @@ private async Task RunAsync(CliCompileOptions cliOptions, IHost host)
             },
         };
 
+        foreach (var item in cliOptions.FixedVars)
+        {
+            compileOptions.ShapeBucketOptions.FixVarMap.Add(item.Name, item.Value);
+        }
+
         // 2. import the model
         var target = CompilerServices.GetTarget(cliOptions.Target);
         using var compileSession = CompileSession.Create(target, compileOptions);
@@ -189,7 +184,7 @@ internal sealed class CliCompileOptions
 
     public string Target { get; set; }
 
-    public int DumpLevel { get; set; }
+    public IEnumerable<DumpFlags> DumpFlags { get; set; }
 
     public string DumpDir { get; set; }
 
@@ -206,6 +201,8 @@ internal sealed class CliCompileOptions
     public string Dataset { get; set; }
 
     public DatasetFormat DatasetFormat { get; set; }
+
+    public IEnumerable<(string Name, int Value)> FixedVars { get; set; }
 }
 
 #pragma warning restore CS8618
diff --git a/src/Nncase.Core/Schedule/ScheduleTypes.cs b/src/Nncase.Core/Schedule/ScheduleTypes.cs
index 8661109f22..6800f79fad 100644
--- a/src/Nncase.Core/Schedule/ScheduleTypes.cs
+++ b/src/Nncase.Core/Schedule/ScheduleTypes.cs
@@ -215,12 +215,12 @@ public SchedFunctionResult()
     /// <summary>
     /// Gets the buffer allocation.
     /// </summary>
-    public Dictionary<IR.Const, System.Range> Rdatas { get; }
+    public Dictionary<IR.Const, ValueRange<long>> Rdatas { get; }
 
     /// <summary>
     /// Gets or sets the data section length.
     /// </summary>
-    public int DataUsage { get; set; }
+    public long DataUsage { get; set; }
 
     /// <summary>
     /// Gets or sets a value indicating whether the Scheduled status.
@@ -250,8 +250,8 @@ public override bool Equals(object? obj)
             return true;
         }
 
-        return EqualityComparer<Dictionary<IR.Const, System.Range>>.Default.Equals(Rdatas, result.Rdatas) &&
-               EqualityComparer<int>.Default.Equals(DataUsage, result.DataUsage);
+        return EqualityComparer<Dictionary<IR.Const, ValueRange<long>>>.Default.Equals(Rdatas, result.Rdatas) &&
+               EqualityComparer<long>.Default.Equals(DataUsage, result.DataUsage);
     }
 
     /// <inheritdoc/>
diff --git a/src/Nncase.Evaluator/Tensors/Reshape.cs b/src/Nncase.Evaluator/Tensors/Reshape.cs
index a619073b36..d5d201bd5b 100644
--- a/src/Nncase.Evaluator/Tensors/Reshape.cs
+++ b/src/Nncase.Evaluator/Tensors/Reshape.cs
@@ -38,6 +38,7 @@ public IRType Visit(ITypeInferenceContext context, Reshape target)
         {
             TensorType tensorType => Visit(context, target, tensorType),
             DistributedType distributedType => Visit(context, target, distributedType),
+            _ => throw new NotImplementedException(),
         };
     }
 
diff --git a/src/Nncase.Importer/Onnx/OnnxImporter.cs b/src/Nncase.Importer/Onnx/OnnxImporter.cs
index 01003a3a03..b87178604a 100644
--- a/src/Nncase.Importer/Onnx/OnnxImporter.cs
+++ b/src/Nncase.Importer/Onnx/OnnxImporter.cs
@@ -52,8 +52,6 @@ protected override (IEnumerable<Var> Inputs, Dictionary<Var, Expr[]> VarMap) Cre
     {
         var bucketOptions = CompileSession.CompileOptions.ShapeBucketOptions;
         _fixVarMap = bucketOptions.FixVarMap;
-
-        // _fixVarMap.Add("N", 384);
         _constTensors = _graph.Initializer
             .ToDictionary(tensor => tensor.Name, tensor => tensor);
 
diff --git a/src/Nncase.Passes/DDrBufferSchdeulePass.cs b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
index 015b9d3dd3..16265f5e75 100644
--- a/src/Nncase.Passes/DDrBufferSchdeulePass.cs
+++ b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
@@ -24,9 +24,9 @@ namespace Nncase.Passes;
 /// </summary>
 public sealed class DDrBufferSchdeulePass : ModulePass
 {
-    private readonly Dictionary<string, Dictionary<MemoryLocation, int>> _moduleUsage = new();
+    private readonly Dictionary<string, Dictionary<MemoryLocation, long>> _moduleUsage = new();
 
-    private readonly Dictionary<string, Dictionary<Const, System.Range>> _moduleRdataMaps = new();
+    private readonly Dictionary<string, Dictionary<Const, ValueRange<long>>> _moduleRdataMaps = new();
 
     private readonly bool _enbaleMergeCall;
 
@@ -91,10 +91,10 @@ protected override async Task<IRModule> RunCoreAsync(IRModule module, RunPassCon
 
 internal sealed class DDrBufferRewriter : ExprRewriter
 {
-    private readonly Dictionary<MemoryLocation, int> _functionUsage;
-    private readonly Dictionary<Const, System.Range> _functionRdatas;
+    private readonly Dictionary<MemoryLocation, long> _functionUsage;
+    private readonly Dictionary<Const, ValueRange<long>> _functionRdatas;
 
-    public DDrBufferRewriter(Dictionary<string, Dictionary<MemoryLocation, int>> moduleUsage, Dictionary<string, Dictionary<Const, System.Range>> moduleRdataMaps)
+    public DDrBufferRewriter(Dictionary<string, Dictionary<MemoryLocation, long>> moduleUsage, Dictionary<string, Dictionary<Const, ValueRange<long>>> moduleRdataMaps)
     {
         ModuleUsage = moduleUsage;
         ModuleRdataMaps = moduleRdataMaps;
@@ -103,13 +103,13 @@ public DDrBufferRewriter(Dictionary<string, Dictionary<MemoryLocation, int>> mod
         Changed = false;
     }
 
-    public Dictionary<string, Dictionary<MemoryLocation, int>> ModuleUsage { get; }
+    public Dictionary<string, Dictionary<MemoryLocation, long>> ModuleUsage { get; }
 
-    public Dictionary<string, Dictionary<Const, System.Range>> ModuleRdataMaps { get; }
+    public Dictionary<string, Dictionary<Const, ValueRange<long>>> ModuleRdataMaps { get; }
 
     public bool Changed { get; private set; }
 
-    public int DataUsage => _functionUsage.GetValueOrDefault(MemoryLocation.Data, 0);
+    public long DataUsage => _functionUsage.GetValueOrDefault(MemoryLocation.Data, 0);
 
     public PrimFunction Entry => (PrimFunction)VisitRoot!;
 
@@ -138,13 +138,13 @@ protected override TIR.MemSpan RewriteLeafMemSpan(TIR.MemSpan memSpan)
 
                 _ = ComputeSize(@const);
                 moduleUsage[memSpan.Location] = start + ComputeSize(@const);
-                memRange = start..(start + ComputeSize(@const));
+                memRange = new(start, start + ComputeSize(@const));
                 moduleRdataMap.Add(@const, memRange);
                 Entry.SchedResult.Rdatas.Add(@const, memRange);
                 Changed = true;
             }
 
-            return memSpan.With(new TensorConst(Tensor.FromPointer((ulong)memRange.Start.Value, new PointerType(constType.DType, constType.Shape))), memRange.End.Value - memRange.Start.Value);
+            return memSpan.With(new TensorConst(Tensor.FromPointer((ulong)memRange.Min, new PointerType(constType.DType, constType.Shape))), memRange.Max - memRange.Min);
         }
 
         // else if (memSpan.Location is MemoryLocation.Data)
@@ -170,9 +170,9 @@ protected override TIR.MemSpan RewriteLeafMemSpan(TIR.MemSpan memSpan)
         return memSpan;
     }
 
-    private int ComputeSize(IValue v) => v.AsTensors().Select(t => t.BytesBuffer.Length).Sum();
+    private long ComputeSize(IValue v) => v.AsTensors().Select(t => t.BytesBuffer.Length).Sum();
 
-    private int ComputeSize(Const @const) => @const switch
+    private long ComputeSize(Const @const) => @const switch
     {
         TensorConst { Value: Tensor tc } => tc.BytesBuffer.Length,
         TupleConst tc => ComputeSize(tc.Value),
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 391dd55cb9..bae9603660 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -41,7 +41,7 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseMatmul))]
     // [ClassData(typeof(TilingCaseMatmulUnary))]
     // [ClassData(typeof(TilingCaseLayerNorm))]
-    [ClassData(typeof(TilingCaseGather))]
+    // [ClassData(typeof(TilingCaseGather))]
     // [ClassData(typeof(TilingCaseSoftmax))]
     // [ClassData(typeof(TilingCaseSlice))]
     // [ClassData(typeof(TilingCaseConcat))]

From a94136a1247a5e24b4cc0402f5d5f8e57a62e409 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 22 Sep 2023 11:00:12 +0800
Subject: [PATCH 203/308] fix to slicing

---
 .../CodeGen/CSourceExtensions.cs              | 19 +++++++++++++++++--
 modules/cpu/src/runtime/cmodel/CMakeLists.txt | 12 +++++++-----
 modules/cpu/src/runtime/elfloader.h           |  2 +-
 modules/cpu/src/runtime/runtime_utils.h       |  4 ++++
 4 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index e58a9dd474..576d8c5fcf 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -47,11 +47,26 @@ public static string ToC(this PrimType primType) =>
     public static string ToSlicing(this TensorType tensorType, string[] begins, IRArray<SBP> ndsbp, Placement placement)
     {
         var hstrides = TensorUtilities.GetStrides(placement.Hierarchy.ToArray());
+        var splits = Enumerable.Range(0, begins.Length).Select(_ => new List<(int H, SBPSplit S)>()).ToArray();
         foreach (var (sbp, i) in ndsbp.Select((s, i) => (s, i)))
         {
-            if (sbp is SBPSplit { Axis: int axis })
+            if (sbp is SBPSplit { Axis: int axis } split)
             {
-                begins[axis] += $" + ({tensorType.Shape[axis]} * {hstrides[i]} * {placement.Name[i]}id)";
+                splits[axis].Add((i, split));
+            }
+        }
+
+        foreach (var splist in splits)
+        {
+            splist.Sort((a, b) => a.H.CompareTo(b.H));
+        }
+
+        for (int i = 0; i < begins.Length; i++)
+        {
+            var sp = splits[i];
+            if (sp.Count > 0)
+            {
+                begins[i] += " + " + sp.Skip(1).Aggregate($"{placement.Name[sp[0].H]}id", (acc, p) => $"({acc} + {placement.Hierarchy[p.H]} * {placement.Name[p.H]}id)");
             }
         }
 
diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index de2b939392..2e5ddae39c 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -37,8 +37,10 @@ endfunction(add_test)
 
 # add_test(demo1 tests/demo1)
 # add_test(demo2 tests/demo2)
-add_test(decoder_layer tests/decoder_layer)
-add_test(norm tests/norm)
-add_test(embed tests/embed)
-add_test(head tests/head)
-add_test(unary tests/unary)
+if(NOT MSVC AND NOT APPLE)
+  add_test(decoder_layer tests/decoder_layer)
+  add_test(norm tests/norm)
+  add_test(embed tests/embed)
+  add_test(head tests/head)
+  add_test(unary tests/unary)
+endif(NOT MSVC AND NOT APPLE)
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/elfloader.h b/modules/cpu/src/runtime/elfloader.h
index b8f5c86905..822aabb249 100644
--- a/modules/cpu/src/runtime/elfloader.h
+++ b/modules/cpu/src/runtime/elfloader.h
@@ -7,8 +7,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#if defined(__linux__)
 #include "method_table_impl.h"
+#if defined(__linux__)
 #include <sys/mman.h>
 #endif
 
diff --git a/modules/cpu/src/runtime/runtime_utils.h b/modules/cpu/src/runtime/runtime_utils.h
index 7865c4f4fc..41e96ced88 100644
--- a/modules/cpu/src/runtime/runtime_utils.h
+++ b/modules/cpu/src/runtime/runtime_utils.h
@@ -6,7 +6,11 @@
 #include <cmath>
 #include <cstddef>
 #include <iostream>
+#if defined(__linux__)
 #include <linux/limits.h>
+#elif defined(__APPLE__)
+#include <pthread.h>
+#endif
 #include <nncase/runtime/cpu/compiler_defs.h>
 #include <numeric>
 #include <vector>

From 87df2c1f539700c4fee9f9ee4a65d7e579852be7 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 22 Sep 2023 11:26:07 +0800
Subject: [PATCH 204/308] fix negative axis

---
 .../CodeGen/CSourceConvertVisitor.cs                 |  6 ++++--
 src/Nncase.Evaluator/NN/Softmax.cs                   | 12 ++++++++++--
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 1e1a547941..e9b96e1d94 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -337,7 +337,8 @@ protected override CSymbol VisitCall(Call expr)
                     IndentScope.Writer.Write($"gather({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {gather.Axis})");
                     break;
                 case IR.XPU.Concat concat:
-                    IndentScope.Writer.Write($"concat({{{string.Join(",", args.SkipLast(1).Select(Visit).Select(s => "&" + s.Name))}}}, {Visit(args[^1]).Name}, {concat.Axis})");
+                    var positiveAxis = concat.Axis > 0 ? concat.Axis : concat.Axis + ((TensorType)args[0].CheckedType).Shape.Rank;
+                    IndentScope.Writer.Write($"concat({{{string.Join(",", args.SkipLast(1).Select(Visit).Select(s => "&" + s.Name))}}}, {Visit(args[^1]).Name}, {positiveAxis})");
                     break;
                 case IR.XPU.Slice slice:
                     var begins = ((TensorConst)expr.Arguments[2]).Value.ToArray<int>();
@@ -370,7 +371,8 @@ protected override CSymbol VisitCall(Call expr)
                     IndentScope.Writer.Write($"__tensor_copy_sync(std::move({Visit(expr.Arguments[1]).Name}), {Visit(expr.Arguments[0]).Name}({{{string.Join(',', newbegins.Select(e => e.ToString()))}}},{{{string.Join(',', newends.Select(e => e.ToString()))}}}))");
                     break;
                 case IR.XPU.Softmax softmax:
-                    IndentScope.Writer.Write($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {softmax.Axis})");
+                    positiveAxis = softmax.Axis > 0 ? softmax.Axis : softmax.Axis + ((TensorType)args[0].CheckedType).Shape.Rank;
+                    IndentScope.Writer.Write($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {positiveAxis})");
                     break;
                 case IR.XPU.Transpose transpose:
                     IndentScope.Writer.Write($"transpose({Visit(args[0]).Name}, {Visit(args[1]).Name}, {{{string.Join(",", transpose.Perm.Select(p => p.ToString()))}}})");
diff --git a/src/Nncase.Evaluator/NN/Softmax.cs b/src/Nncase.Evaluator/NN/Softmax.cs
index 7b02112b8f..a56a3d3dee 100644
--- a/src/Nncase.Evaluator/NN/Softmax.cs
+++ b/src/Nncase.Evaluator/NN/Softmax.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
+using System.Linq;
 using Nncase.CostModel;
 using Nncase.IR;
 using Nncase.IR.NN;
@@ -82,10 +83,11 @@ public IValue Visit(IEvaluateContext context, Softmax softMax)
     public IRType Visit(ITypeInferenceContext context, Softmax target)
     {
         var input = context.CheckArgumentType<IRType>(target, Softmax.Input);
+        var axis = context.GetArgument(target, Softmax.Axis);
         return input switch
         {
             TensorType t => Visit(t),
-            DistributedType d => Visit(d),
+            DistributedType d => Visit(d, axis),
             _ => new InvalidType(input.GetType().Name),
         };
     }
@@ -124,8 +126,14 @@ private IRType Visit(TensorType input)
         return input;
     }
 
-    private IRType Visit(DistributedType input)
+    private IRType Visit(DistributedType input, Expr axisExpr)
     {
+        var axis = ((TensorConst)axisExpr).Value.ToScalar<int>();
+        if (input.NdSBP.Any(sbp => sbp is SBPSplit s && s.Axis == axis switch { >= 0 => axis, _ => axis + input.TensorType.Shape.Rank }))
+        {
+            return new InvalidType("Not support split on Axis for Softmax now.");
+        }
+
         return input;
     }
 }

From e7fa1248764c6e8cc3e7477248f0f30ea98aa345 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 22 Sep 2023 12:03:34 +0800
Subject: [PATCH 205/308] fix matmul evaluator

---
 src/Nncase.Evaluator/Math/MatMul.cs           |  2 +-
 .../Distributed/UnitTestTypeInfer.cs          | 42 ++++++++++++-------
 2 files changed, 27 insertions(+), 17 deletions(-)

diff --git a/src/Nncase.Evaluator/Math/MatMul.cs b/src/Nncase.Evaluator/Math/MatMul.cs
index 23c9aaff22..2862e7234c 100644
--- a/src/Nncase.Evaluator/Math/MatMul.cs
+++ b/src/Nncase.Evaluator/Math/MatMul.cs
@@ -32,7 +32,7 @@ public static IRType VisitDistributedType(DistributedType a, DistributedType b)
         }
 
         var aRank = a.TensorType.Shape.Rank;
-        var bRank = a.TensorType.Shape.Rank;
+        var bRank = b.TensorType.Shape.Rank;
 
         var ndsbp = new SBP[a.Placement.Rank];
         for (int i = 0; i < a.Placement.Rank; i++)
diff --git a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
index bd31d8e2cd..868bde5898 100644
--- a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
@@ -142,21 +142,31 @@ internal sealed class InferMatmulData : TheoryData<DistributedType, DistributedT
     public InferMatmulData()
     {
         var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
-        var lhs = new[] { 1, 64, 384, 8192 };
-        var rhs = new[] { 1, 64, 8192, 384 };
-        var o = new[] { 1, 64, 384, 384 };
-
-        Add(
-            new(new(DataTypes.Float32, new[] { 1, 1, 384, 8192 }), new[] { SBP.S(2), SBP.S(2) }, placement),
-            new(new(DataTypes.Float32, new[] { 1, 64, 8192, 128 }), new SBP[] { SBP.S(2), SBP.S(2) }, placement),
-            new InvalidType(string.Empty));
-        Add(
-            new(new(DataTypes.Float32, lhs), new[] { SBP.S(1), SBP.S(2) }, placement),
-            new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(1), SBP.B }, placement),
-            new DistributedType(new(DataTypes.Float32, o), new[] { SBP.S(1), SBP.S(2) }, placement));
-        Add(
-            new(new(DataTypes.Float32, lhs), new[] { SBP.S(1), SBP.S(3) }, placement),
-            new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(1), SBP.S(2) }, placement),
-            new DistributedType(new(DataTypes.Float32, o), new SBP[] { SBP.S(1), SBP.P }, placement));
+        {
+            var lhs = new[] { 1, 384, 8192 };
+            var rhs = new[] { 8192, 8192 };
+            Add(
+                new(new(DataTypes.Float32, lhs), new SBP[] { SBP.S(1), SBP.B }, placement),
+                new(new(DataTypes.Float32, rhs), new SBP[] { SBP.B, SBP.S(0) }, placement),
+                new InvalidType(string.Empty));
+        }
+
+        {
+            var lhs = new[] { 1, 64, 384, 8192 };
+            var rhs = new[] { 1, 64, 8192, 384 };
+            var o = new[] { 1, 64, 384, 384 };
+            Add(
+                new(new(DataTypes.Float32, new[] { 1, 1, 384, 8192 }), new[] { SBP.S(2), SBP.S(2) }, placement),
+                new(new(DataTypes.Float32, new[] { 1, 64, 8192, 128 }), new SBP[] { SBP.S(2), SBP.S(2) }, placement),
+                new InvalidType(string.Empty));
+            Add(
+                new(new(DataTypes.Float32, lhs), new[] { SBP.S(1), SBP.S(2) }, placement),
+                new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(1), SBP.B }, placement),
+                new DistributedType(new(DataTypes.Float32, o), new[] { SBP.S(1), SBP.S(2) }, placement));
+            Add(
+                new(new(DataTypes.Float32, lhs), new[] { SBP.S(1), SBP.S(3) }, placement),
+                new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(1), SBP.S(2) }, placement),
+                new DistributedType(new(DataTypes.Float32, o), new SBP[] { SBP.S(1), SBP.P }, placement));
+        }
     }
 }

From 73b15369a73ca6230c69d19e24520a4a2303c69e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 22 Sep 2023 14:02:04 +0800
Subject: [PATCH 206/308] add NormAxis

---
 src/Nncase.Compiler/Compiler.cs             |  9 ++-
 src/Nncase.Evaluator/NN/Softmax.cs          |  2 +-
 src/Nncase.Importer/Onnx/Softmax.cs         |  2 +-
 src/Nncase.Passes/Rules/Neutral/NormAxis.cs | 64 +++++++++++++++++++++
 4 files changed, 70 insertions(+), 7 deletions(-)
 create mode 100644 src/Nncase.Passes/Rules/Neutral/NormAxis.cs

diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 53ca97ea13..df10a630cf 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -93,13 +93,12 @@ public void AddPreAndPostProcess(IPassManager passManager)
 
     public void TargetIndependentPass(IPassManager passManager)
     {
-        passManager.AddWithName<DataflowPass>("ReshapeMatMul").Configure(p =>
+        passManager.AddWithName<DataflowPass>("NormAxisAndShape").Configure(p =>
         {
             p.Add<Passes.Rules.Neutral.ReshapeMatMul>();
-        });
-
-        passManager.AddWithName<DataflowPass>("SqueezeShape").Configure(p =>
-        {
+            p.Add<Passes.Rules.Neutral.NormAxisGather>();
+            p.Add<Passes.Rules.Neutral.NormAxisConcat>();
+            p.Add<Passes.Rules.Neutral.NormAxisReduce>();
             p.Add<Passes.Rules.Neutral.SqueezeTransposeShape>();
             p.Add<Passes.Rules.Neutral.Squeeze5DTranspose>();
             p.Add<Passes.Rules.Neutral.SqueezeBinaryShape>();
diff --git a/src/Nncase.Evaluator/NN/Softmax.cs b/src/Nncase.Evaluator/NN/Softmax.cs
index a56a3d3dee..c7640de82f 100644
--- a/src/Nncase.Evaluator/NN/Softmax.cs
+++ b/src/Nncase.Evaluator/NN/Softmax.cs
@@ -129,7 +129,7 @@ private IRType Visit(TensorType input)
     private IRType Visit(DistributedType input, Expr axisExpr)
     {
         var axis = ((TensorConst)axisExpr).Value.ToScalar<int>();
-        if (input.NdSBP.Any(sbp => sbp is SBPSplit s && s.Axis == axis switch { >= 0 => axis, _ => axis + input.TensorType.Shape.Rank }))
+        if (input.NdSBP.Any(sbp => sbp is SBPSplit s && s.Axis == axis))
         {
             return new InvalidType("Not support split on Axis for Softmax now.");
         }
diff --git a/src/Nncase.Importer/Onnx/Softmax.cs b/src/Nncase.Importer/Onnx/Softmax.cs
index cde4fbb3e6..acd65b9606 100644
--- a/src/Nncase.Importer/Onnx/Softmax.cs
+++ b/src/Nncase.Importer/Onnx/Softmax.cs
@@ -43,7 +43,7 @@ private Expr SoftmaxV13Process(in NodeProto op, Func<Expr, Expr, Expr> f)
         {
             var input = GetSingleInputExpr(op);
             var axis = GetIntAttribute(op, "axis", -1);
-            return f(input, axis);
+            return f(input, IR.F.Math.Select(axis < 0, (Rank(input) + axis)[0], axis));
         }
 
         private Expr SoftmaxV1(in NodeProto op)
diff --git a/src/Nncase.Passes/Rules/Neutral/NormAxis.cs b/src/Nncase.Passes/Rules/Neutral/NormAxis.cs
new file mode 100644
index 0000000000..7b23850ca3
--- /dev/null
+++ b/src/Nncase.Passes/Rules/Neutral/NormAxis.cs
@@ -0,0 +1,64 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Linq;
+using Nncase.IR;
+using Nncase.PatternMatch;
+using static Nncase.IR.TypePatternUtility;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.F.NN;
+using static Nncase.PatternMatch.F.Tensors;
+using static Nncase.PatternMatch.Utility;
+
+namespace Nncase.Passes.Rules.Neutral;
+
+[RuleGenerator]
+public sealed partial class NormAxisGather : RewriteRule<CallPattern>
+{
+    /// <inheritdoc/>
+    public override CallPattern Pattern { get; } = IsGather("gather", g => g.Axis < 0, IsWildcard("input") with { TypePattern = HasRank() }, IsWildcard("index") with { TypePattern = HasRank() });
+
+    private Expr? GetReplace(IR.Tensors.Gather gather, Expr input, Expr index)
+    {
+        return IR.F.Tensors.Gather(input, gather.Axis + input.CheckedShape.Rank, index);
+    }
+}
+
+[RuleGenerator]
+public sealed partial class NormAxisConcat : RewriteRule<CallPattern>
+{
+    /// <inheritdoc/>
+    public override CallPattern Pattern { get; } = IsConcat("concat", op => op.Axis < 0, IsTuple(IsVArgsRepeat("inputs", inputs =>
+    {
+        var ps = new Pattern[inputs.Length];
+        for (int i = 0; i < inputs.Length; i++)
+        {
+            ps[i] = IsWildcard(i.ToString()) with { TypePattern = HasRank() };
+        }
+
+        return ps;
+    })));
+
+    private Expr? GetReplace(IR.Tensors.Concat concat, IReadOnlyList<Expr> inputs)
+    {
+        return IR.F.Tensors.Concat(new IR.Tuple(inputs.ToArray()), concat.Axis + inputs[0].CheckedShape.Rank);
+    }
+}
+
+[RuleGenerator]
+public sealed partial class NormAxisReduce : RewriteRule<CallPattern>
+{
+    /// <inheritdoc/>
+    public override CallPattern Pattern { get; } = IsReduce("reduce", "call", _ => true, IsWildcard("input") with { TypePattern = HasRank() }, IsTensorConst("axes"), IsWildcard("initValue"), IsWildcard("keepDims"));
+
+    private Expr? GetReplace(IR.Math.Reduce reduce, Call call, Expr input, int[] axes, Expr initValue, Expr keepDims)
+    {
+        if (axes.Any(axis => axis < 0))
+        {
+            return IR.F.Tensors.Reduce(reduce.ReduceOp, input, axes.Select(axis => axis < 0 ? axis + input.CheckedShape.Rank : axis).ToArray(), initValue, keepDims);
+        }
+
+        return call;
+    }
+}

From 01123560baf859ba88d7939f8f79f252250e98ad Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 22 Sep 2023 16:38:57 +0800
Subject: [PATCH 207/308] fix ToSlice

---
 modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index 576d8c5fcf..2bd96464df 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -58,7 +58,7 @@ public static string ToSlicing(this TensorType tensorType, string[] begins, IRAr
 
         foreach (var splist in splits)
         {
-            splist.Sort((a, b) => a.H.CompareTo(b.H));
+            splist.Sort((a, b) => -a.H.CompareTo(b.H));
         }
 
         for (int i = 0; i < begins.Length; i++)
@@ -66,7 +66,7 @@ public static string ToSlicing(this TensorType tensorType, string[] begins, IRAr
             var sp = splits[i];
             if (sp.Count > 0)
             {
-                begins[i] += " + " + sp.Skip(1).Aggregate($"{placement.Name[sp[0].H]}id", (acc, p) => $"({acc} + {placement.Hierarchy[p.H]} * {placement.Name[p.H]}id)");
+                begins[i] += " + " + sp.Skip(1).Aggregate($"{placement.Name[sp[0].H]}id", (acc, p) => $"({acc} + {TensorUtilities.GetProduct(placement.Hierarchy[(p.H + 1)..])} * {placement.Name[p.H]}id)");
             }
         }
 

From 229e6aab86db7f8ac0a0e311b9ca2f1fbf9f4faf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 22 Sep 2023 20:06:54 +0800
Subject: [PATCH 208/308] fix matmul

---
 src/Nncase.Evaluator/Math/MatMul.cs           | 11 ++++++----
 .../Distributed/UnitTestTypeInfer.cs          | 20 +++++++++++++++++++
 2 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/src/Nncase.Evaluator/Math/MatMul.cs b/src/Nncase.Evaluator/Math/MatMul.cs
index 2862e7234c..15503eb2d3 100644
--- a/src/Nncase.Evaluator/Math/MatMul.cs
+++ b/src/Nncase.Evaluator/Math/MatMul.cs
@@ -33,6 +33,9 @@ public static IRType VisitDistributedType(DistributedType a, DistributedType b)
 
         var aRank = a.TensorType.Shape.Rank;
         var bRank = b.TensorType.Shape.Rank;
+        var oRank = outType.Shape.Rank;
+        var aPad = oRank - aRank;
+        var bPad = oRank - bRank;
 
         var ndsbp = new SBP[a.Placement.Rank];
         for (int i = 0; i < a.Placement.Rank; i++)
@@ -52,9 +55,9 @@ public static IRType VisitDistributedType(DistributedType a, DistributedType b)
                     }
                     else
                     {
-                        if (ax == bx)
+                        if ((ax + aPad) == (bx + bPad))
                         {
-                            ndsbp[i] = SBP.S(ax);
+                            ndsbp[i] = SBP.S(ax + aPad);
                         }
                         else
                         {
@@ -69,7 +72,7 @@ public static IRType VisitDistributedType(DistributedType a, DistributedType b)
                         return invalid;
                     }
 
-                    ndsbp[i] = SBP.S(ax);
+                    ndsbp[i] = SBP.S(ax + aPad);
                     break;
                 case (SBPBroadCast, SBPSplit { Axis: int bx }):
                     if (bx == bRank - 2)
@@ -77,7 +80,7 @@ public static IRType VisitDistributedType(DistributedType a, DistributedType b)
                         return invalid;
                     }
 
-                    ndsbp[i] = SBP.S(bx);
+                    ndsbp[i] = SBP.S(bx + bPad);
                     break;
                 default:
                     return invalid;
diff --git a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
index 868bde5898..bbd62c6762 100644
--- a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
@@ -142,6 +142,26 @@ internal sealed class InferMatmulData : TheoryData<DistributedType, DistributedT
     public InferMatmulData()
     {
         var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+        {
+            var lhs = new[] { 1, 1, 384, 8192 };
+            var rhs = new[] { 64, 8192, 128 };
+            var o = new[] { 1, 64, 384, 128 };
+            Add(
+                new(new(DataTypes.Float32, lhs), new SBP[] { SBP.B, SBP.B }, placement),
+                new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(0), SBP.S(0) }, placement),
+                new DistributedType(new(DataTypes.Float32, o), new SBP[] { SBP.S(1), SBP.S(1) }, placement));
+        }
+
+        {
+            var lhs = new[] { 1, 64, 384, 8192 };
+            var rhs = new[] { 64, 8192, 128 };
+            var o = new[] { 1, 64, 384, 128 };
+            Add(
+                new(new(DataTypes.Float32, lhs), new SBP[] { SBP.S(1), SBP.S(1) }, placement),
+                new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(0), SBP.S(0) }, placement),
+                new DistributedType(new(DataTypes.Float32, o), new SBP[] { SBP.S(1), SBP.S(1) }, placement));
+        }
+
         {
             var lhs = new[] { 1, 384, 8192 };
             var rhs = new[] { 8192, 8192 };

From 50526719212111c07ffd0ccdbb8cbcb7e3813133 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 22 Sep 2023 20:09:13 +0800
Subject: [PATCH 209/308] add GatherReduceScatter

---
 .../CodeGen/CSourceConvertVisitor.cs            | 15 +++++++++++++++
 .../Evaluator/XPU/GatherReduceScatter.cs        | 17 +++++++++++++++++
 .../Evaluator/XPU/XPUModule.cs                  |  1 +
 modules/Nncase.Modules.CPU/IR/XPU/Functional.cs |  5 +++++
 .../IR/XPU/GatherReduceScatter.cs               | 13 +++++++++++++
 .../Passes/Tile/TIRConvertVisitor.cs            | 12 ++++++++++--
 6 files changed, 61 insertions(+), 2 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/GatherReduceScatter.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/GatherReduceScatter.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index e9b96e1d94..77874e0e48 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -379,6 +379,21 @@ protected override CSymbol VisitCall(Call expr)
                     break;
                 case IR.XPU.ReShape reshape:
                     IndentScope.Writer.Write($"__tensor_copy_sync(std::move({Visit(args[1]).Name}),std::move(view({Visit(args[0]).Name},{{{args[1].CheckedShape.ToString()[1..^1]}}})))");
+                    break;
+                case IR.XPU.GatherReduceScatter grs:
+                    if (grs.ReducePosition.Count == 2)
+                    {
+                        IndentScope.Writer.IndWrite($"tdma_all_reduce_async({Visit(args[0]).Name}, {Visit(args[1]).Name}, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
+                    }
+                    else if (grs.ReducePosition[0] == 0)
+                    {
+                        IndentScope.Writer.IndWrite($"tdma_all_reduce_async({Visit(args[0]).Name}, {Visit(args[1]).Name}, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
+                    }
+                    else
+                    {
+                        IndentScope.Writer.IndWrite($"tdma_reduce_async({Visit(args[0]).Name}, {Visit(args[1]).Name}, reduce_op_t::sum, ctx);\n");
+                    }
+
                     break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/GatherReduceScatter.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/GatherReduceScatter.cs
new file mode 100644
index 0000000000..2ec6502918
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/GatherReduceScatter.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public class GatherReduceScatterEvaluator : ITypeInferencer<GatherReduceScatter>
+{
+    public IRType Visit(ITypeInferenceContext context, GatherReduceScatter target)
+    {
+        _ = context.CheckArgumentType<IRType>(target, GatherReduceScatter.Input);
+        _ = context.CheckArgumentType<IRType>(target, GatherReduceScatter.Output);
+        return TupleType.Void;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index ff790c9ac9..7616204df3 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -27,5 +27,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<SoftmaxEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<TransposeEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<ReShapeEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<GatherReduceScatterEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 01bbaa1ecb..8e9f3c8df0 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -71,4 +71,9 @@ public static Call ReShape(Expr input, Expr output)
     {
         return new Call(new IR.XPU.ReShape(), input, output);
     }
+
+    public static Call GatherReduceScatter(Expr input, Expr output, int[] reducePosition)
+    {
+        return new Call(new GatherReduceScatter(reducePosition), input, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/GatherReduceScatter.cs b/modules/Nncase.Modules.CPU/IR/XPU/GatherReduceScatter.cs
new file mode 100644
index 0000000000..81ef62b1fc
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/GatherReduceScatter.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class GatherReduceScatter : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(GatherReduceScatter), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(GatherReduceScatter), 1, "output");
+
+    public IRArray<int> ReducePosition { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 7fcc987fcd..d5b32b61f4 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -117,8 +117,16 @@ private void GenerateBoxing(IR.CPU.Boxing boxing, Buffer[] arguments, Buffer ret
                 break;
             case (DistributedType inType, DistributedType outType):
                 {
-                    _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], None.Default, inType.NdSBP, inType.Placement));
-                    _mainBody.Add(IR.F.XPU.TDMALoad(ret, None.Default, outType.NdSBP, outType.Placement));
+                    var partialSumPos = Enumerable.Range(0, inType.NdSBP.Count).Where(i => inType.NdSBP[i] is SBPPartialSum).ToArray();
+                    if (partialSumPos.Length > 0)
+                    {
+                        _mainBody.Add(IR.F.XPU.GatherReduceScatter(arguments[0], ret, partialSumPos));
+                    }
+                    else
+                    {
+                        _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], None.Default, inType.NdSBP, inType.Placement));
+                        _mainBody.Add(IR.F.XPU.TDMALoad(ret, None.Default, outType.NdSBP, outType.Placement));
+                    }
                 }
 
                 break;

From 5a793d70f3ee3cd206640c39804a278b335f0e3a Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 25 Sep 2023 12:05:42 +0800
Subject: [PATCH 210/308] fix ToSlice

---
 modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index 2bd96464df..4ff250563b 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -66,7 +66,7 @@ public static string ToSlicing(this TensorType tensorType, string[] begins, IRAr
             var sp = splits[i];
             if (sp.Count > 0)
             {
-                begins[i] += " + " + sp.Skip(1).Aggregate($"{placement.Name[sp[0].H]}id", (acc, p) => $"({acc} + {TensorUtilities.GetProduct(placement.Hierarchy[(p.H + 1)..])} * {placement.Name[p.H]}id)");
+                begins[i] += " + " + sp.Skip(1).Aggregate($"{placement.Name[sp[0].H]}id", (acc, p) => $"({acc} + {TensorUtilities.GetProduct(placement.Hierarchy[(p.H + 1)..])} * {placement.Name[p.H]}id)") + $" * {tensorType.Shape[i]}";
             }
         }
 

From 75d722977dda8f576628df2ff2d391043d4ff705 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 25 Sep 2023 13:53:30 +0800
Subject: [PATCH 211/308] refactor auto dist

---
 .../Tile/AutoDistributedConvertVisitor.cs     | 330 ++++++++----------
 .../Utilities/DistributedUtility.cs           |  36 ++
 .../Distributed/UnitTestConstruct.cs          |  11 +
 src/Nncase.Tests/Distributed/UnitTestCost.cs  |   5 +-
 .../Targets/UnitTestCPUTargetTiling.cs        |  42 ++-
 5 files changed, 223 insertions(+), 201 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
index 08a3723d54..34402eb7a1 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
@@ -11,15 +11,12 @@
 
 namespace Nncase.Passes.Tile;
 
-internal sealed class AutoDistributedConvertVisitor : ExprVisitor<IReadOnlyList<Expr>, Unit>
+internal sealed class AutoDistributedConvertVisitor : ExprVisitor<Dictionary<IRType, List<Expr>>, Unit>
 {
-    private readonly Dictionary<Expr, Expr> _originMap;
-
     public AutoDistributedConvertVisitor(TileOptions tileOptions)
     {
         TileOptions = tileOptions;
         Placement = new Placement(Placement.DeviceKind.CPU, tileOptions.Hierarchy, "bt");
-        _originMap = new Dictionary<Expr, Expr>(ReferenceEqualityComparer.Instance);
     }
 
     public TileOptions TileOptions { get; }
@@ -28,144 +25,172 @@ public AutoDistributedConvertVisitor(TileOptions tileOptions)
 
     public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement placement)
     {
-        return Utilities.DistributedUtility.GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).Select(ndsbp => IR.F.CPU.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).ToArray();
+        return Utilities.DistributedUtility.GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).
+            Select(ndsbp => IR.F.CPU.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).
+            ToArray();
     }
 
-    /// <summary>
-    /// when input expression sbp is partial, get the new candidate boxings.
-    /// </summary>
-    /// <param name="expr">input expression.</param>
-    /// <returns>the boxings.</returns>
-    /// <exception cref="NotSupportedException">when expr is tuple.</exception>
-    public static IReadOnlyList<Expr> GetPartialCandidateBoxings(Expr expr)
+    public Expr Convert(Expr body)
     {
-        if (expr is IR.Tuple tuple)
-        {
-            var candidates = tuple.Fields.ToArray().
-                Select(GetPartialCandidateBoxings).
-                CartesianProduct();
-            return candidates.Any() ? candidates.
-                Select(fs => new IR.Tuple(fs.ToArray())).
-                ToArray() : Array.Empty<Expr>();
-        }
-
-        var type = (DistributedType)expr.CheckedType;
-        if (!type.NdSBP.Any(sbp => sbp is SBPBroadCast))
+        var equivalents = Visit(body).Select(g => IR.F.CPU.Boxing(g.Value[0], body.CheckedType)).ToArray();
+        using (new ExprPinner(equivalents))
         {
-            return Array.Empty<Expr>();
+            BranchCut();
         }
 
-        var tensorType = type.TensorType;
-        var candidateNdsbps = new List<SBP>[type.Placement.Rank];
-        for (int i = 0; i < type.Placement.Rank; i++)
+        var graph = new EGraph();
+        foreach (var (exprKey, buckets) in ExprMemo.Where(kv => kv.Key is not Op))
         {
-            candidateNdsbps[i] = new List<SBP>();
-            if (type.NdSBP[i] is SBPPartialSum)
+            foreach (var (typeKey, bucket) in buckets.Where(kv => kv.Value.Any()))
             {
-                candidateNdsbps[i].Add(SBP.B);
-                for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
-                {
-                    if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && Utilities.DistributedUtility.IsDivisible(s, type.Placement.Hierarchy[i]))
-                    {
-                        candidateNdsbps[i].Add(SBP.S(axis));
-                    }
-                }
+                Unions(graph, bucket);
             }
         }
 
-        return candidateNdsbps.CartesianProduct().
-            Select(ndsbp => new DistributedType(tensorType, new IRArray<SBP>(ndsbp), type.Placement)).
-            Select(disttype => IR.F.CPU.Boxing(expr, disttype)).ToArray();
-    }
-
-    public Expr Convert(Expr body)
-    {
-        var equivalents = Visit(body).Select(newbody => IR.F.CPU.Boxing(newbody, body.CheckedType)).ToArray();
-        var graph = new EGraph();
-        var bodyEclasses = equivalents.Select(graph.Add).ToArray();
-        foreach (var cls in bodyEclasses.Skip(1))
-        {
-            graph.Union(bodyEclasses[0], cls);
-        }
-
-        graph.Rebuild();
-        return graph.Extract(bodyEclasses[0], null, out _);
+        var root = Unions(graph, equivalents);
+        return graph.Extract(root, null, out _);
     }
 
-    protected override IReadOnlyList<Expr> DefaultVisitLeaf(Expr expr)
+    protected override Dictionary<IRType, List<Expr>> DefaultVisitLeaf(Expr expr)
     {
-        return Array.Empty<Expr>();
+        return new();
     }
 
-    protected override IReadOnlyList<Expr> VisitLeafTuple(IR.Tuple expr)
+    protected override Dictionary<IRType, List<Expr>> VisitLeafTuple(IR.Tuple expr)
     {
-        return UpdateEquivalents(expr.Fields.ToArray().Select(Visit).CartesianProduct().Select(e => new IR.Tuple(e.ToArray())).ToArray(), expr);
+        return expr.Fields.ToArray().
+                Select(Visit).
+                CartesianProduct().
+                Select(e => new IR.Tuple(e.Select(e => e.Value[0]).ToArray())).
+                GroupBy(tp => tp.CheckedType).
+                ToDictionary(g => g.Key, g => g.ToList<Expr>());
     }
 
-    protected override IReadOnlyList<Expr> VisitLeafCall(Call expr)
+    protected override Dictionary<IRType, List<Expr>> VisitLeafCall(Call expr)
     {
         if (expr.Target is not Op op)
         {
             throw new NotSupportedException("not support auto distributed call function");
         }
 
-        var equivalArgs = op.Parameters.
-            Select(param => VisitLeafArgument(param.ParameterKind, expr.Arguments[param.Index])).ToArray();
-        var candidateEquivalCalls = equivalArgs.
-            CartesianProduct().
-            Select(args => args.ToArray()).
-            Select(args => BuildEquivalCalls(op, args)).
-            SelectMany(i => i).
-            ToArray();
-
-        if (candidateEquivalCalls.Any(t => t.Valid))
+        foreach (var param in op.Parameters)
         {
-            return UpdateEquivalents(Canonicalize(candidateEquivalCalls.Where(t => t.Valid).Select(t => t.Call)), expr);
+            VisitLeafArgument(param.ParameterKind, expr.Arguments[param.Index]);
         }
 
-        var boxingArgs = op.Parameters.Select(param => param.ParameterKind switch
+        return expr.Arguments.ToArray().
+                    Select(Visit).
+                    CartesianProduct().
+                    Select(args => args.ToArray()).
+                    Select(args => BuildEquivalCalls(op, args.Select(kv => kv.Value[0]).ToArray()).ToArray()).
+                    SelectMany(i => i).
+                    GroupBy(c => c.CheckedType).
+                    ToDictionary(g => g.Key, g => new List<Expr>(g.ToList<Expr>()));
+    }
+
+    private Dictionary<IRType, List<Expr>> VisitLeafArgument(ParameterKind parameterKind, Expr expr)
+    {
+        var updateBuckets = (Dictionary<IRType, List<Expr>> buckets, IEnumerable<Expr> equivalents) =>
+        {
+            foreach (var eq in equivalents)
             {
-                ParameterKind.Input => ExprMemo[expr.Arguments[param.Index]].Select(GetReBoxings).SelectMany(i => i),
-                ParameterKind.Attribute => ExprMemo[expr.Arguments[param.Index]],
-                _ => throw new NotSupportedException(),
-            }).ToArray();
-
-        var candidateBoxingCalls = boxingArgs.
-            CartesianProduct().
-            Select(args => args.ToArray()).
-            Select(args => new Call(op, args)).
-            Select<Call, (bool Valid, Call Call)>(c => (c.InferenceType(), c)).
-            ToArray();
+                if (!buckets.TryGetValue(eq.CheckedType, out var bucket))
+                {
+                    bucket = new();
+                    buckets.Add(eq.CheckedType, bucket);
+                }
+
+                bucket.Add(eq);
+            }
+        };
 
-        if (candidateBoxingCalls.Any(t => t.Valid))
+        var buckets = ExprMemo[expr];
+        if (!buckets.Any())
         {
-            return UpdateEquivalents(Canonicalize(candidateBoxingCalls.Where(t => t.Valid).Select(t => t.Call)), expr);
+            switch (parameterKind, expr)
+            {
+                case (ParameterKind.Input, Expr e) when e is Const or Var:
+                    updateBuckets(buckets, GetLeafCandidateBoxings(e, Placement));
+                    break;
+                case (ParameterKind.Input, Expr e) when e is IR.Tuple tp:
+                    foreach (var f in tp.Fields)
+                    {
+                        VisitLeafArgument(parameterKind, f);
+                    }
+
+                    foreach (var (k, v) in VisitLeafTuple(tp))
+                    {
+                        buckets.Add(k, v);
+                    }
+
+                    break;
+                case (ParameterKind.Attribute, Var e):
+                    updateBuckets(buckets, new[] { e });
+                    break;
+                case (ParameterKind.Attribute, TensorConst e):
+                    updateBuckets(buckets, new[] { e.With() }); // remove all old users.
+                    break;
+                default:
+                    throw new InvalidOperationException();
+            }
         }
 
-        throw new InvalidDataException("after reboxing still can't infer!");
+        return buckets;
     }
 
-    private IReadOnlyList<Expr> VisitLeafArgument(ParameterKind parameterKind, Expr expr)
+    private IEnumerable<Call> BuildEquivalCalls(Op target, Expr[] args)
     {
-        IReadOnlyList<Expr> equivalents;
-        if (!ExprMemo[expr].Any())
+        if (!target.Parameters.Where(p => p.ParameterKind == ParameterKind.Input).All(p => IsDistributed(args[p.Index].CheckedType)))
+        {
+            throw new InvalidDataException();
+        }
+
+        var calls = new List<Call>();
+        var call = new Call(target, args);
+        var valid = call.InferenceType();
+        if (!valid)
         {
-            equivalents = (parameterKind, expr) switch
+            // 1. dispose current call
+            using var pinner = new ExprPinner(args);
+            call.Dispose();
+
+            if (target is CPUKernelOp { Target: Reshape } || target is Reshape)
+            {
+                // the reshape need force boxing.
+                var newShape = ((TensorConst)args[1]).Value.ToArray<int>();
+                var inType = (DistributedType)args[0].CheckedType;
+                var tensorType = inType.TensorType with { Shape = newShape };
+                foreach (var boxing in Utilities.DistributedUtility.GetLeafCandidateNDSBPs(tensorType, inType.Placement).
+                    Select(ndsbp => IR.F.CPU.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))))
+                {
+                    if (boxing.CheckedType is InvalidType)
+                    {
+                        boxing.Dispose();
+                    }
+                    else
+                    {
+                        calls.Add(boxing);
+                    }
+                }
+            }
+            else
             {
-                (ParameterKind.Input, Expr e) when e is Const or Var => GetLeafCandidateBoxings(e, Placement),
-                (ParameterKind.Input, Expr e) when e is IR.Tuple tp => tp.Fields.ToArray().Select(f => VisitLeafArgument(parameterKind, f)).CartesianProduct().Select(e => new IR.Tuple(e.ToArray())).ToArray(),
-                (ParameterKind.Attribute, Expr e) when e is Const or Var => new[] { e },
-                _ => throw new InvalidOperationException(),
-            };
-            ExprMemo[expr] = equivalents;
-            UpdateEquivalents(equivalents, expr);
+                // todo expand search space.
+                // calls.AddRange(Utilities.DistributedUtility.GetLeafCandidateNDSBPs(tensorType, inType.Placement).
+                // Select(ndsbp => IR.F.CPU.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))));
+            }
         }
         else
         {
-            equivalents = ExprMemo[expr];
+            calls.Add(call);
+            if (call.CheckedType is DistributedType distributedType)
+            {
+                calls.AddRange(Utilities.DistributedUtility.GetPartialCandidateNDSBPs(distributedType).
+                    Select(ndsbp => IR.F.CPU.Boxing(call, distributedType with { NdSBP = ndsbp })));
+            }
         }
 
-        return equivalents;
+        return calls;
     }
 
     private IReadOnlyList<Expr> GetReBoxings(Expr expr)
@@ -202,99 +227,50 @@ private IReadOnlyList<Expr> GetReBoxings(Expr expr)
             Select(disttype => IR.F.CPU.Boxing(expr, disttype)).ToArray();
     }
 
-    private IEnumerable<(bool Valid, Call Call)> BuildEquivalCalls(Op target, Expr[] args)
+    private bool IsDistributed(IRType type) => type switch
     {
-        if (!target.Parameters.Where(p => p.ParameterKind == ParameterKind.Input).All(p => IsDistributed(args[p.Index].CheckedType)))
-        {
-            throw new InvalidDataException();
-        }
+        DistributedType => true,
+        TupleType t => t.All(IsDistributed),
+        _ => false,
+    };
 
-        var calls = new List<(bool, Call)>();
-        var call = new Call(target, args);
-        var valid = call.InferenceType();
-        calls.Add((valid, call));
-        if (!valid)
+    private EClass Unions(EGraph graph, IEnumerable<Expr> equivalents)
+    {
+        var eids = equivalents.Select(graph.Add).ToArray();
+        foreach (var cls in eids.Skip(1))
         {
-            if (target is CPUKernelOp { Target: Reshape } || target is Reshape)
-            {
-                // the reshape need force boxing.
-                var newShape = ((TensorConst)args[1]).Value.ToArray<int>();
-                var inType = (DistributedType)args[0].CheckedType;
-                var tensorType = inType.TensorType with { Shape = newShape };
-                calls.AddRange(Utilities.DistributedUtility.GetLeafCandidateNDSBPs(tensorType, inType.Placement).
-                    Select(ndsbp => IR.F.CPU.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))).
-                    Select(c => (c.InferenceType(), c)));
-            }
-            else
-            {
-                // when args have partial, we need boxing args.
-                var broadcastArgs = args.Zip(target.Parameters).Select(t => t.Second.ParameterKind == ParameterKind.Input ? GetPartialCandidateBoxings(t.First) : Array.Empty<Expr>()).ToArray();
-
-                if (!broadcastArgs.All(bargs => bargs.Count == 0))
-                {
-                    calls.AddRange(broadcastArgs.Select((bargs, i) => bargs.Any() ? UpdateEquivalents(bargs, _originMap[args[i]]) : bargs.Concat(new[] { args[i] })).
-                        CartesianProduct().
-                        Select(bargs => bargs.ToArray()).
-                        Select(bargs => new Call(target, bargs)).
-                        Select(c => (c.InferenceType(), c)));
-                }
-            }
+            graph.Union(eids[0], cls);
         }
 
-        return calls;
+        graph.Rebuild();
+        return eids[0];
     }
 
-    private IReadOnlyList<Expr> Canonicalize(IEnumerable<Call> candidateEquivalCalls)
+    private void BranchCut()
     {
-        var equivalCalls = new List<Expr>();
-        foreach (var group in candidateEquivalCalls.GroupBy(c => c.CheckedType))
+        bool changed = true;
+        while (changed)
         {
-            if (group.Count() > 1)
+            changed = false;
+            foreach (var (_, bukets) in ExprMemo)
             {
-                // extract group
-                var egrph = new EGraph();
-                var roots = group.Select(egrph.Add).ToArray();
-                foreach (var r in roots.Skip(1))
-                {
-                    egrph.Union(roots[0], r);
-                }
-
-                egrph.Rebuild();
-                var best = egrph.Extract(roots[0], null, out var picks);
-                foreach (var (enode, picked) in picks)
+                foreach (var (_, buket) in bukets.Where(kv => kv.Value.Any()))
                 {
-                    if (!picked && _originMap.TryGetValue(enode.Expr, out var originExpr))
+                    if (!buket[0].Users.Any())
                     {
-                        ExprMemo[originExpr] = ExprMemo[originExpr].Where(e => !ReferenceEquals(e, enode.Expr)).ToArray();
-                        _originMap.Remove(enode.Expr);
+                        foreach (var item in buket)
+                        {
+                            using (new ExprPinner(item.Operands.ToArray()))
+                            {
+                                item.Dispose();
+                            }
+                        }
+
+                        buket.Clear();
+                        changed = true;
                     }
                 }
-
-                equivalCalls.Add(best);
-            }
-            else
-            {
-                equivalCalls.Add(group.First());
             }
         }
-
-        return equivalCalls;
-    }
-
-    private bool IsDistributed(IRType type) => type switch
-    {
-        DistributedType => true,
-        TupleType t => t.All(IsDistributed),
-        _ => false,
-    };
-
-    private IReadOnlyList<Expr> UpdateEquivalents(IReadOnlyList<Expr> equivalents, Expr origin)
-    {
-        foreach (var item in equivalents)
-        {
-            _originMap[item] = origin;
-        }
-
-        return equivalents;
     }
 }
diff --git a/src/Nncase.Core/Utilities/DistributedUtility.cs b/src/Nncase.Core/Utilities/DistributedUtility.cs
index bd899d45c4..68945a0287 100644
--- a/src/Nncase.Core/Utilities/DistributedUtility.cs
+++ b/src/Nncase.Core/Utilities/DistributedUtility.cs
@@ -33,6 +33,42 @@ public static IReadOnlyList<IRArray<SBP>> GetLeafCandidateNDSBPs(TensorType tens
            ToArray();
     }
 
+    public static IReadOnlyList<IRArray<SBP>> GetPartialCandidateNDSBPs(DistributedType distributedType)
+    {
+        IRArray<SBP> ndsbp = distributedType.NdSBP;
+        TensorType tensorType = distributedType.TensorType;
+        Placement placement = distributedType.Placement;
+        if (!ndsbp.Any(sbp => sbp is SBPPartialSum))
+        {
+            return Array.Empty<IRArray<SBP>>();
+        }
+
+        var candidateNdsbps = new List<SBP>[placement.Rank];
+        for (int i = 0; i < placement.Rank; i++)
+        {
+            candidateNdsbps[i] = new List<SBP>();
+            if (ndsbp[i] is SBPPartialSum)
+            {
+                candidateNdsbps[i].Add(SBP.B);
+                for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
+                {
+                    if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && IsDivisible(s, placement.Hierarchy[i]))
+                    {
+                        candidateNdsbps[i].Add(SBP.S(axis));
+                    }
+                }
+            }
+            else
+            {
+                candidateNdsbps[i].Add(ndsbp[i]);
+            }
+        }
+
+        return candidateNdsbps.CartesianProduct().
+            Select(ndsbp => new IRArray<SBP>(ndsbp)).
+            ToArray();
+    }
+
     public static bool IsDistributable(TensorType tensorType, ReadOnlySpan<SBP> ndsbp, Placement placement, [MaybeNullWhen(false)] out TensorType distType)
     {
         distType = null;
diff --git a/src/Nncase.Tests/Distributed/UnitTestConstruct.cs b/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
index b17cd94b54..d493375cf6 100644
--- a/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
@@ -76,6 +76,17 @@ public void TestDistributeTypeEqual()
         Assert.StrictEqual(a, b);
     }
 
+    [Fact]
+    public void TestBoxingEqual()
+    {
+        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
+        var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
+        var a = new IR.CPU.Boxing(new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement));
+        var b = new IR.CPU.Boxing(new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement));
+        Assert.Equal(a, b);
+        Assert.StrictEqual(a, b);
+    }
+
     [Fact]
     public void TestUnary()
     {
diff --git a/src/Nncase.Tests/Distributed/UnitTestCost.cs b/src/Nncase.Tests/Distributed/UnitTestCost.cs
index 096f571fda..72710f55ad 100644
--- a/src/Nncase.Tests/Distributed/UnitTestCost.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestCost.cs
@@ -30,8 +30,9 @@ public void TestPartialToBroadCastCost()
             new SBP[] { SBP.S(3), SBP.P },
          })
         {
-            var input0 = new Var(new DistributedType(tensorType, ndsbp, placement));
-            var candidates = Nncase.Passes.Tile.AutoDistributedConvertVisitor.GetPartialCandidateBoxings(input0);
+            var type = new DistributedType(tensorType, ndsbp, placement);
+            var input0 = new Var(type);
+            var candidates = Utilities.DistributedUtility.GetPartialCandidateNDSBPs(type).Select(ndsbp => IR.F.CPU.Boxing(input0, type with { NdSBP = ndsbp }));
             foreach (var item in candidates)
             {
                 var cost = CompilerServices.EvaluateCost(item);
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index bae9603660..6409a579c7 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -39,7 +39,6 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseBinaryMul))]
     // [ClassData(typeof(TilingCaseUnary))]
     // [ClassData(typeof(TilingCaseMatmul))]
-    // [ClassData(typeof(TilingCaseMatmulUnary))]
     // [ClassData(typeof(TilingCaseLayerNorm))]
     // [ClassData(typeof(TilingCaseGather))]
     // [ClassData(typeof(TilingCaseSoftmax))]
@@ -47,27 +46,27 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseConcat))]
     // [ClassData(typeof(TilingCaseTranspose))]
     // [ClassData(typeof(TilingCaseReshape1))]
-    [ClassData(typeof(TilingCaseReshape2))]
+    // [ClassData(typeof(TilingCaseReshape2))]
+    [ClassData(typeof(TilingCaseMatmulUnary))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
         using (new Diagnostics.DumpScope(main.Name, CompileOptions.DumpFlags))
         {
-#if DEBUG
-            for (var i = 0; i < inputs.Length - 1; i++)
-            {
-                using (var fs = Diagnostics.DumpScope.Current.OpenFile($"input_{i}.bin"))
-                {
-                    fs.Write(inputs[i].BytesBuffer);
-                }
-            }
-
-            using (var fs = Diagnostics.DumpScope.Current.OpenFile($"output_0.bin"))
-            {
-                fs.Write(inputs[^1].BytesBuffer);
-            }
-#endif
-
+            // #if DEBUG
+            //             for (var i = 0; i < inputs.Length - 1; i++)
+            //             {
+            //                 using (var fs = Diagnostics.DumpScope.Current.OpenFile($"input_{i}.bin"))
+            //                 {
+            //                     fs.Write(inputs[i].BytesBuffer);
+            //                 }
+            //             }
+
+            // using (var fs = Diagnostics.DumpScope.Current.OpenFile($"output_0.bin"))
+            //             {
+            //                 fs.Write(inputs[^1].BytesBuffer);
+            //             }
+            // #endif
             await Compile(module);
             var output = Testing.RunKModel(File.ReadAllBytes(Path.Join(Diagnostics.DumpScope.Current.Directory, "test.kmodel")), Diagnostics.DumpScope.Current.Directory, inputs);
             var cos = Tests.Comparator.CosSimilarity(output, Value.FromTensor(inputs[^1]))[0];
@@ -173,7 +172,7 @@ public TilingCaseMatmulLayerNorm()
     }
 }
 
-internal sealed class TilingCaseMHA : TheoryData<Function>
+internal sealed class TilingCaseMHA : TheoryData<Function, Tensor[]>
 {
     public TilingCaseMHA()
     {
@@ -208,7 +207,7 @@ public TilingCaseMHA()
         }
 
         var main = new Function("mha_qk", new Call(fusion, hid_in, pos_ids), new[] { hid_in, pos_ids });
-        Add(main);
+        Add(main, Array.Empty<Tensor>());
     }
 }
 
@@ -456,9 +455,8 @@ public TilingCaseTranspose()
         {
             { fin_a, Value.FromTensor(input_tensor) },
         };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        var main = new Function("transpose", new Call(fusion, in_a), new[] { in_a });
+        _ = fusion.Body.Evaluate(feedDict).AsTensor();
+        _ = new Function("transpose", new Call(fusion, in_a), new[] { in_a });
     }
 }
 

From ef13d5c274bea02f07c6133b52ad71cced46c333 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 25 Sep 2023 15:17:06 +0800
Subject: [PATCH 212/308] fix boxing partial to slice codegen

---
 .../CodeGen/CSourceConvertVisitor.cs          | 24 +++++++++++++++----
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  4 ++--
 .../IR/XPU/GatherReduceScatter.cs             |  4 +++-
 .../Passes/Tile/TIRConvertVisitor.cs          |  9 +++++--
 src/Nncase.Core/DistributedType.cs            | 15 +-----------
 5 files changed, 33 insertions(+), 23 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 77874e0e48..bc789be748 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -381,17 +381,33 @@ protected override CSymbol VisitCall(Call expr)
                     IndentScope.Writer.Write($"__tensor_copy_sync(std::move({Visit(args[1]).Name}),std::move(view({Visit(args[0]).Name},{{{args[1].CheckedShape.ToString()[1..^1]}}})))");
                     break;
                 case IR.XPU.GatherReduceScatter grs:
+                    var ret_name = Visit(args[1]).Name;
+                    bool reshard = args[0].CheckedType != args[1].CheckedType;
+                    if (reshard)
+                    {
+                        IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> {ret_name}_tmp({{{string.Join(",", args[0].CheckedShape)}}});\n");
+                    }
+                    else
+                    {
+                        IndentScope.Writer.IndWrite($"auto {ret_name}_tmp = &{ret_name};\n");
+                    }
+
                     if (grs.ReducePosition.Count == 2)
                     {
-                        IndentScope.Writer.IndWrite($"tdma_all_reduce_async({Visit(args[0]).Name}, {Visit(args[1]).Name}, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
+                        IndentScope.Writer.IndWrite($"tdma_all_reduce_async({Visit(args[0]).Name}, {ret_name}_tmp, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
                     }
-                    else if (grs.ReducePosition[0] == 0)
+                    else if (grs.ReducePosition[0].Hierarchy == 0)
                     {
-                        IndentScope.Writer.IndWrite($"tdma_all_reduce_async({Visit(args[0]).Name}, {Visit(args[1]).Name}, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
+                        IndentScope.Writer.IndWrite($"tdma_all_reduce_async({Visit(args[0]).Name}, {ret_name}_tmp, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
                     }
                     else
                     {
-                        IndentScope.Writer.IndWrite($"tdma_reduce_async({Visit(args[0]).Name}, {Visit(args[1]).Name}, reduce_op_t::sum, ctx);\n");
+                        IndentScope.Writer.IndWrite($"tdma_reduce_async({Visit(args[0]).Name}, {ret_name}_tmp, reduce_op_t::sum, ctx);\n");
+                    }
+
+                    if (reshard)
+                    {
+                        IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}), {ret_name}_tmp{((TensorType)args[1].CheckedType).ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)});\n");
                     }
 
                     break;
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 8e9f3c8df0..f5d2ecfb94 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -72,8 +72,8 @@ public static Call ReShape(Expr input, Expr output)
         return new Call(new IR.XPU.ReShape(), input, output);
     }
 
-    public static Call GatherReduceScatter(Expr input, Expr output, int[] reducePosition)
+    public static Call GatherReduceScatter(Expr input, Expr output, (int, SBP)[] reducePosition, Placement placement)
     {
-        return new Call(new GatherReduceScatter(reducePosition), input, output);
+        return new Call(new GatherReduceScatter(reducePosition, placement), input, output);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/GatherReduceScatter.cs b/modules/Nncase.Modules.CPU/IR/XPU/GatherReduceScatter.cs
index 81ef62b1fc..87588d26c4 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/GatherReduceScatter.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/GatherReduceScatter.cs
@@ -9,5 +9,7 @@ public sealed partial class GatherReduceScatter : XPUKernelOp
 
     public static readonly ParameterInfo Output = new(typeof(GatherReduceScatter), 1, "output");
 
-    public IRArray<int> ReducePosition { get; }
+    public IRArray<(int Hierarchy, SBP SBP)> ReducePosition { get; }
+
+    public Placement Placement { get; }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index d5b32b61f4..20a6d674a0 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -117,10 +117,15 @@ private void GenerateBoxing(IR.CPU.Boxing boxing, Buffer[] arguments, Buffer ret
                 break;
             case (DistributedType inType, DistributedType outType):
                 {
-                    var partialSumPos = Enumerable.Range(0, inType.NdSBP.Count).Where(i => inType.NdSBP[i] is SBPPartialSum).ToArray();
+                    var partialSumPos = Enumerable.Range(0, inType.NdSBP.Count).Where(i => inType.NdSBP[i] is SBPPartialSum).Select(i => (i, outType.NdSBP[i])).ToArray();
                     if (partialSumPos.Length > 0)
                     {
-                        _mainBody.Add(IR.F.XPU.GatherReduceScatter(arguments[0], ret, partialSumPos));
+                        var placement = inType.Placement with
+                        {
+                            Hierarchy = new IRArray<int>(partialSumPos.Select(t => inType.Placement.Hierarchy[t.i])),
+                            Name = new string(partialSumPos.Select(t => inType.Placement.Name[t.i]).ToArray()),
+                        };
+                        _mainBody.Add(IR.F.XPU.GatherReduceScatter(arguments[0], ret, partialSumPos, placement));
                     }
                     else
                     {
diff --git a/src/Nncase.Core/DistributedType.cs b/src/Nncase.Core/DistributedType.cs
index 56896ee266..6cbb61cb50 100644
--- a/src/Nncase.Core/DistributedType.cs
+++ b/src/Nncase.Core/DistributedType.cs
@@ -49,15 +49,8 @@ private SBPBroadCast()
     public override string ToString() => "B";
 }
 
-public sealed record Placement
+public sealed record Placement(Placement.DeviceKind Kind, IRArray<int> Hierarchy, string Name)
 {
-    public Placement(DeviceKind kind, IRArray<int> hierarchy, string name)
-    {
-        Kind = kind;
-        Hierarchy = hierarchy;
-        Name = name;
-    }
-
     /// <summary>
     /// The device kind type.
     /// </summary>
@@ -66,12 +59,6 @@ public enum DeviceKind : uint
         CPU = 0,
     }
 
-    public DeviceKind Kind { get; }
-
-    public IRArray<int> Hierarchy { get; }
-
-    public string Name { get; }
-
     public int Rank => Hierarchy.Count;
 
     public override string ToString() => $"@{Kind} [{string.Join(',', Hierarchy.Zip(Name).Select(t => t.First.ToString() + '@' + t.Second.ToString()))}]";

From caf74d5f4de231a6e89b4118ee0162474bf8f115 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 26 Sep 2023 10:11:25 +0800
Subject: [PATCH 213/308] softmax support split on axis

---
 .../CodeGen/CSourceConvertVisitor.cs          | 27 ++++++-
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  4 +-
 modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs  |  2 +
 .../Passes/Tile/TIRConvertVisitor.cs          |  6 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h | 77 +++++++++++++++++--
 .../cpu/src/runtime/cmodel/include/tensor.h   |  5 +-
 .../Utilities/DistributedUtility.cs           |  2 +-
 src/Nncase.Evaluator/NN/Softmax.cs            | 11 ++-
 .../Targets/UnitTestCPUTargetTiling.cs        |  4 +-
 9 files changed, 113 insertions(+), 25 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index bc789be748..5a99b23ae2 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -371,8 +371,31 @@ protected override CSymbol VisitCall(Call expr)
                     IndentScope.Writer.Write($"__tensor_copy_sync(std::move({Visit(expr.Arguments[1]).Name}), {Visit(expr.Arguments[0]).Name}({{{string.Join(',', newbegins.Select(e => e.ToString()))}}},{{{string.Join(',', newends.Select(e => e.ToString()))}}}))");
                     break;
                 case IR.XPU.Softmax softmax:
-                    positiveAxis = softmax.Axis > 0 ? softmax.Axis : softmax.Axis + ((TensorType)args[0].CheckedType).Shape.Rank;
-                    IndentScope.Writer.Write($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {positiveAxis})");
+                    {
+                        positiveAxis = softmax.Axis > 0 ? softmax.Axis : softmax.Axis + ((TensorType)args[0].CheckedType).Shape.Rank;
+                        var sbpOnAxis = softmax.DistType.NdSBP.Where(sbp => sbp is SBPSplit s && s.Axis == softmax.Axis).ToArray();
+                        switch (sbpOnAxis.Length)
+                        {
+                            case 0:
+                                IndentScope.Writer.IndWrite($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {positiveAxis}, ctx, reduce_strategy_t::none)");
+                                break;
+                            case 1:
+                                if (sbpOnAxis[0] == softmax.DistType.NdSBP[1])
+                                {
+                                    IndentScope.Writer.IndWrite($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {positiveAxis}, ctx, reduce_strategy_t::by_thread)");
+                                }
+                                else
+                                {
+                                    IndentScope.Writer.IndWrite($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {positiveAxis}, ctx, reduce_strategy_t::by_block)");
+                                }
+
+                                break;
+                            case 2:
+                                IndentScope.Writer.IndWrite($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {positiveAxis}, ctx, reduce_strategy_t::all)");
+                                break;
+                        }
+                    }
+
                     break;
                 case IR.XPU.Transpose transpose:
                     IndentScope.Writer.Write($"transpose({Visit(args[0]).Name}, {Visit(args[1]).Name}, {{{string.Join(",", transpose.Perm.Select(p => p.ToString()))}}})");
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index f5d2ecfb94..9036b0cbc3 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -57,9 +57,9 @@ public static Expr Slice(TIR.Buffer input, TIR.Buffer output, Expr begins, Expr
         return new Call(new Slice(distributedType), input, output, begins, ends, axes);
     }
 
-    public static Call Softmax(int axis, Expr input, Expr output)
+    public static Call Softmax(int axis, Expr input, Expr output, DistributedType distributedType)
     {
-        return new Call(new IR.XPU.Softmax(axis), input, output);
+        return new Call(new IR.XPU.Softmax(axis, distributedType), input, output);
     }
 
     public static Call Transpose(int[] perm, Expr input, Expr output)
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs b/modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs
index f96b87fbd0..40945ca4ed 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs
@@ -10,4 +10,6 @@ public sealed partial class Softmax : XPUKernelOp
     public static readonly ParameterInfo Output = new(typeof(Softmax), 1, "output");
 
     public int Axis { get; }
+
+    public DistributedType DistType { get; }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 20a6d674a0..65191a5ef6 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -63,7 +63,7 @@ protected override Unit VisitLeafCall(Call expr)
                 GenerateSlice(slice, arguments[0], ret, expr.Arguments[1], expr.Arguments[2], expr.Arguments[3], (DistributedType)expr.CheckedType);
                 break;
             case Softmax softmax:
-                GenerateSoftmax(softmax, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), arguments, ret);
+                GenerateSoftmax(softmax, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), arguments, ret, (DistributedType)expr.CheckedType);
                 break;
             case Transpose transpose:
                 GenerateTranspose(transpose, ((TensorConst)expr.Arguments[1]).Value.ToArray<int>(), arguments, ret);
@@ -166,9 +166,9 @@ private void GenerateGather(Gather gahter, Buffer[] arguments, Buffer ret)
         _mainBody.Add(IR.F.XPU.Gather(gahter.Axis, arguments[0], arguments[1], ret));
     }
 
-    private void GenerateSoftmax(Softmax softmax, int axis, Buffer[] arguments, Buffer ret)
+    private void GenerateSoftmax(Softmax softmax, int axis, Buffer[] arguments, Buffer ret, DistributedType distributedType)
     {
-        _mainBody.Add(IR.F.XPU.Softmax(axis, arguments[0], ret));
+        _mainBody.Add(IR.F.XPU.Softmax(axis, arguments[0], ret, distributedType));
     }
 
     private void GenerateTranspose(Transpose transpose, int[] perm, Buffer[] arguments, Buffer ret)
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index b3e45db2f4..a43f790e1c 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -16,6 +16,13 @@
 #include <transpose.h>
 #include <unary.h>
 
+enum class reduce_strategy_t : uint8_t {
+    all,
+    by_block,
+    by_thread,
+    none,
+};
+
 #define __tdma_block_sync_apply_macro(func, ctx, ...)                          \
     global_hardware_ctx.lock_block(ctx.bid());                                 \
     int visited = global_hardware_ctx.mark_block_visit(ctx.bid(), ctx.tid());  \
@@ -420,11 +427,6 @@ void tdma_reduce_async(tensor<T, loc_t::local> &src,
     }
 }
 
-enum class reduce_strategy_t : uint8_t {
-    all,
-    by_block,
-};
-
 template <class T, loc_t ALoc>
 void all_reduce_async_visit_func1(int visited, thread_context &ctx,
                                   tensor<T, ALoc> &src) {
@@ -504,7 +506,9 @@ void all_reduce_async_visit_func2_by_block([[maybe_unused]] int visit,
     new_dims[0] = BLOCKS;
     new_strides[0] *= CORES;
 
-    auto viewed_gather_tensor = view(gather_tensor, new_dims, new_strides);
+    auto viewed_gather_tensor = tensor<T>(
+        gather_tensor.data().subspan(ctx.tid() * gather_tensor.strides()[0]),
+        new_dims, new_strides, false);
 
     reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
            dims_t({0}), false);
@@ -580,4 +584,63 @@ void tdma_status() {}
 
 enum class sched_strategy_t : uint8_t { pin_block_tensor, normal };
 
-void set_sched_strategy([[maybe_unused]] sched_strategy_t sch) {}
\ No newline at end of file
+void set_sched_strategy([[maybe_unused]] sched_strategy_t sch) {}
+
+template <loc_t SrcLoc, loc_t DestLoc>
+void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest, int axis,
+             thread_context &ctx,
+             reduce_strategy_t strategy = reduce_strategy_t::none) {
+    if (strategy == reduce_strategy_t::none) {
+        kernels::softmax(src.cdata().data(), dest.data().data(),
+                         src.dimension(), src.strides(), dest.strides(), axis,
+                         1.0f, false);
+    } else {
+        size_t positive_axis = axis < 0 ? src.dimension().size() + axis : axis;
+        dims_t axes{positive_axis};
+        auto reduced_shape = get_reduced_shape(src.dimension(), axes, true);
+        tensor<float> tmp_max(reduced_shape);
+
+        // max
+        auto initial_max = std::numeric_limits<float>::lowest();
+        kernels::reduce(reduce_op_t::max, &initial_max, src.cdata().data(),
+                        tmp_max.data().data(), src.dimension(), positive_axis,
+                        src.strides(), tmp_max.strides(), true);
+        if (strategy == reduce_strategy_t::all ||
+            strategy == reduce_strategy_t::by_block) {
+            tdma_all_reduce_async(tmp_max, tmp_max, reduce_op_t::max, strategy,
+                                  ctx);
+        } else {
+            tdma_reduce_async(tmp_max, tmp_max, reduce_op_t::max, ctx);
+        }
+
+        // x - max
+        kernels::binary(binary_op_t::sub, src.cdata().data(),
+                        tmp_max.cdata().data(), dest.data().data(),
+                        src.dimension(), src.strides(), reduced_shape,
+                        tmp_max.strides(), dest.dimension(), dest.strides());
+
+        // exp(x - max)
+        kernels::unary(unary_op_t::exp, dest.cdata().data(), dest.data().data(),
+                       dest.strides(), dest.dimension(), dest.strides());
+
+        // sum(exp(x - max))
+        float initial_sum = 0;
+        tensor<float> tmp_sum(reduced_shape);
+        kernels::reduce(reduce_op_t::sum, &initial_sum, dest.cdata().data(),
+                        tmp_sum.data().data(), dest.dimension(), positive_axis,
+                        dest.strides(), tmp_sum.strides(), true);
+        if (strategy == reduce_strategy_t::all ||
+            strategy == reduce_strategy_t::by_block) {
+            tdma_all_reduce_async(tmp_sum, tmp_sum, reduce_op_t::sum, strategy,
+                                  ctx);
+        } else {
+            tdma_reduce_async(tmp_sum, tmp_sum, reduce_op_t::sum, ctx);
+        }
+
+        // exp(x - max) / sum(exp(x - max))
+        kernels::binary(binary_op_t::div, dest.data().data(),
+                        tmp_sum.cdata().data(), dest.data().data(),
+                        dest.dimension(), dest.strides(), tmp_sum.dimension(),
+                        tmp_sum.strides(), dest.dimension(), dest.strides());
+    }
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/cpu/src/runtime/cmodel/include/tensor.h
index 1291e44309..bfdabca5bf 100644
--- a/modules/cpu/src/runtime/cmodel/include/tensor.h
+++ b/modules/cpu/src/runtime/cmodel/include/tensor.h
@@ -39,13 +39,14 @@ template <typename T, loc_t Loc = loc_t::local> class tensor {
         }
     }
 
-    tensor(gsl::span<T> data, dims_t dims, strides_t strides)
+    tensor(gsl::span<T> data, dims_t dims, strides_t strides,
+           bool check_size = true)
         : data_(data),
           parent_(data.data()),
           dims_(dims),
           strides_(strides),
           size_(compute_size(dims_, strides_)) {
-        if (size_ != data_.size()) {
+        if (check_size && size_ != data_.size()) {
             runtime_util->rt_assert(false, (char *)"Invalid tensor size");
         }
     }
diff --git a/src/Nncase.Core/Utilities/DistributedUtility.cs b/src/Nncase.Core/Utilities/DistributedUtility.cs
index 68945a0287..4cf1d4950b 100644
--- a/src/Nncase.Core/Utilities/DistributedUtility.cs
+++ b/src/Nncase.Core/Utilities/DistributedUtility.cs
@@ -131,7 +131,7 @@ private static (IReadOnlyList<int> Tile, IReadOnlyList<int> Shape) GetDividedTil
     {
         var shape = distributedType.TensorType.Shape.ToValueArray();
         var tiles = distributedType.TensorType.Shape.ToValueArray();
-        foreach (var (s, i) in distributedType.NdSBP.OfType<SBPSplit>().Select((s, i) => (s, i)))
+        foreach (var (s, i) in distributedType.NdSBP.Select((s, i) => (s, i)).Where(t => t.s is SBPSplit).Select(t => ((SBPSplit)t.s, t.i)))
         {
             tiles[s.Axis] /= distributedType.Placement.Hierarchy[i];
         }
diff --git a/src/Nncase.Evaluator/NN/Softmax.cs b/src/Nncase.Evaluator/NN/Softmax.cs
index c7640de82f..7a183b0c6c 100644
--- a/src/Nncase.Evaluator/NN/Softmax.cs
+++ b/src/Nncase.Evaluator/NN/Softmax.cs
@@ -128,12 +128,11 @@ private IRType Visit(TensorType input)
 
     private IRType Visit(DistributedType input, Expr axisExpr)
     {
-        var axis = ((TensorConst)axisExpr).Value.ToScalar<int>();
-        if (input.NdSBP.Any(sbp => sbp is SBPSplit s && s.Axis == axis))
-        {
-            return new InvalidType("Not support split on Axis for Softmax now.");
-        }
-
+        // var axis = ((TensorConst)axisExpr).Value.ToScalar<int>();
+        // if (input.NdSBP.Any(sbp => sbp is SBPSplit s && s.Axis == axis))
+        // {
+        //     return new InvalidType("Not support split on Axis for Softmax now.");
+        // }
         return input;
     }
 }
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 6409a579c7..701f5f94de 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -41,13 +41,13 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseMatmul))]
     // [ClassData(typeof(TilingCaseLayerNorm))]
     // [ClassData(typeof(TilingCaseGather))]
-    // [ClassData(typeof(TilingCaseSoftmax))]
+    [ClassData(typeof(TilingCaseSoftmax))]
     // [ClassData(typeof(TilingCaseSlice))]
     // [ClassData(typeof(TilingCaseConcat))]
     // [ClassData(typeof(TilingCaseTranspose))]
     // [ClassData(typeof(TilingCaseReshape1))]
     // [ClassData(typeof(TilingCaseReshape2))]
-    [ClassData(typeof(TilingCaseMatmulUnary))]
+    // [ClassData(typeof(TilingCaseMatmulUnary))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);

From 4cf401711b392310e9fcbe5cff1cd73de1a48b90 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 26 Sep 2023 10:35:01 +0800
Subject: [PATCH 214/308] add conv2d cpu kernel

---
 .../CodeGen/CSourceConvertVisitor.cs          |  2 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h | 72 +++++++++++++++++++
 2 files changed, 73 insertions(+), 1 deletion(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 5a99b23ae2..0a305dea70 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -412,7 +412,7 @@ protected override CSymbol VisitCall(Call expr)
                     }
                     else
                     {
-                        IndentScope.Writer.IndWrite($"auto {ret_name}_tmp = &{ret_name};\n");
+                        IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local>& {ret_name}_tmp = {ret_name};\n");
                     }
 
                     if (grs.ReducePosition.Count == 2)
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index a43f790e1c..a618e50774 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -114,6 +114,78 @@ void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &c) {
                     c.dimension(), c.strides());
 }
 
+
+template <typename T, loc_t InLoc, loc_t WLoc, loc_t OutLoc, loc_t BLoc>
+T *im2col(tensor<T, InLoc> &input, dims_t filter, dims_t padding, dims_t stride,
+          [[maybe_unused]] dims_t dilation = {1, 1},
+          [[maybe_unused]] int32_t groups = 1) {
+    // todo: support dilated and group conv2d
+    int32_t N = input.dimension()[0];
+    int32_t C = input.dimension()[1];
+    int32_t H = input.dimension()[2] + padding[0] + padding[2];
+    int32_t W = input.dimension()[3] + padding[1] + padding[3];
+
+    int32_t OH = (H - filter[0]) / stride[0] + 1;
+    int32_t OW = (W - filter[1]) / stride[1] + 1;
+
+    T *cols = runtime_util->malloc((C * filter[0] * filter[1]) * (N * OH * OW) *
+                                   sizeof(T));
+    for (auto c = 0; c < C; c++)
+        for (auto e = 0; e < OH; e++)
+            for (auto f = 0; f < OW; f++)
+                for (auto r = 0; r < filter[0]; r++)
+                    for (auto s = 0; s < filter[1]; s++) {
+                        auto row =
+                            c * filter[0] * filter[1] + r * filter[0] + s;
+                        for (auto b = 0; b < N; b++) {
+                            auto col = e * OW * N + f * N + b;
+                            auto out_index = row * (N * OH * OW) + col;
+                            auto in_index =
+                                b * input.strides()[0] +
+                                c * input.strides()[1] +
+                                (stride[0] * e + r) * input.strides()[2] +
+                                (stride[1] * f + s);
+                            if (row < padding[0] || col < padding[1]) {
+                                cols[out_index] = 0;
+                            } else {
+                                cols[out_index] = input.cdata()[in_index];
+                            }
+                        }
+                    }
+    return cols;
+}
+
+template <typename T, loc_t InLoc, loc_t WLoc, loc_t OutLoc, loc_t BLoc>
+void conv2d(tensor<T, InLoc> &input, tensor<T, WLoc> &weight,
+            tensor<T, BLoc> bias, tensor<T, OutLoc> &output, dims_t padding,
+            dims_t stride, dims_t dilation = {1, 1}, int32_t groups = 1) {
+    // todo: support dilated and group conv2d
+    int32_t N = input.dimension()[0];
+    int32_t C = input.dimension()[1];
+    int32_t H = input.dimension()[2] + padding[0] + padding[2];
+    int32_t W = input.dimension()[3] + padding[1] + padding[3];
+
+    int32_t M = weight.dimension()[0];
+    dims_t filter = {weight.dimension()[2], weight.dimension()[3]};
+
+    int32_t OH = (H - filter[0]) / stride[0] + 1;
+    int32_t OW = (W - filter[1]) / stride[1] + 1;
+
+    auto input_cols = im2col<T, InLoc, WLoc, OutLoc, BLoc>(
+        input, filter, padding, stride, dilation, groups);
+    auto mm = runtime_util->malloc(M * C * OH * OW * sizeof(T));
+    kernels::matmul(weight.cdata(), input.cdata(), mm,
+                    {M, C * filter[0] * filter[1]},
+                    {C * filter[0] * filter[1], 1},
+                    {C * filter[0] * filter[1], N * OH * OW}, {N * OH * OW, 1},
+                    {N * OH * OW, 1});
+    kernels::binary(binary_op_t::add, mm, bias.cdata(), mm, {M, N * OH * OW},
+                    {N * OH * OW, 1}, {M, 1}, {1, 1}, {M, N * OH * OW},
+                    {N * OH * OW, 1});
+    kernels::transpose(mm, output.data(), {M, N, OH, OW}, {3, 0, 1, 2},
+                       {N * OH * OW, 1}, output.strides());
+}
+
 template <typename T, loc_t ALoc, loc_t BLoc>
 void reduce(tensor<T, ALoc> &input, tensor<T, BLoc> &output, reduce_op_t op,
             T init_value, dims_t axis, bool keep_dims) {

From 57fd40908a5d1990452400c958209d95a8dc6a02 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 26 Sep 2023 20:39:35 +0800
Subject: [PATCH 215/308] disable outter split on inner splited axis

---
 src/Nncase.Core/Utilities/DistributedUtility.cs   |  3 ++-
 src/Nncase.Tests/Distributed/UnitTestUtilities.cs | 10 ++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/Nncase.Core/Utilities/DistributedUtility.cs b/src/Nncase.Core/Utilities/DistributedUtility.cs
index 4cf1d4950b..55789e91ee 100644
--- a/src/Nncase.Core/Utilities/DistributedUtility.cs
+++ b/src/Nncase.Core/Utilities/DistributedUtility.cs
@@ -47,12 +47,13 @@ public static IReadOnlyList<IRArray<SBP>> GetPartialCandidateNDSBPs(DistributedT
         for (int i = 0; i < placement.Rank; i++)
         {
             candidateNdsbps[i] = new List<SBP>();
+            var innerSplitedAxes = distributedType.NdSBP.Skip(i + 1).OfType<SBPSplit>().Select(sbp => sbp.Axis).ToList();
             if (ndsbp[i] is SBPPartialSum)
             {
                 candidateNdsbps[i].Add(SBP.B);
                 for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
                 {
-                    if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && IsDivisible(s, placement.Hierarchy[i]))
+                    if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && IsDivisible(s, placement.Hierarchy[i]) && !innerSplitedAxes.Contains(axis))
                     {
                         candidateNdsbps[i].Add(SBP.S(axis));
                     }
diff --git a/src/Nncase.Tests/Distributed/UnitTestUtilities.cs b/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
index 3f1c27b65d..2d09e1b095 100644
--- a/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
@@ -28,4 +28,14 @@ public void TestEffiecicy()
         Assert.True(eff1 > eff2);
         Assert.True(eff2 > eff3);
     }
+
+    [Fact]
+    public void TestGetPartialCandidateNDSBPs()
+    {
+        var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+        var type = new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, placement);
+        var candidateSbps = Utilities.DistributedUtility.GetPartialCandidateNDSBPs(type);
+
+        Assert.Equal(0, candidateSbps.Count(ndsbp => ndsbp == new IRArray<SBP>(new SBP[] { SBP.S(2), SBP.S(2) })));
+    }
 }

From 71c8e7730323535f844e427950e0b2ec899952ab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 27 Sep 2023 12:12:41 +0800
Subject: [PATCH 216/308] fix binary distributedtype infer

---
 src/Nncase.Evaluator/Math/Binary.cs           |  8 +++--
 .../Distributed/UnitTestTypeInfer.cs          | 35 +++++++++++++++++++
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/src/Nncase.Evaluator/Math/Binary.cs b/src/Nncase.Evaluator/Math/Binary.cs
index ac991e43cf..a65e1f921e 100755
--- a/src/Nncase.Evaluator/Math/Binary.cs
+++ b/src/Nncase.Evaluator/Math/Binary.cs
@@ -157,18 +157,20 @@ private IRType Visit(Binary target, DistributedType a, DistributedType b)
                 case (SBPBroadCast, SBPBroadCast):
                     ndsbp[i] = SBP.B;
                     break;
-                case (SBPPartialSum, _):
-                case (_, SBPPartialSum):
+                case (SBPPartialSum, SBPPartialSum):
                     if (target.BinaryOp == BinaryOp.Add)
                     {
                         ndsbp[i] = SBP.P;
                     }
                     else
                     {
-                        return new InvalidType("lhs rhs have partialsum only can add");
+                        return new InvalidType("lhs rhs all partialsum only can be added.");
                     }
 
                     break;
+                case (SBPPartialSum, _):
+                case (_, SBPPartialSum):
+                    return new InvalidType("not support lhs or rhs partial.");
             }
         }
 
diff --git a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
index bbd62c6762..79a956f253 100644
--- a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
@@ -26,6 +26,24 @@ public sealed class UnitTestTypeInfer : TestClassBase
         },
     };
 
+    public static TheoryData<BinaryOp, DistributedType, DistributedType, IRType> InferBinaryData => new() {
+        { BinaryOp.Add,
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.B, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
+          new InvalidType(string.Empty)
+        },
+        { BinaryOp.Add,
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt"))
+        },
+        { BinaryOp.Mul,
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
+          new InvalidType(string.Empty)
+        },
+    };
+
     [Theory]
     [MemberData(nameof(InferUnaryData))]
     public void TestInferUnary(UnaryOp unaryOp, DistributedType inputType, IRType outType)
@@ -42,6 +60,23 @@ public void TestInferUnary(UnaryOp unaryOp, DistributedType inputType, IRType ou
         }
     }
 
+    [Theory]
+    [MemberData(nameof(InferBinaryData))]
+    public void TestInferBinary(BinaryOp binaryOp, DistributedType lhsType, DistributedType rhsType, IRType outType)
+    {
+        var lhs = new Var(lhsType);
+        var rhs = new Var(rhsType);
+        var binary = IR.F.Math.Binary(binaryOp, lhs, rhs);
+        CompilerServices.InferenceType(binary);
+        if (outType is InvalidType && binary.CheckedType is InvalidType)
+        {
+        }
+        else
+        {
+            Assert.Equal(outType, binary.CheckedType);
+        }
+    }
+
     [Theory]
     [ClassData(typeof(InferMatmulData))]
     public void TestInferMatmul(DistributedType lhsType, DistributedType rhsType, IRType outType)

From 6bc903839518752f9d9875748f456b97d16339aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 27 Sep 2023 16:55:52 +0800
Subject: [PATCH 217/308] fixGetPartialCandidateNDSBPs

---
 src/Nncase.Core/Utilities/DistributedUtility.cs  |  2 ++
 .../Distributed/UnitTestUtilities.cs             | 16 ++++++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/src/Nncase.Core/Utilities/DistributedUtility.cs b/src/Nncase.Core/Utilities/DistributedUtility.cs
index 55789e91ee..13b2870bfb 100644
--- a/src/Nncase.Core/Utilities/DistributedUtility.cs
+++ b/src/Nncase.Core/Utilities/DistributedUtility.cs
@@ -66,6 +66,8 @@ public static IReadOnlyList<IRArray<SBP>> GetPartialCandidateNDSBPs(DistributedT
         }
 
         return candidateNdsbps.CartesianProduct().
+            Select(ndsbp => ndsbp.ToArray()).
+            Where(ndsbp => IsDistributable(tensorType, ndsbp, placement, out _)).
             Select(ndsbp => new IRArray<SBP>(ndsbp)).
             ToArray();
     }
diff --git a/src/Nncase.Tests/Distributed/UnitTestUtilities.cs b/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
index 2d09e1b095..c7548d6026 100644
--- a/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
@@ -13,6 +13,14 @@ namespace Nncase.Tests.DistributedTest;
 
 public sealed class UnitTestUtilities
 {
+    public static TheoryData<DistributedType, IRArray<SBP>> GetPartialCandidateNDSBPsNegativeData { get; } = new()
+    {
+        {
+            new DistributedType(new(DataTypes.Float32, new[] { 1, 8, 384, 8192 }), new SBP[] { SBP.P, SBP.P }, new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
+            new SBP[] { SBP.S(1), SBP.S(1) }
+        },
+    };
+
     [Fact]
     public void TestEffiecicy()
     {
@@ -38,4 +46,12 @@ public void TestGetPartialCandidateNDSBPs()
 
         Assert.Equal(0, candidateSbps.Count(ndsbp => ndsbp == new IRArray<SBP>(new SBP[] { SBP.S(2), SBP.S(2) })));
     }
+
+    [Theory]
+    [MemberData(nameof(GetPartialCandidateNDSBPsNegativeData))]
+    public void TestGetPartialCandidateNDSBPsNegative(DistributedType inType, IRArray<SBP> negativeNdsbp)
+    {
+        var candidateSbps = Utilities.DistributedUtility.GetPartialCandidateNDSBPs(inType);
+        Assert.Equal(0, candidateSbps.Count(ndsbp => ndsbp == negativeNdsbp));
+    }
 }

From 5b158e03cafdc2f3c55f346645cef72046c0001b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 27 Sep 2023 18:10:16 +0800
Subject: [PATCH 218/308] pass cpu conv2d

---
 .../CodeGen/CSourceConvertVisitor.cs          |  13 +++
 .../Evaluator/XPU/Conv2D.cs                   |  12 ++
 .../Evaluator/XPU/XPUModule.cs                |   1 +
 modules/Nncase.Modules.CPU/IR/XPU/Conv2D.cs   |  25 ++++
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |   5 +
 .../Passes/Tile/TIRConvertVisitor.cs          |   8 ++
 modules/cpu/src/runtime/cmodel/include/tdma.h |  85 +++++++++-----
 src/Nncase.Core/IR/NN/Conv2D.cs               |   6 +-
 src/Nncase.Evaluator/NN/Conv2D.cs             | 108 ++++++++++++++++--
 .../Targets/UnitTestCPUTargetTiling.cs        |  68 ++++++++---
 10 files changed, 274 insertions(+), 57 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Conv2D.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Conv2D.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 0a305dea70..21693a6af4 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -433,6 +433,19 @@ protected override CSymbol VisitCall(Call expr)
                         IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}), {ret_name}_tmp{((TensorType)args[1].CheckedType).ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)});\n");
                     }
 
+                    break;
+                case IR.XPU.Conv2D conv:
+                    var sbpOnInChannel = conv.DistType.NdSBP.Where(sbp => sbp is SBPPartialSum).ToArray();
+                    string strategy = sbpOnInChannel.Length switch
+                    {
+                        0 => "reduce_strategy_t::none",
+                        1 when sbpOnInChannel[0] == conv.DistType.NdSBP[1] => "reduce_strategy_t::by_thread",
+                        1 => "reduce_strategy_t::by_block",
+                        2 => "reduce_strategy_t::all",
+                        _ => throw new InvalidOperationException("Invalid length"),
+                    };
+
+                    IndentScope.Writer.Write($"conv2d(ctx, {Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {Visit(args[3]).Name}, {{{string.Join(",", conv.Stride.Select(p => p.ToString()))}}}, {{{string.Join(",", conv.Padding.Select(p => p.ToString()))}}}, {{{string.Join(",", conv.Dilation.Select(p => p.ToString()))}}}, {conv.Groups}, {strategy})");
                     break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Conv2D.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Conv2D.cs
new file mode 100644
index 0000000000..7c4ee83412
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Conv2D.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public class Conv2DEvaluator : ITypeInferencer<Conv2D>
+{
+    public IRType Visit(ITypeInferenceContext context, Conv2D target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 7616204df3..a0cc16ba53 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -28,5 +28,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<TransposeEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<ReShapeEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<GatherReduceScatterEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<Conv2DEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Conv2D.cs b/modules/Nncase.Modules.CPU/IR/XPU/Conv2D.cs
new file mode 100644
index 0000000000..301ea9f6e5
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Conv2D.cs
@@ -0,0 +1,25 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Conv2D : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(Conv2D), 0, "input");
+
+    public static readonly ParameterInfo Weights = new(typeof(Conv2D), 1, "weights");
+
+    public static readonly ParameterInfo Bias = new(typeof(Conv2D), 2, "bias");
+
+    public IRArray<int> Stride { get; }
+
+    public IRArray<int> Padding { get; }
+
+    public IRArray<int> Dilation { get; }
+
+    public int Groups { get; }
+
+    public TensorConst FusedClamp { get; }
+
+    public DistributedType DistType { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 9036b0cbc3..50f3911890 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -76,4 +76,9 @@ public static Call GatherReduceScatter(Expr input, Expr output, (int, SBP)[] red
     {
         return new Call(new GatherReduceScatter(reducePosition, placement), input, output);
     }
+
+    public static Call Conv2D(Expr input, Expr weights, Expr bias, Expr output, int[] stride, int[] padding, int[] dilation, int groups, TensorConst fusedClamp, DistributedType distributedType)
+    {
+        return new Call(new Conv2D(stride, padding, dilation, groups, fusedClamp, distributedType), input, weights, bias, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 65191a5ef6..98458e128f 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -77,6 +77,9 @@ protected override Unit VisitLeafCall(Call expr)
             case IR.CPU.Boxing boxing:
                 GenerateBoxing(boxing, arguments, ret, expr);
                 break;
+            case Conv2D conv:
+                GenerateConv2D(conv, arguments, ret, ((TensorConst)expr.Arguments[3]).Value.ToArray<int>(), ((TensorConst)expr.Arguments[4]).Value.ToArray<int>(), ((TensorConst)expr.Arguments[5]).Value.ToArray<int>(), ((TensorConst)expr.Arguments[6]).Value.ToScalar<int>(), (TensorConst)expr.Arguments[7], (DistributedType)expr.CheckedType);
+                break;
             default:
                 throw new NotSupportedException();
         }
@@ -176,6 +179,11 @@ private void GenerateTranspose(Transpose transpose, int[] perm, Buffer[] argumen
         _mainBody.Add(IR.F.XPU.Transpose(perm, arguments[0], ret));
     }
 
+    private void GenerateConv2D(Conv2D conv, Buffer[] arguments, Buffer ret, int[] stride, int[] padding, int[] dilation, int groups, TensorConst fusedClamp, DistributedType distributedType)
+    {
+        _mainBody.Add(IR.F.XPU.Conv2D(arguments[0], arguments[1], arguments[2], ret, stride, padding, dilation, groups, fusedClamp, distributedType));
+    }
+
 #if false
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index a618e50774..a10b032b9c 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -114,8 +114,7 @@ void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &c) {
                     c.dimension(), c.strides());
 }
 
-
-template <typename T, loc_t InLoc, loc_t WLoc, loc_t OutLoc, loc_t BLoc>
+template <typename T, loc_t InLoc>
 T *im2col(tensor<T, InLoc> &input, dims_t filter, dims_t padding, dims_t stride,
           [[maybe_unused]] dims_t dilation = {1, 1},
           [[maybe_unused]] int32_t groups = 1) {
@@ -128,8 +127,9 @@ T *im2col(tensor<T, InLoc> &input, dims_t filter, dims_t padding, dims_t stride,
     int32_t OH = (H - filter[0]) / stride[0] + 1;
     int32_t OW = (W - filter[1]) / stride[1] + 1;
 
-    T *cols = runtime_util->malloc((C * filter[0] * filter[1]) * (N * OH * OW) *
-                                   sizeof(T));
+    auto cols = (T *)runtime_util->malloc((C * filter[0] * filter[1]) *
+                                          (OH * OW * N) * sizeof(T));
+
     for (auto c = 0; c < C; c++)
         for (auto e = 0; e < OH; e++)
             for (auto f = 0; f < OW; f++)
@@ -139,7 +139,7 @@ T *im2col(tensor<T, InLoc> &input, dims_t filter, dims_t padding, dims_t stride,
                             c * filter[0] * filter[1] + r * filter[0] + s;
                         for (auto b = 0; b < N; b++) {
                             auto col = e * OW * N + f * N + b;
-                            auto out_index = row * (N * OH * OW) + col;
+                            auto out_index = row * (OH * OW * N) + col;
                             auto in_index =
                                 b * input.strides()[0] +
                                 c * input.strides()[1] +
@@ -148,42 +148,65 @@ T *im2col(tensor<T, InLoc> &input, dims_t filter, dims_t padding, dims_t stride,
                             if (row < padding[0] || col < padding[1]) {
                                 cols[out_index] = 0;
                             } else {
-                                cols[out_index] = input.cdata()[in_index];
+                                cols[out_index] =
+                                    input.cdata().data()[in_index];
                             }
                         }
                     }
     return cols;
 }
 
-template <typename T, loc_t InLoc, loc_t WLoc, loc_t OutLoc, loc_t BLoc>
-void conv2d(tensor<T, InLoc> &input, tensor<T, WLoc> &weight,
-            tensor<T, BLoc> bias, tensor<T, OutLoc> &output, dims_t padding,
-            dims_t stride, dims_t dilation = {1, 1}, int32_t groups = 1) {
+template <typename T, loc_t InLoc, loc_t WLoc, loc_t BLoc, loc_t OutLoc>
+void conv2d(thread_context &ctx, tensor<T, InLoc> &input,
+            tensor<T, WLoc> &weight, tensor<T, BLoc> &bias,
+            tensor<T, OutLoc> &output, dims_t stride, dims_t padding,
+            dims_t dilation = {1, 1}, int32_t groups = 1,
+            reduce_strategy_t strategy = reduce_strategy_t::none) {
     // todo: support dilated and group conv2d
-    int32_t N = input.dimension()[0];
-    int32_t C = input.dimension()[1];
-    int32_t H = input.dimension()[2] + padding[0] + padding[2];
-    int32_t W = input.dimension()[3] + padding[1] + padding[3];
+    size_t N = input.dimension()[0];
+    size_t C = input.dimension()[1];
+    size_t H = input.dimension()[2] + padding[0] + padding[2];
+    size_t W = input.dimension()[3] + padding[1] + padding[3];
 
-    int32_t M = weight.dimension()[0];
+    size_t M = weight.dimension()[0];
     dims_t filter = {weight.dimension()[2], weight.dimension()[3]};
 
-    int32_t OH = (H - filter[0]) / stride[0] + 1;
-    int32_t OW = (W - filter[1]) / stride[1] + 1;
-
-    auto input_cols = im2col<T, InLoc, WLoc, OutLoc, BLoc>(
-        input, filter, padding, stride, dilation, groups);
-    auto mm = runtime_util->malloc(M * C * OH * OW * sizeof(T));
-    kernels::matmul(weight.cdata(), input.cdata(), mm,
-                    {M, C * filter[0] * filter[1]},
-                    {C * filter[0] * filter[1], 1},
-                    {C * filter[0] * filter[1], N * OH * OW}, {N * OH * OW, 1},
-                    {N * OH * OW, 1});
-    kernels::binary(binary_op_t::add, mm, bias.cdata(), mm, {M, N * OH * OW},
-                    {N * OH * OW, 1}, {M, 1}, {1, 1}, {M, N * OH * OW},
-                    {N * OH * OW, 1});
-    kernels::transpose(mm, output.data(), {M, N, OH, OW}, {3, 0, 1, 2},
-                       {N * OH * OW, 1}, output.strides());
+    size_t OH = (H - filter[0]) / stride[0] + 1;
+    size_t OW = (W - filter[1]) / stride[1] + 1;
+
+    auto input_cols =
+        im2col<T, InLoc>(input, filter, padding, stride, dilation, groups);
+    auto mm = tensor<T>({M, OH*OW*N});
+    kernels::matmul(
+        weight.cdata().data(), input_cols, mm.data().data(),
+        gsl::make_span(dims_t{M, C * filter[0] * filter[1]}),
+        gsl::make_span(dims_t{weight.strides()[0], 1}),
+        gsl::make_span(dims_t{C * filter[0] * filter[1], OH * OW * N}),
+        gsl::make_span(dims_t{OH * OW * N, 1}),
+        gsl::make_span(dims_t{M, OH * OW * N}),
+        gsl::make_span(dims_t{OH * OW * N, 1}));
+    
+    switch (strategy) {
+    case reduce_strategy_t::by_thread:
+        tdma_reduce_async(mm, mm, reduce_op_t::sum, ctx);
+        break;
+    case reduce_strategy_t::by_block:
+    case reduce_strategy_t::all:
+        tdma_all_reduce_async(mm, mm, reduce_op_t::sum, strategy, ctx);
+        break;
+    default:
+        break;
+    }
+    kernels::binary(binary_op_t::add, mm.cdata().data(), bias.cdata().data(), mm.data().data(),
+                    gsl::make_span(dims_t{M, OH * OW * N}),
+                    gsl::make_span(dims_t{OH * OW * N, 1}),
+                    gsl::make_span(dims_t{M, 1}), gsl::make_span(dims_t{1, 1}),
+                    gsl::make_span(dims_t{M, OH * OW * N}),
+                    gsl::make_span(dims_t{OH * OW * N, 1}));
+    kernels::transpose(
+        mm.cdata().data(), output.data().data(), gsl::make_span(dims_t{M, OH, OW, N}),
+        gsl::make_span(dims_t{3, 0, 1, 2}),
+        gsl::make_span(dims_t{OH * OW * N, OW * N, N, 1}), output.strides());
 }
 
 template <typename T, loc_t ALoc, loc_t BLoc>
diff --git a/src/Nncase.Core/IR/NN/Conv2D.cs b/src/Nncase.Core/IR/NN/Conv2D.cs
index 43c1b2fced..84c944e380 100644
--- a/src/Nncase.Core/IR/NN/Conv2D.cs
+++ b/src/Nncase.Core/IR/NN/Conv2D.cs
@@ -21,17 +21,17 @@ public sealed partial class Conv2D : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Conv2D), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Conv2D), 0, "input", ParameterKind.Input);
 
     /// <summary>
     /// Gets Weights.
     /// </summary>
-    public static readonly ParameterInfo Weights = new(typeof(Conv2D), 1, "weights", HasRank(4));
+    public static readonly ParameterInfo Weights = new(typeof(Conv2D), 1, "weights",  HasRank(4), ParameterKind.Input);
 
     /// <summary>
     /// Gets Bias.
     /// </summary>
-    public static readonly ParameterInfo Bias = new(typeof(Conv2D), 2, "bias", HasRank(1));
+    public static readonly ParameterInfo Bias = new(typeof(Conv2D), 2, "bias", HasRank(1), ParameterKind.Input);
 
     /// <summary>
     /// Gets Stride.
diff --git a/src/Nncase.Evaluator/NN/Conv2D.cs b/src/Nncase.Evaluator/NN/Conv2D.cs
index c26e219821..f4315d22a9 100644
--- a/src/Nncase.Evaluator/NN/Conv2D.cs
+++ b/src/Nncase.Evaluator/NN/Conv2D.cs
@@ -48,20 +48,26 @@ public IValue Visit(IEvaluateContext context, Conv2D conv)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Conv2D target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Conv2D.Input);
-        var weights = context.CheckArgumentType<TensorType>(target, Conv2D.Weights);
-        return Visit(context, target, input, weights);
+        var input = context.GetArgumentType(target, Conv2D.Input);
+        var weights = context.GetArgumentType(target, Conv2D.Weights);
+        var bias = context.GetArgumentType(target, Conv2D.Bias);
+        return (input, weights) switch
+        {
+            (DistributedType a, DistributedType b) => Visit(context, target, a, b, (DistributedType)bias),
+            (TensorType a, TensorType b) => Visit(context, target, a, b),
+            _ => new InvalidType(string.Empty),
+        };
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Conv2D target)
     {
-        var inputType = context.GetArgumentType<TensorType>(target, Conv2D.Input);
-        var weightsType = context.GetArgumentType<TensorType>(target, Conv2D.Weights);
-        var biasType = context.GetArgumentType<TensorType>(target, Conv2D.Bias);
-        var outputType = context.GetReturnType<TensorType>();
+        var inputType = context.GetArgumentType<IRType>(target, Conv2D.Input);
+        var weightsType = context.GetArgumentType<IRType>(target, Conv2D.Weights);
+        var biasType = context.GetArgumentType<IRType>(target, Conv2D.Bias);
+        var outputType = context.GetReturnType<IRType>();
 
-        var weightsShape = weightsType.Shape;
+        var weightsShape = weightsType is TensorType ? ((TensorType)weightsType).Shape : ((DistributedType)weightsType).TensorType.Shape;
         var macPerElement = (2 * weightsShape[1] * weightsShape[2] * weightsShape[3]) - 1;
         return new()
         {
@@ -104,4 +110,90 @@ private IRType Visit(ITypeInferenceContext context, Conv2D target, TensorType in
         var args = context.GetArguments(target, Conv2D.Stride, Conv2D.Padding, Conv2D.Dilation, Conv2D.Groups);
         return TypeInference.Conv2DType(input, weights, args[0], args[1], args[2], args[3]);
     }
+
+    private IRType Visit(ITypeInferenceContext context, Conv2D target, DistributedType input, DistributedType weights, DistributedType bias)
+    {
+        if (Visit(context, target, input.TensorType, weights.TensorType) is not TensorType outType)
+        {
+            return new InvalidType(string.Empty);
+        }
+
+        var args = context.GetArguments(target, Conv2D.Stride, Conv2D.Padding, Conv2D.Dilation, Conv2D.Groups);
+
+        // Not support split on h/w/r/s
+        if (input.NdSBP.Any(sbp => sbp is SBPSplit s && s.Axis >= 2) || weights.NdSBP.Any(sbp => sbp is SBPSplit s && s.Axis >= 2))
+        {
+            return new InvalidType(string.Empty);
+        }
+
+        if (input.Placement != weights.Placement)
+        {
+            return new InvalidType("placement not equal");
+        }
+
+        var ndsbp = new SBP[input.Placement.Rank];
+        for (int i = 0; i < input.Placement.Rank; i++)
+        {
+            var invalid = new InvalidType($"({input.NdSBP[i]}, {weights.NdSBP[i]}) not support");
+            switch (input.NdSBP[i], weights.NdSBP[i])
+            {
+                case (SBPSplit { Axis: int ax }, SBPSplit { Axis: int bx }):
+                    // split on ic
+                    if (ax == 1 && bx == 1)
+                    {
+                        if (bias.NdSBP[i] is SBPBroadCast)
+                        {
+                            ndsbp[i] = SBP.P;
+                        }
+                        else
+                        {
+                            return invalid;
+                        }
+                    }
+                    else
+                    {
+                        return invalid;
+                    }
+
+                    break;
+                case (SBPSplit { Axis: int ax }, SBPBroadCast):
+                    if (ax == 0 && bias.NdSBP[i] is SBPBroadCast)
+                    {
+                        ndsbp[i] = SBP.S(ax);
+                    }
+                    else
+                    {
+                        return invalid;
+                    }
+
+                    break;
+                case (SBPBroadCast, SBPSplit { Axis: int bx }):
+                    if (bx == 0 && bias.NdSBP[i] is SBPSplit s && s.Axis == bx)
+                    {
+                        ndsbp[i] = SBP.S(bx + 1);
+                    }
+                    else
+                    {
+                        return invalid;
+                    }
+
+                    break;
+                case (SBPBroadCast, SBPBroadCast):
+                    if (bias.NdSBP[i] is SBPBroadCast)
+                    {
+                        ndsbp[i] = SBP.B;
+                    }
+                    else
+                    {
+                        return invalid;
+                    }
+
+                    break;
+                default:
+                    return invalid;
+            }
+        }
+
+        return new DistributedType(outType, ndsbp, input.Placement);
+    }
 }
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 701f5f94de..21d10262e7 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -9,6 +9,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
+using NetFabric.Hyperlinq;
 using Nncase.CodeGen;
 using Nncase.IR;
 using Nncase.IR.Tensors;
@@ -41,32 +42,33 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseMatmul))]
     // [ClassData(typeof(TilingCaseLayerNorm))]
     // [ClassData(typeof(TilingCaseGather))]
-    [ClassData(typeof(TilingCaseSoftmax))]
+    // [ClassData(typeof(TilingCaseSoftmax))]
     // [ClassData(typeof(TilingCaseSlice))]
     // [ClassData(typeof(TilingCaseConcat))]
     // [ClassData(typeof(TilingCaseTranspose))]
     // [ClassData(typeof(TilingCaseReshape1))]
     // [ClassData(typeof(TilingCaseReshape2))]
     // [ClassData(typeof(TilingCaseMatmulUnary))]
+    [ClassData(typeof(TilingCaseConv2D))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
         using (new Diagnostics.DumpScope(main.Name, CompileOptions.DumpFlags))
         {
-            // #if DEBUG
-            //             for (var i = 0; i < inputs.Length - 1; i++)
-            //             {
-            //                 using (var fs = Diagnostics.DumpScope.Current.OpenFile($"input_{i}.bin"))
-            //                 {
-            //                     fs.Write(inputs[i].BytesBuffer);
-            //                 }
-            //             }
-
-            // using (var fs = Diagnostics.DumpScope.Current.OpenFile($"output_0.bin"))
-            //             {
-            //                 fs.Write(inputs[^1].BytesBuffer);
-            //             }
-            // #endif
+#if DEBUG
+            for (var i = 0; i < inputs.Length - 1; i++)
+            {
+                using (var fs = Diagnostics.DumpScope.Current.OpenFile($"input_{i}.bin"))
+                {
+                    fs.Write(inputs[i].BytesBuffer);
+                }
+            }
+
+            using (var fs = Diagnostics.DumpScope.Current.OpenFile($"output_0.bin"))
+            {
+                fs.Write(inputs[^1].BytesBuffer);
+            }
+#endif
             await Compile(module);
             var output = Testing.RunKModel(File.ReadAllBytes(Path.Join(Diagnostics.DumpScope.Current.Directory, "test.kmodel")), Diagnostics.DumpScope.Current.Directory, inputs);
             var cos = Tests.Comparator.CosSimilarity(output, Value.FromTensor(inputs[^1]))[0];
@@ -517,3 +519,39 @@ public TilingCaseReshape2()
         Add(main, new[] { input_tensor, output });
     }
 }
+
+internal sealed class TilingCaseConv2D : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseConv2D()
+    {
+        var inputShape = new[] { 8, 4, 64, 64 };
+        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+        var weightsShape = new[] { 1, 4, 3, 3 };
+        var weights = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, weightsShape).Evaluate().AsTensor().Cast<float>();
+        var bias = IR.F.Random.Normal(DataTypes.Float32, 0, 2, 2, weightsShape.Take(1).ToArray()).Evaluate().AsTensor().Cast<float>();
+        var stride = new int[] { 1, 1 };
+        var padding = new int[,] { { 0, 0 }, { 0, 0 } };
+        var dilation = new int[] { 1, 1 };
+        var groups = 1;
+        var fusedClamp = new float[] { float.NegativeInfinity, float.PositiveInfinity };
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.Conv2D(PadMode.Constant)), fin, weights, bias, stride, padding, dilation, groups, fusedClamp);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("conv2d", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}

From da74c6f8c3cb09debf6c003bd0bfd63bda7bd578 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 27 Sep 2023 19:58:16 +0800
Subject: [PATCH 219/308] support dilated conv2d

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 35 ++++++++++---------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index a10b032b9c..0140d2869c 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -124,8 +124,8 @@ T *im2col(tensor<T, InLoc> &input, dims_t filter, dims_t padding, dims_t stride,
     int32_t H = input.dimension()[2] + padding[0] + padding[2];
     int32_t W = input.dimension()[3] + padding[1] + padding[3];
 
-    int32_t OH = (H - filter[0]) / stride[0] + 1;
-    int32_t OW = (W - filter[1]) / stride[1] + 1;
+    int32_t OH = (H - dilation[0] * (filter[0] - 1) - 1) / stride[0] + 1;
+    int32_t OW = (W - dilation[1] * (filter[1] - 1) - 1) / stride[1] + 1;
 
     auto cols = (T *)runtime_util->malloc((C * filter[0] * filter[1]) *
                                           (OH * OW * N) * sizeof(T));
@@ -140,11 +140,11 @@ T *im2col(tensor<T, InLoc> &input, dims_t filter, dims_t padding, dims_t stride,
                         for (auto b = 0; b < N; b++) {
                             auto col = e * OW * N + f * N + b;
                             auto out_index = row * (OH * OW * N) + col;
-                            auto in_index =
-                                b * input.strides()[0] +
-                                c * input.strides()[1] +
-                                (stride[0] * e + r) * input.strides()[2] +
-                                (stride[1] * f + s);
+                            auto in_index = b * input.strides()[0] +
+                                            c * input.strides()[1] +
+                                            (stride[0] * e + r * dilation[0]) *
+                                                input.strides()[2] +
+                                            (stride[1] * f + s * dilation[1]);
                             if (row < padding[0] || col < padding[1]) {
                                 cols[out_index] = 0;
                             } else {
@@ -171,12 +171,12 @@ void conv2d(thread_context &ctx, tensor<T, InLoc> &input,
     size_t M = weight.dimension()[0];
     dims_t filter = {weight.dimension()[2], weight.dimension()[3]};
 
-    size_t OH = (H - filter[0]) / stride[0] + 1;
-    size_t OW = (W - filter[1]) / stride[1] + 1;
+    int32_t OH = (H - dilation[0] * (filter[0] - 1) - 1) / stride[0] + 1;
+    int32_t OW = (W - dilation[1] * (filter[1] - 1) - 1) / stride[1] + 1;
 
     auto input_cols =
         im2col<T, InLoc>(input, filter, padding, stride, dilation, groups);
-    auto mm = tensor<T>({M, OH*OW*N});
+    auto mm = tensor<T>({M, OH * OW * N});
     kernels::matmul(
         weight.cdata().data(), input_cols, mm.data().data(),
         gsl::make_span(dims_t{M, C * filter[0] * filter[1]}),
@@ -185,7 +185,7 @@ void conv2d(thread_context &ctx, tensor<T, InLoc> &input,
         gsl::make_span(dims_t{OH * OW * N, 1}),
         gsl::make_span(dims_t{M, OH * OW * N}),
         gsl::make_span(dims_t{OH * OW * N, 1}));
-    
+
     switch (strategy) {
     case reduce_strategy_t::by_thread:
         tdma_reduce_async(mm, mm, reduce_op_t::sum, ctx);
@@ -197,16 +197,17 @@ void conv2d(thread_context &ctx, tensor<T, InLoc> &input,
     default:
         break;
     }
-    kernels::binary(binary_op_t::add, mm.cdata().data(), bias.cdata().data(), mm.data().data(),
-                    gsl::make_span(dims_t{M, OH * OW * N}),
+    kernels::binary(binary_op_t::add, mm.cdata().data(), bias.cdata().data(),
+                    mm.data().data(), gsl::make_span(dims_t{M, OH * OW * N}),
                     gsl::make_span(dims_t{OH * OW * N, 1}),
                     gsl::make_span(dims_t{M, 1}), gsl::make_span(dims_t{1, 1}),
                     gsl::make_span(dims_t{M, OH * OW * N}),
                     gsl::make_span(dims_t{OH * OW * N, 1}));
-    kernels::transpose(
-        mm.cdata().data(), output.data().data(), gsl::make_span(dims_t{M, OH, OW, N}),
-        gsl::make_span(dims_t{3, 0, 1, 2}),
-        gsl::make_span(dims_t{OH * OW * N, OW * N, N, 1}), output.strides());
+    kernels::transpose(mm.cdata().data(), output.data().data(),
+                       gsl::make_span(dims_t{M, OH, OW, N}),
+                       gsl::make_span(dims_t{3, 0, 1, 2}),
+                       gsl::make_span(dims_t{OH * OW * N, OW * N, N, 1}),
+                       output.strides());
 }
 
 template <typename T, loc_t ALoc, loc_t BLoc>

From 56b3a13d8bb08b6edfdf1b2c1d533a85da1e7f56 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 9 Oct 2023 17:38:54 +0800
Subject: [PATCH 220/308] add mha pattern

---
 .../Passes/Rules/MHACombine.cs                | 49 ++++++++++++-------
 src/Nncase.Compiler/Compiler.cs               |  4 +-
 src/Nncase.Core/IR/NN/Conv2D.cs               |  2 +-
 src/Nncase.Passes/Rules/Neutral/NormAxis.cs   | 17 +++++++
 4 files changed, 51 insertions(+), 21 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs
index 3d883c66f5..2fe2459866 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs
@@ -26,30 +26,36 @@ namespace Nncase.Passes.Rules;
 
 /// <summary>
 /// Convert QKV computation to MHA style.
+/// %9 = MatMul(%2, const(f32[768,768]))
+/// %10 = Add(BinaryOp.Add, const(f32[768]), %9)
+/// %11 = Reshape(%10, const(i32[4] : {1,77,12,64}))
+/// %12 = Transpose(%11, const(i64[4] : {0L,2L,1L,3L}))
+/// %13 = Reshape(%12, const(i32[3] : {12,77,64})).
 /// </summary>
 [RuleGenerator]
 public sealed partial class MHACombine : IRewriteRule
 {
-    public IPattern Pattern { get; } =
-        IsTranspose(
-        "tp",
-        "tpCall",
-        _ => true,
-        IsReshape(
-            "rshape",
-            "rshapeCall",
-            _ => true,
-            IsMatMul(
-                "mm",
-                "mmCall",
-                _ => true,
-                IsWildcard("x"),
-                IsTensorConst("w")),
-            IsTensorConst("newShape")),
-        IsTensorConst("perm")) with
-        { TypePattern = HasFixedShape() };
+    public MHACombine(bool hasBias)
+    {
+        HasBias = hasBias;
+        Pattern v0 = IsMatMul("mm", "mmCall", IsWildcard("x"), IsTensorConst("w"));
+        if (HasBias)
+        {
+            v0 = IsAlt(
+                IsBinary("add", "addCall", op => op.BinaryOp == BinaryOp.Add, IsTensorConst("bias"), v0),
+                IsBinary("add", "addCall", op => op.BinaryOp == BinaryOp.Add, v0, IsTensorConst("bias")));
+        }
+
+        var v1 = IsReshape("rshape", "rshapeCall", v0, IsTensorConst("newShape"));
+        var v2 = IsTranspose("tp", "tpCall", v1, IsTensorConst("perm")) with { TypePattern = HasFixedShape() };
+        Pattern = v2;
+    }
+
+    public bool HasBias { get; }
 
-    private Expr? GetReplace(Expr x, Call mmCall, Call rshapeCall, Call tpCall, TensorConst w, TensorConst newShape, TensorConst perm)
+    public IPattern Pattern { get; }
+
+    private Expr? GetReplace(Expr x, Call mmCall, TensorConst w, TensorConst newShape, TensorConst perm, IMatchResult matchResult)
     {
         var mmOutShape = mmCall.CheckedShape.ToValueArray();
         var wReshape = newShape.Value.ToArray<int>().TakeLast(2).ToArray();
@@ -62,6 +68,11 @@ public sealed partial class MHACombine : IRewriteRule
         {
             var newW = Tensors.Transpose(Tensors.Reshape(w, new[] { -1, wReshape[0], wReshape[1] }), new[] { 1, 0, 2 });
             var newMm = Tensors.MatMul(Tensors.Unsqueeze(x, new[] { 1 }), newW);
+            if (HasBias)
+            {
+                return IR.F.Math.Add(newMm, Tensors.Reshape((TensorConst)matchResult["bias"], new[] { -1, 1, wReshape[1] }));
+            }
+
             return newMm;
         }
 
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index df10a630cf..c53b99af43 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -99,6 +99,7 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.Neutral.NormAxisGather>();
             p.Add<Passes.Rules.Neutral.NormAxisConcat>();
             p.Add<Passes.Rules.Neutral.NormAxisReduce>();
+            p.Add<Passes.Rules.Neutral.NormAxisReshape>();
             p.Add<Passes.Rules.Neutral.SqueezeTransposeShape>();
             p.Add<Passes.Rules.Neutral.Squeeze5DTranspose>();
             p.Add<Passes.Rules.Neutral.SqueezeBinaryShape>();
@@ -182,7 +183,8 @@ public void TargetIndependentPass(IPassManager passManager)
 
         passManager.AddWithName<DataflowPass>("MHAFusion").Configure(p =>
         {
-            p.Add<Passes.Rules.MHACombine>();
+            p.Add<Passes.Rules.MHACombine>(true);
+            p.Add<Passes.Rules.MHACombine>(false);
             p.Add<Passes.Rules.Neutral.FoldConstCall>();
 
             // p.Add<Passes.Rules.DumpMM>();
diff --git a/src/Nncase.Core/IR/NN/Conv2D.cs b/src/Nncase.Core/IR/NN/Conv2D.cs
index 84c944e380..0607870481 100644
--- a/src/Nncase.Core/IR/NN/Conv2D.cs
+++ b/src/Nncase.Core/IR/NN/Conv2D.cs
@@ -26,7 +26,7 @@ public sealed partial class Conv2D : Op
     /// <summary>
     /// Gets Weights.
     /// </summary>
-    public static readonly ParameterInfo Weights = new(typeof(Conv2D), 1, "weights",  HasRank(4), ParameterKind.Input);
+    public static readonly ParameterInfo Weights = new(typeof(Conv2D), 1, "weights", HasRank(4), ParameterKind.Input);
 
     /// <summary>
     /// Gets Bias.
diff --git a/src/Nncase.Passes/Rules/Neutral/NormAxis.cs b/src/Nncase.Passes/Rules/Neutral/NormAxis.cs
index 7b23850ca3..8f20454a30 100644
--- a/src/Nncase.Passes/Rules/Neutral/NormAxis.cs
+++ b/src/Nncase.Passes/Rules/Neutral/NormAxis.cs
@@ -62,3 +62,20 @@ public sealed partial class NormAxisReduce : RewriteRule<CallPattern>
         return call;
     }
 }
+
+[RuleGenerator]
+public sealed partial class NormAxisReshape : RewriteRule<CallPattern>
+{
+    /// <inheritdoc/>
+    public override CallPattern Pattern { get; } = IsReshape("reshape", "call", IsWildcard("input") with { TypePattern = HasFixedShape() }, IsTensorConst("newshape")) with { TypePattern = HasFixedShape() };
+
+    private Expr? GetReplace(Call call, Expr input, int[] newshape)
+    {
+        if (newshape.Any(dim => dim < 0))
+        {
+            return IR.F.Tensors.Reshape(input, call.CheckedShape.ToValueArray());
+        }
+
+        return null;
+    }
+}

From 030c5edc09c64c22153b32b8eaaa560039b0822f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 9 Oct 2023 17:40:13 +0800
Subject: [PATCH 221/308] add combine reshape transpose

---
 src/Nncase.Compiler/Compiler.cs               |  1 +
 .../Rules/Neutral/CombineReshape.cs           | 76 +++++++++++++++++++
 src/Nncase.Tests/Rewrite/RewriteBase.cs       | 25 ++++++
 .../Rewrite/UnitTestEGraphRewriteFactory.cs   |  3 +-
 .../Rules/Neutral/UnitTestCombineReshape.cs   | 40 ++++++++++
 5 files changed, 144 insertions(+), 1 deletion(-)

diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 9895f6e0b5..4630d40a6f 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -157,6 +157,7 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.Neutral.CombineUnaryReshape>();
             p.Add<Passes.Rules.Neutral.CombineActivationsReshape>();
             p.Add<Passes.Rules.Neutral.CombineReshapePad>();
+            p.Add<Passes.Rules.Neutral.CombineReshapeTranspose>();
             p.Add<Passes.Rules.Neutral.FoldNopPad>();
             p.Add<Passes.Rules.Neutral.FoldConv2DPads>();
             p.Add<Passes.Rules.Neutral.FuseClampConv2D>();
diff --git a/src/Nncase.Passes/Rules/Neutral/CombineReshape.cs b/src/Nncase.Passes/Rules/Neutral/CombineReshape.cs
index 3f0c2be75d..2fd58e18dd 100644
--- a/src/Nncase.Passes/Rules/Neutral/CombineReshape.cs
+++ b/src/Nncase.Passes/Rules/Neutral/CombineReshape.cs
@@ -201,3 +201,79 @@ public sealed partial class CombineReshapePad : IRewriteRule
         return null;
     }
 }
+
+/// <summary>
+/// combine reshape transpose
+/// e.g. :
+/// %5 // f32[1,77,768]
+/// %6 = Reshape(%5, const(i64[4] : {1L,77L,12L,64L})): // f32[1,77,12,64]
+/// %7 = Transpose(%6, const(i64[4] : {0L,2L,1L,3L})): // f32[1,12,77,64]
+/// %8 = Reshape(%7, const(i32[3] : {12,77,64})): // f32[12,77,64].
+/// after combine :
+/// %5 // f32[1,77,768]
+/// %6 = Reshape(%5, const(i64[4] : {1L,77L,12L,64L})): // f32[1,77,12,64]
+/// %7 = Reshape(%6, const(i64[3] : {77L,12L,64L})): // f32[77L,12L,64L].
+/// %8 = Transpose(%7, const(i64[4] : {1L,0L,2L})): // f32[12,77,64].
+/// then use foldreshape.
+/// </summary>
+[RuleGenerator]
+public sealed partial class CombineReshapeTranspose : IRewriteRule
+{
+    /// <inheritdoc/>
+    public IPattern Pattern { get; } = IsReshape(
+        IsTranspose(
+            null,
+            "trans",
+            IsWildcard("input") with { TypePattern = HasFixedShape() },
+            IsTensorConst("perm")) with
+        { TypePattern = HasFixedShape() },
+        IsTensorConst("newShape"));
+
+    private int FindViewAxis(int[] oldShape, int[] newShape)
+    {
+        var indices = Enumerable.Range(0, oldShape.Length).ToList();
+        foreach (var dim in newShape)
+        {
+            for (int i = 0; i < oldShape.Length; i++)
+            {
+                if (oldShape[i] == dim && indices.IndexOf(i) != -1)
+                {
+                    indices.Remove(i);
+                }
+            }
+        }
+
+        var oneindex = (indices.Count == 1) ? indices[0] : -1;
+        return oneindex;
+    }
+
+    private Expr? GetReplace(Expr input, Call trans, int[] newShape, int[] perm)
+    {
+        var transShape = trans.CheckedShape.ToValueArray();
+
+        if (transShape.Length == newShape.Length + 1)
+        {
+            // check reshape is sequeeze
+            var viewAxis = FindViewAxis(transShape, newShape);
+            if (viewAxis == -1)
+            {
+                return null;
+            }
+
+            var inv = perm.Select((p, i) => (p, i)).OrderBy(tp => tp.p).ToArray();
+            var invViewAxis = inv.Where(tp => tp.i == viewAxis).First().p;
+            var invPerm = perm.ToList();
+            var invNewShape = input.CheckedShape.ToValueList();
+            invNewShape.RemoveAt(invViewAxis);
+            invPerm.Remove(invViewAxis);
+            return IR.F.Tensors.Transpose(IR.F.Tensors.Reshape(input, invNewShape.ToArray()), invPerm.Select(i => i > invViewAxis ? i - 1 : i).ToArray());
+        }
+        else if (transShape.Length == newShape.Length - 1)
+        {
+            // check rehsape is unsequeeze
+            return null;
+        }
+
+        return null;
+    }
+}
diff --git a/src/Nncase.Tests/Rewrite/RewriteBase.cs b/src/Nncase.Tests/Rewrite/RewriteBase.cs
index 3fd4de87fe..9f4e8b9fb0 100644
--- a/src/Nncase.Tests/Rewrite/RewriteBase.cs
+++ b/src/Nncase.Tests/Rewrite/RewriteBase.cs
@@ -2874,3 +2874,28 @@ public PReluTransposeCase()
 
     public Dictionary<Var, IValue> FeedDict { get; }
 }
+
+public sealed class ReshapeTransposeReshapeCase : IRewriteCase
+{
+    public ReshapeTransposeReshapeCase()
+    {
+        var input = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 77, 768 }));
+        {
+            var v0 = Reshape(input, new[] { 1, 77, 12, 64 });
+            var v2 = Transpose(v0, new[] { 0, 2, 1, 3 });
+            var v3 = Reshape(v2, new[] { 12, 77, 64 });
+            PreExpr = new Function(v3, new[] { input });
+        }
+
+        FeedDict = new() { { input, IR.F.Random.Normal(new[] { 1, 77, 768 }).Evaluate() } };
+    }
+
+    public Function PreExpr { get; }
+
+    public IEnumerable<Type> Rules => new[] {
+        typeof(CombineReshapeTranspose),
+        typeof(FoldTwoReshapes),
+    };
+
+    public Dictionary<Var, IValue> FeedDict { get; }
+}
diff --git a/src/Nncase.Tests/Rewrite/UnitTestEGraphRewriteFactory.cs b/src/Nncase.Tests/Rewrite/UnitTestEGraphRewriteFactory.cs
index 61db6ea870..6ec5e4721b 100644
--- a/src/Nncase.Tests/Rewrite/UnitTestEGraphRewriteFactory.cs
+++ b/src/Nncase.Tests/Rewrite/UnitTestEGraphRewriteFactory.cs
@@ -28,7 +28,7 @@ public UnitTestEGraphRewriteFactory()
 
     public static TheoryData<IRewriteCase> DataOne => new()
     {
-        new PReluTransposeCase(),
+        new ReshapeTransposeReshapeCase(),
     };
 
     public static TheoryData<IRewriteCase> DataAll => new()
@@ -111,6 +111,7 @@ public UnitTestEGraphRewriteFactory()
         new ResizeImageCase(),
         new ProdCase(),
         new MultiReshapeCase(),
+        new PReluTransposeCase(),
     };
 
     [Theory]
diff --git a/src/Nncase.Tests/Rules/Neutral/UnitTestCombineReshape.cs b/src/Nncase.Tests/Rules/Neutral/UnitTestCombineReshape.cs
index 9295d4e159..4a0ad063a9 100644
--- a/src/Nncase.Tests/Rules/Neutral/UnitTestCombineReshape.cs
+++ b/src/Nncase.Tests/Rules/Neutral/UnitTestCombineReshape.cs
@@ -35,6 +35,24 @@ public class UnitTestCombineReshape : TransformTestBase
         { BinaryOp.Sub, new[] { 1 }, new[] { 1, 32, 32, 64, }, new[] { 1, 1024, 64, 1 }, true },
     };
 
+    public static readonly TheoryData<int[], int[], int[]> TestCombineReshapeTransposePostiveData =
+    new()
+    {
+        { new[] { 1, 77, 12, 64 }, new[] { 0, 2, 1, 3 }, new[] { 12, 77, 64 } },
+        { new[] { 1, 77, 12, 64 }, new[] { 2, 0, 1, 3 }, new[] { 12, 77, 64 } },
+        { new[] { 1, 77, 12, 64 }, new[] { 2, 1, 0, 3 }, new[] { 12, 77, 64 } },
+        { new[] { 1, 77, 12, 64 }, new[] { 2, 1, 3, 0 }, new[] { 12, 77, 64 } },
+        { new[] { 77, 12, 1, 64 }, new[] { 0, 2, 1, 3 }, new[] { 77, 12, 64 } },
+        { new[] { 77, 12, 1, 64 }, new[] { 3, 0, 2, 1 }, new[] { 64, 77, 12 } },
+    };
+
+    public static readonly TheoryData<int[], int[], int[]> TestCombineReshapeTransposeNegativeData =
+    new()
+    {
+        { new[] { 1, 77, 1, 64 }, new[] { 2, 1, 3, 0 }, new[] { 77, 64, 1 } },
+        { new[] { 1, 77, 12, 64 }, new[] { 1, 0, 2, 3 }, new[] { 1, 77, 768 } },
+    };
+
     public static IEnumerable<object[]> CombineBinaryReshapePositiveData =>
         new[]
         {
@@ -197,4 +215,26 @@ public void TestCombineReshapePadNegative(int[] inShape, int[] shape, int[] pads
         var rootPre = Tensors.Reshape(NN.Pad(a, Tensor.From(pads, new[] { pads.Length / 2, 2 }), PadMode.Constant, 0f), shape);
         TestNotMatch<CombineReshapePad>(rootPre);
     }
+
+    [Theory]
+    [MemberData(nameof(TestCombineReshapeTransposePostiveData))]
+    public void TestCombineReshapeTransposePostive(int[] inShape, int[] perm, int[] newshape)
+    {
+        var input = new Var("input", new TensorType(DataTypes.Float32, inShape));
+        var feed_dict = new Dictionary<Var, IValue>
+        {
+            { input, Random.Normal(DataTypes.Float32, 0, 1, 0, inShape).Evaluate() },
+        };
+        var rootPre = Tensors.Reshape(Tensors.Transpose(input, perm), newshape);
+        TestMatched<CombineReshapeTranspose>(rootPre, feed_dict);
+    }
+
+    [Theory]
+    [MemberData(nameof(TestCombineReshapeTransposeNegativeData))]
+    public void TestCombineReshapeTransposeNegative(int[] inShape, int[] perm, int[] newshape)
+    {
+        var input = new Var("input", new TensorType(DataTypes.Float32, inShape));
+        var rootPre = Tensors.Reshape(Tensors.Transpose(input, perm), newshape);
+        TestNotMatch<CombineReshapeTranspose>(rootPre);
+    }
 }

From 1cf7cf70795dfa2a8bc7b0377f893211a0899bd5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 11 Oct 2023 10:35:34 +0800
Subject: [PATCH 222/308] fix mha fusion/ add rules

---
 .../Passes/Rules/CombineMHA.cs                | 121 ++++++++++++++++++
 .../Passes/Rules/MHACombine.cs                |  81 ------------
 .../Passes/Rules/MHAFusion.cs                 |  76 ++++++++++-
 src/Nncase.Compiler/Compiler.cs               |   7 +-
 src/Nncase.Core/IR/NN/Activations.cs          |   5 +
 src/Nncase.Core/IR/NN/Functional.cs           |   7 +-
 src/Nncase.Core/IR/NN/LayerNorm.cs            |   2 +
 src/Nncase.Core/LinqExtensions.cs             |  17 +++
 src/Nncase.Core/PatternMatch/MatchResult.cs   |   2 +-
 src/Nncase.Evaluator/NN/Activations.cs        |   3 +-
 .../Mutators/IFusionMergeRule.cs              |   8 +-
 .../Rules/Neutral/CombineReshape.cs           |  20 +--
 .../Rules/Neutral/CombineTranspose.cs         |  44 +++++++
 .../Rules/Neutral/FoldReshape.cs              |  23 ++++
 src/Nncase.Passes/Rules/Neutral/FoldSwish.cs  |  41 +++---
 src/Nncase.Passes/RulesUtility.cs             |  38 ++++++
 src/Nncase.Tests/Rewrite/RewriteBase.cs       |  25 ++++
 .../Rewrite/UnitTestDataFlowRewriteFactory.cs |   3 +-
 .../Rules/Neutral/UnitTestCombineReshape.cs   |  35 +++--
 .../Rules/Neutral/UnitTestCombineTranspose.cs |  41 +++++-
 .../Rules/Neutral/UnitTestFoldReshape.cs      |  18 +++
 21 files changed, 467 insertions(+), 150 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/CombineMHA.cs
 delete mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs
 create mode 100644 src/Nncase.Passes/RulesUtility.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/CombineMHA.cs b/modules/Nncase.Modules.CPU/Passes/Rules/CombineMHA.cs
new file mode 100644
index 0000000000..e8de33a9e5
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/CombineMHA.cs
@@ -0,0 +1,121 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.CPU;
+using Nncase.IR.F;
+using Nncase.IR.Math;
+using Nncase.IR.NN;
+using Nncase.IR.Tensors;
+using Nncase.Passes.Rules.Neutral;
+using Nncase.PatternMatch;
+using Nncase.Targets;
+using static Nncase.IR.TypePatternUtility;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.F.Tensors;
+using static Nncase.PatternMatch.Utility;
+using static Nncase.Utilities.ReplaceUtility;
+
+namespace Nncase.Passes.Rules;
+
+/// <summary>
+/// Convert QKV computation to MHA style.
+/// %9 = MatMul(%2, const(f32[768,768]))
+/// %10 = Add(BinaryOp.Add, const(f32[768]), %9)
+/// %11 = Reshape(%10, const(i32[4] : {1,77,12,64}))
+/// %12 = Transpose(%11, const(i64[4] : {0L,2L,1L,3L}))
+/// %13 = Reshape(%12, const(i32[3] : {12,77,64})).
+/// </summary>
+[RuleGenerator]
+public sealed partial class CombineMHA : IRewriteRule
+{
+    public CombineMHA()
+    {
+        Pattern v0 = IsMatMul("mm", "mmCall", IsWildcard("x"), IsTensorConst("w"));
+
+        var bias = IsAlt(
+            IsBinary("add", "addCall", op => op.BinaryOp == BinaryOp.Add, IsTensorConst("bias"), v0),
+            IsBinary("add", "addCall", op => op.BinaryOp == BinaryOp.Add, v0, IsTensorConst("bias")),
+            v0);
+        var scale = IsAlt(
+            IsBinary("mul", "mulCall", op => op.BinaryOp == BinaryOp.Mul, bias, IsTensorConst("scale")),
+            IsBinary("mul", "mulCall", op => op.BinaryOp == BinaryOp.Mul, IsTensorConst("scale"), bias),
+            bias);
+
+        var v1 = IsReshape("rshape", "rshapeCall", scale, IsTensorConst("newShape"));
+        var v2 = IsTranspose("tp", "tpCall", v1, IsTensorConst("perm")) with { TypePattern = HasFixedShape() };
+        Pattern = v2;
+    }
+
+    public IPattern Pattern { get; }
+
+    private Expr? GetReplace(Expr x, Call mmCall, TensorConst w, TensorConst newShape, int[] perm, IMatchResult matchResult)
+    {
+        var mmOutShape = mmCall.CheckedShape.ToValueArray();
+        var wReshape = newShape.Value.ToArray<int>().TakeLast(2).ToArray();
+
+        // TODO: add more patterns, only llama65b for now
+        if (perm.Length == 4 && perm.SequenceEqual(new[] { 0, 2, 1, 3 })
+             && wReshape.Aggregate(1, (x, y) => x * y) == mmOutShape[^1]
+             && (mmOutShape.Length == 2 || (mmOutShape.Length == 3 && mmOutShape[0] == 1)))
+        {
+            var newW = Tensors.Transpose(Tensors.Reshape(w, new[] { -1, wReshape[0], wReshape[1] }), new[] { 1, 0, 2 });
+            var newMm = Tensors.MatMul(Tensors.Unsqueeze(x, new[] { 1 }), newW);
+            if (matchResult["bias"] is TensorConst bias)
+            {
+                return null;
+            }
+
+            if (matchResult["scale"] is TensorConst scale)
+            {
+                return null;
+            }
+
+            return newMm;
+        }
+        else if (perm.Length == 3 && perm.SequenceEqual(new[] { 1, 0, 2 })
+            && wReshape.Aggregate(1, (x, y) => x * y) == mmOutShape[^1]
+            && (mmOutShape.Length == 2 || (mmOutShape.Length == 3 && mmOutShape[0] == 1)))
+        {
+            var newW = Tensors.Transpose(Tensors.Reshape(w, new[] { -1, wReshape[0], wReshape[1] }), new[] { 1, 0, 2 });
+            var newMm = Tensors.MatMul(x, newW);
+            if (matchResult["bias"] is TensorConst bias)
+            {
+                newMm = IR.F.Math.Add(newMm, bias.Value.Shape.IsScalar ? bias : Tensors.Reshape(bias, new[] { -1, 1, wReshape[1] }));
+            }
+
+            if (matchResult["scale"] is TensorConst scale)
+            {
+                newMm = IR.F.Math.Mul(newMm, scale.Value.Shape.IsScalar ? scale : Tensors.Reshape(scale, new[] { -1, 1, wReshape[1] }));
+            }
+
+            return newMm;
+        }
+        else if (perm.Length == 3 && perm.SequenceEqual(new[] { 1, 2, 0 })
+            && wReshape.Aggregate(1, (x, y) => x * y) == mmOutShape[^1]
+            && (mmOutShape.Length == 2 || (mmOutShape.Length == 3 && mmOutShape[0] == 1)))
+        {
+            var newW = Tensors.Transpose(Tensors.Reshape(w, new[] { -1, wReshape[0], wReshape[1] }), new[] { 1, 0, 2 });
+            var newMm = Tensors.MatMul(x, newW);
+            if (matchResult["bias"] is TensorConst bias)
+            {
+                newMm = IR.F.Math.Add(newMm, bias.Value.Shape.IsScalar ? bias : Tensors.Reshape(bias, new[] { -1, 1, wReshape[1] }));
+            }
+
+            if (matchResult["scale"] is TensorConst scale)
+            {
+                newMm = IR.F.Math.Mul(newMm, scale.Value.Shape.IsScalar ? scale : Tensors.Reshape(scale, new[] { -1, 1, wReshape[1] }));
+            }
+
+            return Tensors.Transpose(newMm, new[] { 0, 2, 1 });
+        }
+
+        return null;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs
deleted file mode 100644
index 2fe2459866..0000000000
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHACombine.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reactive;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-using Nncase.IR.CPU;
-using Nncase.IR.F;
-using Nncase.IR.Math;
-using Nncase.IR.NN;
-using Nncase.IR.Tensors;
-using Nncase.Passes.Rules.Neutral;
-using Nncase.PatternMatch;
-using Nncase.Targets;
-using static Nncase.IR.TypePatternUtility;
-using static Nncase.PatternMatch.F.Math;
-using static Nncase.PatternMatch.F.Tensors;
-using static Nncase.PatternMatch.Utility;
-using static Nncase.Utilities.ReplaceUtility;
-
-namespace Nncase.Passes.Rules;
-
-/// <summary>
-/// Convert QKV computation to MHA style.
-/// %9 = MatMul(%2, const(f32[768,768]))
-/// %10 = Add(BinaryOp.Add, const(f32[768]), %9)
-/// %11 = Reshape(%10, const(i32[4] : {1,77,12,64}))
-/// %12 = Transpose(%11, const(i64[4] : {0L,2L,1L,3L}))
-/// %13 = Reshape(%12, const(i32[3] : {12,77,64})).
-/// </summary>
-[RuleGenerator]
-public sealed partial class MHACombine : IRewriteRule
-{
-    public MHACombine(bool hasBias)
-    {
-        HasBias = hasBias;
-        Pattern v0 = IsMatMul("mm", "mmCall", IsWildcard("x"), IsTensorConst("w"));
-        if (HasBias)
-        {
-            v0 = IsAlt(
-                IsBinary("add", "addCall", op => op.BinaryOp == BinaryOp.Add, IsTensorConst("bias"), v0),
-                IsBinary("add", "addCall", op => op.BinaryOp == BinaryOp.Add, v0, IsTensorConst("bias")));
-        }
-
-        var v1 = IsReshape("rshape", "rshapeCall", v0, IsTensorConst("newShape"));
-        var v2 = IsTranspose("tp", "tpCall", v1, IsTensorConst("perm")) with { TypePattern = HasFixedShape() };
-        Pattern = v2;
-    }
-
-    public bool HasBias { get; }
-
-    public IPattern Pattern { get; }
-
-    private Expr? GetReplace(Expr x, Call mmCall, TensorConst w, TensorConst newShape, TensorConst perm, IMatchResult matchResult)
-    {
-        var mmOutShape = mmCall.CheckedShape.ToValueArray();
-        var wReshape = newShape.Value.ToArray<int>().TakeLast(2).ToArray();
-
-        // TODO: add more patterns, only llama65b for now
-        if (perm.CheckedShape.Size == 4
-            && perm.Value.ToArray<int>().SequenceEqual(new[] { 0, 2, 1, 3 })
-             && wReshape.Aggregate(1, (x, y) => x * y) == mmOutShape[^1]
-             && (mmOutShape.Length == 2 || (mmOutShape.Length == 3 && mmOutShape[0] == 1)))
-        {
-            var newW = Tensors.Transpose(Tensors.Reshape(w, new[] { -1, wReshape[0], wReshape[1] }), new[] { 1, 0, 2 });
-            var newMm = Tensors.MatMul(Tensors.Unsqueeze(x, new[] { 1 }), newW);
-            if (HasBias)
-            {
-                return IR.F.Math.Add(newMm, Tensors.Reshape((TensorConst)matchResult["bias"], new[] { -1, 1, wReshape[1] }));
-            }
-
-            return newMm;
-        }
-
-        return null;
-    }
-}
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index 56b4bfdcc0..51b2d4f5a8 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -15,6 +15,8 @@
 using Nncase.Passes.Rules.Neutral;
 using Nncase.PatternMatch;
 using Nncase.Targets;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.F.NN;
 using static Nncase.PatternMatch.F.Tensors;
 using static Nncase.PatternMatch.Utility;
 using static Nncase.Utilities.ReplaceUtility;
@@ -33,6 +35,16 @@ public MHAMerger(IReadOnlyDictionary<Expr, Var> multiVarMap)
         _multiVarMap = multiVarMap;
     }
 
+    protected override Expr VisitCall(Call expr, Unit context)
+    {
+        if (_multiVarMap.TryGetValue(expr, out var newVar))
+        {
+            return newVar;
+        }
+
+        return base.VisitCall(expr, context);
+    }
+
     protected override Expr VisitLeafCall(Call expr, Unit context)
     {
         var target = Clone(expr.Target, context);
@@ -124,7 +136,7 @@ private static Pattern CreatePattern()
             new Var(mask.CheckedType!),
         };
 
-        var callFusion = new Call(new Fusion("MHABertBase", $"{root.Target.GetType().Name}", "cpu", root, newInputs.OfType<Var>().ToArray()), x, mask);
+        var callFusion = new Call(new Fusion("MHABertBase", $"{nameof(FuseMHA1)}_{Count}", ModuleKind, root, newInputs.OfType<Var>().ToArray()), x, mask);
         return callFusion;
     }
 }
@@ -239,7 +251,67 @@ private static Pattern CreatePattern()
         var merger = new MHAMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("MHALLaMA65B", $"{root.Target.GetType().Name}", "cpu", clonedRoot, newInputs.OfType<Var>().ToArray()), hidden_in, position_ids, attn_mask);
+        var callFusion = new Call(new Fusion("MHALLaMA65B", $"{nameof(FuseMHA2)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), hidden_in, position_ids, attn_mask);
+        return callFusion;
+    }
+}
+
+/// <summary>
+/// stable-disffusion text encoder.
+/// </summary>
+[RuleGenerator]
+public sealed partial class FuseMHA3 : FusionMaker
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern => CreatePattern();
+
+    private static Pattern CreatePattern()
+    {
+        var v19 = IsWildcard("input");
+        var v20 = IsLayerNorm(2, 0.000009999999747378752f, true, v19, IsTensorConst(), IsTensorConst()); // f32[1,77,768]
+        var v21 = IsMatMul(v20, IsTensorConst()); // f32[1,77,3072]
+        var v22 = IsBinary(BinaryOp.Add, IsTensorConst(), v21); // f32[1,77,3072]
+        var v23 = IsSwish(v22, IsTensorConst()); // f32[1,77,3072]
+        var v24 = IsMatMul(v23, IsTensorConst()); // f32[1,77,768]
+        var v25 = IsBinary(BinaryOp.Add, IsTensorConst(), v24); // f32[1,77,768]
+        var v26 = IsBinary(BinaryOp.Add, v19, v25); // f32[1,77,768]
+        var v27 = IsLayerNorm(2, 0.000009999999747378752f, true, v26, IsTensorConst(), IsTensorConst()); // f32[1,77,768]
+        var v28 = IsMatMul(v27, IsTensorConst()); // f32[12,77,64]
+        var v29 = IsBinary(BinaryOp.Add, v28, IsTensorConst()); // f32[12,77,64]
+        var v30 = IsBinary(BinaryOp.Mul, v29, IsTensorConst()); // f32[12,77,64]
+        var v31 = IsMatMul(v27, IsTensorConst()); // f32[12,77,64]
+        var v32 = IsBinary(BinaryOp.Add, v31, IsTensorConst()); // f32[12,77,64]
+        var v33 = IsTranspose(v32, IsTensorConst()); // f32[12,64,77]
+        var v34 = IsMatMul(v30, v33); // f32[12,77,77]
+        var v35 = IsBinary(BinaryOp.Add, v34, IsTensorConst()); // f32[12,77,77]
+        var v36 = IsSoftmax(v35, IsTensorConst()); // f32[12,77,77]
+        var v37 = IsMatMul(v27, IsTensorConst()); // f32[12,77,64]
+        var v38 = IsBinary(BinaryOp.Add, v37, IsTensorConst()); // f32[12,77,64]
+        var v39 = IsMatMul(v36, v38); // f32[12,77,64]
+        var v40 = IsTranspose(v39, IsTensorConst()); // f32[77,12,64]
+        var v41 = IsReshape(v40, IsTensorConst()); // f32[1,77,768]
+        var v42 = IsMatMul(v41, IsTensorConst()); // f32[1,77,768]
+        var v43 = IsBinary(BinaryOp.Add, IsTensorConst(), v42); // f32[1,77,768]
+        var v44 = IsBinary(null, "root", BinaryOp.Add, v26, v43); // f32[1,77,768]
+        return v44;
+    }
+
+    private Call? GetReplace(Call root, Expr input)
+    {
+        var newInputs = new List<Expr>
+        {
+            new Var(input.CheckedType!),
+        };
+
+        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
+        {
+            { input, (Var)newInputs[0] },
+        };
+        var merger = new MHAMerger(multiVarMap);
+        var clonedRoot = merger.Clone(root, default);
+
+        var callFusion = new Call(new Fusion("MHASDTextEncoder", $"{nameof(FuseMHA3)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
         return callFusion;
     }
 }
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index c53b99af43..cd716d0ee6 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -163,6 +163,8 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.Neutral.CombineUnaryReshape>();
             p.Add<Passes.Rules.Neutral.CombineActivationsReshape>();
             p.Add<Passes.Rules.Neutral.CombineReshapePad>();
+            p.Add<Passes.Rules.Neutral.CombineReshapeTranspose>();
+            p.Add<Passes.Rules.Neutral.CombineTransposeReshape>();
             p.Add<Passes.Rules.Neutral.FoldNopPad>();
             p.Add<Passes.Rules.Neutral.FoldConv2DPads>();
             p.Add<Passes.Rules.Neutral.FuseClampConv2D>();
@@ -174,6 +176,7 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.Neutral.ReshapeToTranspose>();
             p.Add<Passes.Rules.Neutral.FoldNopReshape>();
             p.Add<Passes.Rules.Neutral.FoldTwoReshapes>();
+            p.Add<Passes.Rules.Neutral.FoldReshapeBinaryConstReshape>();
             p.Add<Passes.Rules.Neutral.ReluToClamp>();
             p.Add<Passes.Rules.Neutral.Relu6ToClamp>();
             p.Add<Passes.Rules.Neutral.FoldNopSlice>();
@@ -183,8 +186,7 @@ public void TargetIndependentPass(IPassManager passManager)
 
         passManager.AddWithName<DataflowPass>("MHAFusion").Configure(p =>
         {
-            p.Add<Passes.Rules.MHACombine>(true);
-            p.Add<Passes.Rules.MHACombine>(false);
+            p.Add<Passes.Rules.CombineMHA>();
             p.Add<Passes.Rules.Neutral.FoldConstCall>();
 
             // p.Add<Passes.Rules.DumpMM>();
@@ -192,6 +194,7 @@ public void TargetIndependentPass(IPassManager passManager)
             // p.Add<Passes.Rules.DumpGather>();
             p.Add<Passes.Rules.FuseMHA1>();
             p.Add<Passes.Rules.FuseMHA2>();
+            p.Add<Passes.Rules.FuseMHA3>();
         });
 
         _compileSession.Target.RegisterTargetInDependentPass(passManager, _compileSession.CompileOptions);
diff --git a/src/Nncase.Core/IR/NN/Activations.cs b/src/Nncase.Core/IR/NN/Activations.cs
index 523a4018d2..1866e65220 100644
--- a/src/Nncase.Core/IR/NN/Activations.cs
+++ b/src/Nncase.Core/IR/NN/Activations.cs
@@ -155,6 +155,11 @@ public sealed partial class Swish : ActivationOp
     /// Gets input.
     /// </summary>
     public static readonly ParameterInfo Input = new(typeof(Swish), 0, "input", ParameterKind.Input);
+
+    /// <summary>
+    /// Gets beta.
+    /// </summary>
+    public static readonly ParameterInfo Beta = new(typeof(Swish), 1, "beta", IsFloatScalar());
 }
 
 /// <summary>
diff --git a/src/Nncase.Core/IR/NN/Functional.cs b/src/Nncase.Core/IR/NN/Functional.cs
index bc99c82c77..7f2e1dee07 100644
--- a/src/Nncase.Core/IR/NN/Functional.cs
+++ b/src/Nncase.Core/IR/NN/Functional.cs
@@ -101,5 +101,10 @@ public static Call ReduceWindow2D(ReduceOp reduceOp, Expr input, Expr initValue,
     /// <summary>
     /// create Swish call.
     /// </summary>
-    public static Call Swish(Expr input) => new Call(new Swish(), input);
+    public static Call Swish(Expr input) => new Call(new Swish(), input, 1);
+
+    /// <summary>
+    /// create Swish call.
+    /// </summary>
+    public static Call Swish(Expr input, Expr beta) => new Call(new Swish(), input, beta);
 }
diff --git a/src/Nncase.Core/IR/NN/LayerNorm.cs b/src/Nncase.Core/IR/NN/LayerNorm.cs
index 33436fe50c..2474f44fc2 100644
--- a/src/Nncase.Core/IR/NN/LayerNorm.cs
+++ b/src/Nncase.Core/IR/NN/LayerNorm.cs
@@ -38,4 +38,6 @@ public sealed partial class LayerNorm : Op
     public float Epsilon { get; }
 
     public bool UseMean { get; }
+
+    public override string DisplayProperty() => $"Axis: {Axis}, Epsilon: {Epsilon}, UseMean: {UseMean}";
 }
diff --git a/src/Nncase.Core/LinqExtensions.cs b/src/Nncase.Core/LinqExtensions.cs
index ed5a5bfa16..b40f14a8d5 100644
--- a/src/Nncase.Core/LinqExtensions.cs
+++ b/src/Nncase.Core/LinqExtensions.cs
@@ -46,6 +46,23 @@ from item in sequence
               select accseq.Concat(new[] { item }));
     }
 
+    /// <summary>
+    /// Get the permutation of the source.
+    /// </summary>
+    /// <typeparam name="T">Element type.</typeparam>
+    /// <param name="source">Source sequences.</param>
+    /// <returns>Permutated sequences.</returns>
+    public static IEnumerable<T[]> Permutate<T>(this IEnumerable<T> source)
+    {
+        return Permutation(source, Enumerable.Empty<T>());
+
+        IEnumerable<T[]> Permutation(IEnumerable<T> reminder, IEnumerable<T> prefix) =>
+            !reminder.Any() ? new[] { prefix.ToArray() } :
+            reminder.SelectMany((c, i) => Permutation(
+                reminder.Take(i).Concat(reminder.Skip(i + 1)).ToArray(),
+                prefix.Append(c)));
+    }
+
     /// <summary>
     /// take or default.
     /// </summary>
diff --git a/src/Nncase.Core/PatternMatch/MatchResult.cs b/src/Nncase.Core/PatternMatch/MatchResult.cs
index c03ab84d1b..9c086ed2a6 100644
--- a/src/Nncase.Core/PatternMatch/MatchResult.cs
+++ b/src/Nncase.Core/PatternMatch/MatchResult.cs
@@ -41,7 +41,7 @@ where kv.Key.Name is not null
     public object this[IPattern pattern] => _patternMap[pattern];
 
     /// <inheritdoc/>
-    public object this[string name] => _stringMap[name];
+    public object this[string name] => _stringMap.GetValueOrDefault(name, null!);
 
     /// <inheritdoc/>
     public IEnumerator<KeyValuePair<IPattern, object>> GetEnumerator()
diff --git a/src/Nncase.Evaluator/NN/Activations.cs b/src/Nncase.Evaluator/NN/Activations.cs
index e49f167228..2712d960d4 100644
--- a/src/Nncase.Evaluator/NN/Activations.cs
+++ b/src/Nncase.Evaluator/NN/Activations.cs
@@ -526,7 +526,8 @@ public class SwishEvaluator : IEvaluator<Swish>, ITypeInferencer<Swish>, ICostEv
     public IValue Visit(IEvaluateContext context, Swish swish)
     {
         var input = context.GetOrtArgumentValue(swish, Swish.Input);
-        return OrtKI.Mul(OrtKI.Sigmoid(input), input).ToValue();
+        var beta = context.GetOrtArgumentValue(swish, Swish.Beta);
+        return OrtKI.Mul(OrtKI.Sigmoid(input * beta), input).ToValue();
     }
 
     /// <inheritdoc/>
diff --git a/src/Nncase.Passes/Mutators/IFusionMergeRule.cs b/src/Nncase.Passes/Mutators/IFusionMergeRule.cs
index 15878bcc71..bc1e558b1e 100644
--- a/src/Nncase.Passes/Mutators/IFusionMergeRule.cs
+++ b/src/Nncase.Passes/Mutators/IFusionMergeRule.cs
@@ -668,14 +668,8 @@ private bool ProcessFusionMerge(Func<Expr, Expr> mergedFusionRewriteCallBack, Fu
         {
             if (caller_inputs[i] is Call { Target: Fusion })
             {
-                Fusion callee_fusion;
-                try
+                if (result[$"callee_fusion_{i}"] is not Fusion callee_fusion)
                 {
-                    callee_fusion = (Fusion)result[$"callee_fusion_{i}"];
-                }
-                catch (KeyNotFoundException)
-                {
-                    // when matched fusion(fusion(x,y)), the input => fusion(x,y)
                     return false;
                 }
 
diff --git a/src/Nncase.Passes/Rules/Neutral/CombineReshape.cs b/src/Nncase.Passes/Rules/Neutral/CombineReshape.cs
index 2fd58e18dd..8c36b0b537 100644
--- a/src/Nncase.Passes/Rules/Neutral/CombineReshape.cs
+++ b/src/Nncase.Passes/Rules/Neutral/CombineReshape.cs
@@ -229,24 +229,6 @@ public sealed partial class CombineReshapeTranspose : IRewriteRule
         { TypePattern = HasFixedShape() },
         IsTensorConst("newShape"));
 
-    private int FindViewAxis(int[] oldShape, int[] newShape)
-    {
-        var indices = Enumerable.Range(0, oldShape.Length).ToList();
-        foreach (var dim in newShape)
-        {
-            for (int i = 0; i < oldShape.Length; i++)
-            {
-                if (oldShape[i] == dim && indices.IndexOf(i) != -1)
-                {
-                    indices.Remove(i);
-                }
-            }
-        }
-
-        var oneindex = (indices.Count == 1) ? indices[0] : -1;
-        return oneindex;
-    }
-
     private Expr? GetReplace(Expr input, Call trans, int[] newShape, int[] perm)
     {
         var transShape = trans.CheckedShape.ToValueArray();
@@ -254,7 +236,7 @@ private int FindViewAxis(int[] oldShape, int[] newShape)
         if (transShape.Length == newShape.Length + 1)
         {
             // check reshape is sequeeze
-            var viewAxis = FindViewAxis(transShape, newShape);
+            var viewAxis = RulesUtility.FindSqueezeAxis(transShape, newShape);
             if (viewAxis == -1)
             {
                 return null;
diff --git a/src/Nncase.Passes/Rules/Neutral/CombineTranspose.cs b/src/Nncase.Passes/Rules/Neutral/CombineTranspose.cs
index c1435250b7..4d979c8a56 100644
--- a/src/Nncase.Passes/Rules/Neutral/CombineTranspose.cs
+++ b/src/Nncase.Passes/Rules/Neutral/CombineTranspose.cs
@@ -344,6 +344,50 @@ public sealed partial class CombineTransposeReduce : IRewriteRule
     }
 }
 
+/// <summary>
+/// x // [12, 77, 64]
+/// transpose(reshape(x, [1, 12, 77, 64]), [0, 2, 1, 3]) => reshape(transpose(x, [1, 0, 2]), [1, 77, 12, 64]).
+/// </summary>
+[RuleGenerator]
+public sealed partial class CombineTransposeReshape : IRewriteRule
+{
+    /// <inheritdoc/>
+    public IPattern Pattern { get; } = IsTranspose(
+        null,
+        "trans",
+        IsReshape(
+            IsWildcard("input") with { TypePattern = HasFixedShape() },
+            IsTensorConst("newShape")) with
+        { TypePattern = HasFixedShape() },
+        IsTensorConst("perm"));
+
+    private Expr? GetReplace(Call trans, Expr input, int[] newShape, int[] perm)
+    {
+        var inShape = input.CheckedShape.ToValueArray();
+        var outShape = trans.CheckedShape.ToValueArray();
+        if (!(newShape.Length == inShape.Length + 1))
+        {
+            return null;
+        }
+
+        // check reshape is sequeeze
+        var axis = RulesUtility.FindSqueezeAxis(newShape, inShape);
+        if (axis == -1)
+        {
+            return null;
+        }
+
+        var newPerm = perm.ToList();
+        newPerm.Remove(axis);
+        newPerm = newPerm.Select(i => i > axis ? i - 1 : i).ToList();
+
+        var inv = perm.Select((p, i) => (p, i)).OrderBy(tp => tp.p).ToArray();
+        var invNewShape = newPerm.Select(i => inShape[i]).ToList();
+        invNewShape.Insert(perm.ToList().IndexOf(axis), 1);
+        return Reshape(Transpose(input, newPerm.ToArray()), invNewShape.ToArray());
+    }
+}
+
 /// <summary>
 /// Combine Transpose with Unary
 /// reduce(transpose(x,p), a) => transpose(reduce(x, invtranspose(a, p)), p).
diff --git a/src/Nncase.Passes/Rules/Neutral/FoldReshape.cs b/src/Nncase.Passes/Rules/Neutral/FoldReshape.cs
index 2d12883101..013d76f86e 100644
--- a/src/Nncase.Passes/Rules/Neutral/FoldReshape.cs
+++ b/src/Nncase.Passes/Rules/Neutral/FoldReshape.cs
@@ -62,6 +62,29 @@ public sealed partial class FoldTwoReshapes : IRewriteRule
     }
 }
 
+/// <summary>
+/// Fold sequeeze reshape(binary(unsequeeze reshape(x), const)).
+/// </summary>
+[RuleGenerator]
+public sealed partial class FoldReshapeBinaryConstReshape : IRewriteRule
+{
+    /// <inheritdoc/>
+    public IPattern Pattern { get; } =
+        IsReshape(IsSwappableBinary("binary", null, b => b.BinaryOp is BinaryOp.Add or BinaryOp.Mul, IsReshape(IsWildcard("input") with { TypePattern = HasFixedShape() }, IsTensorConst("unsqShape")), IsTensorConst("binaryConst")), IsTensorConst("sqShape"));
+
+    private Expr? GetReplace(Expr input, Binary binary, int[] unsqShape, TensorConst binaryConst, int[] sqShape)
+    {
+        var inShape = input.CheckedShape.ToValueArray();
+        if (!(sqShape.SequenceEqual(inShape) && RulesUtility.FindSqueezeAxis(unsqShape, sqShape) is int axis && axis != -1 && (
+            (binaryConst.Value.Shape.Rank == unsqShape.Length && binaryConst.Value.Shape[axis].Value == 1) || (Evaluator.TypeInference.BroadcastType((TensorType)input.CheckedType, (TensorType)binaryConst.CheckedType) is TensorType outType && outType.Shape.ToValueArray().SequenceEqual(inShape)))))
+        {
+            return null;
+        }
+
+        return IR.F.Math.Binary(binary.BinaryOp, input, (binaryConst.Value.Shape.Rank == unsqShape.Length && binaryConst.Value.Shape[axis].Value == 1) ? IR.F.Tensors.Squeeze(binaryConst, new[] { axis }) : binaryConst);
+    }
+}
+
 /// <summary>
 /// Fold nop <see cref="IR.Tensors.Reshape"/>.
 /// </summary>
diff --git a/src/Nncase.Passes/Rules/Neutral/FoldSwish.cs b/src/Nncase.Passes/Rules/Neutral/FoldSwish.cs
index 0d53cca146..7cfdc3e95d 100644
--- a/src/Nncase.Passes/Rules/Neutral/FoldSwish.cs
+++ b/src/Nncase.Passes/Rules/Neutral/FoldSwish.cs
@@ -4,6 +4,7 @@
 using Nncase.IR;
 using Nncase.IR.Math;
 using Nncase.PatternMatch;
+using static Nncase.IR.TypePatternUtility;
 using static Nncase.PatternMatch.F.Math;
 using static Nncase.PatternMatch.F.NN;
 using static Nncase.PatternMatch.Utility;
@@ -11,37 +12,37 @@
 namespace Nncase.Passes.Rules.Neutral;
 
 [RuleGenerator]
-public sealed partial class FoldSwishPattern1 : RewriteRule<CallPattern>
+public sealed partial class FoldSwishPattern1 : RewriteRule<Pattern>
 {
+    public FoldSwishPattern1()
+    {
+        var input = IsWildcard("input");
+        Pattern = IsSwappableBinary(null, null, b => b.BinaryOp == BinaryOp.Mul, IsSigmoid(input), input);
+    }
+
     /// <inheritdoc/>
-    public override CallPattern Pattern { get; } =
-        IsBinary(null, "binaryCall", BinaryOp.Mul, IsSigmoid(null, "sigmoidCall", IsWildcard("input")));
+    public override Pattern Pattern { get; }
 
-    private Expr? GetReplace(Call binaryCall, Call sigmoidCall, Expr input)
+    private Expr? GetReplace(Expr input)
     {
-        if (binaryCall[Binary.Rhs] == input)
-        {
-            return IR.F.NN.Swish(input);
-        }
-
-        return null;
+        return IR.F.NN.Swish(input);
     }
 }
 
 [RuleGenerator]
-public sealed partial class FoldSwishPattern2 : RewriteRule<CallPattern>
+public sealed partial class FoldSwishPattern2 : RewriteRule<Pattern>
 {
+    public FoldSwishPattern2()
+    {
+        var input = IsWildcard("input");
+        Pattern = IsSwappableBinary(null, null, b => b.BinaryOp == BinaryOp.Mul, IsSigmoid(IsSwappableBinary(null, null, b => b.BinaryOp == BinaryOp.Mul, input, IsTensorConst("beta", IsFloatScalar()))), input);
+    }
+
     /// <inheritdoc/>
-    public override CallPattern Pattern { get; } =
-        IsBinary(null, "binaryCall", BinaryOp.Mul, IsWildcard(), IsSigmoid(null, "sigmoidCall", IsWildcard("input")));
+    public override Pattern Pattern { get; }
 
-    private Expr? GetReplace(Call binaryCall, Call sigmoidCall, Expr input)
+    private Expr? GetReplace(Expr input, TensorConst beta)
     {
-        if (binaryCall[Binary.Lhs] == input)
-        {
-            return IR.F.NN.Swish(input);
-        }
-
-        return null;
+        return IR.F.NN.Swish(input, beta);
     }
 }
diff --git a/src/Nncase.Passes/RulesUtility.cs b/src/Nncase.Passes/RulesUtility.cs
new file mode 100644
index 0000000000..29afea1468
--- /dev/null
+++ b/src/Nncase.Passes/RulesUtility.cs
@@ -0,0 +1,38 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Linq;
+
+namespace Nncase.Passes;
+
+public static class RulesUtility
+{
+    /// <summary>
+    /// find sequeezed axis index.
+    /// </summary>
+    /// <param name="oldShape">old shape.</param>
+    /// <param name="newShape">new shape.</param>
+    /// <returns>axis, if not found return -1.</returns>
+    public static int FindSqueezeAxis(int[] oldShape, int[] newShape)
+    {
+        if (oldShape.Length <= newShape.Length)
+        {
+            return -1;
+        }
+
+        var indices = Enumerable.Range(0, oldShape.Length).ToList();
+        foreach (var dim in newShape)
+        {
+            for (int i = 0; i < oldShape.Length; i++)
+            {
+                if (oldShape[i] == dim && indices.IndexOf(i) != -1)
+                {
+                    indices.Remove(i);
+                }
+            }
+        }
+
+        var oneindex = (indices.Count == 1) ? indices[0] : -1;
+        return oneindex;
+    }
+}
diff --git a/src/Nncase.Tests/Rewrite/RewriteBase.cs b/src/Nncase.Tests/Rewrite/RewriteBase.cs
index 1f875de863..9ed77ee56c 100644
--- a/src/Nncase.Tests/Rewrite/RewriteBase.cs
+++ b/src/Nncase.Tests/Rewrite/RewriteBase.cs
@@ -2899,3 +2899,28 @@ public ReshapeTransposeReshapeCase()
 
     public Dictionary<Var, IValue> FeedDict { get; }
 }
+
+public sealed class ReshapeBinaryConstReshapeCase : IRewriteCase
+{
+    public ReshapeBinaryConstReshapeCase()
+    {
+        var v9 = new Var("v9", new TensorType(DataTypes.Float32, new[] { 12, 77, 77 }));
+        {
+            var v10 = Reshape(v9, new[] { 1, 12, 77, 77 }); // f32[1,12,77,77]
+            var v11 = IR.F.Math.Add(v10, IR.F.Random.Normal(new[] { 1, 1, 77, 77 }).Evaluate().AsTensor()); // f32[1,12,77,77]
+            var v12 = Reshape(v11, new[] { 12, 77, 77 }); // f32[12,77,77]
+
+            PreExpr = new Function(v12, new[] { v9 });
+        }
+
+        FeedDict = new() { { v9, IR.F.Random.Normal(new[] { 12, 77, 77 }).Evaluate() } };
+    }
+
+    public Function PreExpr { get; }
+
+    public IEnumerable<Type> Rules => new[] {
+        typeof(FoldReshapeBinaryConstReshape),
+    };
+
+    public Dictionary<Var, IValue> FeedDict { get; }
+}
diff --git a/src/Nncase.Tests/Rewrite/UnitTestDataFlowRewriteFactory.cs b/src/Nncase.Tests/Rewrite/UnitTestDataFlowRewriteFactory.cs
index f9080652a7..06dcc60c9b 100644
--- a/src/Nncase.Tests/Rewrite/UnitTestDataFlowRewriteFactory.cs
+++ b/src/Nncase.Tests/Rewrite/UnitTestDataFlowRewriteFactory.cs
@@ -15,7 +15,7 @@ public class UnitTestDataFlowRewriteFactory : TestClassBase
 {
     public static TheoryData<IRewriteCase> DataOne => new()
     {
-        new CombineClampAddMul(),
+        new ReshapeBinaryConstReshapeCase(),
     };
 
     public static TheoryData<IRewriteCase> DataAll => new()
@@ -31,6 +31,7 @@ public class UnitTestDataFlowRewriteFactory : TestClassBase
         new Conv2DPadsCase(),
         new ReduceWindow2DPadsCase(),
         new MobileNetV1TransposeCase(),
+        new CombineClampAddMul(),
     };
 
     [Theory]
diff --git a/src/Nncase.Tests/Rules/Neutral/UnitTestCombineReshape.cs b/src/Nncase.Tests/Rules/Neutral/UnitTestCombineReshape.cs
index 4a0ad063a9..918b685d23 100644
--- a/src/Nncase.Tests/Rules/Neutral/UnitTestCombineReshape.cs
+++ b/src/Nncase.Tests/Rules/Neutral/UnitTestCombineReshape.cs
@@ -35,17 +35,6 @@ public class UnitTestCombineReshape : TransformTestBase
         { BinaryOp.Sub, new[] { 1 }, new[] { 1, 32, 32, 64, }, new[] { 1, 1024, 64, 1 }, true },
     };
 
-    public static readonly TheoryData<int[], int[], int[]> TestCombineReshapeTransposePostiveData =
-    new()
-    {
-        { new[] { 1, 77, 12, 64 }, new[] { 0, 2, 1, 3 }, new[] { 12, 77, 64 } },
-        { new[] { 1, 77, 12, 64 }, new[] { 2, 0, 1, 3 }, new[] { 12, 77, 64 } },
-        { new[] { 1, 77, 12, 64 }, new[] { 2, 1, 0, 3 }, new[] { 12, 77, 64 } },
-        { new[] { 1, 77, 12, 64 }, new[] { 2, 1, 3, 0 }, new[] { 12, 77, 64 } },
-        { new[] { 77, 12, 1, 64 }, new[] { 0, 2, 1, 3 }, new[] { 77, 12, 64 } },
-        { new[] { 77, 12, 1, 64 }, new[] { 3, 0, 2, 1 }, new[] { 64, 77, 12 } },
-    };
-
     public static readonly TheoryData<int[], int[], int[]> TestCombineReshapeTransposeNegativeData =
     new()
     {
@@ -217,7 +206,7 @@ public void TestCombineReshapePadNegative(int[] inShape, int[] shape, int[] pads
     }
 
     [Theory]
-    [MemberData(nameof(TestCombineReshapeTransposePostiveData))]
+    [ClassData(typeof(CombineReshapeTransposePostiveData))]
     public void TestCombineReshapeTransposePostive(int[] inShape, int[] perm, int[] newshape)
     {
         var input = new Var("input", new TensorType(DataTypes.Float32, inShape));
@@ -237,4 +226,26 @@ public void TestCombineReshapeTransposeNegative(int[] inShape, int[] perm, int[]
         var rootPre = Tensors.Reshape(Tensors.Transpose(input, perm), newshape);
         TestNotMatch<CombineReshapeTranspose>(rootPre);
     }
+
+    private sealed class CombineReshapeTransposePostiveData : TheoryData<int[], int[], int[]>
+    {
+        public CombineReshapeTransposePostiveData()
+        {
+            var inshapes = new[] {
+                new[] { 1, 77, 12, 64 },
+                new[] { 77, 1, 12, 64 },
+                new[] { 77, 12, 1, 64 },
+                new[] { 77, 12, 64, 1 },
+             };
+
+            var perms = new[] { 0, 1, 2, 3 }.Permutate().ToArray();
+
+            foreach (var (inshape, perm) in new[] { inshapes, perms }.CartesianProduct().Select(i => i.ToArray()).Select(i => (i[0], i[1])))
+            {
+                var newshape = perm.Select(i => inshape[i]).ToList();
+                newshape.Remove(1);
+                Add(inshape, perm, newshape.ToArray());
+            }
+        }
+    }
 }
diff --git a/src/Nncase.Tests/Rules/Neutral/UnitTestCombineTranspose.cs b/src/Nncase.Tests/Rules/Neutral/UnitTestCombineTranspose.cs
index 440a53e551..dcde48a8b7 100644
--- a/src/Nncase.Tests/Rules/Neutral/UnitTestCombineTranspose.cs
+++ b/src/Nncase.Tests/Rules/Neutral/UnitTestCombineTranspose.cs
@@ -39,14 +39,14 @@ public class UnitTestCombineTranspose : TransformTestBase
     };
 
     public static IEnumerable<object[]> CombineBinaryTransposePositiveData =>
-        new[]
-        {
+    new[]
+    {
             new object[] { new[] { 5, 4 }, new[] { 5, 4 }, new[] { 1, 0 } },
             new object[] { new[] { 4, 4 }, new[] { 4, 4 }, new[] { 1, 0 } },
             new object[] { new[] { 4 }, new[] { 4 }, new[] { 0 } },
             new object[] { new[] { 1, 3, 4 }, new[] { 1, 3, 4 }, new[] { 0, 2, 1 } },
             new object[] { new[] { 1, 3, 2, 4 }, new[] { 1, 3, 2, 4 }, new[] { 0, 2, 3, 1 } },
-        };
+    };
 
     public static IEnumerable<object[]> CombineConstBinaryTransposeNotMatchData =>
         new[]
@@ -359,4 +359,39 @@ public void TestCombineTransposeUnaryPositive(UnaryOp opType, int[] inShape, int
         var rootPre = IR.F.Math.Unary(opType, Tensors.Transpose(a, perm));
         TestMatched<CombineTransposeUnary>(rootPre, normal);
     }
+
+    [Theory]
+    [ClassData(typeof(CombineTransposeReshapePostiveData))]
+    public void TestCombineTransposeReshapePostive(int[] inShape, int[] newShape, int[] perm)
+    {
+        var a = new Var(new TensorType(DataTypes.Float32, inShape));
+        var feed_dict = new Dictionary<Var, IValue>
+        {
+            { a, Random.Normal(DataTypes.Float32, 0, 1, 0, inShape).Evaluate() },
+        };
+        var rootPre = Tensors.Transpose(Tensors.Reshape(a, newShape), perm);
+        TestMatched<CombineTransposeReshape>(rootPre, feed_dict);
+    }
+
+    private sealed class CombineTransposeReshapePostiveData : TheoryData<int[], int[], int[]>
+    {
+        public CombineTransposeReshapePostiveData()
+        {
+            var inshapes = new[] { new[] { 12, 77, 64 } };
+
+            var newShapes = new[] {
+                new[] { 1, 12, 77, 64 },
+                new[] { 12, 1, 77, 64 },
+                new[] { 12, 77, 1, 64 },
+                new[] { 12, 77, 64, 1 },
+            };
+
+            var perms = new[] { 0, 1, 2, 3 }.Permutate().ToArray();
+
+            foreach (var (a, b, c) in new[] { inshapes, newShapes, perms }.CartesianProduct().Select(i => i.ToArray()).Select(i => (i[0], i[1], i[2])))
+            {
+                Add(a, b, c);
+            }
+        }
+    }
 }
diff --git a/src/Nncase.Tests/Rules/Neutral/UnitTestFoldReshape.cs b/src/Nncase.Tests/Rules/Neutral/UnitTestFoldReshape.cs
index 2108420fa7..c608939a2d 100644
--- a/src/Nncase.Tests/Rules/Neutral/UnitTestFoldReshape.cs
+++ b/src/Nncase.Tests/Rules/Neutral/UnitTestFoldReshape.cs
@@ -19,6 +19,12 @@ namespace Nncase.Tests.Rules.NeutralTest;
 
 public class UnitTestFoldReshape : TransformTestBase
 {
+    public static TheoryData<int[], int[], int[], int[]> TestReshapeBinaryConstReshapePositiveData => new()
+    {
+        { new[] { 12, 77, 77 }, new[] { 1, 12, 77, 77 }, new[] { 1, 1, 77, 77 }, new[] { 12, 77, 77 } },
+        { new[] { 12, 77, 77 }, new[] { 1, 12, 77, 77 }, new[] { 77 }, new[] { 12, 77, 77 } },
+    };
+
     public static IEnumerable<object[]> TestFoldNopReshapePositiveData =>
         new[]
         {
@@ -99,4 +105,16 @@ public void TestReshapeToTransposeNegative(int[] shape, int[] newShape)
         var rootPre = Tensors.Reshape(a, newShape);
         TestNotMatch<ReshapeToTranspose>(rootPre);
     }
+
+    [Theory]
+    [MemberData(nameof(TestReshapeBinaryConstReshapePositiveData))]
+    public void TestReshapeBinaryConstReshapePositive(int[] inShape, int[] unsqShape, int[] constShape, int[] sqShape)
+    {
+        var a = Random.Normal(DataTypes.Float32, 0, 1, 0, inShape);
+        var v0 = Tensors.Reshape(a, unsqShape);
+        var v1 = Math.Binary(BinaryOp.Add, v0, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, constShape).Evaluate().AsTensor());
+        var v2 = Tensors.Reshape(v1, sqShape);
+        var rootPre = v2;
+        TestMatched<FoldReshapeBinaryConstReshape>(rootPre);
+    }
 }

From 96e22a7d30644edb04fe9e2d036bdd54d5d5047c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 11 Oct 2023 14:22:18 +0800
Subject: [PATCH 223/308] fix rdata map dispose

---
 .../Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs  | 11 +++++++--
 .../Passes/Rules/MHAFusion.cs                 | 22 +++++++++---------
 src/Nncase.Core/IR/TensorConst.cs             |  2 +-
 .../Diagnostics/ILPrintVisitor.cs             |  8 +------
 src/Nncase.Evaluator/Math/Binary.cs           | 23 +++++++++++--------
 .../Distributed/UnitTestTypeInfer.cs          |  5 ++++
 6 files changed, 40 insertions(+), 31 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs b/modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs
index 173b6ffeef..22a75beb56 100644
--- a/modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs
+++ b/modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs
@@ -11,9 +11,16 @@
 
 namespace Nncase.IR.CPU;
 
-[PatternFunctionalGenerator]
-public sealed partial class CPUKernelOp : Op
+public sealed class CPUKernelOp : Op
 {
+    private readonly ExprPinner _exprPinner;
+
+    public CPUKernelOp(Op target)
+    {
+        _exprPinner = new(target);
+        Target = target;
+    }
+
     /// <summary>
     /// Gets the target.
     /// </summary>
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index 51b2d4f5a8..25b088c46b 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -268,15 +268,8 @@ public sealed partial class FuseMHA3 : FusionMaker
 
     private static Pattern CreatePattern()
     {
-        var v19 = IsWildcard("input");
-        var v20 = IsLayerNorm(2, 0.000009999999747378752f, true, v19, IsTensorConst(), IsTensorConst()); // f32[1,77,768]
-        var v21 = IsMatMul(v20, IsTensorConst()); // f32[1,77,3072]
-        var v22 = IsBinary(BinaryOp.Add, IsTensorConst(), v21); // f32[1,77,3072]
-        var v23 = IsSwish(v22, IsTensorConst()); // f32[1,77,3072]
-        var v24 = IsMatMul(v23, IsTensorConst()); // f32[1,77,768]
-        var v25 = IsBinary(BinaryOp.Add, IsTensorConst(), v24); // f32[1,77,768]
-        var v26 = IsBinary(BinaryOp.Add, v19, v25); // f32[1,77,768]
-        var v27 = IsLayerNorm(2, 0.000009999999747378752f, true, v26, IsTensorConst(), IsTensorConst()); // f32[1,77,768]
+        var v26 = IsWildcard("input");
+        var v27 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v26, IsTensorConst(), IsTensorConst()); // f32[1,77,768]
         var v28 = IsMatMul(v27, IsTensorConst()); // f32[12,77,64]
         var v29 = IsBinary(BinaryOp.Add, v28, IsTensorConst()); // f32[12,77,64]
         var v30 = IsBinary(BinaryOp.Mul, v29, IsTensorConst()); // f32[12,77,64]
@@ -293,8 +286,15 @@ private static Pattern CreatePattern()
         var v41 = IsReshape(v40, IsTensorConst()); // f32[1,77,768]
         var v42 = IsMatMul(v41, IsTensorConst()); // f32[1,77,768]
         var v43 = IsBinary(BinaryOp.Add, IsTensorConst(), v42); // f32[1,77,768]
-        var v44 = IsBinary(null, "root", BinaryOp.Add, v26, v43); // f32[1,77,768]
-        return v44;
+        var v44 = IsBinary(BinaryOp.Add, v26, v43); // f32[1,77,768]
+        var v45 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v44, IsTensorConst(), IsTensorConst()); // f32[1,77,768]
+        var v46 = IsMatMul(v45, IsTensorConst()); // f32[1,77,3072]
+        var v47 = IsBinary(BinaryOp.Add, IsTensorConst(), v46); // f32[1,77,3072]
+        var v48 = IsSwish(v47, IsTensorConst()); // f32[1,77,3072]
+        var v49 = IsMatMul(v48, IsTensorConst()); // f32[1,77,768]
+        var v50 = IsBinary(BinaryOp.Add, IsTensorConst(), v49); // f32[1,77,768]
+        var v51 = IsBinary(null, "root", BinaryOp.Add, v44, v50); // f32[1,77,768]
+        return v51;
     }
 
     private Call? GetReplace(Call root, Expr input)
diff --git a/src/Nncase.Core/IR/TensorConst.cs b/src/Nncase.Core/IR/TensorConst.cs
index 64b1fd6442..9e651978ed 100644
--- a/src/Nncase.Core/IR/TensorConst.cs
+++ b/src/Nncase.Core/IR/TensorConst.cs
@@ -146,7 +146,7 @@ public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunct
     public override bool Equals(object? obj) => Equals(obj as TensorConst);
 
     /// <inheritdoc/>
-    public bool Equals(TensorConst? other) => other is not null && base.Equals(other) && EqualityComparer<Tensor>.Default.Equals(Value, other.Value);
+    public bool Equals(TensorConst? other) => other is not null && (ReferenceEquals(this, other) || GetHashCode() == other.GetHashCode()) && EqualityComparer<Tensor>.Default.Equals(Value, other.Value);
 
     /// <inheritdoc/>
     protected override int GetHashCodeCore() => HashCode.Combine(Value);
diff --git a/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs b/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
index 9393ae8a5d..4a447073b8 100644
--- a/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/ILPrintVisitor.cs
@@ -476,13 +476,7 @@ protected override string VisitPrimFunctionWrapper(PrimFunctionWrapper expr)
     /// <inheritdoc/>
     protected override string VisitOp(Op expr)
     {
-        return expr switch
-        {
-            Unary op => op.UnaryOp.ToString(),
-            Binary op => op.BinaryOp.ToString(),
-            Compare op => op.CompareOp.ToString(),
-            _ => expr.GetType().Name,
-        };
+        return expr.GetType().Name;
     }
 
     /// <inheritdoc/>
diff --git a/src/Nncase.Evaluator/Math/Binary.cs b/src/Nncase.Evaluator/Math/Binary.cs
index a65e1f921e..2e12f8b228 100755
--- a/src/Nncase.Evaluator/Math/Binary.cs
+++ b/src/Nncase.Evaluator/Math/Binary.cs
@@ -135,24 +135,33 @@ private IRType Visit(Binary target, DistributedType a, DistributedType b)
             return new InvalidType("lhs rhs have different placement");
         }
 
+        var rType = Visit(target, a.TensorType, b.TensorType);
+        if (rType is not TensorType tensorType)
+        {
+            return rType;
+        }
+
+        // assume broadcast shapes are left algin
+        var padA = tensorType.Shape.Rank - a.TensorType.Shape.Rank;
+        var padB = tensorType.Shape.Rank - b.TensorType.Shape.Rank;
         var ndsbp = new SBP[a.Placement.Rank];
         for (int i = 0; i < a.Placement.Rank; i++)
         {
             switch (a.NdSBP[i], b.NdSBP[i])
             {
                 case (SBPSplit sa, SBPSplit sb):
-                    if (sa != sb)
+                    if ((padA + sa.Axis) != (padB + sb.Axis))
                     {
                         return new InvalidType($"lhs rhs sbp at {i} not equal");
                     }
 
-                    ndsbp[i] = sa;
+                    ndsbp[i] = SBP.S(padA + sa.Axis);
                     break;
                 case (SBPSplit s1, SBPBroadCast):
-                    ndsbp[i] = s1;
+                    ndsbp[i] = SBP.S(padA + s1.Axis);
                     break;
                 case (SBPBroadCast, SBPSplit s2):
-                    ndsbp[i] = s2;
+                    ndsbp[i] = SBP.S(padB + s2.Axis);
                     break;
                 case (SBPBroadCast, SBPBroadCast):
                     ndsbp[i] = SBP.B;
@@ -174,12 +183,6 @@ private IRType Visit(Binary target, DistributedType a, DistributedType b)
             }
         }
 
-        var rType = Visit(target, a.TensorType, b.TensorType);
-        if (rType is not TensorType tensorType)
-        {
-            return rType;
-        }
-
         return new DistributedType(tensorType, ndsbp, a.Placement);
     }
 
diff --git a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
index 79a956f253..88bd52bc31 100644
--- a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
@@ -42,6 +42,11 @@ public sealed class UnitTestTypeInfer : TestClassBase
           new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
           new InvalidType(string.Empty)
         },
+        { BinaryOp.Add,
+          new DistributedType(new(DataTypes.Float32, new[] { 3072 }), new SBP[] { SBP.S(0), SBP.S(0) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 77, 3072 }), new SBP[] { SBP.B, SBP.B }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 77, 3072 }), new SBP[] { SBP.S(2), SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt"))
+        },
     };
 
     [Theory]

From c801ad8bb98ca3936808e683f339b2c6e0059ff6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 11 Oct 2023 16:32:12 +0800
Subject: [PATCH 224/308] add xpu reduce arg

---
 .../CodeGen/CSourceConvertVisitor.cs          |  3 +
 .../Evaluator/XPU/ReduceArg.cs                | 15 ++++
 .../Evaluator/XPU/XPUModule.cs                |  1 +
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  5 ++
 .../Nncase.Modules.CPU/IR/XPU/ReduceArg.cs    | 44 ++++++++++
 .../Passes/Rules/MHAFusion.cs                 | 83 ++++++++++++++++++-
 .../Passes/Tile/TIRConvertVisitor.cs          |  8 ++
 src/Nncase.Compiler/Compiler.cs               |  2 +
 src/Nncase.Core/IR/Math/ReduceArg.cs          |  4 +-
 src/Nncase.Evaluator/Math/ReduceArg.cs        | 35 ++++++--
 10 files changed, 191 insertions(+), 9 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/ReduceArg.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/ReduceArg.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 21693a6af4..eb066f9a21 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -447,6 +447,9 @@ protected override CSymbol VisitCall(Call expr)
 
                     IndentScope.Writer.Write($"conv2d(ctx, {Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {Visit(args[3]).Name}, {{{string.Join(",", conv.Stride.Select(p => p.ToString()))}}}, {{{string.Join(",", conv.Padding.Select(p => p.ToString()))}}}, {{{string.Join(",", conv.Dilation.Select(p => p.ToString()))}}}, {conv.Groups}, {strategy})");
                     break;
+                case IR.XPU.ReduceArg reduceArg:
+                    IndentScope.Writer.Write($"reduce_arg({Visit(args[0]).Name}, {Visit(args[1]).Name}, {reduceArg.Axis}, {reduceArg.KeepDims}, {reduceArg.SelectLastIndex}, {reduceArg.ReduceArgOp}, {reduceArg.DestType.ToC()})");
+                    break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
             }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/ReduceArg.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/ReduceArg.cs
new file mode 100644
index 0000000000..f20e03fdad
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/ReduceArg.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class ReduceArgEvaluator : ITypeInferencer<ReduceArg>
+{
+    public IRType Visit(ITypeInferenceContext context, ReduceArg target)
+    {
+        return TupleType.Void;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index a0cc16ba53..dddfc8e805 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -29,5 +29,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<ReShapeEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<GatherReduceScatterEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<Conv2DEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<ReduceArgEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 50f3911890..65970e7570 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -81,4 +81,9 @@ public static Call Conv2D(Expr input, Expr weights, Expr bias, Expr output, int[
     {
         return new Call(new Conv2D(stride, padding, dilation, groups, fusedClamp, distributedType), input, weights, bias, output);
     }
+
+    public static Call ReduceArg(Expr input, Expr output, int axis, bool keepdims, bool selectLastIndex, ReduceArgOp op, DataType dataType)
+    {
+        return new Call(new ReduceArg(axis, keepdims, selectLastIndex, op, dataType), input, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/ReduceArg.cs b/modules/Nncase.Modules.CPU/IR/XPU/ReduceArg.cs
new file mode 100644
index 0000000000..cb714faa8a
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/ReduceArg.cs
@@ -0,0 +1,44 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.PatternMatch;
+
+namespace Nncase.IR.XPU;
+
+/// <summary>
+/// ReduceArg expression.
+/// </summary>
+public sealed partial class ReduceArg : XPUKernelOp
+{
+    /// <summary>
+    /// Gets input.
+    /// </summary>
+    public static readonly ParameterInfo Input = new(typeof(ReduceArg), 0, "input", ParameterKind.Input);
+
+    /// <summary>
+    /// Gets Axis.
+    /// </summary>
+    /// <remarks>Named dim in torch.</remarks>
+    public int Axis { get; }
+
+    /// <summary>
+    /// Gets whether to keep dims.
+    /// </summary>
+    public bool KeepDims { get; }
+
+    /// <summary>
+    /// Gets whether to select the last index.
+    /// </summary>
+    /// <remarks>Only used in onnx.</remarks>
+    public bool SelectLastIndex { get; }
+
+    public ReduceArgOp ReduceArgOp { get; }
+
+    public DataType DestType { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index 25b088c46b..3fb857a4bd 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -311,7 +311,88 @@ private static Pattern CreatePattern()
         var merger = new MHAMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("MHASDTextEncoder", $"{nameof(FuseMHA3)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        var callFusion = new Call(new Fusion("SDTextEncoderMHA", $"{nameof(FuseMHA3)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        return callFusion;
+    }
+}
+
+/// <summary>
+/// stable-disffusion text encoder header.
+/// </summary>
+[RuleGenerator]
+public sealed partial class FuseSDTextEncoderHeader : FusionMaker
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern => CreatePattern();
+
+    private static Pattern CreatePattern()
+    {
+        var v0 = IsWildcard("input");
+        var v1 = IsGather(0, IsTensorConst(), v0); // f32[12,77,64]
+        var v2 = IsBinary(null, "root", BinaryOp.Add, v1, IsTensorConst()); // f32[12,77,64]
+        return v2;
+    }
+
+    private Call? GetReplace(Call root, Expr input)
+    {
+        var newInputs = new List<Var>
+        {
+            new Var(input.CheckedType!),
+        };
+
+        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
+        {
+            { input, newInputs[0] },
+        };
+        var merger = new MHAMerger(multiVarMap);
+        var clonedRoot = merger.Clone(root, default);
+
+        var callFusion = new Call(new Fusion("SDTextEncoderHeader", $"{nameof(FuseSDTextEncoderHeader)}_{Count}", ModuleKind, clonedRoot, newInputs.ToArray()), input);
+        return callFusion;
+    }
+}
+
+/// <summary>
+/// stable-disffusion text encoder header.
+/// </summary>
+[RuleGenerator]
+public sealed partial class FuseSDTextEncoderTail : FusionMaker
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern => CreatePattern();
+
+    private static Pattern CreatePattern()
+    {
+        var vinput_ids = IsWildcard("input_ids");
+        var v13 = IsWildcard("input");
+        var v14 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v13, IsTensorConst(), IsTensorConst()); // f32[1,77,768]
+        var v15 = IsReshape(v14, IsTensorConst()); // f32[77,768]
+        var v16 = IsReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64, vinput_ids, IsTensorConst(), IsTensorConst(), IsTensorConst()); // i64[1]
+        var v17 = IsBinary(BinaryOp.Add, v16, IsTensorConst()); // i64[1]
+        var v18 = IsGather(null, "root", Axis: 0, v15, v17); // f32[1,768]
+        return v18;
+    }
+
+    private Call? GetReplace(Call root, Expr input_ids, Expr input)
+    {
+        var newInputs = new Var[]
+        {
+            new Var(input_ids.CheckedType!),
+            new Var(input.CheckedType!),
+        };
+
+        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
+        {
+            { input_ids, newInputs[0] },
+            { input, newInputs[1] },
+        };
+
+        var merger = new MHAMerger(multiVarMap);
+        var clonedRoot = merger.Clone(root, default);
+
+        var callFusion = new Call(new Fusion("SDTextEncoderTail", $"{nameof(FuseSDTextEncoderTail)}_{Count}", ModuleKind, clonedRoot, newInputs), input_ids, input);
         return callFusion;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 98458e128f..15903ff96d 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -80,6 +80,9 @@ protected override Unit VisitLeafCall(Call expr)
             case Conv2D conv:
                 GenerateConv2D(conv, arguments, ret, ((TensorConst)expr.Arguments[3]).Value.ToArray<int>(), ((TensorConst)expr.Arguments[4]).Value.ToArray<int>(), ((TensorConst)expr.Arguments[5]).Value.ToArray<int>(), ((TensorConst)expr.Arguments[6]).Value.ToScalar<int>(), (TensorConst)expr.Arguments[7], (DistributedType)expr.CheckedType);
                 break;
+            case ReduceArg reduceArg:
+                GenerateReduceArg(reduceArg, arguments, ret, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), ((TensorConst)expr.Arguments[2]).Value.ToScalar<bool>(), ((TensorConst)expr.Arguments[3]).Value.ToScalar<bool>(), reduceArg.ReduceArgOp, reduceArg.DestType);
+                break;
             default:
                 throw new NotSupportedException();
         }
@@ -184,6 +187,11 @@ private void GenerateConv2D(Conv2D conv, Buffer[] arguments, Buffer ret, int[] s
         _mainBody.Add(IR.F.XPU.Conv2D(arguments[0], arguments[1], arguments[2], ret, stride, padding, dilation, groups, fusedClamp, distributedType));
     }
 
+    private void GenerateReduceArg(ReduceArg reduceArg, Buffer[] arguments, Buffer ret, int axis, bool keepdims, bool selectLastIndex, ReduceArgOp op, DataType dataType)
+    {
+        _mainBody.Add(IR.F.XPU.ReduceArg(arguments[0], ret, axis, keepdims, selectLastIndex, op, dataType));
+    }
+
 #if false
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index cd716d0ee6..09f7e874bd 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -195,6 +195,8 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.FuseMHA1>();
             p.Add<Passes.Rules.FuseMHA2>();
             p.Add<Passes.Rules.FuseMHA3>();
+            p.Add<Passes.Rules.FuseSDTextEncoderTail>();
+            p.Add<Passes.Rules.FuseSDTextEncoderHeader>();
         });
 
         _compileSession.Target.RegisterTargetInDependentPass(passManager, _compileSession.CompileOptions);
diff --git a/src/Nncase.Core/IR/Math/ReduceArg.cs b/src/Nncase.Core/IR/Math/ReduceArg.cs
index ecad8e95e2..70e24cb1e5 100644
--- a/src/Nncase.Core/IR/Math/ReduceArg.cs
+++ b/src/Nncase.Core/IR/Math/ReduceArg.cs
@@ -21,7 +21,7 @@ public sealed partial class ReduceArg : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(ReduceArg), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(ReduceArg), 0, "input", ParameterKind.Input);
 
     /// <summary>
     /// Gets Axis.
@@ -45,5 +45,5 @@ public sealed partial class ReduceArg : Op
     public DataType DestType { get; }
 
     /// <inheritdoc/>
-    public override string DisplayProperty() => $"ReduceArgOp.{ReduceArgOp}";
+    public override string DisplayProperty() => $"ReduceArgOp.{ReduceArgOp}, DestType: {DestType}";
 }
diff --git a/src/Nncase.Evaluator/Math/ReduceArg.cs b/src/Nncase.Evaluator/Math/ReduceArg.cs
index 5ded2c065f..4777f4435b 100644
--- a/src/Nncase.Evaluator/Math/ReduceArg.cs
+++ b/src/Nncase.Evaluator/Math/ReduceArg.cs
@@ -40,16 +40,23 @@ public IValue Visit(IEvaluateContext context, ReduceArg reduceArg)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, ReduceArg target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, ReduceArg.Input);
-        return Visit(context, target, input);
+        var input = context.CheckArgumentType<IRType>(target, ReduceArg.Input);
+        return input switch
+        {
+            TensorType tensorType => Visit(context, target, tensorType),
+            DistributedType distributedType => Visit(context, target, distributedType),
+            _ => new InvalidType(string.Empty),
+        };
     }
 
     public Cost Visit(ICostEvaluateContext context, ReduceArg target)
     {
-        var input = context.GetArgumentType<TensorType>(target, ReduceArg.Input);
-        var ret = context.GetReturnType<TensorType>();
-        uint input_elem = input.Shape.Aggregate(1U, (acc, d) => acc * (d.IsFixed ? (uint)d.FixedValue : 1U));
-        uint ret_elem = ret.Shape.Aggregate(1U, (acc, d) => acc * (d.IsFixed ? (uint)d.FixedValue : 1U));
+        var input = context.GetArgumentType<IRType>(target, ReduceArg.Input);
+        var ret = context.GetReturnType<IRType>();
+        var inShape = input switch { TensorType t => t.Shape, DistributedType d => d.TensorType.Shape, _ => throw new NotImplementedException() };
+        var rShape = ret switch { TensorType t => t.Shape, DistributedType d => d.TensorType.Shape, _ => throw new NotImplementedException() };
+        uint input_elem = inShape.Aggregate(1U, (acc, d) => acc * (d.IsFixed ? (uint)d.FixedValue : 1U));
+        uint ret_elem = rShape.Aggregate(1U, (acc, d) => acc * (d.IsFixed ? (uint)d.FixedValue : 1U));
         uint macPerElement = input_elem / ret_elem;
         return new() { [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(input), [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(ret), [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(ret, macPerElement), };
     }
@@ -93,4 +100,20 @@ private IRType Visit(ITypeInferenceContext context, ReduceArg target, TensorType
             return new InvalidType("ReduceArg axis and keepDims are not const");
         }
     }
+
+    private IRType Visit(ITypeInferenceContext context, ReduceArg target, DistributedType distributedType)
+    {
+        var rType = Visit(context, target, distributedType.TensorType);
+        if (rType is not TensorType tensorType)
+        {
+            return rType;
+        }
+
+        if (!distributedType.NdSBP.All(sbp => sbp is SBPBroadCast))
+        {
+            return new InvalidType(string.Empty);
+        }
+
+        return distributedType with { TensorType = tensorType };
+    }
 }

From a9160d0d1d16cee68c8f4afece7500c3d0d1ea8d Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Wed, 11 Oct 2023 08:35:11 +0000
Subject: [PATCH 225/308] Apply code-format changes

---
 .../Evaluator/XPU/ReduceArg.cs                |    2 +-
 .../Nncase.Modules.CPU/IR/XPU/ReduceArg.cs    |    6 +-
 modules/cpu/src/runtime/elfloader.h           |    2 +-
 .../nncase/kernels/stackvm/tensor_ops.h       |  636 ++++--
 .../nncase/runtime/stackvm/op_reader.h        | 1952 +++++++----------
 .../include/nncase/runtime/stackvm/opcode.h   | 1391 +++++-------
 src/Native/src/kernels/stackvm/tensor_ops.cpp |    5 +-
 src/Native/src/runtime/stackvm/op_reader.cpp  |   96 +-
 src/Native/src/runtime/stackvm/ops/tensor.cpp |  624 ++++--
 .../runtime/stackvm/runtime_function_ops.h    |    9 +-
 10 files changed, 2413 insertions(+), 2310 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/ReduceArg.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/ReduceArg.cs
index f20e03fdad..5bb1170054 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/ReduceArg.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/ReduceArg.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/ReduceArg.cs b/modules/Nncase.Modules.CPU/IR/XPU/ReduceArg.cs
index cb714faa8a..89a6fc0ec6 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/ReduceArg.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/ReduceArg.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
@@ -28,12 +28,12 @@ public sealed partial class ReduceArg : XPUKernelOp
     public int Axis { get; }
 
     /// <summary>
-    /// Gets whether to keep dims.
+    /// Gets a value indicating whether gets whether to keep dims.
     /// </summary>
     public bool KeepDims { get; }
 
     /// <summary>
-    /// Gets whether to select the last index.
+    /// Gets a value indicating whether gets whether to select the last index.
     /// </summary>
     /// <remarks>Only used in onnx.</remarks>
     public bool SelectLastIndex { get; }
diff --git a/modules/cpu/src/runtime/elfloader.h b/modules/cpu/src/runtime/elfloader.h
index 822aabb249..959201c53a 100644
--- a/modules/cpu/src/runtime/elfloader.h
+++ b/modules/cpu/src/runtime/elfloader.h
@@ -1,13 +1,13 @@
 #pragma once
 #include "elfload.h"
 #include "hardware_def.h"
+#include "method_table_impl.h"
 #include <inttypes.h>
 #include <math.h>
 #include <nncase/runtime/cpu/compiler_defs.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "method_table_impl.h"
 #if defined(__linux__)
 #include <sys/mman.h>
 #endif
diff --git a/src/Native/include/nncase/kernels/stackvm/tensor_ops.h b/src/Native/include/nncase/kernels/stackvm/tensor_ops.h
index 27c0766226..84cae4e387 100644
--- a/src/Native/include/nncase/kernels/stackvm/tensor_ops.h
+++ b/src/Native/include/nncase/kernels/stackvm/tensor_ops.h
@@ -1,4 +1,5 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM +00:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM
+ * +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -25,194 +26,449 @@
 
 BEGIN_NS_NNCASE_KERNELS_MODULE(stackvm)
 
-NNCASE_API result<value_t> batch_normalization(value_t input, value_t scale, value_t bias, value_t input_mean, value_t input_var, value_t epsilon, value_t momentum, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> batch_to_space(value_t input, value_t block_shape, value_t crops, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> binary(runtime::stackvm::binary_op_t binary_op, value_t lhs, value_t rhs, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> bitcast(prim_type_t type, prim_type_t new_type, value_t input, value_t new_shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> broadcast(value_t input, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> broadcast_shape(value_t inputs, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> bucket_pad(value_t input, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> cast(typecode_t new_type, runtime::stackvm::cast_mode_t cast_mode, value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> celu(value_t input, value_t alpha, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> clamp(value_t input, value_t min, value_t max, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> compare(runtime::stackvm::compare_op_t compare_op, value_t lhs, value_t rhs, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> concat(int32_t axis, value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> condition(bool can_fold_const_call, value_t predicate, value_t value, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> constant_of_shape(value_t shape, value_t value, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> conv2d(runtime::stackvm::pad_mode_t pad_mode, value_t input, value_t weights, value_t bias, value_t stride, value_t padding, value_t dilation, value_t groups, value_t fused_clamp, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> conv2d_shape(value_t input, value_t weights, value_t padding, value_t stride, value_t dilation, value_t groups, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> conv2d_transpose(runtime::stackvm::pad_mode_t pad_mode, value_t input, value_t weights, value_t bias, value_t output_shape, value_t stride, value_t padding, value_t output_padding, value_t dilation, value_t groups, value_t fused_clamp, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> conv2d_transpose_shape(value_t input, value_t weights, value_t stride, value_t dilation, value_t padding, value_t output_padding, value_t groups, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> cum_sum(value_t input, value_t axis, value_t exclusive, value_t reverse, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> dequantize(typecode_t target_type, value_t input, value_t dequant_param, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> elu(value_t input, value_t alpha, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> erf(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> expand(value_t input, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> fake_dequantize(typecode_t target_type, value_t input, value_t dequant_param, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> fake_quantize(typecode_t target_type, value_t input, value_t quant_param, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> fix_shape(value_t input, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> flatten(value_t input, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> gather(int32_t axis, value_t input, value_t index, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> gather_elements(value_t input, value_t axis, value_t indices, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> gather_nd(value_t input, value_t batch_dims, value_t index, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> gelu(value_t input, value_t alpha, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> get_item(value_t input, value_t index, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> get_paddings(value_t input_shape, value_t weights_shape, value_t strides, value_t dilations, value_t same, value_t lower, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> hard_sigmoid(value_t input, value_t alpha, value_t beta, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> hard_swish(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> hardmax(value_t input, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> index_of(value_t input, value_t value, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> instance_normalization(value_t input, value_t scale, value_t bias, value_t epsilon, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> l2_normalization(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> layer_norm(int32_t axis, float epsilon, bool use_mean, value_t input, value_t scale, value_t bias, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> leaky_relu(value_t input, value_t alpha, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> log_softmax(value_t input, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> lp_normalization(value_t input, value_t axis, value_t p, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> lrn(value_t input, value_t alpha, value_t beta, value_t bias, value_t size, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> lstm(runtime::stackvm::lstmdirection_t direction, runtime::stackvm::lstmlayout_t layout, std::vector<std::string> activations, value_t x, value_t w, value_t r, value_t b, value_t sequence_lens, value_t initial_h, value_t initial_c, value_t p, value_t activation_alpha, value_t activation_beta, value_t clip, value_t hidden_size, value_t input_forget, value_t output_size, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> mat_mul(value_t lhs, value_t rhs, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> mat_mul_shape(value_t lhs, value_t rhs, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> normal(typecode_t type, value_t mean, value_t scale, value_t seed, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> normal_like(typecode_t type, value_t input, value_t mean, value_t scale, value_t seed, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> one_hot(runtime::stackvm::one_hot_mode_t one_hot_mode, value_t indices, value_t depth, value_t values, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> pad(runtime::stackvm::pad_mode_t pad_mode, value_t input, value_t pads, value_t value, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> prelu(value_t input, value_t slope, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> prod(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> quant_param_of(runtime::stackvm::quant_mode_t quant_mode, value_t range, value_t bits, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> quantize(typecode_t target_type, value_t input, value_t quant_param, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> range(value_t begin, value_t end, value_t step, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> range_of(bool is_range_of_weight, value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> rank(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> reduce(runtime::stackvm::reduce_op_t reduce_op, value_t input, value_t axis, value_t init_value, value_t keep_dims, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> reduce_arg(runtime::stackvm::reduce_arg_op_t reduce_arg_op, typecode_t dest_type, value_t input, value_t axis, value_t keep_dims, value_t select_last_index, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> reduce_window2d(runtime::stackvm::reduce_op_t reduce_op, value_t input, value_t init_value, value_t filter, value_t stride, value_t padding, value_t dilation, value_t ceil_mode, value_t count_include_pad, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> relu(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> relu6(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> require(std::string message, bool can_fold_const_call, value_t predicate, value_t value, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> reshape(value_t input, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> reshape_shape(value_t input_shape, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> resize_image(runtime::stackvm::image_resize_mode_t resize_mode, runtime::stackvm::image_resize_transformation_mode_t transformation_mode, runtime::stackvm::image_resize_nearest_mode_t nearest_mode, bool is_tfresize, value_t input, value_t roi, value_t new_size, value_t cubic_coeff_a, value_t exclude_outside, value_t extrapolation_value, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> reverse_sequence(value_t input, value_t seq_lens, value_t batch_axis, value_t time_axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> scatter_nd(value_t input, value_t indices, value_t updates, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> select(value_t predicate, value_t true_value, value_t false_value, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> selu(value_t input, value_t alpha, value_t gamma, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> shape_of(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> sigmoid(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> size_of(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> slice(value_t input, value_t begins, value_t ends, value_t axes, value_t strides, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> softmax(value_t input, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> softplus(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> softsign(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> space_to_batch(value_t input, value_t block_shape, value_t paddings, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> split(value_t input, value_t axis, value_t sections, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> squeeze(value_t input, value_t dim, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> squeeze_shape(value_t input_shape, value_t dim, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> stack(value_t inputs, value_t axis, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> swish(value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> tile(value_t input, value_t repeats, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> top_k(value_t x, value_t k, value_t axis, value_t largest, value_t sorted, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> transpose(value_t input, value_t perm, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> transpose_shape(value_t input_shape, value_t perm, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> trilu(value_t input, value_t k, value_t upper, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> unary(runtime::stackvm::unary_op_t unary_op, value_t input, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> uniform(typecode_t type, value_t high, value_t low, value_t seed, value_t shape, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> uniform_like(typecode_t type, value_t input, value_t high, value_t low, value_t seed, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> unsqueeze(value_t input, value_t dim, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> unsqueeze_shape(value_t input_shape, value_t dim, value_t output = nullptr, kernel_context &context = default_kernel_context());
-
-NNCASE_API result<value_t> where(bool is_tf_where, value_t cond, value_t x, value_t y, value_t output = nullptr, kernel_context &context = default_kernel_context());
+NNCASE_API result<value_t>
+batch_normalization(value_t input, value_t scale, value_t bias,
+                    value_t input_mean, value_t input_var, value_t epsilon,
+                    value_t momentum, value_t output = nullptr,
+                    kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+batch_to_space(value_t input, value_t block_shape, value_t crops,
+               value_t output = nullptr,
+               kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+binary(runtime::stackvm::binary_op_t binary_op, value_t lhs, value_t rhs,
+       value_t output = nullptr,
+       kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+bitcast(prim_type_t type, prim_type_t new_type, value_t input,
+        value_t new_shape, value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+broadcast(value_t input, value_t shape, value_t output = nullptr,
+          kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+broadcast_shape(value_t inputs, value_t output = nullptr,
+                kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+bucket_pad(value_t input, value_t shape, value_t output = nullptr,
+           kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+cast(typecode_t new_type, runtime::stackvm::cast_mode_t cast_mode,
+     value_t input, value_t output = nullptr,
+     kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+celu(value_t input, value_t alpha, value_t output = nullptr,
+     kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+clamp(value_t input, value_t min, value_t max, value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+compare(runtime::stackvm::compare_op_t compare_op, value_t lhs, value_t rhs,
+        value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+concat(int32_t axis, value_t input, value_t output = nullptr,
+       kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+condition(bool can_fold_const_call, value_t predicate, value_t value,
+          value_t output = nullptr,
+          kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+constant_of_shape(value_t shape, value_t value, value_t output = nullptr,
+                  kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+conv2d(runtime::stackvm::pad_mode_t pad_mode, value_t input, value_t weights,
+       value_t bias, value_t stride, value_t padding, value_t dilation,
+       value_t groups, value_t fused_clamp, value_t output = nullptr,
+       kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+conv2d_shape(value_t input, value_t weights, value_t padding, value_t stride,
+             value_t dilation, value_t groups, value_t output = nullptr,
+             kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+conv2d_transpose(runtime::stackvm::pad_mode_t pad_mode, value_t input,
+                 value_t weights, value_t bias, value_t output_shape,
+                 value_t stride, value_t padding, value_t output_padding,
+                 value_t dilation, value_t groups, value_t fused_clamp,
+                 value_t output = nullptr,
+                 kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+conv2d_transpose_shape(value_t input, value_t weights, value_t stride,
+                       value_t dilation, value_t padding,
+                       value_t output_padding, value_t groups,
+                       value_t output = nullptr,
+                       kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+cum_sum(value_t input, value_t axis, value_t exclusive, value_t reverse,
+        value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+dequantize(typecode_t target_type, value_t input, value_t dequant_param,
+           value_t output = nullptr,
+           kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+elu(value_t input, value_t alpha, value_t output = nullptr,
+    kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+erf(value_t input, value_t output = nullptr,
+    kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+expand(value_t input, value_t shape, value_t output = nullptr,
+       kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+fake_dequantize(typecode_t target_type, value_t input, value_t dequant_param,
+                value_t output = nullptr,
+                kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+fake_quantize(typecode_t target_type, value_t input, value_t quant_param,
+              value_t output = nullptr,
+              kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+fix_shape(value_t input, value_t shape, value_t output = nullptr,
+          kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+flatten(value_t input, value_t axis, value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+gather(int32_t axis, value_t input, value_t index, value_t output = nullptr,
+       kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+gather_elements(value_t input, value_t axis, value_t indices,
+                value_t output = nullptr,
+                kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+gather_nd(value_t input, value_t batch_dims, value_t index,
+          value_t output = nullptr,
+          kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+gelu(value_t input, value_t alpha, value_t output = nullptr,
+     kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+get_item(value_t input, value_t index, value_t output = nullptr,
+         kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+get_paddings(value_t input_shape, value_t weights_shape, value_t strides,
+             value_t dilations, value_t same, value_t lower,
+             value_t output = nullptr,
+             kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+hard_sigmoid(value_t input, value_t alpha, value_t beta,
+             value_t output = nullptr,
+             kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+hard_swish(value_t input, value_t output = nullptr,
+           kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+hardmax(value_t input, value_t axis, value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+index_of(value_t input, value_t value, value_t output = nullptr,
+         kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+instance_normalization(value_t input, value_t scale, value_t bias,
+                       value_t epsilon, value_t output = nullptr,
+                       kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+l2_normalization(value_t input, value_t output = nullptr,
+                 kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+layer_norm(int32_t axis, float epsilon, bool use_mean, value_t input,
+           value_t scale, value_t bias, value_t output = nullptr,
+           kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+leaky_relu(value_t input, value_t alpha, value_t output = nullptr,
+           kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+log_softmax(value_t input, value_t axis, value_t output = nullptr,
+            kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+lp_normalization(value_t input, value_t axis, value_t p,
+                 value_t output = nullptr,
+                 kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+lrn(value_t input, value_t alpha, value_t beta, value_t bias, value_t size,
+    value_t output = nullptr,
+    kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+lstm(runtime::stackvm::lstmdirection_t direction,
+     runtime::stackvm::lstmlayout_t layout,
+     std::vector<std::string> activations, value_t x, value_t w, value_t r,
+     value_t b, value_t sequence_lens, value_t initial_h, value_t initial_c,
+     value_t p, value_t activation_alpha, value_t activation_beta, value_t clip,
+     value_t hidden_size, value_t input_forget, value_t output_size,
+     value_t output = nullptr,
+     kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+mat_mul(value_t lhs, value_t rhs, value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+mat_mul_shape(value_t lhs, value_t rhs, value_t output = nullptr,
+              kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+normal(typecode_t type, value_t mean, value_t scale, value_t seed,
+       value_t shape, value_t output = nullptr,
+       kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+normal_like(typecode_t type, value_t input, value_t mean, value_t scale,
+            value_t seed, value_t output = nullptr,
+            kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+one_hot(runtime::stackvm::one_hot_mode_t one_hot_mode, value_t indices,
+        value_t depth, value_t values, value_t axis, value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+pad(runtime::stackvm::pad_mode_t pad_mode, value_t input, value_t pads,
+    value_t value, value_t output = nullptr,
+    kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+prelu(value_t input, value_t slope, value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+prod(value_t input, value_t output = nullptr,
+     kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+quant_param_of(runtime::stackvm::quant_mode_t quant_mode, value_t range,
+               value_t bits, value_t output = nullptr,
+               kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+quantize(typecode_t target_type, value_t input, value_t quant_param,
+         value_t output = nullptr,
+         kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+range(value_t begin, value_t end, value_t step, value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+range_of(bool is_range_of_weight, value_t input, value_t output = nullptr,
+         kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+rank(value_t input, value_t output = nullptr,
+     kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+reduce(runtime::stackvm::reduce_op_t reduce_op, value_t input, value_t axis,
+       value_t init_value, value_t keep_dims, value_t output = nullptr,
+       kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+reduce_arg(runtime::stackvm::reduce_arg_op_t reduce_arg_op,
+           typecode_t dest_type, value_t input, value_t axis, value_t keep_dims,
+           value_t select_last_index, value_t output = nullptr,
+           kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+reduce_window2d(runtime::stackvm::reduce_op_t reduce_op, value_t input,
+                value_t init_value, value_t filter, value_t stride,
+                value_t padding, value_t dilation, value_t ceil_mode,
+                value_t count_include_pad, value_t output = nullptr,
+                kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+relu(value_t input, value_t output = nullptr,
+     kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+relu6(value_t input, value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+require(std::string message, bool can_fold_const_call, value_t predicate,
+        value_t value, value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+reshape(value_t input, value_t shape, value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+reshape_shape(value_t input_shape, value_t shape, value_t output = nullptr,
+              kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t> resize_image(
+    runtime::stackvm::image_resize_mode_t resize_mode,
+    runtime::stackvm::image_resize_transformation_mode_t transformation_mode,
+    runtime::stackvm::image_resize_nearest_mode_t nearest_mode,
+    bool is_tfresize, value_t input, value_t roi, value_t new_size,
+    value_t cubic_coeff_a, value_t exclude_outside, value_t extrapolation_value,
+    value_t output = nullptr,
+    kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+reverse_sequence(value_t input, value_t seq_lens, value_t batch_axis,
+                 value_t time_axis, value_t output = nullptr,
+                 kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+scatter_nd(value_t input, value_t indices, value_t updates,
+           value_t output = nullptr,
+           kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+select(value_t predicate, value_t true_value, value_t false_value,
+       value_t output = nullptr,
+       kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+selu(value_t input, value_t alpha, value_t gamma, value_t output = nullptr,
+     kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+shape_of(value_t input, value_t output = nullptr,
+         kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+sigmoid(value_t input, value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+size_of(value_t input, value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+slice(value_t input, value_t begins, value_t ends, value_t axes,
+      value_t strides, value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+softmax(value_t input, value_t axis, value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+softplus(value_t input, value_t output = nullptr,
+         kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+softsign(value_t input, value_t output = nullptr,
+         kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+space_to_batch(value_t input, value_t block_shape, value_t paddings,
+               value_t output = nullptr,
+               kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+split(value_t input, value_t axis, value_t sections, value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+squeeze(value_t input, value_t dim, value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+squeeze_shape(value_t input_shape, value_t dim, value_t output = nullptr,
+              kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+stack(value_t inputs, value_t axis, value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+swish(value_t input, value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+tile(value_t input, value_t repeats, value_t output = nullptr,
+     kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+top_k(value_t x, value_t k, value_t axis, value_t largest, value_t sorted,
+      value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+transpose(value_t input, value_t perm, value_t output = nullptr,
+          kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+transpose_shape(value_t input_shape, value_t perm, value_t output = nullptr,
+                kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+trilu(value_t input, value_t k, value_t upper, value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+unary(runtime::stackvm::unary_op_t unary_op, value_t input,
+      value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+uniform(typecode_t type, value_t high, value_t low, value_t seed, value_t shape,
+        value_t output = nullptr,
+        kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+uniform_like(typecode_t type, value_t input, value_t high, value_t low,
+             value_t seed, value_t output = nullptr,
+             kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+unsqueeze(value_t input, value_t dim, value_t output = nullptr,
+          kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+unsqueeze_shape(value_t input_shape, value_t dim, value_t output = nullptr,
+                kernel_context &context = default_kernel_context());
+
+NNCASE_API result<value_t>
+where(bool is_tf_where, value_t cond, value_t x, value_t y,
+      value_t output = nullptr,
+      kernel_context &context = default_kernel_context());
 
 END_NS_NNCASE_KERNELS_MODULE
diff --git a/src/Native/include/nncase/runtime/stackvm/op_reader.h b/src/Native/include/nncase/runtime/stackvm/op_reader.h
index a7ec8bee9f..ffde6669bd 100644
--- a/src/Native/include/nncase/runtime/stackvm/op_reader.h
+++ b/src/Native/include/nncase/runtime/stackvm/op_reader.h
@@ -1,4 +1,5 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM +00:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM
+ * +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -22,67 +23,48 @@
 
 BEGIN_NS_NNCASE_RT_MODULE(stackvm)
 
-template <opcode_t Op>
-struct op_reader;
+template <opcode_t Op> struct op_reader;
 
-template <>
-struct op_reader<opcode_t::NOP>
-{
-    nop_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::NOP> {
+    nop_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         nop_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::BR>
-{
-    br_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::BR> {
+    br_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         br_op_t op;
         op.target = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::BR_TRUE>
-{
-    br_true_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::BR_TRUE> {
+    br_true_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         br_true_op_t op;
         op.target = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::BR_FALSE>
-{
-    br_false_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::BR_FALSE> {
+    br_false_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         br_false_op_t op;
         op.target = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::RET>
-{
-    ret_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::RET> {
+    ret_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ret_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CALL>
-{
-    call_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CALL> {
+    call_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         call_op_t op;
         op.args = reader.read_unaligned<uint16_t>();
         op.target = reader.read_unaligned<int32_t>();
@@ -90,22 +72,16 @@ struct op_reader<opcode_t::CALL>
     }
 };
 
-template <>
-struct op_reader<opcode_t::ECALL>
-{
-    ecall_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::ECALL> {
+    ecall_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ecall_op_t op;
         op.args = reader.read_unaligned<uint16_t>();
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::EXTCALL>
-{
-    extcall_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::EXTCALL> {
+    extcall_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         extcall_op_t op;
         op.args = reader.read_unaligned<uint16_t>();
         op.is_prim_func = reader.read_unaligned<bool>();
@@ -113,11 +89,8 @@ struct op_reader<opcode_t::EXTCALL>
     }
 };
 
-template <>
-struct op_reader<opcode_t::CUSCALL>
-{
-    cuscall_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CUSCALL> {
+    cuscall_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         cuscall_op_t op;
         op.registered_name = reader.read_string();
         op.fields_span = reader.read_span(reader.read_unaligned<uint32_t>());
@@ -126,243 +99,171 @@ struct op_reader<opcode_t::CUSCALL>
     }
 };
 
-template <>
-struct op_reader<opcode_t::THROW>
-{
-    throw_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::THROW> {
+    throw_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         throw_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::BREAK>
-{
-    break_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::BREAK> {
+    break_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         break_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDC_I4>
-{
-    ldc_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDC_I4> {
+    ldc_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldc_i4_op_t op;
         op.imm = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDNULL>
-{
-    ldnull_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDNULL> {
+    ldnull_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldnull_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDC_I4_0>
-{
-    ldc_i4_0_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDC_I4_0> {
+    ldc_i4_0_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldc_i4_0_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDC_I4_1>
-{
-    ldc_i4_1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDC_I4_1> {
+    ldc_i4_1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldc_i4_1_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDC_R4>
-{
-    ldc_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDC_R4> {
+    ldc_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldc_r4_op_t op;
         op.imm = reader.read_unaligned<float>();
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDIND_I1>
-{
-    ldind_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDIND_I1> {
+    ldind_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldind_i1_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDIND_I2>
-{
-    ldind_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDIND_I2> {
+    ldind_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldind_i2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDIND_I4>
-{
-    ldind_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDIND_I4> {
+    ldind_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldind_i4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDIND_I>
-{
-    ldind_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDIND_I> {
+    ldind_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldind_i_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDIND_U1>
-{
-    ldind_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDIND_U1> {
+    ldind_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldind_u1_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDIND_U2>
-{
-    ldind_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDIND_U2> {
+    ldind_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldind_u2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDIND_U4>
-{
-    ldind_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDIND_U4> {
+    ldind_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldind_u4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDIND_U>
-{
-    ldind_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDIND_U> {
+    ldind_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldind_u_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDIND_BR2>
-{
-    ldind_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDIND_BR2> {
+    ldind_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldind_br2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDIND_R4>
-{
-    ldind_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDIND_R4> {
+    ldind_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldind_r4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STIND_I1>
-{
-    stind_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STIND_I1> {
+    stind_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stind_i1_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STIND_I2>
-{
-    stind_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STIND_I2> {
+    stind_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stind_i2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STIND_I4>
-{
-    stind_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STIND_I4> {
+    stind_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stind_i4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STIND_I>
-{
-    stind_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STIND_I> {
+    stind_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stind_i_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STIND_BR2>
-{
-    stind_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STIND_BR2> {
+    stind_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stind_br2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STIND_R4>
-{
-    stind_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STIND_R4> {
+    stind_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stind_r4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LEA_GP>
-{
-    lea_gp_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LEA_GP> {
+    lea_gp_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         lea_gp_op_t op;
         op.gpid = reader.read_unaligned<uint8_t>();
         op.offset = reader.read_unaligned<int32_t>();
@@ -370,718 +271,507 @@ struct op_reader<opcode_t::LEA_GP>
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDELEM_I1>
-{
-    ldelem_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDELEM_I1> {
+    ldelem_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldelem_i1_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDELEM_I2>
-{
-    ldelem_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDELEM_I2> {
+    ldelem_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldelem_i2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDELEM_I4>
-{
-    ldelem_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDELEM_I4> {
+    ldelem_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldelem_i4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDELEM_I>
-{
-    ldelem_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDELEM_I> {
+    ldelem_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldelem_i_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDELEM_U1>
-{
-    ldelem_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDELEM_U1> {
+    ldelem_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldelem_u1_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDELEM_U2>
-{
-    ldelem_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDELEM_U2> {
+    ldelem_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldelem_u2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDELEM_U4>
-{
-    ldelem_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDELEM_U4> {
+    ldelem_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldelem_u4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDELEM_U>
-{
-    ldelem_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDELEM_U> {
+    ldelem_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldelem_u_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDELEM_BR2>
-{
-    ldelem_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDELEM_BR2> {
+    ldelem_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldelem_br2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDELEM_R4>
-{
-    ldelem_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDELEM_R4> {
+    ldelem_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldelem_r4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STELEM_I1>
-{
-    stelem_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STELEM_I1> {
+    stelem_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stelem_i1_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STELEM_I2>
-{
-    stelem_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STELEM_I2> {
+    stelem_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stelem_i2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STELEM_I4>
-{
-    stelem_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STELEM_I4> {
+    stelem_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stelem_i4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STELEM_I>
-{
-    stelem_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STELEM_I> {
+    stelem_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stelem_i_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STELEM_BR2>
-{
-    stelem_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STELEM_BR2> {
+    stelem_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stelem_br2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STELEM_R4>
-{
-    stelem_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STELEM_R4> {
+    stelem_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stelem_r4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDARG>
-{
-    ldarg_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDARG> {
+    ldarg_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldarg_op_t op;
         op.index = reader.read_unaligned<uint16_t>();
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDARG_0>
-{
-    ldarg_0_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDARG_0> {
+    ldarg_0_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldarg_0_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDARG_1>
-{
-    ldarg_1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDARG_1> {
+    ldarg_1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldarg_1_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDARG_2>
-{
-    ldarg_2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDARG_2> {
+    ldarg_2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldarg_2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDARG_3>
-{
-    ldarg_3_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDARG_3> {
+    ldarg_3_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldarg_3_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDARG_4>
-{
-    ldarg_4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDARG_4> {
+    ldarg_4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldarg_4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDARG_5>
-{
-    ldarg_5_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDARG_5> {
+    ldarg_5_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldarg_5_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDTUPLE_ELEM>
-{
-    ldtuple_elem_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDTUPLE_ELEM> {
+    ldtuple_elem_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldtuple_elem_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDTUPLE>
-{
-    ldtuple_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDTUPLE> {
+    ldtuple_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldtuple_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDDATATYPE>
-{
-    lddatatype_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDDATATYPE> {
+    lddatatype_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         lddatatype_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDTENSOR>
-{
-    ldtensor_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDTENSOR> {
+    ldtensor_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldtensor_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDLOCAL>
-{
-    ldlocal_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDLOCAL> {
+    ldlocal_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldlocal_op_t op;
         op.index = reader.read_unaligned<uint16_t>();
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::STLOCAL>
-{
-    stlocal_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::STLOCAL> {
+    stlocal_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         stlocal_op_t op;
         op.index = reader.read_unaligned<uint16_t>();
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::LDSCALAR>
-{
-    ldscalar_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::LDSCALAR> {
+    ldscalar_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ldscalar_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::DUP>
-{
-    dup_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::DUP> {
+    dup_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         dup_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::POP>
-{
-    pop_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::POP> {
+    pop_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         pop_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::NEG>
-{
-    neg_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::NEG> {
+    neg_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         neg_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::ADD>
-{
-    add_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::ADD> {
+    add_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         add_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::SUB>
-{
-    sub_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::SUB> {
+    sub_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         sub_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::MUL>
-{
-    mul_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::MUL> {
+    mul_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         mul_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::DIV>
-{
-    div_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::DIV> {
+    div_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         div_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::DIV_U>
-{
-    div_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::DIV_U> {
+    div_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         div_u_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::REM>
-{
-    rem_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::REM> {
+    rem_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         rem_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::REM_U>
-{
-    rem_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::REM_U> {
+    rem_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         rem_u_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::AND>
-{
-    and_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::AND> {
+    and_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         and_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::OR>
-{
-    or_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::OR> {
+    or_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         or_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::XOR>
-{
-    xor_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::XOR> {
+    xor_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         xor_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::NOT>
-{
-    not_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::NOT> {
+    not_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         not_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::SHL>
-{
-    shl_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::SHL> {
+    shl_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         shl_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::SHR>
-{
-    shr_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::SHR> {
+    shr_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         shr_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::SHR_U>
-{
-    shr_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::SHR_U> {
+    shr_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         shr_u_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CLT>
-{
-    clt_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CLT> {
+    clt_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         clt_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CLT_U>
-{
-    clt_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CLT_U> {
+    clt_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         clt_u_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CLE>
-{
-    cle_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CLE> {
+    cle_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         cle_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CLE_U>
-{
-    cle_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CLE_U> {
+    cle_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         cle_u_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CEQ>
-{
-    ceq_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CEQ> {
+    ceq_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         ceq_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CGE>
-{
-    cge_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CGE> {
+    cge_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         cge_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CGE_U>
-{
-    cge_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CGE_U> {
+    cge_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         cge_u_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CGT>
-{
-    cgt_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CGT> {
+    cgt_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         cgt_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CGT_U>
-{
-    cgt_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CGT_U> {
+    cgt_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         cgt_u_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CNE>
-{
-    cne_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CNE> {
+    cne_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         cne_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CONV_I1>
-{
-    conv_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CONV_I1> {
+    conv_i1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         conv_i1_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CONV_I2>
-{
-    conv_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CONV_I2> {
+    conv_i2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         conv_i2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CONV_I4>
-{
-    conv_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CONV_I4> {
+    conv_i4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         conv_i4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CONV_I>
-{
-    conv_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CONV_I> {
+    conv_i_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         conv_i_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CONV_U1>
-{
-    conv_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CONV_U1> {
+    conv_u1_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         conv_u1_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CONV_U2>
-{
-    conv_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CONV_U2> {
+    conv_u2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         conv_u2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CONV_U4>
-{
-    conv_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CONV_U4> {
+    conv_u4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         conv_u4_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CONV_U>
-{
-    conv_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CONV_U> {
+    conv_u_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         conv_u_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CONV_BR2>
-{
-    conv_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CONV_BR2> {
+    conv_br2_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         conv_br2_op_t op;
         return op;
     }
 };
 
-template <>
-struct op_reader<opcode_t::CONV_R4>
-{
-    conv_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct op_reader<opcode_t::CONV_R4> {
+    conv_r4_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         conv_r4_op_t op;
         return op;
     }
 };
 
-template <tensor_function_t Op>
-struct tensor_op_reader;
+template <tensor_function_t Op> struct tensor_op_reader;
 
-template <>
-struct tensor_op_reader<tensor_function_t::batch_normalization>
-{
-    tensor_batch_normalization_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::batch_normalization> {
+    tensor_batch_normalization_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_batch_normalization_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::batch_to_space>
-{
-    tensor_batch_to_space_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::batch_to_space> {
+    tensor_batch_to_space_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_batch_to_space_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::binary>
-{
-    tensor_binary_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::binary> {
+    tensor_binary_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_binary_op_t op;
-        op.binary_op = static_cast<binary_op_t>(reader.read_unaligned<uint8_t>());
+        op.binary_op =
+            static_cast<binary_op_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::bitcast>
-{
-    tensor_bitcast_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::bitcast> {
+    tensor_bitcast_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_bitcast_op_t op;
         op.type = reader.read_unaligned<prim_type_t>();
         op.new_type = reader.read_unaligned<prim_type_t>();
@@ -1089,372 +779,281 @@ struct tensor_op_reader<tensor_function_t::bitcast>
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::broadcast>
-{
-    tensor_broadcast_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::broadcast> {
+    tensor_broadcast_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_broadcast_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::broadcast_shape>
-{
-    tensor_broadcast_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::broadcast_shape> {
+    tensor_broadcast_shape_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_broadcast_shape_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::bucket_pad>
-{
-    tensor_bucket_pad_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::bucket_pad> {
+    tensor_bucket_pad_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_bucket_pad_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::cast>
-{
-    tensor_cast_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::cast> {
+    tensor_cast_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_cast_op_t op;
         op.new_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
-        op.cast_mode = static_cast<cast_mode_t>(reader.read_unaligned<uint32_t>());
+        op.cast_mode =
+            static_cast<cast_mode_t>(reader.read_unaligned<uint32_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::celu>
-{
-    tensor_celu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::celu> {
+    tensor_celu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_celu_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::clamp>
-{
-    tensor_clamp_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::clamp> {
+    tensor_clamp_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_clamp_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::compare>
-{
-    tensor_compare_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::compare> {
+    tensor_compare_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_compare_op_t op;
-        op.compare_op = static_cast<compare_op_t>(reader.read_unaligned<uint8_t>());
+        op.compare_op =
+            static_cast<compare_op_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::concat>
-{
-    tensor_concat_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::concat> {
+    tensor_concat_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_concat_op_t op;
         op.axis = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::condition>
-{
-    tensor_condition_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::condition> {
+    tensor_condition_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_condition_op_t op;
         op.can_fold_const_call = reader.read_unaligned<bool>();
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::constant_of_shape>
-{
-    tensor_constant_of_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::constant_of_shape> {
+    tensor_constant_of_shape_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_constant_of_shape_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::conv2d>
-{
-    tensor_conv2d_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::conv2d> {
+    tensor_conv2d_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_conv2d_op_t op;
         op.pad_mode = static_cast<pad_mode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::conv2d_shape>
-{
-    tensor_conv2d_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::conv2d_shape> {
+    tensor_conv2d_shape_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_conv2d_shape_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::conv2d_transpose>
-{
-    tensor_conv2d_transpose_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::conv2d_transpose> {
+    tensor_conv2d_transpose_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_conv2d_transpose_op_t op;
         op.pad_mode = static_cast<pad_mode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::conv2d_transpose_shape>
-{
-    tensor_conv2d_transpose_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::conv2d_transpose_shape> {
+    tensor_conv2d_transpose_shape_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_conv2d_transpose_shape_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::cum_sum>
-{
-    tensor_cum_sum_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::cum_sum> {
+    tensor_cum_sum_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_cum_sum_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::dequantize>
-{
-    tensor_dequantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::dequantize> {
+    tensor_dequantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_dequantize_op_t op;
-        op.target_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
+        op.target_type =
+            static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::elu>
-{
-    tensor_elu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::elu> {
+    tensor_elu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_elu_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::erf>
-{
-    tensor_erf_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::erf> {
+    tensor_erf_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_erf_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::expand>
-{
-    tensor_expand_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::expand> {
+    tensor_expand_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_expand_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::fake_dequantize>
-{
-    tensor_fake_dequantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::fake_dequantize> {
+    tensor_fake_dequantize_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_fake_dequantize_op_t op;
-        op.target_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
+        op.target_type =
+            static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::fake_quantize>
-{
-    tensor_fake_quantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::fake_quantize> {
+    tensor_fake_quantize_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_fake_quantize_op_t op;
-        op.target_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
+        op.target_type =
+            static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::fix_shape>
-{
-    tensor_fix_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::fix_shape> {
+    tensor_fix_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_fix_shape_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::flatten>
-{
-    tensor_flatten_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::flatten> {
+    tensor_flatten_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_flatten_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::gather>
-{
-    tensor_gather_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::gather> {
+    tensor_gather_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_gather_op_t op;
         op.axis = reader.read_unaligned<int32_t>();
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::gather_elements>
-{
-    tensor_gather_elements_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::gather_elements> {
+    tensor_gather_elements_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_gather_elements_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::gather_nd>
-{
-    tensor_gather_nd_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::gather_nd> {
+    tensor_gather_nd_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_gather_nd_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::gelu>
-{
-    tensor_gelu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::gelu> {
+    tensor_gelu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_gelu_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::get_item>
-{
-    tensor_get_item_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::get_item> {
+    tensor_get_item_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_get_item_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::get_paddings>
-{
-    tensor_get_paddings_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::get_paddings> {
+    tensor_get_paddings_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_get_paddings_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::hard_sigmoid>
-{
-    tensor_hard_sigmoid_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::hard_sigmoid> {
+    tensor_hard_sigmoid_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_hard_sigmoid_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::hard_swish>
-{
-    tensor_hard_swish_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::hard_swish> {
+    tensor_hard_swish_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_hard_swish_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::hardmax>
-{
-    tensor_hardmax_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::hardmax> {
+    tensor_hardmax_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_hardmax_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::index_of>
-{
-    tensor_index_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::index_of> {
+    tensor_index_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_index_of_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::instance_normalization>
-{
-    tensor_instance_normalization_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::instance_normalization> {
+    tensor_instance_normalization_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_instance_normalization_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::l2_normalization>
-{
-    tensor_l2_normalization_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::l2_normalization> {
+    tensor_l2_normalization_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_l2_normalization_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::layer_norm>
-{
-    tensor_layer_norm_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::layer_norm> {
+    tensor_layer_norm_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_layer_norm_op_t op;
         op.axis = reader.read_unaligned<int32_t>();
         op.epsilon = reader.read_unaligned<float>();
@@ -1463,255 +1062,198 @@ struct tensor_op_reader<tensor_function_t::layer_norm>
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::leaky_relu>
-{
-    tensor_leaky_relu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::leaky_relu> {
+    tensor_leaky_relu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_leaky_relu_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::log_softmax>
-{
-    tensor_log_softmax_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::log_softmax> {
+    tensor_log_softmax_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_log_softmax_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::lp_normalization>
-{
-    tensor_lp_normalization_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::lp_normalization> {
+    tensor_lp_normalization_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_lp_normalization_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::lrn>
-{
-    tensor_lrn_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::lrn> {
+    tensor_lrn_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_lrn_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::lstm>
-{
-    tensor_lstm_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::lstm> {
+    tensor_lstm_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_lstm_op_t op;
-        op.direction = static_cast<lstmdirection_t>(reader.read_unaligned<uint32_t>());
-        op.layout = static_cast<lstmlayout_t>(reader.read_unaligned<uint32_t>());
+        op.direction =
+            static_cast<lstmdirection_t>(reader.read_unaligned<uint32_t>());
+        op.layout =
+            static_cast<lstmlayout_t>(reader.read_unaligned<uint32_t>());
         op.activations = reader.read_string_array();
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::mat_mul>
-{
-    tensor_mat_mul_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::mat_mul> {
+    tensor_mat_mul_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_mat_mul_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::mat_mul_shape>
-{
-    tensor_mat_mul_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::mat_mul_shape> {
+    tensor_mat_mul_shape_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_mat_mul_shape_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::normal>
-{
-    tensor_normal_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::normal> {
+    tensor_normal_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_normal_op_t op;
         op.type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::normal_like>
-{
-    tensor_normal_like_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::normal_like> {
+    tensor_normal_like_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_normal_like_op_t op;
         op.type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::one_hot>
-{
-    tensor_one_hot_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::one_hot> {
+    tensor_one_hot_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_one_hot_op_t op;
-        op.one_hot_mode = static_cast<one_hot_mode_t>(reader.read_unaligned<uint8_t>());
+        op.one_hot_mode =
+            static_cast<one_hot_mode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::pad>
-{
-    tensor_pad_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::pad> {
+    tensor_pad_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_pad_op_t op;
         op.pad_mode = static_cast<pad_mode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::prelu>
-{
-    tensor_prelu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::prelu> {
+    tensor_prelu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_prelu_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::prod>
-{
-    tensor_prod_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::prod> {
+    tensor_prod_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_prod_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::quant_param_of>
-{
-    tensor_quant_param_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::quant_param_of> {
+    tensor_quant_param_of_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_quant_param_of_op_t op;
-        op.quant_mode = static_cast<quant_mode_t>(reader.read_unaligned<uint32_t>());
+        op.quant_mode =
+            static_cast<quant_mode_t>(reader.read_unaligned<uint32_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::quantize>
-{
-    tensor_quantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::quantize> {
+    tensor_quantize_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_quantize_op_t op;
-        op.target_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
+        op.target_type =
+            static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::range>
-{
-    tensor_range_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::range> {
+    tensor_range_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_range_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::range_of>
-{
-    tensor_range_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::range_of> {
+    tensor_range_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_range_of_op_t op;
         op.is_range_of_weight = reader.read_unaligned<bool>();
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::rank>
-{
-    tensor_rank_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::rank> {
+    tensor_rank_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_rank_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::reduce>
-{
-    tensor_reduce_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::reduce> {
+    tensor_reduce_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_reduce_op_t op;
-        op.reduce_op = static_cast<reduce_op_t>(reader.read_unaligned<uint8_t>());
+        op.reduce_op =
+            static_cast<reduce_op_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::reduce_arg>
-{
-    tensor_reduce_arg_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::reduce_arg> {
+    tensor_reduce_arg_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_reduce_arg_op_t op;
-        op.reduce_arg_op = static_cast<reduce_arg_op_t>(reader.read_unaligned<uint8_t>());
-        op.dest_type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
+        op.reduce_arg_op =
+            static_cast<reduce_arg_op_t>(reader.read_unaligned<uint8_t>());
+        op.dest_type =
+            static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::reduce_window2d>
-{
-    tensor_reduce_window2d_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::reduce_window2d> {
+    tensor_reduce_window2d_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_reduce_window2d_op_t op;
-        op.reduce_op = static_cast<reduce_op_t>(reader.read_unaligned<uint8_t>());
+        op.reduce_op =
+            static_cast<reduce_op_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::relu>
-{
-    tensor_relu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::relu> {
+    tensor_relu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_relu_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::relu6>
-{
-    tensor_relu6_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::relu6> {
+    tensor_relu6_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_relu6_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::require>
-{
-    tensor_require_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::require> {
+    tensor_require_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_require_op_t op;
         op.message = reader.read_string();
         op.can_fold_const_call = reader.read_unaligned<bool>();
@@ -1719,427 +1261,635 @@ struct tensor_op_reader<tensor_function_t::require>
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::reshape>
-{
-    tensor_reshape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::reshape> {
+    tensor_reshape_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_reshape_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::reshape_shape>
-{
-    tensor_reshape_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::reshape_shape> {
+    tensor_reshape_shape_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_reshape_shape_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::resize_image>
-{
-    tensor_resize_image_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::resize_image> {
+    tensor_resize_image_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_resize_image_op_t op;
-        op.resize_mode = static_cast<image_resize_mode_t>(reader.read_unaligned<uint8_t>());
-        op.transformation_mode = static_cast<image_resize_transformation_mode_t>(reader.read_unaligned<uint32_t>());
-        op.nearest_mode = static_cast<image_resize_nearest_mode_t>(reader.read_unaligned<uint32_t>());
+        op.resize_mode =
+            static_cast<image_resize_mode_t>(reader.read_unaligned<uint8_t>());
+        op.transformation_mode =
+            static_cast<image_resize_transformation_mode_t>(
+                reader.read_unaligned<uint32_t>());
+        op.nearest_mode = static_cast<image_resize_nearest_mode_t>(
+            reader.read_unaligned<uint32_t>());
         op.is_tfresize = reader.read_unaligned<bool>();
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::reverse_sequence>
-{
-    tensor_reverse_sequence_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::reverse_sequence> {
+    tensor_reverse_sequence_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_reverse_sequence_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::scatter_nd>
-{
-    tensor_scatter_nd_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::scatter_nd> {
+    tensor_scatter_nd_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_scatter_nd_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::select>
-{
-    tensor_select_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::select> {
+    tensor_select_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_select_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::selu>
-{
-    tensor_selu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::selu> {
+    tensor_selu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_selu_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::shape_of>
-{
-    tensor_shape_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::shape_of> {
+    tensor_shape_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_shape_of_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::sigmoid>
-{
-    tensor_sigmoid_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::sigmoid> {
+    tensor_sigmoid_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_sigmoid_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::size_of>
-{
-    tensor_size_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::size_of> {
+    tensor_size_of_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_size_of_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::slice>
-{
-    tensor_slice_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::slice> {
+    tensor_slice_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_slice_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::softmax>
-{
-    tensor_softmax_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::softmax> {
+    tensor_softmax_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_softmax_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::softplus>
-{
-    tensor_softplus_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::softplus> {
+    tensor_softplus_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_softplus_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::softsign>
-{
-    tensor_softsign_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::softsign> {
+    tensor_softsign_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_softsign_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::space_to_batch>
-{
-    tensor_space_to_batch_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::space_to_batch> {
+    tensor_space_to_batch_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_space_to_batch_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::split>
-{
-    tensor_split_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::split> {
+    tensor_split_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_split_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::squeeze>
-{
-    tensor_squeeze_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::squeeze> {
+    tensor_squeeze_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_squeeze_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::squeeze_shape>
-{
-    tensor_squeeze_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::squeeze_shape> {
+    tensor_squeeze_shape_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_squeeze_shape_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::stack>
-{
-    tensor_stack_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::stack> {
+    tensor_stack_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_stack_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::swish>
-{
-    tensor_swish_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::swish> {
+    tensor_swish_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_swish_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::tile>
-{
-    tensor_tile_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::tile> {
+    tensor_tile_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_tile_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::top_k>
-{
-    tensor_top_k_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::top_k> {
+    tensor_top_k_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_top_k_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::transpose>
-{
-    tensor_transpose_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::transpose> {
+    tensor_transpose_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_transpose_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::transpose_shape>
-{
-    tensor_transpose_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::transpose_shape> {
+    tensor_transpose_shape_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_transpose_shape_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::trilu>
-{
-    tensor_trilu_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::trilu> {
+    tensor_trilu_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_trilu_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::unary>
-{
-    tensor_unary_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::unary> {
+    tensor_unary_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_unary_op_t op;
         op.unary_op = static_cast<unary_op_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::uniform>
-{
-    tensor_uniform_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::uniform> {
+    tensor_uniform_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_uniform_op_t op;
         op.type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::uniform_like>
-{
-    tensor_uniform_like_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::uniform_like> {
+    tensor_uniform_like_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_uniform_like_op_t op;
         op.type = static_cast<typecode_t>(reader.read_unaligned<uint8_t>());
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::unsqueeze>
-{
-    tensor_unsqueeze_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::unsqueeze> {
+    tensor_unsqueeze_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_unsqueeze_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::unsqueeze_shape>
-{
-    tensor_unsqueeze_shape_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::unsqueeze_shape> {
+    tensor_unsqueeze_shape_op_t
+    operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_unsqueeze_shape_op_t op;
         return op;
     }
 };
 
-template <>
-struct tensor_op_reader<tensor_function_t::where>
-{
-    tensor_where_op_t operator()(NNCASE_UNUSED span_reader &reader) const
-    {
+template <> struct tensor_op_reader<tensor_function_t::where> {
+    tensor_where_op_t operator()(NNCASE_UNUSED span_reader &reader) const {
         tensor_where_op_t op;
         op.is_tf_where = reader.read_unaligned<bool>();
         return op;
     }
 };
 
-class NNCASE_API tensor_op_visitor
-{
-public:
-    result<void> visit(tensor_function_t tensor_funct, span_reader &reader) noexcept;
-
-    virtual result<void> visit(NNCASE_UNUSED const tensor_batch_normalization_op_t &op) noexcept { return default_visit(tensor_function_t::batch_normalization, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_batch_to_space_op_t &op) noexcept { return default_visit(tensor_function_t::batch_to_space, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_binary_op_t &op) noexcept { return default_visit(tensor_function_t::binary, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_bitcast_op_t &op) noexcept { return default_visit(tensor_function_t::bitcast, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_broadcast_op_t &op) noexcept { return default_visit(tensor_function_t::broadcast, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_broadcast_shape_op_t &op) noexcept { return default_visit(tensor_function_t::broadcast_shape, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_bucket_pad_op_t &op) noexcept { return default_visit(tensor_function_t::bucket_pad, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_cast_op_t &op) noexcept { return default_visit(tensor_function_t::cast, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_celu_op_t &op) noexcept { return default_visit(tensor_function_t::celu, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_clamp_op_t &op) noexcept { return default_visit(tensor_function_t::clamp, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_compare_op_t &op) noexcept { return default_visit(tensor_function_t::compare, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_concat_op_t &op) noexcept { return default_visit(tensor_function_t::concat, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_condition_op_t &op) noexcept { return default_visit(tensor_function_t::condition, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_constant_of_shape_op_t &op) noexcept { return default_visit(tensor_function_t::constant_of_shape, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_conv2d_op_t &op) noexcept { return default_visit(tensor_function_t::conv2d, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_conv2d_shape_op_t &op) noexcept { return default_visit(tensor_function_t::conv2d_shape, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_conv2d_transpose_op_t &op) noexcept { return default_visit(tensor_function_t::conv2d_transpose, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_conv2d_transpose_shape_op_t &op) noexcept { return default_visit(tensor_function_t::conv2d_transpose_shape, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_cum_sum_op_t &op) noexcept { return default_visit(tensor_function_t::cum_sum, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_dequantize_op_t &op) noexcept { return default_visit(tensor_function_t::dequantize, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_elu_op_t &op) noexcept { return default_visit(tensor_function_t::elu, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_erf_op_t &op) noexcept { return default_visit(tensor_function_t::erf, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_expand_op_t &op) noexcept { return default_visit(tensor_function_t::expand, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_fake_dequantize_op_t &op) noexcept { return default_visit(tensor_function_t::fake_dequantize, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_fake_quantize_op_t &op) noexcept { return default_visit(tensor_function_t::fake_quantize, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_fix_shape_op_t &op) noexcept { return default_visit(tensor_function_t::fix_shape, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_flatten_op_t &op) noexcept { return default_visit(tensor_function_t::flatten, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_gather_op_t &op) noexcept { return default_visit(tensor_function_t::gather, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_gather_elements_op_t &op) noexcept { return default_visit(tensor_function_t::gather_elements, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_gather_nd_op_t &op) noexcept { return default_visit(tensor_function_t::gather_nd, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_gelu_op_t &op) noexcept { return default_visit(tensor_function_t::gelu, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_get_item_op_t &op) noexcept { return default_visit(tensor_function_t::get_item, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_get_paddings_op_t &op) noexcept { return default_visit(tensor_function_t::get_paddings, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_hard_sigmoid_op_t &op) noexcept { return default_visit(tensor_function_t::hard_sigmoid, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_hard_swish_op_t &op) noexcept { return default_visit(tensor_function_t::hard_swish, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_hardmax_op_t &op) noexcept { return default_visit(tensor_function_t::hardmax, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_index_of_op_t &op) noexcept { return default_visit(tensor_function_t::index_of, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_instance_normalization_op_t &op) noexcept { return default_visit(tensor_function_t::instance_normalization, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_l2_normalization_op_t &op) noexcept { return default_visit(tensor_function_t::l2_normalization, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_layer_norm_op_t &op) noexcept { return default_visit(tensor_function_t::layer_norm, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_leaky_relu_op_t &op) noexcept { return default_visit(tensor_function_t::leaky_relu, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_log_softmax_op_t &op) noexcept { return default_visit(tensor_function_t::log_softmax, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_lp_normalization_op_t &op) noexcept { return default_visit(tensor_function_t::lp_normalization, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_lrn_op_t &op) noexcept { return default_visit(tensor_function_t::lrn, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_lstm_op_t &op) noexcept { return default_visit(tensor_function_t::lstm, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_mat_mul_op_t &op) noexcept { return default_visit(tensor_function_t::mat_mul, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_mat_mul_shape_op_t &op) noexcept { return default_visit(tensor_function_t::mat_mul_shape, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_normal_op_t &op) noexcept { return default_visit(tensor_function_t::normal, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_normal_like_op_t &op) noexcept { return default_visit(tensor_function_t::normal_like, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_one_hot_op_t &op) noexcept { return default_visit(tensor_function_t::one_hot, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_pad_op_t &op) noexcept { return default_visit(tensor_function_t::pad, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_prelu_op_t &op) noexcept { return default_visit(tensor_function_t::prelu, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_prod_op_t &op) noexcept { return default_visit(tensor_function_t::prod, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_quant_param_of_op_t &op) noexcept { return default_visit(tensor_function_t::quant_param_of, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_quantize_op_t &op) noexcept { return default_visit(tensor_function_t::quantize, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_range_op_t &op) noexcept { return default_visit(tensor_function_t::range, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_range_of_op_t &op) noexcept { return default_visit(tensor_function_t::range_of, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_rank_op_t &op) noexcept { return default_visit(tensor_function_t::rank, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_reduce_op_t &op) noexcept { return default_visit(tensor_function_t::reduce, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_reduce_arg_op_t &op) noexcept { return default_visit(tensor_function_t::reduce_arg, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_reduce_window2d_op_t &op) noexcept { return default_visit(tensor_function_t::reduce_window2d, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_relu_op_t &op) noexcept { return default_visit(tensor_function_t::relu, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_relu6_op_t &op) noexcept { return default_visit(tensor_function_t::relu6, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_require_op_t &op) noexcept { return default_visit(tensor_function_t::require, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_reshape_op_t &op) noexcept { return default_visit(tensor_function_t::reshape, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_reshape_shape_op_t &op) noexcept { return default_visit(tensor_function_t::reshape_shape, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_resize_image_op_t &op) noexcept { return default_visit(tensor_function_t::resize_image, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_reverse_sequence_op_t &op) noexcept { return default_visit(tensor_function_t::reverse_sequence, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_scatter_nd_op_t &op) noexcept { return default_visit(tensor_function_t::scatter_nd, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_select_op_t &op) noexcept { return default_visit(tensor_function_t::select, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_selu_op_t &op) noexcept { return default_visit(tensor_function_t::selu, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_shape_of_op_t &op) noexcept { return default_visit(tensor_function_t::shape_of, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_sigmoid_op_t &op) noexcept { return default_visit(tensor_function_t::sigmoid, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_size_of_op_t &op) noexcept { return default_visit(tensor_function_t::size_of, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_slice_op_t &op) noexcept { return default_visit(tensor_function_t::slice, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_softmax_op_t &op) noexcept { return default_visit(tensor_function_t::softmax, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_softplus_op_t &op) noexcept { return default_visit(tensor_function_t::softplus, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_softsign_op_t &op) noexcept { return default_visit(tensor_function_t::softsign, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_space_to_batch_op_t &op) noexcept { return default_visit(tensor_function_t::space_to_batch, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_split_op_t &op) noexcept { return default_visit(tensor_function_t::split, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_squeeze_op_t &op) noexcept { return default_visit(tensor_function_t::squeeze, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_squeeze_shape_op_t &op) noexcept { return default_visit(tensor_function_t::squeeze_shape, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_stack_op_t &op) noexcept { return default_visit(tensor_function_t::stack, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_swish_op_t &op) noexcept { return default_visit(tensor_function_t::swish, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_tile_op_t &op) noexcept { return default_visit(tensor_function_t::tile, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_top_k_op_t &op) noexcept { return default_visit(tensor_function_t::top_k, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_transpose_op_t &op) noexcept { return default_visit(tensor_function_t::transpose, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_transpose_shape_op_t &op) noexcept { return default_visit(tensor_function_t::transpose_shape, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_trilu_op_t &op) noexcept { return default_visit(tensor_function_t::trilu, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_unary_op_t &op) noexcept { return default_visit(tensor_function_t::unary, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_uniform_op_t &op) noexcept { return default_visit(tensor_function_t::uniform, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_uniform_like_op_t &op) noexcept { return default_visit(tensor_function_t::uniform_like, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_unsqueeze_op_t &op) noexcept { return default_visit(tensor_function_t::unsqueeze, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_unsqueeze_shape_op_t &op) noexcept { return default_visit(tensor_function_t::unsqueeze_shape, &op); }
-    virtual result<void> visit(NNCASE_UNUSED const tensor_where_op_t &op) noexcept { return default_visit(tensor_function_t::where, &op); }
-
-protected:
-    virtual result<void> default_visit(NNCASE_UNUSED tensor_function_t tensor_funct, NNCASE_UNUSED const void *op) noexcept { return err(std::errc::not_supported); }
+class NNCASE_API tensor_op_visitor {
+  public:
+    result<void> visit(tensor_function_t tensor_funct,
+                       span_reader &reader) noexcept;
+
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_batch_normalization_op_t &op) noexcept {
+        return default_visit(tensor_function_t::batch_normalization, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_batch_to_space_op_t &op) noexcept {
+        return default_visit(tensor_function_t::batch_to_space, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_binary_op_t &op) noexcept {
+        return default_visit(tensor_function_t::binary, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_bitcast_op_t &op) noexcept {
+        return default_visit(tensor_function_t::bitcast, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_broadcast_op_t &op) noexcept {
+        return default_visit(tensor_function_t::broadcast, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_broadcast_shape_op_t &op) noexcept {
+        return default_visit(tensor_function_t::broadcast_shape, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_bucket_pad_op_t &op) noexcept {
+        return default_visit(tensor_function_t::bucket_pad, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_cast_op_t &op) noexcept {
+        return default_visit(tensor_function_t::cast, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_celu_op_t &op) noexcept {
+        return default_visit(tensor_function_t::celu, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_clamp_op_t &op) noexcept {
+        return default_visit(tensor_function_t::clamp, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_compare_op_t &op) noexcept {
+        return default_visit(tensor_function_t::compare, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_concat_op_t &op) noexcept {
+        return default_visit(tensor_function_t::concat, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_condition_op_t &op) noexcept {
+        return default_visit(tensor_function_t::condition, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_constant_of_shape_op_t &op) noexcept {
+        return default_visit(tensor_function_t::constant_of_shape, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_conv2d_op_t &op) noexcept {
+        return default_visit(tensor_function_t::conv2d, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_conv2d_shape_op_t &op) noexcept {
+        return default_visit(tensor_function_t::conv2d_shape, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_conv2d_transpose_op_t &op) noexcept {
+        return default_visit(tensor_function_t::conv2d_transpose, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_conv2d_transpose_shape_op_t &op) noexcept {
+        return default_visit(tensor_function_t::conv2d_transpose_shape, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_cum_sum_op_t &op) noexcept {
+        return default_visit(tensor_function_t::cum_sum, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_dequantize_op_t &op) noexcept {
+        return default_visit(tensor_function_t::dequantize, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_elu_op_t &op) noexcept {
+        return default_visit(tensor_function_t::elu, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_erf_op_t &op) noexcept {
+        return default_visit(tensor_function_t::erf, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_expand_op_t &op) noexcept {
+        return default_visit(tensor_function_t::expand, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_fake_dequantize_op_t &op) noexcept {
+        return default_visit(tensor_function_t::fake_dequantize, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_fake_quantize_op_t &op) noexcept {
+        return default_visit(tensor_function_t::fake_quantize, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_fix_shape_op_t &op) noexcept {
+        return default_visit(tensor_function_t::fix_shape, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_flatten_op_t &op) noexcept {
+        return default_visit(tensor_function_t::flatten, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_gather_op_t &op) noexcept {
+        return default_visit(tensor_function_t::gather, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_gather_elements_op_t &op) noexcept {
+        return default_visit(tensor_function_t::gather_elements, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_gather_nd_op_t &op) noexcept {
+        return default_visit(tensor_function_t::gather_nd, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_gelu_op_t &op) noexcept {
+        return default_visit(tensor_function_t::gelu, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_get_item_op_t &op) noexcept {
+        return default_visit(tensor_function_t::get_item, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_get_paddings_op_t &op) noexcept {
+        return default_visit(tensor_function_t::get_paddings, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_hard_sigmoid_op_t &op) noexcept {
+        return default_visit(tensor_function_t::hard_sigmoid, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_hard_swish_op_t &op) noexcept {
+        return default_visit(tensor_function_t::hard_swish, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_hardmax_op_t &op) noexcept {
+        return default_visit(tensor_function_t::hardmax, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_index_of_op_t &op) noexcept {
+        return default_visit(tensor_function_t::index_of, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_instance_normalization_op_t &op) noexcept {
+        return default_visit(tensor_function_t::instance_normalization, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_l2_normalization_op_t &op) noexcept {
+        return default_visit(tensor_function_t::l2_normalization, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_layer_norm_op_t &op) noexcept {
+        return default_visit(tensor_function_t::layer_norm, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_leaky_relu_op_t &op) noexcept {
+        return default_visit(tensor_function_t::leaky_relu, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_log_softmax_op_t &op) noexcept {
+        return default_visit(tensor_function_t::log_softmax, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_lp_normalization_op_t &op) noexcept {
+        return default_visit(tensor_function_t::lp_normalization, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_lrn_op_t &op) noexcept {
+        return default_visit(tensor_function_t::lrn, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_lstm_op_t &op) noexcept {
+        return default_visit(tensor_function_t::lstm, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_mat_mul_op_t &op) noexcept {
+        return default_visit(tensor_function_t::mat_mul, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_mat_mul_shape_op_t &op) noexcept {
+        return default_visit(tensor_function_t::mat_mul_shape, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_normal_op_t &op) noexcept {
+        return default_visit(tensor_function_t::normal, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_normal_like_op_t &op) noexcept {
+        return default_visit(tensor_function_t::normal_like, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_one_hot_op_t &op) noexcept {
+        return default_visit(tensor_function_t::one_hot, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_pad_op_t &op) noexcept {
+        return default_visit(tensor_function_t::pad, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_prelu_op_t &op) noexcept {
+        return default_visit(tensor_function_t::prelu, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_prod_op_t &op) noexcept {
+        return default_visit(tensor_function_t::prod, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_quant_param_of_op_t &op) noexcept {
+        return default_visit(tensor_function_t::quant_param_of, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_quantize_op_t &op) noexcept {
+        return default_visit(tensor_function_t::quantize, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_range_op_t &op) noexcept {
+        return default_visit(tensor_function_t::range, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_range_of_op_t &op) noexcept {
+        return default_visit(tensor_function_t::range_of, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_rank_op_t &op) noexcept {
+        return default_visit(tensor_function_t::rank, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_reduce_op_t &op) noexcept {
+        return default_visit(tensor_function_t::reduce, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_reduce_arg_op_t &op) noexcept {
+        return default_visit(tensor_function_t::reduce_arg, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_reduce_window2d_op_t &op) noexcept {
+        return default_visit(tensor_function_t::reduce_window2d, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_relu_op_t &op) noexcept {
+        return default_visit(tensor_function_t::relu, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_relu6_op_t &op) noexcept {
+        return default_visit(tensor_function_t::relu6, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_require_op_t &op) noexcept {
+        return default_visit(tensor_function_t::require, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_reshape_op_t &op) noexcept {
+        return default_visit(tensor_function_t::reshape, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_reshape_shape_op_t &op) noexcept {
+        return default_visit(tensor_function_t::reshape_shape, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_resize_image_op_t &op) noexcept {
+        return default_visit(tensor_function_t::resize_image, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_reverse_sequence_op_t &op) noexcept {
+        return default_visit(tensor_function_t::reverse_sequence, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_scatter_nd_op_t &op) noexcept {
+        return default_visit(tensor_function_t::scatter_nd, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_select_op_t &op) noexcept {
+        return default_visit(tensor_function_t::select, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_selu_op_t &op) noexcept {
+        return default_visit(tensor_function_t::selu, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_shape_of_op_t &op) noexcept {
+        return default_visit(tensor_function_t::shape_of, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_sigmoid_op_t &op) noexcept {
+        return default_visit(tensor_function_t::sigmoid, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_size_of_op_t &op) noexcept {
+        return default_visit(tensor_function_t::size_of, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_slice_op_t &op) noexcept {
+        return default_visit(tensor_function_t::slice, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_softmax_op_t &op) noexcept {
+        return default_visit(tensor_function_t::softmax, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_softplus_op_t &op) noexcept {
+        return default_visit(tensor_function_t::softplus, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_softsign_op_t &op) noexcept {
+        return default_visit(tensor_function_t::softsign, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_space_to_batch_op_t &op) noexcept {
+        return default_visit(tensor_function_t::space_to_batch, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_split_op_t &op) noexcept {
+        return default_visit(tensor_function_t::split, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_squeeze_op_t &op) noexcept {
+        return default_visit(tensor_function_t::squeeze, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_squeeze_shape_op_t &op) noexcept {
+        return default_visit(tensor_function_t::squeeze_shape, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_stack_op_t &op) noexcept {
+        return default_visit(tensor_function_t::stack, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_swish_op_t &op) noexcept {
+        return default_visit(tensor_function_t::swish, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_tile_op_t &op) noexcept {
+        return default_visit(tensor_function_t::tile, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_top_k_op_t &op) noexcept {
+        return default_visit(tensor_function_t::top_k, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_transpose_op_t &op) noexcept {
+        return default_visit(tensor_function_t::transpose, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_transpose_shape_op_t &op) noexcept {
+        return default_visit(tensor_function_t::transpose_shape, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_trilu_op_t &op) noexcept {
+        return default_visit(tensor_function_t::trilu, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_unary_op_t &op) noexcept {
+        return default_visit(tensor_function_t::unary, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_uniform_op_t &op) noexcept {
+        return default_visit(tensor_function_t::uniform, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_uniform_like_op_t &op) noexcept {
+        return default_visit(tensor_function_t::uniform_like, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_unsqueeze_op_t &op) noexcept {
+        return default_visit(tensor_function_t::unsqueeze, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_unsqueeze_shape_op_t &op) noexcept {
+        return default_visit(tensor_function_t::unsqueeze_shape, &op);
+    }
+    virtual result<void>
+    visit(NNCASE_UNUSED const tensor_where_op_t &op) noexcept {
+        return default_visit(tensor_function_t::where, &op);
+    }
+
+  protected:
+    virtual result<void>
+    default_visit(NNCASE_UNUSED tensor_function_t tensor_funct,
+                  NNCASE_UNUSED const void *op) noexcept {
+        return err(std::errc::not_supported);
+    }
 };
 
 END_NS_NNCASE_RT_MODULE
diff --git a/src/Native/include/nncase/runtime/stackvm/opcode.h b/src/Native/include/nncase/runtime/stackvm/opcode.h
index 6bf7ac71c1..8a5225b54e 100644
--- a/src/Native/include/nncase/runtime/stackvm/opcode.h
+++ b/src/Native/include/nncase/runtime/stackvm/opcode.h
@@ -1,4 +1,5 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM +00:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM
+ * +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -22,8 +23,7 @@ BEGIN_NS_NNCASE_RT_MODULE(stackvm)
 
 // Enums
 
-enum class opcode_t : uint8_t
-{
+enum class opcode_t : uint8_t {
     NOP = 0,
     LDNULL = 1,
     LDC_I4 = 2,
@@ -127,8 +127,7 @@ enum class opcode_t : uint8_t
     TENSOR = 100,
 };
 
-enum class tensor_function_t : uint16_t
-{
+enum class tensor_function_t : uint16_t {
     batch_normalization = 0,
     batch_to_space = 1,
     celu = 8,
@@ -226,8 +225,7 @@ enum class tensor_function_t : uint16_t
     resize_image = 66,
 };
 
-enum class binary_op_t : uint8_t
-{
+enum class binary_op_t : uint8_t {
     add = 0,
     sub = 1,
     mul = 2,
@@ -246,16 +244,14 @@ enum class binary_op_t : uint8_t
     right_shift = 15,
 };
 
-enum class cast_mode_t : int32_t
-{
+enum class cast_mode_t : int32_t {
     kdefault = 0,
     exact = 1,
     check_overflow = 2,
     reinterpret = 3,
 };
 
-enum class compare_op_t : uint8_t
-{
+enum class compare_op_t : uint8_t {
     equal = 0,
     not_equal = 1,
     lower_than = 2,
@@ -264,42 +260,36 @@ enum class compare_op_t : uint8_t
     greater_or_equal = 5,
 };
 
-enum class pad_mode_t : uint8_t
-{
+enum class pad_mode_t : uint8_t {
     constant = 0,
     reflect = 1,
     symmetric = 2,
     edge = 3,
 };
 
-enum class lstmdirection_t : int32_t
-{
+enum class lstmdirection_t : int32_t {
     forward = 0,
     reverse = 1,
     bidirectional = 2,
 };
 
-enum class lstmlayout_t : int32_t
-{
+enum class lstmlayout_t : int32_t {
     zero = 0,
     one = 1,
 };
 
-enum class one_hot_mode_t : uint8_t
-{
+enum class one_hot_mode_t : uint8_t {
     normal = 0,
     process_neg = 1,
 };
 
-enum class quant_mode_t : int32_t
-{
+enum class quant_mode_t : int32_t {
     unsigned_mode = 0,
     signed_symmetric_mode = 1,
     signed_asymmetric_mode = 2,
 };
 
-enum class reduce_op_t : uint8_t
-{
+enum class reduce_op_t : uint8_t {
     mean = 0,
     min = 1,
     max = 2,
@@ -307,20 +297,17 @@ enum class reduce_op_t : uint8_t
     prod = 4,
 };
 
-enum class reduce_arg_op_t : uint8_t
-{
+enum class reduce_arg_op_t : uint8_t {
     arg_min = 0,
     arg_max = 1,
 };
 
-enum class image_resize_mode_t : uint8_t
-{
+enum class image_resize_mode_t : uint8_t {
     bilinear = 0,
     nearest_neighbor = 1,
 };
 
-enum class image_resize_transformation_mode_t : int32_t
-{
+enum class image_resize_transformation_mode_t : int32_t {
     half_pixel = 0,
     pytorch_half_pixel = 1,
     align_corners = 2,
@@ -328,16 +315,14 @@ enum class image_resize_transformation_mode_t : int32_t
     tfcrop_and_resize = 4,
 };
 
-enum class image_resize_nearest_mode_t : int32_t
-{
+enum class image_resize_nearest_mode_t : int32_t {
     round_prefer_floor = 0,
     round_prefer_ceil = 1,
     floor = 2,
     ceil = 3,
 };
 
-enum class unary_op_t : uint8_t
-{
+enum class unary_op_t : uint8_t {
     abs = 0,
     acos = 1,
     acosh = 2,
@@ -364,1058 +349,900 @@ enum class unary_op_t : uint8_t
 
 // Instructions
 
-struct nop_op_t
-{
-};
+struct nop_op_t {};
 
-struct br_op_t
-{
+struct br_op_t {
     int32_t target;
 };
 
-struct br_true_op_t
-{
+struct br_true_op_t {
     int32_t target;
 };
 
-struct br_false_op_t
-{
+struct br_false_op_t {
     int32_t target;
 };
 
-struct ret_op_t
-{
-};
+struct ret_op_t {};
 
-struct call_op_t
-{
+struct call_op_t {
     uint16_t args;
     int32_t target;
 };
 
-struct ecall_op_t
-{
+struct ecall_op_t {
     uint16_t args;
 };
 
-struct extcall_op_t
-{
+struct extcall_op_t {
     uint16_t args;
     bool is_prim_func;
 };
 
-struct cuscall_op_t
-{
+struct cuscall_op_t {
     std::string registered_name;
     gsl::span<const gsl::byte> fields_span;
     uint16_t args;
 };
 
-struct throw_op_t
-{
-};
+struct throw_op_t {};
 
-struct break_op_t
-{
-};
+struct break_op_t {};
 
-struct ldc_i4_op_t
-{
+struct ldc_i4_op_t {
     int32_t imm;
 };
 
-struct ldnull_op_t
-{
-};
+struct ldnull_op_t {};
 
-struct ldc_i4_0_op_t
-{
-};
+struct ldc_i4_0_op_t {};
 
-struct ldc_i4_1_op_t
-{
-};
+struct ldc_i4_1_op_t {};
 
-struct ldc_r4_op_t
-{
+struct ldc_r4_op_t {
     float imm;
 };
 
-struct ldind_i1_op_t
-{
-};
+struct ldind_i1_op_t {};
 
-struct ldind_i2_op_t
-{
-};
+struct ldind_i2_op_t {};
 
-struct ldind_i4_op_t
-{
-};
+struct ldind_i4_op_t {};
 
-struct ldind_i_op_t
-{
-};
+struct ldind_i_op_t {};
 
-struct ldind_u1_op_t
-{
-};
+struct ldind_u1_op_t {};
 
-struct ldind_u2_op_t
-{
-};
+struct ldind_u2_op_t {};
 
-struct ldind_u4_op_t
-{
-};
+struct ldind_u4_op_t {};
 
-struct ldind_u_op_t
-{
-};
+struct ldind_u_op_t {};
 
-struct ldind_br2_op_t
-{
-};
+struct ldind_br2_op_t {};
 
-struct ldind_r4_op_t
-{
-};
+struct ldind_r4_op_t {};
 
-struct stind_i1_op_t
-{
-};
+struct stind_i1_op_t {};
 
-struct stind_i2_op_t
-{
-};
+struct stind_i2_op_t {};
 
-struct stind_i4_op_t
-{
-};
+struct stind_i4_op_t {};
 
-struct stind_i_op_t
-{
-};
+struct stind_i_op_t {};
 
-struct stind_br2_op_t
-{
-};
+struct stind_br2_op_t {};
 
-struct stind_r4_op_t
-{
-};
+struct stind_r4_op_t {};
 
-struct lea_gp_op_t
-{
+struct lea_gp_op_t {
     uint8_t gpid;
     int32_t offset;
 };
 
-struct ldelem_i1_op_t
-{
-};
+struct ldelem_i1_op_t {};
 
-struct ldelem_i2_op_t
-{
-};
+struct ldelem_i2_op_t {};
 
-struct ldelem_i4_op_t
-{
-};
+struct ldelem_i4_op_t {};
 
-struct ldelem_i_op_t
-{
-};
+struct ldelem_i_op_t {};
 
-struct ldelem_u1_op_t
-{
-};
+struct ldelem_u1_op_t {};
 
-struct ldelem_u2_op_t
-{
-};
+struct ldelem_u2_op_t {};
 
-struct ldelem_u4_op_t
-{
-};
+struct ldelem_u4_op_t {};
 
-struct ldelem_u_op_t
-{
-};
+struct ldelem_u_op_t {};
 
-struct ldelem_br2_op_t
-{
-};
+struct ldelem_br2_op_t {};
 
-struct ldelem_r4_op_t
-{
-};
+struct ldelem_r4_op_t {};
 
-struct stelem_i1_op_t
-{
-};
+struct stelem_i1_op_t {};
 
-struct stelem_i2_op_t
-{
-};
+struct stelem_i2_op_t {};
 
-struct stelem_i4_op_t
-{
-};
+struct stelem_i4_op_t {};
 
-struct stelem_i_op_t
-{
-};
+struct stelem_i_op_t {};
 
-struct stelem_br2_op_t
-{
-};
+struct stelem_br2_op_t {};
 
-struct stelem_r4_op_t
-{
-};
+struct stelem_r4_op_t {};
 
-struct ldarg_op_t
-{
+struct ldarg_op_t {
     uint16_t index;
 };
 
-struct ldarg_0_op_t
-{
-};
+struct ldarg_0_op_t {};
 
-struct ldarg_1_op_t
-{
-};
+struct ldarg_1_op_t {};
 
-struct ldarg_2_op_t
-{
-};
+struct ldarg_2_op_t {};
 
-struct ldarg_3_op_t
-{
-};
+struct ldarg_3_op_t {};
 
-struct ldarg_4_op_t
-{
-};
+struct ldarg_4_op_t {};
 
-struct ldarg_5_op_t
-{
-};
+struct ldarg_5_op_t {};
 
-struct ldtuple_elem_op_t
-{
-};
+struct ldtuple_elem_op_t {};
 
-struct ldtuple_op_t
-{
-};
+struct ldtuple_op_t {};
 
-struct lddatatype_op_t
-{
-};
+struct lddatatype_op_t {};
 
-struct ldtensor_op_t
-{
-};
+struct ldtensor_op_t {};
 
-struct ldlocal_op_t
-{
+struct ldlocal_op_t {
     uint16_t index;
 };
 
-struct stlocal_op_t
-{
+struct stlocal_op_t {
     uint16_t index;
 };
 
-struct ldscalar_op_t
-{
-};
+struct ldscalar_op_t {};
 
-struct dup_op_t
-{
-};
+struct dup_op_t {};
 
-struct pop_op_t
-{
-};
+struct pop_op_t {};
 
-struct neg_op_t
-{
-};
+struct neg_op_t {};
 
-struct add_op_t
-{
-};
+struct add_op_t {};
 
-struct sub_op_t
-{
-};
+struct sub_op_t {};
 
-struct mul_op_t
-{
-};
+struct mul_op_t {};
 
-struct div_op_t
-{
-};
+struct div_op_t {};
 
-struct div_u_op_t
-{
-};
+struct div_u_op_t {};
 
-struct rem_op_t
-{
-};
+struct rem_op_t {};
 
-struct rem_u_op_t
-{
-};
+struct rem_u_op_t {};
 
-struct and_op_t
-{
-};
+struct and_op_t {};
 
-struct or_op_t
-{
-};
+struct or_op_t {};
 
-struct xor_op_t
-{
-};
+struct xor_op_t {};
 
-struct not_op_t
-{
-};
+struct not_op_t {};
 
-struct shl_op_t
-{
-};
+struct shl_op_t {};
 
-struct shr_op_t
-{
-};
+struct shr_op_t {};
 
-struct shr_u_op_t
-{
-};
+struct shr_u_op_t {};
 
-struct clt_op_t
-{
-};
+struct clt_op_t {};
 
-struct clt_u_op_t
-{
-};
+struct clt_u_op_t {};
 
-struct cle_op_t
-{
-};
+struct cle_op_t {};
 
-struct cle_u_op_t
-{
-};
+struct cle_u_op_t {};
 
-struct ceq_op_t
-{
-};
+struct ceq_op_t {};
 
-struct cge_op_t
-{
-};
+struct cge_op_t {};
 
-struct cge_u_op_t
-{
-};
+struct cge_u_op_t {};
 
-struct cgt_op_t
-{
-};
+struct cgt_op_t {};
 
-struct cgt_u_op_t
-{
-};
+struct cgt_u_op_t {};
 
-struct cne_op_t
-{
-};
+struct cne_op_t {};
 
-struct conv_i1_op_t
-{
-};
+struct conv_i1_op_t {};
 
-struct conv_i2_op_t
-{
-};
+struct conv_i2_op_t {};
 
-struct conv_i4_op_t
-{
-};
+struct conv_i4_op_t {};
 
-struct conv_i_op_t
-{
-};
+struct conv_i_op_t {};
 
-struct conv_u1_op_t
-{
-};
+struct conv_u1_op_t {};
 
-struct conv_u2_op_t
-{
-};
+struct conv_u2_op_t {};
 
-struct conv_u4_op_t
-{
-};
+struct conv_u4_op_t {};
 
-struct conv_u_op_t
-{
-};
+struct conv_u_op_t {};
 
-struct conv_br2_op_t
-{
-};
+struct conv_br2_op_t {};
 
-struct conv_r4_op_t
-{
-};
+struct conv_r4_op_t {};
 
 // Tensor instructions
 
-struct tensor_batch_normalization_op_t
-{
-};
+struct tensor_batch_normalization_op_t {};
 
-struct tensor_batch_to_space_op_t
-{
-};
+struct tensor_batch_to_space_op_t {};
 
-struct tensor_binary_op_t
-{
+struct tensor_binary_op_t {
     binary_op_t binary_op;
 };
 
-struct tensor_bitcast_op_t
-{
+struct tensor_bitcast_op_t {
     prim_type_t type;
     prim_type_t new_type;
 };
 
-struct tensor_broadcast_op_t
-{
-};
+struct tensor_broadcast_op_t {};
 
-struct tensor_broadcast_shape_op_t
-{
-};
+struct tensor_broadcast_shape_op_t {};
 
-struct tensor_bucket_pad_op_t
-{
-};
+struct tensor_bucket_pad_op_t {};
 
-struct tensor_cast_op_t
-{
+struct tensor_cast_op_t {
     typecode_t new_type;
     cast_mode_t cast_mode;
 };
 
-struct tensor_celu_op_t
-{
-};
+struct tensor_celu_op_t {};
 
-struct tensor_clamp_op_t
-{
-};
+struct tensor_clamp_op_t {};
 
-struct tensor_compare_op_t
-{
+struct tensor_compare_op_t {
     compare_op_t compare_op;
 };
 
-struct tensor_concat_op_t
-{
+struct tensor_concat_op_t {
     int32_t axis;
 };
 
-struct tensor_condition_op_t
-{
+struct tensor_condition_op_t {
     bool can_fold_const_call;
 };
 
-struct tensor_constant_of_shape_op_t
-{
-};
+struct tensor_constant_of_shape_op_t {};
 
-struct tensor_conv2d_op_t
-{
+struct tensor_conv2d_op_t {
     pad_mode_t pad_mode;
 };
 
-struct tensor_conv2d_shape_op_t
-{
-};
+struct tensor_conv2d_shape_op_t {};
 
-struct tensor_conv2d_transpose_op_t
-{
+struct tensor_conv2d_transpose_op_t {
     pad_mode_t pad_mode;
 };
 
-struct tensor_conv2d_transpose_shape_op_t
-{
-};
+struct tensor_conv2d_transpose_shape_op_t {};
 
-struct tensor_cum_sum_op_t
-{
-};
+struct tensor_cum_sum_op_t {};
 
-struct tensor_dequantize_op_t
-{
+struct tensor_dequantize_op_t {
     typecode_t target_type;
 };
 
-struct tensor_elu_op_t
-{
-};
+struct tensor_elu_op_t {};
 
-struct tensor_erf_op_t
-{
-};
+struct tensor_erf_op_t {};
 
-struct tensor_expand_op_t
-{
-};
+struct tensor_expand_op_t {};
 
-struct tensor_fake_dequantize_op_t
-{
+struct tensor_fake_dequantize_op_t {
     typecode_t target_type;
 };
 
-struct tensor_fake_quantize_op_t
-{
+struct tensor_fake_quantize_op_t {
     typecode_t target_type;
 };
 
-struct tensor_fix_shape_op_t
-{
-};
+struct tensor_fix_shape_op_t {};
 
-struct tensor_flatten_op_t
-{
-};
+struct tensor_flatten_op_t {};
 
-struct tensor_gather_op_t
-{
+struct tensor_gather_op_t {
     int32_t axis;
 };
 
-struct tensor_gather_elements_op_t
-{
-};
+struct tensor_gather_elements_op_t {};
 
-struct tensor_gather_nd_op_t
-{
-};
+struct tensor_gather_nd_op_t {};
 
-struct tensor_gelu_op_t
-{
-};
+struct tensor_gelu_op_t {};
 
-struct tensor_get_item_op_t
-{
-};
+struct tensor_get_item_op_t {};
 
-struct tensor_get_paddings_op_t
-{
-};
+struct tensor_get_paddings_op_t {};
 
-struct tensor_hard_sigmoid_op_t
-{
-};
+struct tensor_hard_sigmoid_op_t {};
 
-struct tensor_hard_swish_op_t
-{
-};
+struct tensor_hard_swish_op_t {};
 
-struct tensor_hardmax_op_t
-{
-};
+struct tensor_hardmax_op_t {};
 
-struct tensor_index_of_op_t
-{
-};
+struct tensor_index_of_op_t {};
 
-struct tensor_instance_normalization_op_t
-{
-};
+struct tensor_instance_normalization_op_t {};
 
-struct tensor_l2_normalization_op_t
-{
-};
+struct tensor_l2_normalization_op_t {};
 
-struct tensor_layer_norm_op_t
-{
+struct tensor_layer_norm_op_t {
     int32_t axis;
     float epsilon;
     bool use_mean;
 };
 
-struct tensor_leaky_relu_op_t
-{
-};
+struct tensor_leaky_relu_op_t {};
 
-struct tensor_log_softmax_op_t
-{
-};
+struct tensor_log_softmax_op_t {};
 
-struct tensor_lp_normalization_op_t
-{
-};
+struct tensor_lp_normalization_op_t {};
 
-struct tensor_lrn_op_t
-{
-};
+struct tensor_lrn_op_t {};
 
-struct tensor_lstm_op_t
-{
+struct tensor_lstm_op_t {
     lstmdirection_t direction;
     lstmlayout_t layout;
     std::vector<std::string> activations;
 };
 
-struct tensor_mat_mul_op_t
-{
-};
+struct tensor_mat_mul_op_t {};
 
-struct tensor_mat_mul_shape_op_t
-{
-};
+struct tensor_mat_mul_shape_op_t {};
 
-struct tensor_normal_op_t
-{
+struct tensor_normal_op_t {
     typecode_t type;
 };
 
-struct tensor_normal_like_op_t
-{
+struct tensor_normal_like_op_t {
     typecode_t type;
 };
 
-struct tensor_one_hot_op_t
-{
+struct tensor_one_hot_op_t {
     one_hot_mode_t one_hot_mode;
 };
 
-struct tensor_pad_op_t
-{
+struct tensor_pad_op_t {
     pad_mode_t pad_mode;
 };
 
-struct tensor_prelu_op_t
-{
-};
+struct tensor_prelu_op_t {};
 
-struct tensor_prod_op_t
-{
-};
+struct tensor_prod_op_t {};
 
-struct tensor_quant_param_of_op_t
-{
+struct tensor_quant_param_of_op_t {
     quant_mode_t quant_mode;
 };
 
-struct tensor_quantize_op_t
-{
+struct tensor_quantize_op_t {
     typecode_t target_type;
 };
 
-struct tensor_range_op_t
-{
-};
+struct tensor_range_op_t {};
 
-struct tensor_range_of_op_t
-{
+struct tensor_range_of_op_t {
     bool is_range_of_weight;
 };
 
-struct tensor_rank_op_t
-{
-};
+struct tensor_rank_op_t {};
 
-struct tensor_reduce_op_t
-{
+struct tensor_reduce_op_t {
     reduce_op_t reduce_op;
 };
 
-struct tensor_reduce_arg_op_t
-{
+struct tensor_reduce_arg_op_t {
     reduce_arg_op_t reduce_arg_op;
     typecode_t dest_type;
 };
 
-struct tensor_reduce_window2d_op_t
-{
+struct tensor_reduce_window2d_op_t {
     reduce_op_t reduce_op;
 };
 
-struct tensor_relu_op_t
-{
-};
+struct tensor_relu_op_t {};
 
-struct tensor_relu6_op_t
-{
-};
+struct tensor_relu6_op_t {};
 
-struct tensor_require_op_t
-{
+struct tensor_require_op_t {
     std::string message;
     bool can_fold_const_call;
 };
 
-struct tensor_reshape_op_t
-{
-};
+struct tensor_reshape_op_t {};
 
-struct tensor_reshape_shape_op_t
-{
-};
+struct tensor_reshape_shape_op_t {};
 
-struct tensor_resize_image_op_t
-{
+struct tensor_resize_image_op_t {
     image_resize_mode_t resize_mode;
     image_resize_transformation_mode_t transformation_mode;
     image_resize_nearest_mode_t nearest_mode;
     bool is_tfresize;
 };
 
-struct tensor_reverse_sequence_op_t
-{
-};
+struct tensor_reverse_sequence_op_t {};
 
-struct tensor_scatter_nd_op_t
-{
-};
+struct tensor_scatter_nd_op_t {};
 
-struct tensor_select_op_t
-{
-};
+struct tensor_select_op_t {};
 
-struct tensor_selu_op_t
-{
-};
+struct tensor_selu_op_t {};
 
-struct tensor_shape_of_op_t
-{
-};
+struct tensor_shape_of_op_t {};
 
-struct tensor_sigmoid_op_t
-{
-};
+struct tensor_sigmoid_op_t {};
 
-struct tensor_size_of_op_t
-{
-};
+struct tensor_size_of_op_t {};
 
-struct tensor_slice_op_t
-{
-};
+struct tensor_slice_op_t {};
 
-struct tensor_softmax_op_t
-{
-};
+struct tensor_softmax_op_t {};
 
-struct tensor_softplus_op_t
-{
-};
+struct tensor_softplus_op_t {};
 
-struct tensor_softsign_op_t
-{
-};
+struct tensor_softsign_op_t {};
 
-struct tensor_space_to_batch_op_t
-{
-};
+struct tensor_space_to_batch_op_t {};
 
-struct tensor_split_op_t
-{
-};
+struct tensor_split_op_t {};
 
-struct tensor_squeeze_op_t
-{
-};
+struct tensor_squeeze_op_t {};
 
-struct tensor_squeeze_shape_op_t
-{
-};
+struct tensor_squeeze_shape_op_t {};
 
-struct tensor_stack_op_t
-{
-};
+struct tensor_stack_op_t {};
 
-struct tensor_swish_op_t
-{
-};
+struct tensor_swish_op_t {};
 
-struct tensor_tile_op_t
-{
-};
+struct tensor_tile_op_t {};
 
-struct tensor_top_k_op_t
-{
-};
+struct tensor_top_k_op_t {};
 
-struct tensor_transpose_op_t
-{
-};
+struct tensor_transpose_op_t {};
 
-struct tensor_transpose_shape_op_t
-{
-};
+struct tensor_transpose_shape_op_t {};
 
-struct tensor_trilu_op_t
-{
-};
+struct tensor_trilu_op_t {};
 
-struct tensor_unary_op_t
-{
+struct tensor_unary_op_t {
     unary_op_t unary_op;
 };
 
-struct tensor_uniform_op_t
-{
+struct tensor_uniform_op_t {
     typecode_t type;
 };
 
-struct tensor_uniform_like_op_t
-{
+struct tensor_uniform_like_op_t {
     typecode_t type;
 };
 
-struct tensor_unsqueeze_op_t
-{
-};
+struct tensor_unsqueeze_op_t {};
 
-struct tensor_unsqueeze_shape_op_t
-{
-};
+struct tensor_unsqueeze_shape_op_t {};
 
-struct tensor_where_op_t
-{
+struct tensor_where_op_t {
     bool is_tf_where;
 };
 
-
-
-
-inline std::string to_string(tensor_function_t tensor_funct)
-{
-    switch(tensor_funct)
-    {
-        case tensor_function_t::batch_normalization: return "batch_normalization";
-        case tensor_function_t::batch_to_space: return "batch_to_space";
-        case tensor_function_t::celu: return "celu";
-        case tensor_function_t::conv2d: return "conv2d";
-        case tensor_function_t::conv2d_transpose: return "conv2d_transpose";
-        case tensor_function_t::elu: return "elu";
-        case tensor_function_t::erf: return "erf";
-        case tensor_function_t::gelu: return "gelu";
-        case tensor_function_t::hardmax: return "hardmax";
-        case tensor_function_t::hard_sigmoid: return "hard_sigmoid";
-        case tensor_function_t::hard_swish: return "hard_swish";
-        case tensor_function_t::instance_normalization: return "instance_normalization";
-        case tensor_function_t::l2_normalization: return "l2_normalization";
-        case tensor_function_t::layer_norm: return "layer_norm";
-        case tensor_function_t::leaky_relu: return "leaky_relu";
-        case tensor_function_t::log_softmax: return "log_softmax";
-        case tensor_function_t::lp_normalization: return "lp_normalization";
-        case tensor_function_t::lrn: return "lrn";
-        case tensor_function_t::one_hot: return "one_hot";
-        case tensor_function_t::pad: return "pad";
-        case tensor_function_t::prelu: return "prelu";
-        case tensor_function_t::reduce_window2d: return "reduce_window2d";
-        case tensor_function_t::relu: return "relu";
-        case tensor_function_t::relu6: return "relu6";
-        case tensor_function_t::selu: return "selu";
-        case tensor_function_t::sigmoid: return "sigmoid";
-        case tensor_function_t::softmax: return "softmax";
-        case tensor_function_t::softplus: return "softplus";
-        case tensor_function_t::softsign: return "softsign";
-        case tensor_function_t::space_to_batch: return "space_to_batch";
-        case tensor_function_t::swish: return "swish";
-        case tensor_function_t::binary: return "binary";
-        case tensor_function_t::clamp: return "clamp";
-        case tensor_function_t::compare: return "compare";
-        case tensor_function_t::condition: return "condition";
-        case tensor_function_t::cum_sum: return "cum_sum";
-        case tensor_function_t::dequantize: return "dequantize";
-        case tensor_function_t::fake_dequantize: return "fake_dequantize";
-        case tensor_function_t::fake_quantize: return "fake_quantize";
-        case tensor_function_t::mat_mul: return "mat_mul";
-        case tensor_function_t::quantize: return "quantize";
-        case tensor_function_t::quant_param_of: return "quant_param_of";
-        case tensor_function_t::range_of: return "range_of";
-        case tensor_function_t::reduce: return "reduce";
-        case tensor_function_t::reduce_arg: return "reduce_arg";
-        case tensor_function_t::require: return "require";
-        case tensor_function_t::select: return "select";
-        case tensor_function_t::unary: return "unary";
-        case tensor_function_t::bitcast: return "bitcast";
-        case tensor_function_t::broadcast: return "broadcast";
-        case tensor_function_t::bucket_pad: return "bucket_pad";
-        case tensor_function_t::cast: return "cast";
-        case tensor_function_t::concat: return "concat";
-        case tensor_function_t::constant_of_shape: return "constant_of_shape";
-        case tensor_function_t::expand: return "expand";
-        case tensor_function_t::fix_shape: return "fix_shape";
-        case tensor_function_t::flatten: return "flatten";
-        case tensor_function_t::gather: return "gather";
-        case tensor_function_t::gather_elements: return "gather_elements";
-        case tensor_function_t::gather_nd: return "gather_nd";
-        case tensor_function_t::get_item: return "get_item";
-        case tensor_function_t::index_of: return "index_of";
-        case tensor_function_t::prod: return "prod";
-        case tensor_function_t::range: return "range";
-        case tensor_function_t::rank: return "rank";
-        case tensor_function_t::reshape: return "reshape";
-        case tensor_function_t::reverse_sequence: return "reverse_sequence";
-        case tensor_function_t::scatter_nd: return "scatter_nd";
-        case tensor_function_t::shape_of: return "shape_of";
-        case tensor_function_t::size_of: return "size_of";
-        case tensor_function_t::slice: return "slice";
-        case tensor_function_t::split: return "split";
-        case tensor_function_t::squeeze: return "squeeze";
-        case tensor_function_t::stack: return "stack";
-        case tensor_function_t::tile: return "tile";
-        case tensor_function_t::top_k: return "top_k";
-        case tensor_function_t::transpose: return "transpose";
-        case tensor_function_t::trilu: return "trilu";
-        case tensor_function_t::unsqueeze: return "unsqueeze";
-        case tensor_function_t::where: return "where";
-        case tensor_function_t::broadcast_shape: return "broadcast_shape";
-        case tensor_function_t::conv2d_shape: return "conv2d_shape";
-        case tensor_function_t::conv2d_transpose_shape: return "conv2d_transpose_shape";
-        case tensor_function_t::get_paddings: return "get_paddings";
-        case tensor_function_t::mat_mul_shape: return "mat_mul_shape";
-        case tensor_function_t::reshape_shape: return "reshape_shape";
-        case tensor_function_t::squeeze_shape: return "squeeze_shape";
-        case tensor_function_t::transpose_shape: return "transpose_shape";
-        case tensor_function_t::unsqueeze_shape: return "unsqueeze_shape";
-        case tensor_function_t::lstm: return "lstm";
-        case tensor_function_t::normal: return "normal";
-        case tensor_function_t::normal_like: return "normal_like";
-        case tensor_function_t::uniform: return "uniform";
-        case tensor_function_t::uniform_like: return "uniform_like";
-        case tensor_function_t::resize_image: return "resize_image";
+inline std::string to_string(tensor_function_t tensor_funct) {
+    switch (tensor_funct) {
+    case tensor_function_t::batch_normalization:
+        return "batch_normalization";
+    case tensor_function_t::batch_to_space:
+        return "batch_to_space";
+    case tensor_function_t::celu:
+        return "celu";
+    case tensor_function_t::conv2d:
+        return "conv2d";
+    case tensor_function_t::conv2d_transpose:
+        return "conv2d_transpose";
+    case tensor_function_t::elu:
+        return "elu";
+    case tensor_function_t::erf:
+        return "erf";
+    case tensor_function_t::gelu:
+        return "gelu";
+    case tensor_function_t::hardmax:
+        return "hardmax";
+    case tensor_function_t::hard_sigmoid:
+        return "hard_sigmoid";
+    case tensor_function_t::hard_swish:
+        return "hard_swish";
+    case tensor_function_t::instance_normalization:
+        return "instance_normalization";
+    case tensor_function_t::l2_normalization:
+        return "l2_normalization";
+    case tensor_function_t::layer_norm:
+        return "layer_norm";
+    case tensor_function_t::leaky_relu:
+        return "leaky_relu";
+    case tensor_function_t::log_softmax:
+        return "log_softmax";
+    case tensor_function_t::lp_normalization:
+        return "lp_normalization";
+    case tensor_function_t::lrn:
+        return "lrn";
+    case tensor_function_t::one_hot:
+        return "one_hot";
+    case tensor_function_t::pad:
+        return "pad";
+    case tensor_function_t::prelu:
+        return "prelu";
+    case tensor_function_t::reduce_window2d:
+        return "reduce_window2d";
+    case tensor_function_t::relu:
+        return "relu";
+    case tensor_function_t::relu6:
+        return "relu6";
+    case tensor_function_t::selu:
+        return "selu";
+    case tensor_function_t::sigmoid:
+        return "sigmoid";
+    case tensor_function_t::softmax:
+        return "softmax";
+    case tensor_function_t::softplus:
+        return "softplus";
+    case tensor_function_t::softsign:
+        return "softsign";
+    case tensor_function_t::space_to_batch:
+        return "space_to_batch";
+    case tensor_function_t::swish:
+        return "swish";
+    case tensor_function_t::binary:
+        return "binary";
+    case tensor_function_t::clamp:
+        return "clamp";
+    case tensor_function_t::compare:
+        return "compare";
+    case tensor_function_t::condition:
+        return "condition";
+    case tensor_function_t::cum_sum:
+        return "cum_sum";
+    case tensor_function_t::dequantize:
+        return "dequantize";
+    case tensor_function_t::fake_dequantize:
+        return "fake_dequantize";
+    case tensor_function_t::fake_quantize:
+        return "fake_quantize";
+    case tensor_function_t::mat_mul:
+        return "mat_mul";
+    case tensor_function_t::quantize:
+        return "quantize";
+    case tensor_function_t::quant_param_of:
+        return "quant_param_of";
+    case tensor_function_t::range_of:
+        return "range_of";
+    case tensor_function_t::reduce:
+        return "reduce";
+    case tensor_function_t::reduce_arg:
+        return "reduce_arg";
+    case tensor_function_t::require:
+        return "require";
+    case tensor_function_t::select:
+        return "select";
+    case tensor_function_t::unary:
+        return "unary";
+    case tensor_function_t::bitcast:
+        return "bitcast";
+    case tensor_function_t::broadcast:
+        return "broadcast";
+    case tensor_function_t::bucket_pad:
+        return "bucket_pad";
+    case tensor_function_t::cast:
+        return "cast";
+    case tensor_function_t::concat:
+        return "concat";
+    case tensor_function_t::constant_of_shape:
+        return "constant_of_shape";
+    case tensor_function_t::expand:
+        return "expand";
+    case tensor_function_t::fix_shape:
+        return "fix_shape";
+    case tensor_function_t::flatten:
+        return "flatten";
+    case tensor_function_t::gather:
+        return "gather";
+    case tensor_function_t::gather_elements:
+        return "gather_elements";
+    case tensor_function_t::gather_nd:
+        return "gather_nd";
+    case tensor_function_t::get_item:
+        return "get_item";
+    case tensor_function_t::index_of:
+        return "index_of";
+    case tensor_function_t::prod:
+        return "prod";
+    case tensor_function_t::range:
+        return "range";
+    case tensor_function_t::rank:
+        return "rank";
+    case tensor_function_t::reshape:
+        return "reshape";
+    case tensor_function_t::reverse_sequence:
+        return "reverse_sequence";
+    case tensor_function_t::scatter_nd:
+        return "scatter_nd";
+    case tensor_function_t::shape_of:
+        return "shape_of";
+    case tensor_function_t::size_of:
+        return "size_of";
+    case tensor_function_t::slice:
+        return "slice";
+    case tensor_function_t::split:
+        return "split";
+    case tensor_function_t::squeeze:
+        return "squeeze";
+    case tensor_function_t::stack:
+        return "stack";
+    case tensor_function_t::tile:
+        return "tile";
+    case tensor_function_t::top_k:
+        return "top_k";
+    case tensor_function_t::transpose:
+        return "transpose";
+    case tensor_function_t::trilu:
+        return "trilu";
+    case tensor_function_t::unsqueeze:
+        return "unsqueeze";
+    case tensor_function_t::where:
+        return "where";
+    case tensor_function_t::broadcast_shape:
+        return "broadcast_shape";
+    case tensor_function_t::conv2d_shape:
+        return "conv2d_shape";
+    case tensor_function_t::conv2d_transpose_shape:
+        return "conv2d_transpose_shape";
+    case tensor_function_t::get_paddings:
+        return "get_paddings";
+    case tensor_function_t::mat_mul_shape:
+        return "mat_mul_shape";
+    case tensor_function_t::reshape_shape:
+        return "reshape_shape";
+    case tensor_function_t::squeeze_shape:
+        return "squeeze_shape";
+    case tensor_function_t::transpose_shape:
+        return "transpose_shape";
+    case tensor_function_t::unsqueeze_shape:
+        return "unsqueeze_shape";
+    case tensor_function_t::lstm:
+        return "lstm";
+    case tensor_function_t::normal:
+        return "normal";
+    case tensor_function_t::normal_like:
+        return "normal_like";
+    case tensor_function_t::uniform:
+        return "uniform";
+    case tensor_function_t::uniform_like:
+        return "uniform_like";
+    case tensor_function_t::resize_image:
+        return "resize_image";
     }
     return "unknown tensor_function_t";
 }
 
-inline std::string to_string(opcode_t code)
-{
-    switch(code)
-    {
-      case opcode_t::NOP: return "NOP";
-      case opcode_t::LDNULL: return "LDNULL";
-      case opcode_t::LDC_I4: return "LDC_I4";
-      case opcode_t::LDC_I4_0: return "LDC_I4_0";
-      case opcode_t::LDC_I4_1: return "LDC_I4_1";
-      case opcode_t::LDC_R4: return "LDC_R4";
-      case opcode_t::LDIND_I1: return "LDIND_I1";
-      case opcode_t::LDIND_I2: return "LDIND_I2";
-      case opcode_t::LDIND_I4: return "LDIND_I4";
-      case opcode_t::LDIND_I: return "LDIND_I";
-      case opcode_t::LDIND_U1: return "LDIND_U1";
-      case opcode_t::LDIND_U2: return "LDIND_U2";
-      case opcode_t::LDIND_U4: return "LDIND_U4";
-      case opcode_t::LDIND_U: return "LDIND_U";
-      case opcode_t::LDIND_BR2: return "LDIND_BR2";
-      case opcode_t::LDIND_R4: return "LDIND_R4";
-      case opcode_t::STIND_I1: return "STIND_I1";
-      case opcode_t::STIND_I2: return "STIND_I2";
-      case opcode_t::STIND_I4: return "STIND_I4";
-      case opcode_t::STIND_I: return "STIND_I";
-      case opcode_t::STIND_BR2: return "STIND_BR2";
-      case opcode_t::STIND_R4: return "STIND_R4";
-      case opcode_t::LEA_GP: return "LEA_GP";
-      case opcode_t::LDELEM_I1: return "LDELEM_I1";
-      case opcode_t::LDELEM_I2: return "LDELEM_I2";
-      case opcode_t::LDELEM_I4: return "LDELEM_I4";
-      case opcode_t::LDELEM_I: return "LDELEM_I";
-      case opcode_t::LDELEM_U1: return "LDELEM_U1";
-      case opcode_t::LDELEM_U2: return "LDELEM_U2";
-      case opcode_t::LDELEM_U4: return "LDELEM_U4";
-      case opcode_t::LDELEM_U: return "LDELEM_U";
-      case opcode_t::LDELEM_BR2: return "LDELEM_BR2";
-      case opcode_t::LDELEM_R4: return "LDELEM_R4";
-      case opcode_t::STELEM_I1: return "STELEM_I1";
-      case opcode_t::STELEM_I2: return "STELEM_I2";
-      case opcode_t::STELEM_I4: return "STELEM_I4";
-      case opcode_t::STELEM_I: return "STELEM_I";
-      case opcode_t::STELEM_BR2: return "STELEM_BR2";
-      case opcode_t::STELEM_R4: return "STELEM_R4";
-      case opcode_t::LDARG: return "LDARG";
-      case opcode_t::LDARG_0: return "LDARG_0";
-      case opcode_t::LDARG_1: return "LDARG_1";
-      case opcode_t::LDARG_2: return "LDARG_2";
-      case opcode_t::LDARG_3: return "LDARG_3";
-      case opcode_t::LDARG_4: return "LDARG_4";
-      case opcode_t::LDARG_5: return "LDARG_5";
-      case opcode_t::DUP: return "DUP";
-      case opcode_t::POP: return "POP";
-      case opcode_t::LDLOCAL: return "LDLOCAL";
-      case opcode_t::STLOCAL: return "STLOCAL";
-      case opcode_t::LDTUPLE_ELEM: return "LDTUPLE_ELEM";
-      case opcode_t::LDTUPLE: return "LDTUPLE";
-      case opcode_t::LDDATATYPE: return "LDDATATYPE";
-      case opcode_t::LDTENSOR: return "LDTENSOR";
-      case opcode_t::LDSCALAR: return "LDSCALAR";
-      case opcode_t::NEG: return "NEG";
-      case opcode_t::ADD: return "ADD";
-      case opcode_t::SUB: return "SUB";
-      case opcode_t::MUL: return "MUL";
-      case opcode_t::DIV: return "DIV";
-      case opcode_t::DIV_U: return "DIV_U";
-      case opcode_t::REM: return "REM";
-      case opcode_t::REM_U: return "REM_U";
-      case opcode_t::AND: return "AND";
-      case opcode_t::OR: return "OR";
-      case opcode_t::XOR: return "XOR";
-      case opcode_t::NOT: return "NOT";
-      case opcode_t::SHL: return "SHL";
-      case opcode_t::SHR: return "SHR";
-      case opcode_t::SHR_U: return "SHR_U";
-      case opcode_t::CLT: return "CLT";
-      case opcode_t::CLT_U: return "CLT_U";
-      case opcode_t::CLE: return "CLE";
-      case opcode_t::CLE_U: return "CLE_U";
-      case opcode_t::CEQ: return "CEQ";
-      case opcode_t::CGE: return "CGE";
-      case opcode_t::CGE_U: return "CGE_U";
-      case opcode_t::CGT: return "CGT";
-      case opcode_t::CGT_U: return "CGT_U";
-      case opcode_t::CNE: return "CNE";
-      case opcode_t::CONV_I1: return "CONV_I1";
-      case opcode_t::CONV_I2: return "CONV_I2";
-      case opcode_t::CONV_I4: return "CONV_I4";
-      case opcode_t::CONV_I: return "CONV_I";
-      case opcode_t::CONV_U1: return "CONV_U1";
-      case opcode_t::CONV_U2: return "CONV_U2";
-      case opcode_t::CONV_U4: return "CONV_U4";
-      case opcode_t::CONV_U: return "CONV_U";
-      case opcode_t::CONV_BR2: return "CONV_BR2";
-      case opcode_t::CONV_R4: return "CONV_R4";
-      case opcode_t::BR: return "BR";
-      case opcode_t::BR_TRUE: return "BR_TRUE";
-      case opcode_t::BR_FALSE: return "BR_FALSE";
-      case opcode_t::RET: return "RET";
-      case opcode_t::CALL: return "CALL";
-      case opcode_t::ECALL: return "ECALL";
-      case opcode_t::EXTCALL: return "EXTCALL";
-      case opcode_t::CUSCALL: return "CUSCALL";
-      case opcode_t::THROW: return "THROW";
-      case opcode_t::BREAK: return "BREAK";
-      case opcode_t::TENSOR: return "TENSOR";
+inline std::string to_string(opcode_t code) {
+    switch (code) {
+    case opcode_t::NOP:
+        return "NOP";
+    case opcode_t::LDNULL:
+        return "LDNULL";
+    case opcode_t::LDC_I4:
+        return "LDC_I4";
+    case opcode_t::LDC_I4_0:
+        return "LDC_I4_0";
+    case opcode_t::LDC_I4_1:
+        return "LDC_I4_1";
+    case opcode_t::LDC_R4:
+        return "LDC_R4";
+    case opcode_t::LDIND_I1:
+        return "LDIND_I1";
+    case opcode_t::LDIND_I2:
+        return "LDIND_I2";
+    case opcode_t::LDIND_I4:
+        return "LDIND_I4";
+    case opcode_t::LDIND_I:
+        return "LDIND_I";
+    case opcode_t::LDIND_U1:
+        return "LDIND_U1";
+    case opcode_t::LDIND_U2:
+        return "LDIND_U2";
+    case opcode_t::LDIND_U4:
+        return "LDIND_U4";
+    case opcode_t::LDIND_U:
+        return "LDIND_U";
+    case opcode_t::LDIND_BR2:
+        return "LDIND_BR2";
+    case opcode_t::LDIND_R4:
+        return "LDIND_R4";
+    case opcode_t::STIND_I1:
+        return "STIND_I1";
+    case opcode_t::STIND_I2:
+        return "STIND_I2";
+    case opcode_t::STIND_I4:
+        return "STIND_I4";
+    case opcode_t::STIND_I:
+        return "STIND_I";
+    case opcode_t::STIND_BR2:
+        return "STIND_BR2";
+    case opcode_t::STIND_R4:
+        return "STIND_R4";
+    case opcode_t::LEA_GP:
+        return "LEA_GP";
+    case opcode_t::LDELEM_I1:
+        return "LDELEM_I1";
+    case opcode_t::LDELEM_I2:
+        return "LDELEM_I2";
+    case opcode_t::LDELEM_I4:
+        return "LDELEM_I4";
+    case opcode_t::LDELEM_I:
+        return "LDELEM_I";
+    case opcode_t::LDELEM_U1:
+        return "LDELEM_U1";
+    case opcode_t::LDELEM_U2:
+        return "LDELEM_U2";
+    case opcode_t::LDELEM_U4:
+        return "LDELEM_U4";
+    case opcode_t::LDELEM_U:
+        return "LDELEM_U";
+    case opcode_t::LDELEM_BR2:
+        return "LDELEM_BR2";
+    case opcode_t::LDELEM_R4:
+        return "LDELEM_R4";
+    case opcode_t::STELEM_I1:
+        return "STELEM_I1";
+    case opcode_t::STELEM_I2:
+        return "STELEM_I2";
+    case opcode_t::STELEM_I4:
+        return "STELEM_I4";
+    case opcode_t::STELEM_I:
+        return "STELEM_I";
+    case opcode_t::STELEM_BR2:
+        return "STELEM_BR2";
+    case opcode_t::STELEM_R4:
+        return "STELEM_R4";
+    case opcode_t::LDARG:
+        return "LDARG";
+    case opcode_t::LDARG_0:
+        return "LDARG_0";
+    case opcode_t::LDARG_1:
+        return "LDARG_1";
+    case opcode_t::LDARG_2:
+        return "LDARG_2";
+    case opcode_t::LDARG_3:
+        return "LDARG_3";
+    case opcode_t::LDARG_4:
+        return "LDARG_4";
+    case opcode_t::LDARG_5:
+        return "LDARG_5";
+    case opcode_t::DUP:
+        return "DUP";
+    case opcode_t::POP:
+        return "POP";
+    case opcode_t::LDLOCAL:
+        return "LDLOCAL";
+    case opcode_t::STLOCAL:
+        return "STLOCAL";
+    case opcode_t::LDTUPLE_ELEM:
+        return "LDTUPLE_ELEM";
+    case opcode_t::LDTUPLE:
+        return "LDTUPLE";
+    case opcode_t::LDDATATYPE:
+        return "LDDATATYPE";
+    case opcode_t::LDTENSOR:
+        return "LDTENSOR";
+    case opcode_t::LDSCALAR:
+        return "LDSCALAR";
+    case opcode_t::NEG:
+        return "NEG";
+    case opcode_t::ADD:
+        return "ADD";
+    case opcode_t::SUB:
+        return "SUB";
+    case opcode_t::MUL:
+        return "MUL";
+    case opcode_t::DIV:
+        return "DIV";
+    case opcode_t::DIV_U:
+        return "DIV_U";
+    case opcode_t::REM:
+        return "REM";
+    case opcode_t::REM_U:
+        return "REM_U";
+    case opcode_t::AND:
+        return "AND";
+    case opcode_t::OR:
+        return "OR";
+    case opcode_t::XOR:
+        return "XOR";
+    case opcode_t::NOT:
+        return "NOT";
+    case opcode_t::SHL:
+        return "SHL";
+    case opcode_t::SHR:
+        return "SHR";
+    case opcode_t::SHR_U:
+        return "SHR_U";
+    case opcode_t::CLT:
+        return "CLT";
+    case opcode_t::CLT_U:
+        return "CLT_U";
+    case opcode_t::CLE:
+        return "CLE";
+    case opcode_t::CLE_U:
+        return "CLE_U";
+    case opcode_t::CEQ:
+        return "CEQ";
+    case opcode_t::CGE:
+        return "CGE";
+    case opcode_t::CGE_U:
+        return "CGE_U";
+    case opcode_t::CGT:
+        return "CGT";
+    case opcode_t::CGT_U:
+        return "CGT_U";
+    case opcode_t::CNE:
+        return "CNE";
+    case opcode_t::CONV_I1:
+        return "CONV_I1";
+    case opcode_t::CONV_I2:
+        return "CONV_I2";
+    case opcode_t::CONV_I4:
+        return "CONV_I4";
+    case opcode_t::CONV_I:
+        return "CONV_I";
+    case opcode_t::CONV_U1:
+        return "CONV_U1";
+    case opcode_t::CONV_U2:
+        return "CONV_U2";
+    case opcode_t::CONV_U4:
+        return "CONV_U4";
+    case opcode_t::CONV_U:
+        return "CONV_U";
+    case opcode_t::CONV_BR2:
+        return "CONV_BR2";
+    case opcode_t::CONV_R4:
+        return "CONV_R4";
+    case opcode_t::BR:
+        return "BR";
+    case opcode_t::BR_TRUE:
+        return "BR_TRUE";
+    case opcode_t::BR_FALSE:
+        return "BR_FALSE";
+    case opcode_t::RET:
+        return "RET";
+    case opcode_t::CALL:
+        return "CALL";
+    case opcode_t::ECALL:
+        return "ECALL";
+    case opcode_t::EXTCALL:
+        return "EXTCALL";
+    case opcode_t::CUSCALL:
+        return "CUSCALL";
+    case opcode_t::THROW:
+        return "THROW";
+    case opcode_t::BREAK:
+        return "BREAK";
+    case opcode_t::TENSOR:
+        return "TENSOR";
     }
     return "unknown opcode_t";
 }
diff --git a/src/Native/src/kernels/stackvm/tensor_ops.cpp b/src/Native/src/kernels/stackvm/tensor_ops.cpp
index 22b504adc2..704ef28ae9 100644
--- a/src/Native/src/kernels/stackvm/tensor_ops.cpp
+++ b/src/Native/src/kernels/stackvm/tensor_ops.cpp
@@ -48,8 +48,9 @@ result<value_t> nncase::kernels::stackvm::batch_normalization(
 }
 
 result<value_t> nncase::kernels::stackvm::layer_norm(
-    int32_t axis, float epsilon, [[maybe_unused]] bool use_mean, value_t input, value_t scale, value_t bias,
-    value_t output, [[maybe_unused]] kernel_context &context) {
+    int32_t axis, float epsilon, [[maybe_unused]] bool use_mean, value_t input,
+    value_t scale, value_t bias, value_t output,
+    [[maybe_unused]] kernel_context &context) {
     try_f32_input(input_mem, input);
     try_f32_input(scale_mem, scale);
     try_f32_input(bias_mem, bias);
diff --git a/src/Native/src/runtime/stackvm/op_reader.cpp b/src/Native/src/runtime/stackvm/op_reader.cpp
index fcdf55117c..4cb7f0e36a 100644
--- a/src/Native/src/runtime/stackvm/op_reader.cpp
+++ b/src/Native/src/runtime/stackvm/op_reader.cpp
@@ -1,4 +1,5 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM +00:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM
+ * +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -20,14 +21,15 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace nncase::runtime::stackvm;
 
-result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reader &reader) noexcept
-{
-     switch (tensor_funct)
-     {
+result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct,
+                                      span_reader &reader) noexcept {
+    switch (tensor_funct) {
     case tensor_function_t::batch_normalization:
-        return visit(tensor_op_reader<tensor_function_t::batch_normalization>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::batch_normalization>()(reader));
     case tensor_function_t::batch_to_space:
-        return visit(tensor_op_reader<tensor_function_t::batch_to_space>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::batch_to_space>()(reader));
     case tensor_function_t::binary:
         return visit(tensor_op_reader<tensor_function_t::binary>()(reader));
     case tensor_function_t::bitcast:
@@ -35,7 +37,8 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::broadcast:
         return visit(tensor_op_reader<tensor_function_t::broadcast>()(reader));
     case tensor_function_t::broadcast_shape:
-        return visit(tensor_op_reader<tensor_function_t::broadcast_shape>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::broadcast_shape>()(reader));
     case tensor_function_t::bucket_pad:
         return visit(tensor_op_reader<tensor_function_t::bucket_pad>()(reader));
     case tensor_function_t::cast:
@@ -51,15 +54,20 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::condition:
         return visit(tensor_op_reader<tensor_function_t::condition>()(reader));
     case tensor_function_t::constant_of_shape:
-        return visit(tensor_op_reader<tensor_function_t::constant_of_shape>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::constant_of_shape>()(reader));
     case tensor_function_t::conv2d:
         return visit(tensor_op_reader<tensor_function_t::conv2d>()(reader));
     case tensor_function_t::conv2d_shape:
-        return visit(tensor_op_reader<tensor_function_t::conv2d_shape>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::conv2d_shape>()(reader));
     case tensor_function_t::conv2d_transpose:
-        return visit(tensor_op_reader<tensor_function_t::conv2d_transpose>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::conv2d_transpose>()(reader));
     case tensor_function_t::conv2d_transpose_shape:
-        return visit(tensor_op_reader<tensor_function_t::conv2d_transpose_shape>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::conv2d_transpose_shape>()(
+                reader));
     case tensor_function_t::cum_sum:
         return visit(tensor_op_reader<tensor_function_t::cum_sum>()(reader));
     case tensor_function_t::dequantize:
@@ -71,9 +79,11 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::expand:
         return visit(tensor_op_reader<tensor_function_t::expand>()(reader));
     case tensor_function_t::fake_dequantize:
-        return visit(tensor_op_reader<tensor_function_t::fake_dequantize>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::fake_dequantize>()(reader));
     case tensor_function_t::fake_quantize:
-        return visit(tensor_op_reader<tensor_function_t::fake_quantize>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::fake_quantize>()(reader));
     case tensor_function_t::fix_shape:
         return visit(tensor_op_reader<tensor_function_t::fix_shape>()(reader));
     case tensor_function_t::flatten:
@@ -81,7 +91,8 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::gather:
         return visit(tensor_op_reader<tensor_function_t::gather>()(reader));
     case tensor_function_t::gather_elements:
-        return visit(tensor_op_reader<tensor_function_t::gather_elements>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::gather_elements>()(reader));
     case tensor_function_t::gather_nd:
         return visit(tensor_op_reader<tensor_function_t::gather_nd>()(reader));
     case tensor_function_t::gelu:
@@ -89,9 +100,11 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::get_item:
         return visit(tensor_op_reader<tensor_function_t::get_item>()(reader));
     case tensor_function_t::get_paddings:
-        return visit(tensor_op_reader<tensor_function_t::get_paddings>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::get_paddings>()(reader));
     case tensor_function_t::hard_sigmoid:
-        return visit(tensor_op_reader<tensor_function_t::hard_sigmoid>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::hard_sigmoid>()(reader));
     case tensor_function_t::hard_swish:
         return visit(tensor_op_reader<tensor_function_t::hard_swish>()(reader));
     case tensor_function_t::hardmax:
@@ -99,17 +112,22 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::index_of:
         return visit(tensor_op_reader<tensor_function_t::index_of>()(reader));
     case tensor_function_t::instance_normalization:
-        return visit(tensor_op_reader<tensor_function_t::instance_normalization>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::instance_normalization>()(
+                reader));
     case tensor_function_t::l2_normalization:
-        return visit(tensor_op_reader<tensor_function_t::l2_normalization>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::l2_normalization>()(reader));
     case tensor_function_t::layer_norm:
         return visit(tensor_op_reader<tensor_function_t::layer_norm>()(reader));
     case tensor_function_t::leaky_relu:
         return visit(tensor_op_reader<tensor_function_t::leaky_relu>()(reader));
     case tensor_function_t::log_softmax:
-        return visit(tensor_op_reader<tensor_function_t::log_softmax>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::log_softmax>()(reader));
     case tensor_function_t::lp_normalization:
-        return visit(tensor_op_reader<tensor_function_t::lp_normalization>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::lp_normalization>()(reader));
     case tensor_function_t::lrn:
         return visit(tensor_op_reader<tensor_function_t::lrn>()(reader));
     case tensor_function_t::lstm:
@@ -117,11 +135,13 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::mat_mul:
         return visit(tensor_op_reader<tensor_function_t::mat_mul>()(reader));
     case tensor_function_t::mat_mul_shape:
-        return visit(tensor_op_reader<tensor_function_t::mat_mul_shape>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::mat_mul_shape>()(reader));
     case tensor_function_t::normal:
         return visit(tensor_op_reader<tensor_function_t::normal>()(reader));
     case tensor_function_t::normal_like:
-        return visit(tensor_op_reader<tensor_function_t::normal_like>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::normal_like>()(reader));
     case tensor_function_t::one_hot:
         return visit(tensor_op_reader<tensor_function_t::one_hot>()(reader));
     case tensor_function_t::pad:
@@ -131,7 +151,8 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::prod:
         return visit(tensor_op_reader<tensor_function_t::prod>()(reader));
     case tensor_function_t::quant_param_of:
-        return visit(tensor_op_reader<tensor_function_t::quant_param_of>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::quant_param_of>()(reader));
     case tensor_function_t::quantize:
         return visit(tensor_op_reader<tensor_function_t::quantize>()(reader));
     case tensor_function_t::range:
@@ -145,7 +166,8 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::reduce_arg:
         return visit(tensor_op_reader<tensor_function_t::reduce_arg>()(reader));
     case tensor_function_t::reduce_window2d:
-        return visit(tensor_op_reader<tensor_function_t::reduce_window2d>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::reduce_window2d>()(reader));
     case tensor_function_t::relu:
         return visit(tensor_op_reader<tensor_function_t::relu>()(reader));
     case tensor_function_t::relu6:
@@ -155,11 +177,14 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::reshape:
         return visit(tensor_op_reader<tensor_function_t::reshape>()(reader));
     case tensor_function_t::reshape_shape:
-        return visit(tensor_op_reader<tensor_function_t::reshape_shape>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::reshape_shape>()(reader));
     case tensor_function_t::resize_image:
-        return visit(tensor_op_reader<tensor_function_t::resize_image>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::resize_image>()(reader));
     case tensor_function_t::reverse_sequence:
-        return visit(tensor_op_reader<tensor_function_t::reverse_sequence>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::reverse_sequence>()(reader));
     case tensor_function_t::scatter_nd:
         return visit(tensor_op_reader<tensor_function_t::scatter_nd>()(reader));
     case tensor_function_t::select:
@@ -181,13 +206,15 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::softsign:
         return visit(tensor_op_reader<tensor_function_t::softsign>()(reader));
     case tensor_function_t::space_to_batch:
-        return visit(tensor_op_reader<tensor_function_t::space_to_batch>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::space_to_batch>()(reader));
     case tensor_function_t::split:
         return visit(tensor_op_reader<tensor_function_t::split>()(reader));
     case tensor_function_t::squeeze:
         return visit(tensor_op_reader<tensor_function_t::squeeze>()(reader));
     case tensor_function_t::squeeze_shape:
-        return visit(tensor_op_reader<tensor_function_t::squeeze_shape>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::squeeze_shape>()(reader));
     case tensor_function_t::stack:
         return visit(tensor_op_reader<tensor_function_t::stack>()(reader));
     case tensor_function_t::swish:
@@ -199,7 +226,8 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::transpose:
         return visit(tensor_op_reader<tensor_function_t::transpose>()(reader));
     case tensor_function_t::transpose_shape:
-        return visit(tensor_op_reader<tensor_function_t::transpose_shape>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::transpose_shape>()(reader));
     case tensor_function_t::trilu:
         return visit(tensor_op_reader<tensor_function_t::trilu>()(reader));
     case tensor_function_t::unary:
@@ -207,11 +235,13 @@ result<void> tensor_op_visitor::visit(tensor_function_t tensor_funct, span_reade
     case tensor_function_t::uniform:
         return visit(tensor_op_reader<tensor_function_t::uniform>()(reader));
     case tensor_function_t::uniform_like:
-        return visit(tensor_op_reader<tensor_function_t::uniform_like>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::uniform_like>()(reader));
     case tensor_function_t::unsqueeze:
         return visit(tensor_op_reader<tensor_function_t::unsqueeze>()(reader));
     case tensor_function_t::unsqueeze_shape:
-        return visit(tensor_op_reader<tensor_function_t::unsqueeze_shape>()(reader));
+        return visit(
+            tensor_op_reader<tensor_function_t::unsqueeze_shape>()(reader));
     case tensor_function_t::where:
         return visit(tensor_op_reader<tensor_function_t::where>()(reader));
     default:
diff --git a/src/Native/src/runtime/stackvm/ops/tensor.cpp b/src/Native/src/runtime/stackvm/ops/tensor.cpp
index 0893e73e59..3172fd0f90 100644
--- a/src/Native/src/runtime/stackvm/ops/tensor.cpp
+++ b/src/Native/src/runtime/stackvm/ops/tensor.cpp
@@ -1,4 +1,5 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:08 AM +00:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:08 AM
+ * +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -23,8 +24,8 @@ using namespace nncase::runtime;
 using namespace nncase::runtime::stackvm;
 
 #ifdef NNCASE_DUMP_MANAGER
-#define dump_op(op) \
-    auto dump_manager = module().interp().dump_manager(); \
+#define dump_op(op)                                                            \
+    auto dump_manager = module().interp().dump_manager();                      \
     dump_manager->dump_op(op)
 #define dump_input(var) dump_manager->dump_input(var, #var)
 #define dump_output(var) dump_manager->dump_output(var)
@@ -34,8 +35,8 @@ using namespace nncase::runtime::stackvm;
 #define dump_output(var)
 #endif
 
-
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_batch_normalization_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_batch_normalization_op_t &op) noexcept {
     dump_op("batch_normalization");
     try_var(input, pop_value());
     dump_input(input);
@@ -51,13 +52,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_batch
     dump_input(epsilon);
     try_var(momentum, pop_value());
     dump_input(momentum);
-    try_var(output, kernels::stackvm::batch_normalization(input, scale, bias, input_mean, input_var, epsilon, momentum, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::batch_normalization(
+                        input, scale, bias, input_mean, input_var, epsilon,
+                        momentum, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_batch_to_space_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_batch_to_space_op_t &op) noexcept {
     dump_op("batch_to_space");
     try_var(input, pop_value());
     dump_input(input);
@@ -65,93 +69,111 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_batch
     dump_input(block_shape);
     try_var(crops, pop_value());
     dump_input(crops);
-    try_var(output, kernels::stackvm::batch_to_space(input, block_shape, crops, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::batch_to_space(input, block_shape, crops, nullptr,
+                                             module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_binary_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_binary_op_t &op) noexcept {
     dump_op("binary");
     try_var(lhs, pop_value());
     dump_input(lhs);
     try_var(rhs, pop_value());
     dump_input(rhs);
-    try_var(output, kernels::stackvm::binary(op.binary_op, lhs, rhs, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::binary(op.binary_op, lhs, rhs, nullptr,
+                                             module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_bitcast_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_bitcast_op_t &op) noexcept {
     dump_op("bitcast");
     try_var(input, pop_value());
     dump_input(input);
     try_var(new_shape, pop_value());
     dump_input(new_shape);
-    try_var(output, kernels::stackvm::bitcast(op.type, op.new_type, input, new_shape, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::bitcast(op.type, op.new_type, input, new_shape,
+                                      nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_broadcast_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_broadcast_op_t &op) noexcept {
     dump_op("broadcast");
     try_var(input, pop_value());
     dump_input(input);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::broadcast(input, shape, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::broadcast(input, shape, nullptr,
+                                                module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_broadcast_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_broadcast_shape_op_t &op) noexcept {
     dump_op("broadcast_shape");
     try_var(inputs, pop_value());
     dump_input(inputs);
-    try_var(output, kernels::stackvm::broadcast_shape(inputs, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::broadcast_shape(
+                        inputs, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_bucket_pad_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_bucket_pad_op_t &op) noexcept {
     dump_op("bucket_pad");
     try_var(input, pop_value());
     dump_input(input);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::bucket_pad(input, shape, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::bucket_pad(input, shape, nullptr,
+                                                 module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_cast_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_cast_op_t &op) noexcept {
     dump_op("cast");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::cast(op.new_type, op.cast_mode, input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::cast(op.new_type, op.cast_mode, input,
+                                           nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_celu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_celu_op_t &op) noexcept {
     dump_op("celu");
     try_var(input, pop_value());
     dump_input(input);
     try_var(alpha, pop_value());
     dump_input(alpha);
-    try_var(output, kernels::stackvm::celu(input, alpha, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::celu(input, alpha, nullptr,
+                                           module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_clamp_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_clamp_op_t &op) noexcept {
     dump_op("clamp");
     try_var(input, pop_value());
     dump_input(input);
@@ -159,59 +181,70 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_clamp
     dump_input(min);
     try_var(max, pop_value());
     dump_input(max);
-    try_var(output, kernels::stackvm::clamp(input, min, max, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::clamp(input, min, max, nullptr,
+                                            module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_compare_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_compare_op_t &op) noexcept {
     dump_op("compare");
     try_var(lhs, pop_value());
     dump_input(lhs);
     try_var(rhs, pop_value());
     dump_input(rhs);
-    try_var(output, kernels::stackvm::compare(op.compare_op, lhs, rhs, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::compare(op.compare_op, lhs, rhs, nullptr,
+                                              module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_concat_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_concat_op_t &op) noexcept {
     dump_op("concat");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::concat(op.axis, input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::concat(op.axis, input, nullptr,
+                                             module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_condition_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_condition_op_t &op) noexcept {
     dump_op("condition");
     try_var(predicate, pop_value());
     dump_input(predicate);
     try_var(value, pop_value());
     dump_input(value);
-    try_var(output, kernels::stackvm::condition(op.can_fold_const_call, predicate, value, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::condition(op.can_fold_const_call,
+                                                predicate, value, nullptr,
+                                                module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_constant_of_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_constant_of_shape_op_t &op) noexcept {
     dump_op("constant_of_shape");
     try_var(shape, pop_value());
     dump_input(shape);
     try_var(value, pop_value());
     dump_input(value);
-    try_var(output, kernels::stackvm::constant_of_shape(shape, value, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::constant_of_shape(
+                        shape, value, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2d_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_conv2d_op_t &op) noexcept {
     dump_op("conv2d");
     try_var(input, pop_value());
     dump_input(input);
@@ -229,13 +262,17 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2
     dump_input(groups);
     try_var(fused_clamp, pop_value());
     dump_input(fused_clamp);
-    try_var(output, kernels::stackvm::conv2d(op.pad_mode, input, weights, bias, stride, padding, dilation, groups, fused_clamp, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::conv2d(op.pad_mode, input, weights, bias, stride,
+                                     padding, dilation, groups, fused_clamp,
+                                     nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2d_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_conv2d_shape_op_t &op) noexcept {
     dump_op("conv2d_shape");
     try_var(input, pop_value());
     dump_input(input);
@@ -249,13 +286,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2
     dump_input(dilation);
     try_var(groups, pop_value());
     dump_input(groups);
-    try_var(output, kernels::stackvm::conv2d_shape(input, weights, padding, stride, dilation, groups, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::conv2d_shape(
+                        input, weights, padding, stride, dilation, groups,
+                        nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2d_transpose_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_conv2d_transpose_op_t &op) noexcept {
     dump_op("conv2d_transpose");
     try_var(input, pop_value());
     dump_input(input);
@@ -277,13 +317,17 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2
     dump_input(groups);
     try_var(fused_clamp, pop_value());
     dump_input(fused_clamp);
-    try_var(output, kernels::stackvm::conv2d_transpose(op.pad_mode, input, weights, bias, output_shape, stride, padding, output_padding, dilation, groups, fused_clamp, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::conv2d_transpose(
+                        op.pad_mode, input, weights, bias, output_shape, stride,
+                        padding, output_padding, dilation, groups, fused_clamp,
+                        nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2d_transpose_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_conv2d_transpose_shape_op_t &op) noexcept {
     dump_op("conv2d_transpose_shape");
     try_var(input, pop_value());
     dump_input(input);
@@ -299,13 +343,17 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_conv2
     dump_input(output_padding);
     try_var(groups, pop_value());
     dump_input(groups);
-    try_var(output, kernels::stackvm::conv2d_transpose_shape(input, weights, stride, dilation, padding, output_padding, groups, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::conv2d_transpose_shape(
+                input, weights, stride, dilation, padding, output_padding,
+                groups, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_cum_sum_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_cum_sum_op_t &op) noexcept {
     dump_op("cum_sum");
     try_var(input, pop_value());
     dump_input(input);
@@ -315,119 +363,143 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_cum_s
     dump_input(exclusive);
     try_var(reverse, pop_value());
     dump_input(reverse);
-    try_var(output, kernels::stackvm::cum_sum(input, axis, exclusive, reverse, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::cum_sum(input, axis, exclusive, reverse, nullptr,
+                                      module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_dequantize_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_dequantize_op_t &op) noexcept {
     dump_op("dequantize");
     try_var(input, pop_value());
     dump_input(input);
     try_var(dequant_param, pop_value());
     dump_input(dequant_param);
-    try_var(output, kernels::stackvm::dequantize(op.target_type, input, dequant_param, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::dequantize(op.target_type, input, dequant_param,
+                                         nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_elu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_elu_op_t &op) noexcept {
     dump_op("elu");
     try_var(input, pop_value());
     dump_input(input);
     try_var(alpha, pop_value());
     dump_input(alpha);
-    try_var(output, kernels::stackvm::elu(input, alpha, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::elu(input, alpha, nullptr,
+                                          module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_erf_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_erf_op_t &op) noexcept {
     dump_op("erf");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::erf(input, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::erf(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_expand_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_expand_op_t &op) noexcept {
     dump_op("expand");
     try_var(input, pop_value());
     dump_input(input);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::expand(input, shape, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::expand(input, shape, nullptr,
+                                             module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_fake_dequantize_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_fake_dequantize_op_t &op) noexcept {
     dump_op("fake_dequantize");
     try_var(input, pop_value());
     dump_input(input);
     try_var(dequant_param, pop_value());
     dump_input(dequant_param);
-    try_var(output, kernels::stackvm::fake_dequantize(op.target_type, input, dequant_param, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::fake_dequantize(
+                        op.target_type, input, dequant_param, nullptr,
+                        module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_fake_quantize_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_fake_quantize_op_t &op) noexcept {
     dump_op("fake_quantize");
     try_var(input, pop_value());
     dump_input(input);
     try_var(quant_param, pop_value());
     dump_input(quant_param);
-    try_var(output, kernels::stackvm::fake_quantize(op.target_type, input, quant_param, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::fake_quantize(op.target_type, input,
+                                                    quant_param, nullptr,
+                                                    module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_fix_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_fix_shape_op_t &op) noexcept {
     dump_op("fix_shape");
     try_var(input, pop_value());
     dump_input(input);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::fix_shape(input, shape, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::fix_shape(input, shape, nullptr,
+                                                module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_flatten_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_flatten_op_t &op) noexcept {
     dump_op("flatten");
     try_var(input, pop_value());
     dump_input(input);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::flatten(input, axis, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::flatten(input, axis, nullptr,
+                                              module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_gather_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_gather_op_t &op) noexcept {
     dump_op("gather");
     try_var(input, pop_value());
     dump_input(input);
     try_var(index, pop_value());
     dump_input(index);
-    try_var(output, kernels::stackvm::gather(op.axis, input, index, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::gather(op.axis, input, index, nullptr,
+                                             module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_gather_elements_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_gather_elements_op_t &op) noexcept {
     dump_op("gather_elements");
     try_var(input, pop_value());
     dump_input(input);
@@ -435,13 +507,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_gathe
     dump_input(axis);
     try_var(indices, pop_value());
     dump_input(indices);
-    try_var(output, kernels::stackvm::gather_elements(input, axis, indices, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::gather_elements(input, axis, indices, nullptr,
+                                              module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_gather_nd_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_gather_nd_op_t &op) noexcept {
     dump_op("gather_nd");
     try_var(input, pop_value());
     dump_input(input);
@@ -449,37 +524,44 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_gathe
     dump_input(batch_dims);
     try_var(index, pop_value());
     dump_input(index);
-    try_var(output, kernels::stackvm::gather_nd(input, batch_dims, index, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::gather_nd(input, batch_dims, index, nullptr,
+                                        module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_gelu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_gelu_op_t &op) noexcept {
     dump_op("gelu");
     try_var(input, pop_value());
     dump_input(input);
     try_var(alpha, pop_value());
     dump_input(alpha);
-    try_var(output, kernels::stackvm::gelu(input, alpha, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::gelu(input, alpha, nullptr,
+                                           module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_get_item_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_get_item_op_t &op) noexcept {
     dump_op("get_item");
     try_var(input, pop_value());
     dump_input(input);
     try_var(index, pop_value());
     dump_input(index);
-    try_var(output, kernels::stackvm::get_item(input, index, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::get_item(input, index, nullptr,
+                                               module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_get_paddings_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_get_paddings_op_t &op) noexcept {
     dump_op("get_paddings");
     try_var(input_shape, pop_value());
     dump_input(input_shape);
@@ -493,13 +575,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_get_p
     dump_input(same);
     try_var(lower, pop_value());
     dump_input(lower);
-    try_var(output, kernels::stackvm::get_paddings(input_shape, weights_shape, strides, dilations, same, lower, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::get_paddings(
+                        input_shape, weights_shape, strides, dilations, same,
+                        lower, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_hard_sigmoid_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_hard_sigmoid_op_t &op) noexcept {
     dump_op("hard_sigmoid");
     try_var(input, pop_value());
     dump_input(input);
@@ -507,47 +592,55 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_hard_
     dump_input(alpha);
     try_var(beta, pop_value());
     dump_input(beta);
-    try_var(output, kernels::stackvm::hard_sigmoid(input, alpha, beta, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::hard_sigmoid(input, alpha, beta, nullptr,
+                                                   module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_hard_swish_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_hard_swish_op_t &op) noexcept {
     dump_op("hard_swish");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::hard_swish(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::hard_swish(input, nullptr,
+                                                 module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_hardmax_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_hardmax_op_t &op) noexcept {
     dump_op("hardmax");
     try_var(input, pop_value());
     dump_input(input);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::hardmax(input, axis, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::hardmax(input, axis, nullptr,
+                                              module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_index_of_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_index_of_op_t &op) noexcept {
     dump_op("index_of");
     try_var(input, pop_value());
     dump_input(input);
     try_var(value, pop_value());
     dump_input(value);
-    try_var(output, kernels::stackvm::index_of(input, value, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::index_of(input, value, nullptr,
+                                               module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_instance_normalization_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_instance_normalization_op_t &op) noexcept {
     dump_op("instance_normalization");
     try_var(input, pop_value());
     dump_input(input);
@@ -557,23 +650,28 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_insta
     dump_input(bias);
     try_var(epsilon, pop_value());
     dump_input(epsilon);
-    try_var(output, kernels::stackvm::instance_normalization(input, scale, bias, epsilon, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::instance_normalization(
+                        input, scale, bias, epsilon, nullptr,
+                        module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_l2_normalization_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_l2_normalization_op_t &op) noexcept {
     dump_op("l2_normalization");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::l2_normalization(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::l2_normalization(
+                        input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_layer_norm_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_layer_norm_op_t &op) noexcept {
     dump_op("layer_norm");
     try_var(input, pop_value());
     dump_input(input);
@@ -581,37 +679,44 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_layer
     dump_input(scale);
     try_var(bias, pop_value());
     dump_input(bias);
-    try_var(output, kernels::stackvm::layer_norm(op.axis, op.epsilon, op.use_mean, input, scale, bias, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::layer_norm(
+                        op.axis, op.epsilon, op.use_mean, input, scale, bias,
+                        nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_leaky_relu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_leaky_relu_op_t &op) noexcept {
     dump_op("leaky_relu");
     try_var(input, pop_value());
     dump_input(input);
     try_var(alpha, pop_value());
     dump_input(alpha);
-    try_var(output, kernels::stackvm::leaky_relu(input, alpha, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::leaky_relu(input, alpha, nullptr,
+                                                 module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_log_softmax_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_log_softmax_op_t &op) noexcept {
     dump_op("log_softmax");
     try_var(input, pop_value());
     dump_input(input);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::log_softmax(input, axis, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::log_softmax(input, axis, nullptr,
+                                                  module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_lp_normalization_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_lp_normalization_op_t &op) noexcept {
     dump_op("lp_normalization");
     try_var(input, pop_value());
     dump_input(input);
@@ -619,13 +724,15 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_lp_no
     dump_input(axis);
     try_var(p, pop_value());
     dump_input(p);
-    try_var(output, kernels::stackvm::lp_normalization(input, axis, p, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::lp_normalization(
+                        input, axis, p, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_lrn_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_lrn_op_t &op) noexcept {
     dump_op("lrn");
     try_var(input, pop_value());
     dump_input(input);
@@ -637,13 +744,15 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_lrn_o
     dump_input(bias);
     try_var(size, pop_value());
     dump_input(size);
-    try_var(output, kernels::stackvm::lrn(input, alpha, beta, bias, size, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::lrn(input, alpha, beta, bias, size,
+                                          nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_lstm_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_lstm_op_t &op) noexcept {
     dump_op("lstm");
     try_var(x, pop_value());
     dump_input(x);
@@ -673,37 +782,47 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_lstm_
     dump_input(input_forget);
     try_var(output_size, pop_value());
     dump_input(output_size);
-    try_var(output, kernels::stackvm::lstm(op.direction, op.layout, op.activations, x, w, r, b, sequence_lens, initial_h, initial_c, p, activation_alpha, activation_beta, clip, hidden_size, input_forget, output_size, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::lstm(op.direction, op.layout, op.activations, x,
+                                   w, r, b, sequence_lens, initial_h, initial_c,
+                                   p, activation_alpha, activation_beta, clip,
+                                   hidden_size, input_forget, output_size,
+                                   nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_mat_mul_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_mat_mul_op_t &op) noexcept {
     dump_op("mat_mul");
     try_var(lhs, pop_value());
     dump_input(lhs);
     try_var(rhs, pop_value());
     dump_input(rhs);
-    try_var(output, kernels::stackvm::mat_mul(lhs, rhs, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::mat_mul(lhs, rhs, nullptr,
+                                              module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_mat_mul_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_mat_mul_shape_op_t &op) noexcept {
     dump_op("mat_mul_shape");
     try_var(lhs, pop_value());
     dump_input(lhs);
     try_var(rhs, pop_value());
     dump_input(rhs);
-    try_var(output, kernels::stackvm::mat_mul_shape(lhs, rhs, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::mat_mul_shape(lhs, rhs, nullptr,
+                                                    module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_normal_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_normal_op_t &op) noexcept {
     dump_op("normal");
     try_var(mean, pop_value());
     dump_input(mean);
@@ -713,13 +832,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_norma
     dump_input(seed);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::normal(op.type, mean, scale, seed, shape, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::normal(op.type, mean, scale, seed, shape, nullptr,
+                                     module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_normal_like_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_normal_like_op_t &op) noexcept {
     dump_op("normal_like");
     try_var(input, pop_value());
     dump_input(input);
@@ -729,13 +851,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_norma
     dump_input(scale);
     try_var(seed, pop_value());
     dump_input(seed);
-    try_var(output, kernels::stackvm::normal_like(op.type, input, mean, scale, seed, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::normal_like(op.type, input, mean, scale, seed,
+                                          nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_one_hot_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_one_hot_op_t &op) noexcept {
     dump_op("one_hot");
     try_var(indices, pop_value());
     dump_input(indices);
@@ -745,13 +870,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_one_h
     dump_input(values);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::one_hot(op.one_hot_mode, indices, depth, values, axis, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::one_hot(op.one_hot_mode, indices, depth,
+                                              values, axis, nullptr,
+                                              module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_pad_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_pad_op_t &op) noexcept {
     dump_op("pad");
     try_var(input, pop_value());
     dump_input(input);
@@ -759,59 +887,71 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_pad_o
     dump_input(pads);
     try_var(value, pop_value());
     dump_input(value);
-    try_var(output, kernels::stackvm::pad(op.pad_mode, input, pads, value, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::pad(op.pad_mode, input, pads, value,
+                                          nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_prelu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_prelu_op_t &op) noexcept {
     dump_op("prelu");
     try_var(input, pop_value());
     dump_input(input);
     try_var(slope, pop_value());
     dump_input(slope);
-    try_var(output, kernels::stackvm::prelu(input, slope, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::prelu(input, slope, nullptr,
+                                            module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_prod_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_prod_op_t &op) noexcept {
     dump_op("prod");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::prod(input, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::prod(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_quant_param_of_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_quant_param_of_op_t &op) noexcept {
     dump_op("quant_param_of");
     try_var(range, pop_value());
     dump_input(range);
     try_var(bits, pop_value());
     dump_input(bits);
-    try_var(output, kernels::stackvm::quant_param_of(op.quant_mode, range, bits, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::quant_param_of(
+                        op.quant_mode, range, bits, nullptr,
+                        module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_quantize_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_quantize_op_t &op) noexcept {
     dump_op("quantize");
     try_var(input, pop_value());
     dump_input(input);
     try_var(quant_param, pop_value());
     dump_input(quant_param);
-    try_var(output, kernels::stackvm::quantize(op.target_type, input, quant_param, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::quantize(op.target_type, input, quant_param,
+                                       nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_range_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_range_op_t &op) noexcept {
     dump_op("range");
     try_var(begin, pop_value());
     dump_input(begin);
@@ -819,33 +959,40 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_range
     dump_input(end);
     try_var(step, pop_value());
     dump_input(step);
-    try_var(output, kernels::stackvm::range(begin, end, step, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::range(begin, end, step, nullptr,
+                                            module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_range_of_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_range_of_op_t &op) noexcept {
     dump_op("range_of");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::range_of(op.is_range_of_weight, input, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::range_of(op.is_range_of_weight, input, nullptr,
+                                       module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_rank_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_rank_op_t &op) noexcept {
     dump_op("rank");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::rank(input, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::rank(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reduce_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_reduce_op_t &op) noexcept {
     dump_op("reduce");
     try_var(input, pop_value());
     dump_input(input);
@@ -855,13 +1002,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reduc
     dump_input(init_value);
     try_var(keep_dims, pop_value());
     dump_input(keep_dims);
-    try_var(output, kernels::stackvm::reduce(op.reduce_op, input, axis, init_value, keep_dims, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::reduce(op.reduce_op, input, axis,
+                                             init_value, keep_dims, nullptr,
+                                             module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reduce_arg_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_reduce_arg_op_t &op) noexcept {
     dump_op("reduce_arg");
     try_var(input, pop_value());
     dump_input(input);
@@ -871,13 +1021,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reduc
     dump_input(keep_dims);
     try_var(select_last_index, pop_value());
     dump_input(select_last_index);
-    try_var(output, kernels::stackvm::reduce_arg(op.reduce_arg_op, op.dest_type, input, axis, keep_dims, select_last_index, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::reduce_arg(
+                        op.reduce_arg_op, op.dest_type, input, axis, keep_dims,
+                        select_last_index, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reduce_window2d_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_reduce_window2d_op_t &op) noexcept {
     dump_op("reduce_window2d");
     try_var(input, pop_value());
     dump_input(input);
@@ -895,69 +1048,84 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reduc
     dump_input(ceil_mode);
     try_var(count_include_pad, pop_value());
     dump_input(count_include_pad);
-    try_var(output, kernels::stackvm::reduce_window2d(op.reduce_op, input, init_value, filter, stride, padding, dilation, ceil_mode, count_include_pad, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::reduce_window2d(
+                        op.reduce_op, input, init_value, filter, stride,
+                        padding, dilation, ceil_mode, count_include_pad,
+                        nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_relu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_relu_op_t &op) noexcept {
     dump_op("relu");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::relu(input, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::relu(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_relu6_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_relu6_op_t &op) noexcept {
     dump_op("relu6");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::relu6(input, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::relu6(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_require_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_require_op_t &op) noexcept {
     dump_op("require");
     try_var(predicate, pop_value());
     dump_input(predicate);
     try_var(value, pop_value());
     dump_input(value);
-    try_var(output, kernels::stackvm::require(op.message, op.can_fold_const_call, predicate, value, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::require(
+                        op.message, op.can_fold_const_call, predicate, value,
+                        nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reshape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_reshape_op_t &op) noexcept {
     dump_op("reshape");
     try_var(input, pop_value());
     dump_input(input);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::reshape(input, shape, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::reshape(input, shape, nullptr,
+                                              module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reshape_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_reshape_shape_op_t &op) noexcept {
     dump_op("reshape_shape");
     try_var(input_shape, pop_value());
     dump_input(input_shape);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::reshape_shape(input_shape, shape, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::reshape_shape(input_shape, shape, nullptr,
+                                                    module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_resize_image_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_resize_image_op_t &op) noexcept {
     dump_op("resize_image");
     try_var(input, pop_value());
     dump_input(input);
@@ -971,13 +1139,18 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_resiz
     dump_input(exclude_outside);
     try_var(extrapolation_value, pop_value());
     dump_input(extrapolation_value);
-    try_var(output, kernels::stackvm::resize_image(op.resize_mode, op.transformation_mode, op.nearest_mode, op.is_tfresize, input, roi, new_size, cubic_coeff_a, exclude_outside, extrapolation_value, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::resize_image(
+                        op.resize_mode, op.transformation_mode, op.nearest_mode,
+                        op.is_tfresize, input, roi, new_size, cubic_coeff_a,
+                        exclude_outside, extrapolation_value, nullptr,
+                        module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_reverse_sequence_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_reverse_sequence_op_t &op) noexcept {
     dump_op("reverse_sequence");
     try_var(input, pop_value());
     dump_input(input);
@@ -987,13 +1160,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_rever
     dump_input(batch_axis);
     try_var(time_axis, pop_value());
     dump_input(time_axis);
-    try_var(output, kernels::stackvm::reverse_sequence(input, seq_lens, batch_axis, time_axis, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::reverse_sequence(
+                        input, seq_lens, batch_axis, time_axis, nullptr,
+                        module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_scatter_nd_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_scatter_nd_op_t &op) noexcept {
     dump_op("scatter_nd");
     try_var(input, pop_value());
     dump_input(input);
@@ -1001,13 +1177,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_scatt
     dump_input(indices);
     try_var(updates, pop_value());
     dump_input(updates);
-    try_var(output, kernels::stackvm::scatter_nd(input, indices, updates, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::scatter_nd(input, indices, updates, nullptr,
+                                         module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_select_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_select_op_t &op) noexcept {
     dump_op("select");
     try_var(predicate, pop_value());
     dump_input(predicate);
@@ -1015,13 +1194,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_selec
     dump_input(true_value);
     try_var(false_value, pop_value());
     dump_input(false_value);
-    try_var(output, kernels::stackvm::select(predicate, true_value, false_value, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::select(predicate, true_value, false_value,
+                                     nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_selu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_selu_op_t &op) noexcept {
     dump_op("selu");
     try_var(input, pop_value());
     dump_input(input);
@@ -1029,43 +1211,51 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_selu_
     dump_input(alpha);
     try_var(gamma, pop_value());
     dump_input(gamma);
-    try_var(output, kernels::stackvm::selu(input, alpha, gamma, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::selu(input, alpha, gamma, nullptr,
+                                           module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_shape_of_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_shape_of_op_t &op) noexcept {
     dump_op("shape_of");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::shape_of(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::shape_of(input, nullptr,
+                                               module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_sigmoid_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_sigmoid_op_t &op) noexcept {
     dump_op("sigmoid");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::sigmoid(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::sigmoid(input, nullptr,
+                                              module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_size_of_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_size_of_op_t &op) noexcept {
     dump_op("size_of");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::size_of(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::size_of(input, nullptr,
+                                              module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_slice_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_slice_op_t &op) noexcept {
     dump_op("slice");
     try_var(input, pop_value());
     dump_input(input);
@@ -1077,45 +1267,54 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_slice
     dump_input(axes);
     try_var(strides, pop_value());
     dump_input(strides);
-    try_var(output, kernels::stackvm::slice(input, begins, ends, axes, strides, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::slice(input, begins, ends, axes, strides, nullptr,
+                                    module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_softmax_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_softmax_op_t &op) noexcept {
     dump_op("softmax");
     try_var(input, pop_value());
     dump_input(input);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::softmax(input, axis, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::softmax(input, axis, nullptr,
+                                              module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_softplus_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_softplus_op_t &op) noexcept {
     dump_op("softplus");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::softplus(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::softplus(input, nullptr,
+                                               module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_softsign_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_softsign_op_t &op) noexcept {
     dump_op("softsign");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::softsign(input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::softsign(input, nullptr,
+                                               module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_space_to_batch_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_space_to_batch_op_t &op) noexcept {
     dump_op("space_to_batch");
     try_var(input, pop_value());
     dump_input(input);
@@ -1123,13 +1322,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_space
     dump_input(block_shape);
     try_var(paddings, pop_value());
     dump_input(paddings);
-    try_var(output, kernels::stackvm::space_to_batch(input, block_shape, paddings, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::space_to_batch(
+                        input, block_shape, paddings, nullptr,
+                        module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_split_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_split_op_t &op) noexcept {
     dump_op("split");
     try_var(input, pop_value());
     dump_input(input);
@@ -1137,71 +1339,83 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_split
     dump_input(axis);
     try_var(sections, pop_value());
     dump_input(sections);
-    try_var(output, kernels::stackvm::split(input, axis, sections, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::split(input, axis, sections, nullptr,
+                                            module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_squeeze_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_squeeze_op_t &op) noexcept {
     dump_op("squeeze");
     try_var(input, pop_value());
     dump_input(input);
     try_var(dim, pop_value());
     dump_input(dim);
-    try_var(output, kernels::stackvm::squeeze(input, dim, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::squeeze(input, dim, nullptr,
+                                              module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_squeeze_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_squeeze_shape_op_t &op) noexcept {
     dump_op("squeeze_shape");
     try_var(input_shape, pop_value());
     dump_input(input_shape);
     try_var(dim, pop_value());
     dump_input(dim);
-    try_var(output, kernels::stackvm::squeeze_shape(input_shape, dim, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::squeeze_shape(input_shape, dim, nullptr,
+                                                    module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_stack_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_stack_op_t &op) noexcept {
     dump_op("stack");
     try_var(inputs, pop_value());
     dump_input(inputs);
     try_var(axis, pop_value());
     dump_input(axis);
-    try_var(output, kernels::stackvm::stack(inputs, axis, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::stack(inputs, axis, nullptr,
+                                            module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_swish_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_swish_op_t &op) noexcept {
     dump_op("swish");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::swish(input, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::swish(input, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_tile_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_tile_op_t &op) noexcept {
     dump_op("tile");
     try_var(input, pop_value());
     dump_input(input);
     try_var(repeats, pop_value());
     dump_input(repeats);
-    try_var(output, kernels::stackvm::tile(input, repeats, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::tile(input, repeats, nullptr,
+                                           module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_top_k_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_top_k_op_t &op) noexcept {
     dump_op("top_k");
     try_var(x, pop_value());
     dump_input(x);
@@ -1213,37 +1427,44 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_top_k
     dump_input(largest);
     try_var(sorted, pop_value());
     dump_input(sorted);
-    try_var(output, kernels::stackvm::top_k(x, k, axis, largest, sorted, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::top_k(x, k, axis, largest, sorted, nullptr,
+                                    module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_transpose_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_transpose_op_t &op) noexcept {
     dump_op("transpose");
     try_var(input, pop_value());
     dump_input(input);
     try_var(perm, pop_value());
     dump_input(perm);
-    try_var(output, kernels::stackvm::transpose(input, perm, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::transpose(input, perm, nullptr,
+                                                module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_transpose_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_transpose_shape_op_t &op) noexcept {
     dump_op("transpose_shape");
     try_var(input_shape, pop_value());
     dump_input(input_shape);
     try_var(perm, pop_value());
     dump_input(perm);
-    try_var(output, kernels::stackvm::transpose_shape(input_shape, perm, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::transpose_shape(
+                        input_shape, perm, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_trilu_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_trilu_op_t &op) noexcept {
     dump_op("trilu");
     try_var(input, pop_value());
     dump_input(input);
@@ -1251,23 +1472,27 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_trilu
     dump_input(k);
     try_var(upper, pop_value());
     dump_input(upper);
-    try_var(output, kernels::stackvm::trilu(input, k, upper, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::trilu(input, k, upper, nullptr,
+                                            module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_unary_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_unary_op_t &op) noexcept {
     dump_op("unary");
     try_var(input, pop_value());
     dump_input(input);
-    try_var(output, kernels::stackvm::unary(op.unary_op, input, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::unary(op.unary_op, input, nullptr,
+                                            module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_uniform_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_uniform_op_t &op) noexcept {
     dump_op("uniform");
     try_var(high, pop_value());
     dump_input(high);
@@ -1277,13 +1502,16 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_unifo
     dump_input(seed);
     try_var(shape, pop_value());
     dump_input(shape);
-    try_var(output, kernels::stackvm::uniform(op.type, high, low, seed, shape, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::uniform(op.type, high, low, seed, shape, nullptr,
+                                      module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_uniform_like_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_uniform_like_op_t &op) noexcept {
     dump_op("uniform_like");
     try_var(input, pop_value());
     dump_input(input);
@@ -1293,37 +1521,44 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_unifo
     dump_input(low);
     try_var(seed, pop_value());
     dump_input(seed);
-    try_var(output, kernels::stackvm::uniform_like(op.type, input, high, low, seed, nullptr, module().kernel_context()));
+    try_var(output,
+            kernels::stackvm::uniform_like(op.type, input, high, low, seed,
+                                           nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_unsqueeze_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_unsqueeze_op_t &op) noexcept {
     dump_op("unsqueeze");
     try_var(input, pop_value());
     dump_input(input);
     try_var(dim, pop_value());
     dump_input(dim);
-    try_var(output, kernels::stackvm::unsqueeze(input, dim, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::unsqueeze(input, dim, nullptr,
+                                                module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_unsqueeze_shape_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_unsqueeze_shape_op_t &op) noexcept {
     dump_op("unsqueeze_shape");
     try_var(input_shape, pop_value());
     dump_input(input_shape);
     try_var(dim, pop_value());
     dump_input(dim);
-    try_var(output, kernels::stackvm::unsqueeze_shape(input_shape, dim, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::unsqueeze_shape(
+                        input_shape, dim, nullptr, module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
 }
 
-result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_where_op_t &op) noexcept {
+result<void> stackvm_runtime_function::visit(
+    [[maybe_unused]] const tensor_where_op_t &op) noexcept {
     dump_op("where");
     try_var(cond, pop_value());
     dump_input(cond);
@@ -1331,7 +1566,8 @@ result<void> stackvm_runtime_function::visit([[maybe_unused]] const tensor_where
     dump_input(x);
     try_var(y, pop_value());
     dump_input(y);
-    try_var(output, kernels::stackvm::where(op.is_tf_where, cond, x, y, nullptr, module().kernel_context()));
+    try_var(output, kernels::stackvm::where(op.is_tf_where, cond, x, y, nullptr,
+                                            module().kernel_context()));
     dump_output(output);
     stack_.push(std::move(output));
     return ok();
diff --git a/src/Native/src/runtime/stackvm/runtime_function_ops.h b/src/Native/src/runtime/stackvm/runtime_function_ops.h
index eee188a832..351b758b88 100644
--- a/src/Native/src/runtime/stackvm/runtime_function_ops.h
+++ b/src/Native/src/runtime/stackvm/runtime_function_ops.h
@@ -1,4 +1,5 @@
-/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM +00:00.
+/* This file is generated by tools/stackvm_gen/IsaGen at 9/20/2023 10:17:07 AM
+ * +00:00.
  *
  * Copyright 2019-2021 Canaan Inc.
  *
@@ -32,7 +33,8 @@ result<void> visit(const tensor_constant_of_shape_op_t &op) noexcept override;
 result<void> visit(const tensor_conv2d_op_t &op) noexcept override;
 result<void> visit(const tensor_conv2d_shape_op_t &op) noexcept override;
 result<void> visit(const tensor_conv2d_transpose_op_t &op) noexcept override;
-result<void> visit(const tensor_conv2d_transpose_shape_op_t &op) noexcept override;
+result<void>
+visit(const tensor_conv2d_transpose_shape_op_t &op) noexcept override;
 result<void> visit(const tensor_cum_sum_op_t &op) noexcept override;
 result<void> visit(const tensor_dequantize_op_t &op) noexcept override;
 result<void> visit(const tensor_elu_op_t &op) noexcept override;
@@ -52,7 +54,8 @@ result<void> visit(const tensor_hard_sigmoid_op_t &op) noexcept override;
 result<void> visit(const tensor_hard_swish_op_t &op) noexcept override;
 result<void> visit(const tensor_hardmax_op_t &op) noexcept override;
 result<void> visit(const tensor_index_of_op_t &op) noexcept override;
-result<void> visit(const tensor_instance_normalization_op_t &op) noexcept override;
+result<void>
+visit(const tensor_instance_normalization_op_t &op) noexcept override;
 result<void> visit(const tensor_l2_normalization_op_t &op) noexcept override;
 result<void> visit(const tensor_layer_norm_op_t &op) noexcept override;
 result<void> visit(const tensor_leaky_relu_op_t &op) noexcept override;

From 1b8b3653e6a3a10c4eb7037cbaea48ad9a0fc9bc Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 11 Oct 2023 16:38:38 +0800
Subject: [PATCH 226/308] add VAE fusion

---
 .../Passes/Rules/VAEFusion.cs                 | 122 ++++++++++++++++++
 src/Nncase.Compiler/Compiler.cs               |   1 +
 src/Nncase.Core/IR/NN/Functional.cs           |   2 +-
 3 files changed, 124 insertions(+), 1 deletion(-)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
new file mode 100644
index 0000000000..3982a3f58e
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
@@ -0,0 +1,122 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.CPU;
+using Nncase.IR.Math;
+using Nncase.IR.NN;
+using Nncase.IR.Tensors;
+using Nncase.Passes.Rules.Neutral;
+using Nncase.PatternMatch;
+using Nncase.Targets;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.F.NN;
+using static Nncase.PatternMatch.F.Tensors;
+using static Nncase.PatternMatch.Utility;
+using static Nncase.Utilities.ReplaceUtility;
+
+namespace Nncase.Passes.Rules;
+
+/// <summary>
+/// VAE Merger for all.
+/// </summary>
+public sealed class VAEMerger : ExprCloner<Unit>
+{
+    private readonly IReadOnlyDictionary<Expr, Var> _multiVarMap;
+
+    public VAEMerger(IReadOnlyDictionary<Expr, Var> multiVarMap)
+    {
+        _multiVarMap = multiVarMap;
+    }
+
+    protected override Expr VisitCall(Call expr, Unit context)
+    {
+        if (_multiVarMap.TryGetValue(expr, out var newVar))
+        {
+            return newVar;
+        }
+
+        return base.VisitCall(expr, context);
+    }
+
+    protected override Expr VisitLeafCall(Call expr, Unit context)
+    {
+        var target = Clone(expr.Target, context);
+        var arguments = CloneArray(expr.Arguments, context);
+        if (target is Binary)
+        {
+            arguments = arguments.Select(e => e switch { TensorConst { Value: Tensor { Shape.IsScalar: true } } tc => Const.FromTensor(Tensor.FromBytes(tc.ValueType.DType, tc.Value.BytesBuffer.ToArray(), new[] { 1 })), _ => e }).ToArray();
+        }
+
+        return expr.With(target: target, arguments: arguments);
+    }
+
+    protected override Expr VisitLeafVar(Var expr, Unit context)
+    {
+        if (_multiVarMap.TryGetValue(expr, out var newVar))
+        {
+            return newVar;
+        }
+
+        throw new InvalidOperationException();
+    }
+}
+
+/// <summary>
+/// stable-disffusion VAE Decoder straight res-block.
+/// </summary>
+[RuleGenerator]
+public sealed partial class FuseVAEDec1 : FusionMaker
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern => CreatePattern();
+
+    private static Pattern CreatePattern()
+    {
+        var v1 = IsWildcard("input");
+        var v2 = IsReshape(v1, IsTensorConst());
+        var v3 = IsInstanceNormalization(v2, IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v4 = IsReshape(v3, IsTensorConst());
+        var v5 = IsBinary(BinaryOp.Mul, v4, IsTensorConst());
+        var v6 = IsBinary(BinaryOp.Add, v5, IsTensorConst());
+        var v7 = IsSwish(v6, IsTensorConst());
+        var v8 = IsConv2D(PadMode.Constant, v7, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v9 = IsReshape(v8, IsTensorConst());
+        var v10 = IsInstanceNormalization(v9, IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v11 = IsReshape(v10, IsTensorConst());
+        var v12 = IsBinary(BinaryOp.Mul, v11, IsTensorConst());
+        var v13 = IsBinary(BinaryOp.Add, v12, IsTensorConst());
+        var v14 = IsSwish(v13, IsTensorConst());
+        var v15 = IsConv2D(PadMode.Constant, v14, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+
+        // var v16 = IsConv2D(PadMode.Constant, v1, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v17 = IsSwappableBinary(null!, "root", b => b.BinaryOp == BinaryOp.Add, v1, v15);
+
+        return v17!;
+    }
+
+    private Call? GetReplace(Call root, Expr input)
+    {
+        var newInputs = new List<Expr>
+        {
+            new Var(input.CheckedType!),
+        };
+
+        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
+        {
+            { input, (Var)newInputs[0] },
+        };
+        var merger = new VAEMerger(multiVarMap);
+        var clonedRoot = merger.Clone(root, default);
+
+        var callFusion = new Call(new Fusion("VAEDecResSraight", $"{nameof(FuseVAEDec1)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        return callFusion;
+    }
+}
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index cd716d0ee6..b138a9c2eb 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -195,6 +195,7 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.FuseMHA1>();
             p.Add<Passes.Rules.FuseMHA2>();
             p.Add<Passes.Rules.FuseMHA3>();
+            p.Add<Passes.Rules.FuseVAEDec1>();
         });
 
         _compileSession.Target.RegisterTargetInDependentPass(passManager, _compileSession.CompileOptions);
diff --git a/src/Nncase.Core/IR/NN/Functional.cs b/src/Nncase.Core/IR/NN/Functional.cs
index 7f2e1dee07..96daf207d3 100644
--- a/src/Nncase.Core/IR/NN/Functional.cs
+++ b/src/Nncase.Core/IR/NN/Functional.cs
@@ -101,7 +101,7 @@ public static Call ReduceWindow2D(ReduceOp reduceOp, Expr input, Expr initValue,
     /// <summary>
     /// create Swish call.
     /// </summary>
-    public static Call Swish(Expr input) => new Call(new Swish(), input, 1);
+    public static Call Swish(Expr input) => new Call(new Swish(), input, 1f);
 
     /// <summary>
     /// create Swish call.

From 332d778d56423496ff58e74518f61ab3b6bc5efc Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 11 Oct 2023 19:51:28 +0800
Subject: [PATCH 227/308] fuse VAE

---
 .../Passes/Rules/VAEFusion.cs                 | 123 +++++++++++++++++-
 src/Nncase.Compiler/Compiler.cs               |   4 +-
 2 files changed, 119 insertions(+), 8 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
index 3982a3f58e..a223e9333d 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
@@ -15,6 +15,7 @@
 using Nncase.Passes.Rules.Neutral;
 using Nncase.PatternMatch;
 using Nncase.Targets;
+using static Nncase.PatternMatch.F.Imaging;
 using static Nncase.PatternMatch.F.Math;
 using static Nncase.PatternMatch.F.NN;
 using static Nncase.PatternMatch.F.Tensors;
@@ -69,10 +70,10 @@ protected override Expr VisitLeafVar(Var expr, Unit context)
 }
 
 /// <summary>
-/// stable-disffusion VAE Decoder straight res-block.
+/// stable-disffusion VAE Decoder res-block.
 /// </summary>
 [RuleGenerator]
-public sealed partial class FuseVAEDec1 : FusionMaker
+public sealed partial class FuseVAEDecRes : FusionMaker
 {
     public override string ModuleKind { get; } = CPUTarget.Kind;
 
@@ -80,7 +81,12 @@ public sealed partial class FuseVAEDec1 : FusionMaker
 
     private static Pattern CreatePattern()
     {
-        var v1 = IsWildcard("input");
+        var vIn = IsWildcard("input");
+        var vConv0 = IsConv2D(PadMode.Constant, vIn, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var vResize = IsResizeImage(ImageResizeMode.NearestNeighbor, ImageResizeTransformationMode.Asymmetric, ImageResizeNearestMode.Floor, false, vIn, IsWildcard(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var vConv1 = IsConv2D(PadMode.Constant, vConv0, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var vConv2 = IsConv2D(PadMode.Constant, vResize, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v1 = IsAlt(vConv2, vConv1, vIn);
         var v2 = IsReshape(v1, IsTensorConst());
         var v3 = IsInstanceNormalization(v2, IsTensorConst(), IsTensorConst(), IsTensorConst());
         var v4 = IsReshape(v3, IsTensorConst());
@@ -95,11 +101,114 @@ private static Pattern CreatePattern()
         var v13 = IsBinary(BinaryOp.Add, v12, IsTensorConst());
         var v14 = IsSwish(v13, IsTensorConst());
         var v15 = IsConv2D(PadMode.Constant, v14, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v16 = IsConv2D(PadMode.Constant, v1, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v17 = IsSwappableBinary(null!, "root", b => b.BinaryOp == BinaryOp.Add, v16, v15);
+        var v18 = IsSwappableBinary(null!, "root", b => b.BinaryOp == BinaryOp.Add, v1, v15);
+        var root = IsAlt(v17, v18);
 
-        // var v16 = IsConv2D(PadMode.Constant, v1, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v17 = IsSwappableBinary(null!, "root", b => b.BinaryOp == BinaryOp.Add, v1, v15);
+        return root;
+    }
+
+    private Call? GetReplace(Call root, Expr input)
+    {
+        var newInputs = new List<Expr>
+        {
+            new Var(input.CheckedType!),
+        };
+
+        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
+        {
+            { input, (Var)newInputs[0] },
+        };
+        var merger = new VAEMerger(multiVarMap);
+        var clonedRoot = merger.Clone(root, default);
 
-        return v17!;
+        var callFusion = new Call(new Fusion("VAEDecRes", $"{nameof(FuseVAEDecRes)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        return callFusion;
+    }
+}
+
+/// <summary>
+/// stable-disffusion VAE Decoder Head.
+/// </summary>
+[RuleGenerator]
+public sealed partial class FuseVAEDecHead : FusionMaker
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern => CreatePattern();
+
+    private static Pattern CreatePattern()
+    {
+        var v72 = IsWildcard("input");
+        var v73 = IsReshape(v72, IsTensorConst());
+        var v74 = IsInstanceNormalization(v73, IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v75 = IsReshape(v74, IsTensorConst());
+        var v76 = IsBinary(BinaryOp.Mul, v75, IsTensorConst());
+        var v77 = IsBinary(BinaryOp.Add, v76, IsTensorConst());
+        var v78 = IsSwish(v77, IsTensorConst());
+        var v79 = IsConv2D(null, "root", PadMode.Constant, v78, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+
+        return v79!;
+    }
+
+    private Call? GetReplace(Call root, Expr input)
+    {
+        var newInputs = new List<Expr>
+        {
+            new Var(input.CheckedType!),
+        };
+
+        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
+        {
+            { input, (Var)newInputs[0] },
+        };
+        var merger = new VAEMerger(multiVarMap);
+        var clonedRoot = merger.Clone(root, default);
+
+        var callFusion = new Call(new Fusion("VAEDecHead", $"{nameof(FuseVAEDecHead)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        return callFusion;
+    }
+}
+
+/// <summary>
+/// stable-disffusion VAE Decoder MHA.
+/// </summary>
+[RuleGenerator]
+public sealed partial class FuseVAEDecMHA : FusionMaker
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern => CreatePattern();
+
+    private static Pattern CreatePattern()
+    {
+        var v0 = IsWildcard("input");
+        var v1 = IsReshape(v0, IsTensorConst());
+        var v2 = IsInstanceNormalization(v1, IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v3 = IsReshape(v2, IsTensorConst());
+        var v4 = IsBinary(BinaryOp.Mul, v3, IsTensorConst());
+        var v5 = IsBinary(BinaryOp.Add, v4, IsTensorConst());
+        var v6 = IsReshape(v5, IsTensorConst());
+        var v7 = IsTranspose(v6, IsTensorConst());
+        var v8 = IsMatMul(v7, IsTensorConst());
+        var v9 = IsBinary(BinaryOp.Add, IsTensorConst(), v8);
+        var v10 = IsMatMul(v7, IsTensorConst());
+        var v11 = IsBinary(BinaryOp.Add, IsTensorConst(), v10);
+        var v12 = IsTranspose(v11, IsTensorConst());
+        var v13 = IsMatMul(v9, v12);
+        var v14 = IsBinary(BinaryOp.Mul, v13, IsTensorConst());
+        var v15 = IsBinary(BinaryOp.Add, v14, IsTensorConst());
+        var v16 = IsSoftmax(v15, IsTensorConst());
+        var v17 = IsMatMul(v7, IsTensorConst());
+        var v18 = IsBinary(BinaryOp.Add, IsTensorConst(), v17);
+        var v19 = IsMatMul(v16, v18);
+        var v20 = IsMatMul(v19, IsTensorConst());
+        var v21 = IsTranspose(v20, IsTensorConst());
+        var v22 = IsBinary(BinaryOp.Add, IsTensorConst(), v21);
+        var v23 = IsReshape(v22, IsTensorConst());
+        var v24 = IsBinary(null!, "root", BinaryOp.Add, v23, v0);
+        return v24!;
     }
 
     private Call? GetReplace(Call root, Expr input)
@@ -116,7 +225,7 @@ private static Pattern CreatePattern()
         var merger = new VAEMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("VAEDecResSraight", $"{nameof(FuseVAEDec1)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        var callFusion = new Call(new Fusion("VAEDecMHA", $"{nameof(FuseVAEDecMHA)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
         return callFusion;
     }
 }
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 8a45ee16e7..07efb7b133 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -195,7 +195,9 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.FuseMHA1>();
             p.Add<Passes.Rules.FuseMHA2>();
             p.Add<Passes.Rules.FuseMHA3>();
-            p.Add<Passes.Rules.FuseVAEDec1>();
+            p.Add<Passes.Rules.FuseVAEDecRes>();
+            p.Add<Passes.Rules.FuseVAEDecHead>();
+            p.Add<Passes.Rules.FuseVAEDecMHA>();
             p.Add<Passes.Rules.FuseSDTextEncoderTail>();
             p.Add<Passes.Rules.FuseSDTextEncoderHeader>();
         });

From 191da3a10c68b8255209494fc33d6e5c4c1e671a Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 12 Oct 2023 14:04:03 +0800
Subject: [PATCH 228/308] support xpu instance norm

---
 .../CodeGen/CSourceConvertVisitor.cs          | 45 ++++++++++++++++
 .../Evaluator/XPU/InstanceNorm.cs             | 12 +++++
 .../Evaluator/XPU/XPUModule.cs                |  1 +
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  5 ++
 .../Nncase.Modules.CPU/IR/XPU/InstanceNorm.cs | 19 +++++++
 .../Passes/Tile/TIRConvertVisitor.cs          |  8 +++
 .../runtime/cmodel/include/instance_norm.h    | 51 +++++++++++++++++++
 modules/cpu/src/runtime/cmodel/include/tdma.h | 17 +++++++
 src/Nncase.Core/IR/NN/Normalization.cs        |  6 +--
 src/Nncase.Evaluator/NN/Normalization.cs      | 49 ++++++++++++++++--
 src/Nncase.Passes/Rules/Neutral/FoldSwish.cs  |  4 +-
 .../Targets/UnitTestCPUTargetTiling.cs        | 38 +++++++++++++-
 12 files changed, 245 insertions(+), 10 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/InstanceNorm.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/InstanceNorm.cs
 create mode 100644 modules/cpu/src/runtime/cmodel/include/instance_norm.h

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index eb066f9a21..2e6145f46c 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -332,6 +332,51 @@ protected override CSymbol VisitCall(Call expr)
                         IndentScope.Writer.IndWrite("}\n");
                     }
 
+                    break;
+                case IR.XPU.InstanceNorm instancenorm:
+                    using (_ = new IndentScope())
+                    {
+                        IndentScope.Writer.IndWrite($"{{\n");
+
+                        var dividedType = Utilities.DistributedUtility.GetDividedTensorType(instancenorm.DistType);
+                        var sbpOnAxis = instancenorm.DistType.NdSBP.Where(sbp => sbp is SBPSplit s && s.Axis > 1).ToArray();
+                        switch (sbpOnAxis.Length)
+                        {
+                            case 0:
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
+                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
+                                IndentScope.Writer.IndWrite($"instance_norm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({instancenorm.Epsilon}), {instancenorm.DistType.TensorType.Shape[2]});\n");
+                                break;
+                            case 1:
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
+                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
+                                if (sbpOnAxis[0] == instancenorm.DistType.NdSBP[1])
+                                {
+                                    IndentScope.Writer.IndWrite($"tdma_reduce_async(sum, sum, reduce_op_t::sum, ctx);\n");
+                                    IndentScope.Writer.IndWrite($"tdma_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, ctx);\n");
+                                }
+                                else
+                                {
+                                    IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum, sum, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
+                                    IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
+                                }
+
+                                IndentScope.Writer.IndWrite($"instance_norm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({instancenorm.Epsilon}), {instancenorm.DistType.TensorType.Shape[2]});\n"); break;
+                            case 2:
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
+                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
+                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
+                                IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum, sum, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
+                                IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
+                                IndentScope.Writer.IndWrite($"instance_norm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({instancenorm.Epsilon}), {instancenorm.DistType.TensorType.Shape[2]});\n");
+                                break;
+                        }
+
+                        IndentScope.Writer.IndWrite("}\n");
+                    }
+
                     break;
                 case IR.XPU.Gather gather:
                     IndentScope.Writer.Write($"gather({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {gather.Axis})");
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/InstanceNorm.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/InstanceNorm.cs
new file mode 100644
index 0000000000..f86323668e
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/InstanceNorm.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class InstanceNormEvaluator : ITypeInferencer<InstanceNorm>
+{
+    public IRType Visit(ITypeInferenceContext context, InstanceNorm target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index dddfc8e805..662a552b48 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -21,6 +21,7 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<BinaryEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<MatmulEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<LayerNormEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<InstanceNormEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<GatherEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<ConcatEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<SliceEvaluator>(reuse: Reuse.Singleton);
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 65970e7570..c757ff2f7e 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -42,6 +42,11 @@ public static Call LayerNorm(int axis, float eps, bool useMean, Expr input, Expr
         return new Call(new LayerNorm(axis, eps, useMean, distributedType), input, scale, bias, output);
     }
 
+    public static Call InstanceNorm(float eps, Expr input, Expr scale, Expr bias, Expr output, DistributedType distributedType)
+    {
+        return new Call(new InstanceNorm(eps, distributedType), input, scale, bias, output);
+    }
+
     public static Call Gather(int axis, Expr input, Expr indices, Expr output)
     {
         return new Call(new IR.XPU.Gather(axis), input, indices, output);
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/InstanceNorm.cs b/modules/Nncase.Modules.CPU/IR/XPU/InstanceNorm.cs
new file mode 100644
index 0000000000..a75142d8fa
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/InstanceNorm.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class InstanceNorm : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(InstanceNorm), 0, "input");
+
+    public static readonly ParameterInfo Scale = new(typeof(InstanceNorm), 1, "scale");
+
+    public static readonly ParameterInfo Bias = new(typeof(InstanceNorm), 2, "bias");
+
+    public static readonly ParameterInfo Output = new(typeof(InstanceNorm), 3, "output");
+
+    public float Epsilon { get; }
+
+    public DistributedType DistType { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 15903ff96d..9c365b0c51 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -53,6 +53,9 @@ protected override Unit VisitLeafCall(Call expr)
             case LayerNorm layernorm:
                 GenerateLayerNorm(layernorm, arguments, ret, (DistributedType)expr.Arguments[0].CheckedType);
                 break;
+            case InstanceNormalization instnorm:
+                GenerateInstanceNorm(instnorm, ((TensorConst)expr.Arguments[3]).Value.ToScalar<float>(), arguments, ret, (DistributedType)expr.Arguments[0].CheckedType);
+                break;
             case Gather gather:
                 GenerateGather(gather, arguments, ret);
                 break;
@@ -167,6 +170,11 @@ private void GenerateLayerNorm(LayerNorm layerNorm, Buffer[] arguments, Buffer r
         _mainBody.Add(IR.F.XPU.LayerNorm(layerNorm.Axis, layerNorm.Epsilon, layerNorm.UseMean, arguments[0], arguments[1], arguments[2], ret, distributedType));
     }
 
+    private void GenerateInstanceNorm(InstanceNormalization instNorm, float eps, Buffer[] arguments, Buffer ret, DistributedType distributedType)
+    {
+        _mainBody.Add(IR.F.XPU.InstanceNorm(eps, arguments[0], arguments[1], arguments[2], ret, distributedType));
+    }
+
     private void GenerateGather(Gather gahter, Buffer[] arguments, Buffer ret)
     {
         _mainBody.Add(IR.F.XPU.Gather(gahter.Axis, arguments[0], arguments[1], ret));
diff --git a/modules/cpu/src/runtime/cmodel/include/instance_norm.h b/modules/cpu/src/runtime/cmodel/include/instance_norm.h
new file mode 100644
index 0000000000..9c00517226
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/instance_norm.h
@@ -0,0 +1,51 @@
+#include "runtime_utils.h"
+#include <apply.h>
+#include <cmath>
+#ifdef __riscv_vector_
+#include <riscv_vector.h>
+#endif
+
+using namespace nncase::runtime::cpu;
+namespace kernels {
+
+namespace {
+template <typename T>
+void instance_norm_naive_impl(
+    const T *input, const T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
+    gsl::span<const size_t> input_shape, gsl::span<const size_t> input_stride,
+    gsl::span<const size_t> output_stride,
+    [[maybe_unused]] gsl::span<const size_t> sum_strides,
+    gsl::span<const size_t> gamma_strides, T eps, int32_t norm_size) noexcept {
+    auto axis = 2;
+    apply(input_shape, [&](gsl::span<const size_t> input_index) -> void {
+        //  input_index
+        auto o_offset = offset(sum_strides, input_index.subspan(0, axis));
+        auto mean = sum[o_offset] / norm_size;
+        auto sigma = nncase_mt->float_unary_sqrt(sum_sqr[o_offset] / norm_size -
+                                                 mean * mean + eps);
+
+        auto input_offset = offset(input_stride, input_index);
+        auto in_offset =
+            offset(gamma_strides, input_index.subspan(axis - 1, 1));
+        output[offset(output_stride, input_index)] =
+            (input[input_offset] - mean) / sigma * gamma[in_offset] +
+            beta[in_offset];
+    });
+}
+} // namespace
+
+template <class T>
+void instance_norm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma,
+                   T *beta, dims_t input_dims, strides_t input_strides,
+                   strides_t output_strides, strides_t sum_strides,
+                   strides_t gamma_strides, T eps, int32_t norm_size) {
+    return instance_norm_naive_impl(
+        input, sum, sum_sqr, output, gamma, beta,
+        gsl::make_span(input_dims).template as_span<const size_t>(),
+        gsl::make_span(input_strides).template as_span<const size_t>(),
+        gsl::make_span(output_strides).template as_span<const size_t>(),
+        gsl::make_span(sum_strides).template as_span<const size_t>(),
+        gsl::make_span(gamma_strides).template as_span<const size_t>(), eps,
+        norm_size);
+}
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 0140d2869c..2e3a2e31d7 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -8,6 +8,7 @@
 #include <gather.h>
 #include <hardware_context.h>
 #include <layernorm.h>
+#include <instance_norm.h>
 #include <matmul.h>
 #include <reduce.h>
 #include <softmax.h>
@@ -255,6 +256,22 @@ void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
                        norm_size, rms_norm);
 }
 
+template <typename T, loc_t ALoc, loc_t BLoc>
+void instance_norm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
+               tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
+               tensor<T, loc_t::local> &gamma, tensor<T, loc_t::local> &beta,
+               T eps, int32_t norm_size) {
+    assert(sum.strides() == sum_sqr.strides());
+    assert(is_contiguous(sum.dimension(), sum.strides()));
+    assert(gamma.strides() == beta.strides());
+    assert(is_contiguous(gamma.dimension(), gamma.strides()));
+    kernels::instance_norm(
+        input.cdata().data(), sum.data().data(), sum_sqr.data().data(),
+        output.data().data(), gamma.data().data(), beta.data().data(),
+        input.dimension(), input.strides(), output.strides(), sum.strides(),
+        gamma.strides(), eps, norm_size);
+}
+
 template <typename T, loc_t ALoc>
 void reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
                     tensor<T, loc_t::local> &sum_sqr) {
diff --git a/src/Nncase.Core/IR/NN/Normalization.cs b/src/Nncase.Core/IR/NN/Normalization.cs
index ba91f13f83..2b7b74168c 100644
--- a/src/Nncase.Core/IR/NN/Normalization.cs
+++ b/src/Nncase.Core/IR/NN/Normalization.cs
@@ -61,17 +61,17 @@ public sealed partial class InstanceNormalization : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(InstanceNormalization), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(InstanceNormalization), 0, "input", ParameterKind.Input);
 
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Scale = new(typeof(InstanceNormalization), 1, "scale");
+    public static readonly ParameterInfo Scale = new(typeof(InstanceNormalization), 1, "scale", ParameterKind.Input);
 
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Bias = new(typeof(InstanceNormalization), 2, "bias");
+    public static readonly ParameterInfo Bias = new(typeof(InstanceNormalization), 2, "bias", ParameterKind.Input);
 
     /// <summary>
     /// Gets Epsilon.
diff --git a/src/Nncase.Evaluator/NN/Normalization.cs b/src/Nncase.Evaluator/NN/Normalization.cs
index 1bc2c75bd2..8ad56df403 100644
--- a/src/Nncase.Evaluator/NN/Normalization.cs
+++ b/src/Nncase.Evaluator/NN/Normalization.cs
@@ -153,15 +153,22 @@ public IValue Visit(IEvaluateContext context, InstanceNormalization i)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, InstanceNormalization target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, InstanceNormalization.Input);
-        return Visit(input);
+        var input = context.CheckArgumentType<IRType>(target, InstanceNormalization.Input);
+        var scale = context.CheckArgumentType<IRType>(target, InstanceNormalization.Scale);
+        var bias = context.CheckArgumentType<IRType>(target, InstanceNormalization.Bias);
+        return (input, scale, bias) switch
+        {
+            (DistributedType a, DistributedType b, DistributedType c) => Visit(a, b, c),
+            (TensorType a, TensorType, TensorType) => Visit(a),
+            _ => new InvalidType(input.GetType().ToString()),
+        };
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, InstanceNormalization target)
     {
-        var inputType = context.GetArgumentType<TensorType>(target, InstanceNormalization.Input);
-        var returnType = context.GetReturnType<TensorType>();
+        var inputType = context.GetArgumentType<IRType>(target, InstanceNormalization.Input);
+        var returnType = context.GetReturnType<IRType>();
         return new()
         {
             [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType),
@@ -183,6 +190,40 @@ private IRType Visit(TensorType input)
     {
         return input;
     }
+
+    private IRType Visit(DistributedType input, DistributedType scale, DistributedType bias)
+    {
+        var invalid = new InvalidType($"{input}, {scale}, {bias} not support");
+        if (input.Placement != scale.Placement || scale.Placement != bias.Placement)
+        {
+            return invalid;
+        }
+
+        var ndsbp = new SBP[input.Placement.Rank];
+
+        // scale & bias always on Channel
+        const int rAxis = 1;
+
+        for (int i = 0; i < input.Placement.Rank; i++)
+        {
+            switch (input.NdSBP[i], scale.NdSBP[i], bias.NdSBP[i])
+            {
+                case (SBPSplit { Axis: int ix }, SBPSplit { Axis: int sx }, SBPSplit { Axis: int bx }) when ix == rAxis && sx == (ix - rAxis) && bx == sx:
+                    ndsbp[i] = SBP.S(ix);
+                    break;
+                case (SBPSplit { Axis: int ix }, SBPBroadCast, SBPBroadCast) when ix != rAxis:
+                    ndsbp[i] = SBP.S(ix);
+                    break;
+                case (SBPBroadCast, SBPBroadCast, SBPBroadCast):
+                    ndsbp[i] = SBP.B;
+                    break;
+                default:
+                    return invalid;
+            }
+        }
+
+        return new DistributedType(input.TensorType, ndsbp, input.Placement);
+    }
 }
 
 /// <summary>
diff --git a/src/Nncase.Passes/Rules/Neutral/FoldSwish.cs b/src/Nncase.Passes/Rules/Neutral/FoldSwish.cs
index 7cfdc3e95d..b8ff58e72e 100644
--- a/src/Nncase.Passes/Rules/Neutral/FoldSwish.cs
+++ b/src/Nncase.Passes/Rules/Neutral/FoldSwish.cs
@@ -17,7 +17,7 @@ public sealed partial class FoldSwishPattern1 : RewriteRule<Pattern>
     public FoldSwishPattern1()
     {
         var input = IsWildcard("input");
-        Pattern = IsSwappableBinary(null, null, b => b.BinaryOp == BinaryOp.Mul, IsSigmoid(input), input);
+        Pattern = IsSwappableBinary(null!, null, b => b.BinaryOp == BinaryOp.Mul, IsSigmoid(input), input);
     }
 
     /// <inheritdoc/>
@@ -35,7 +35,7 @@ public sealed partial class FoldSwishPattern2 : RewriteRule<Pattern>
     public FoldSwishPattern2()
     {
         var input = IsWildcard("input");
-        Pattern = IsSwappableBinary(null, null, b => b.BinaryOp == BinaryOp.Mul, IsSigmoid(IsSwappableBinary(null, null, b => b.BinaryOp == BinaryOp.Mul, input, IsTensorConst("beta", IsFloatScalar()))), input);
+        Pattern = IsSwappableBinary(null!, null, b => b.BinaryOp == BinaryOp.Mul, IsSigmoid(IsSwappableBinary(null!, null, b => b.BinaryOp == BinaryOp.Mul, input, IsTensorConst("beta", IsFloatScalar()))), input);
     }
 
     /// <inheritdoc/>
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 21d10262e7..5091582ecf 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -49,7 +49,8 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseReshape1))]
     // [ClassData(typeof(TilingCaseReshape2))]
     // [ClassData(typeof(TilingCaseMatmulUnary))]
-    [ClassData(typeof(TilingCaseConv2D))]
+    // [ClassData(typeof(TilingCaseConv2D))]
+    [ClassData(typeof(TilingCaseInstanceNorm))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -376,6 +377,41 @@ public TilingCaseLayerNorm()
     }
 }
 
+internal sealed class TilingCaseInstanceNorm : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseInstanceNorm()
+    {
+        var shape = new[] { 1, 32, 65536 };
+        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
+        var scale = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { shape[1] }).Evaluate().AsTensor();
+        var bias = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 3, new[] { shape[1] }).Evaluate().AsTensor();
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, shape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.InstanceNormalization()), fin, scale, bias, 1e-5);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("instance_norm", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
+        {
+            fs.Write(input_tensor.BytesBuffer);
+        }
+
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}
+
 internal sealed class TilingCaseGather : TheoryData<Function, Tensor[]>
 {
     public TilingCaseGather()

From 58861a47f87db5add1a265b9078fe532c308e835 Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Thu, 12 Oct 2023 06:07:04 +0000
Subject: [PATCH 229/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 2e3a2e31d7..f02afbde0f 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -7,8 +7,8 @@
 #include <functional>
 #include <gather.h>
 #include <hardware_context.h>
-#include <layernorm.h>
 #include <instance_norm.h>
+#include <layernorm.h>
 #include <matmul.h>
 #include <reduce.h>
 #include <softmax.h>
@@ -258,18 +258,18 @@ void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
 
 template <typename T, loc_t ALoc, loc_t BLoc>
 void instance_norm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
-               tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
-               tensor<T, loc_t::local> &gamma, tensor<T, loc_t::local> &beta,
-               T eps, int32_t norm_size) {
+                   tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
+                   tensor<T, loc_t::local> &gamma,
+                   tensor<T, loc_t::local> &beta, T eps, int32_t norm_size) {
     assert(sum.strides() == sum_sqr.strides());
     assert(is_contiguous(sum.dimension(), sum.strides()));
     assert(gamma.strides() == beta.strides());
     assert(is_contiguous(gamma.dimension(), gamma.strides()));
-    kernels::instance_norm(
-        input.cdata().data(), sum.data().data(), sum_sqr.data().data(),
-        output.data().data(), gamma.data().data(), beta.data().data(),
-        input.dimension(), input.strides(), output.strides(), sum.strides(),
-        gamma.strides(), eps, norm_size);
+    kernels::instance_norm(input.cdata().data(), sum.data().data(),
+                           sum_sqr.data().data(), output.data().data(),
+                           gamma.data().data(), beta.data().data(),
+                           input.dimension(), input.strides(), output.strides(),
+                           sum.strides(), gamma.strides(), eps, norm_size);
 }
 
 template <typename T, loc_t ALoc>

From 53505d6fe259e4c999f2ff46db081e6d2459cc08 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Thu, 12 Oct 2023 15:37:37 +0800
Subject: [PATCH 230/308] add reduce arg

---
 .../CodeGen/CSourceCompiler.cs                |  2 +-
 .../CodeGen/CSourceConvertVisitor.cs          |  2 +-
 .../CodeGen/CSourceExtensions.cs              |  7 ++
 .../src/runtime/cmodel/include/reduce_arg.h   | 80 +++++++++++++++++++
 modules/cpu/src/runtime/cmodel/include/tdma.h | 11 +++
 python/common/pystreambuf.h                   |  1 +
 src/Nncase.Evaluator/Math/ReduceArg.cs        | 31 +++++++
 .../Targets/UnitTestCPUTargetTiling.cs        | 60 +++++++++++++-
 8 files changed, 191 insertions(+), 3 deletions(-)
 create mode 100644 modules/cpu/src/runtime/cmodel/include/reduce_arg.h

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
index 05d9fd6f82..7f7249d3a9 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
@@ -135,7 +135,7 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
             // return $"-c \"export PATH=/data/huochenghai/toolchain/riscv64-unknown-linux_gnu_12.0.1/bin:$PATH && cd {sourcePath} && mkdir -p build && cd build && rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=riscv64-unknown-linux-gnu-gcc -DCMAKE_CXX_COMPILER=riscv64-unknown-linux-gnu-g++ -DCMAKE_SYSTEM_PROCESSOR=riscv64 && cmake --build .\"";
-            return $"-c \"cd {sourcePath} && mkdir -p build && cd build && rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Debug && cmake --build .\"";
+            return $"-c \"cd {sourcePath} && /bin/mkdir -p build && cd build && /bin/rm -rf * && /root/miniconda3/envs/ci/bin/cmake .. -DCMAKE_BUILD_TYPE=Debug && /root/miniconda3/envs/ci/bin/cmake --build .\"";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
         {
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index eb066f9a21..671c0a0f75 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -448,7 +448,7 @@ protected override CSymbol VisitCall(Call expr)
                     IndentScope.Writer.Write($"conv2d(ctx, {Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {Visit(args[3]).Name}, {{{string.Join(",", conv.Stride.Select(p => p.ToString()))}}}, {{{string.Join(",", conv.Padding.Select(p => p.ToString()))}}}, {{{string.Join(",", conv.Dilation.Select(p => p.ToString()))}}}, {conv.Groups}, {strategy})");
                     break;
                 case IR.XPU.ReduceArg reduceArg:
-                    IndentScope.Writer.Write($"reduce_arg({Visit(args[0]).Name}, {Visit(args[1]).Name}, {reduceArg.Axis}, {reduceArg.KeepDims}, {reduceArg.SelectLastIndex}, {reduceArg.ReduceArgOp}, {reduceArg.DestType.ToC()})");
+                    IndentScope.Writer.Write($"reduce_arg({Visit(args[0]).Name}, {Visit(args[1]).Name}, {reduceArg.Axis}, {reduceArg.KeepDims.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, {reduceArg.SelectLastIndex.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, reduce_arg_op_t::{reduceArg.ReduceArgOp.ToC()})");
                     break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index 4ff250563b..6eb03510ad 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -29,6 +29,13 @@ internal static class CSourceExtensions
     public static string ToC(this PrimType primType) =>
         _primTypeToC[primType];
 
+    public static string ToC(this ReduceArgOp op) => op switch
+    {
+        ReduceArgOp.ArgMin => "arg_min",
+        ReduceArgOp.ArgMax => "arg_max",
+        _ => throw new NotImplementedException(),
+    };
+
     public static string ToC(this DataType dataType) => dataType switch
     {
         PrimType ptype => ptype.ToC(),
diff --git a/modules/cpu/src/runtime/cmodel/include/reduce_arg.h b/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
new file mode 100644
index 0000000000..a911c6b137
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
@@ -0,0 +1,80 @@
+#pragma once
+#include "runtime_utils.h"
+#include <cmath>
+#include <unordered_map>
+
+enum class reduce_arg_op_t : uint8_t {
+    arg_min = 0,
+    arg_max = 1,
+};
+
+namespace kernels {
+template <class TReducer, class TOutput, class T>
+void reduce_arg_impl(TReducer &&reducer, T init_value, const T *input,
+                     TOutput *output, gsl::span<const size_t> in_shape,
+                     gsl::span<const size_t> out_shape,
+                     gsl::span<const size_t> in_strides,
+                     gsl::span<const size_t> out_strides,
+                     gsl::span<const size_t> axes, bool keep_dims,
+                     bool select_last_idx) noexcept {
+    const float epsilon = 0.000001f;
+
+    // init with init_value
+    auto output_size = compute_size(out_shape);
+    auto ptr = (T *)runtime_util->malloc(output_size * sizeof(T));
+    apply(out_shape, [&](gsl::span<const size_t> index) -> void {
+        ptr[offset(out_strides, index)] = init_value;
+    });
+
+    // collect all min/max indices
+    auto out_map = (TOutput *)runtime_util->malloc(output_size * 2 * sizeof(TOutput));
+    // std::unordered_map<size_t, std::vector<TOutput>> out_map;
+    apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        const auto src = input[offset(in_strides, index)];
+        auto out_idx =
+            offset(out_strides, get_reduced_offset(index, axes, keep_dims));
+        auto &dst = ptr[out_idx];
+        auto ret = reducer(src, dst);
+        if (ret) {
+            out_map[out_idx * 2 + 0] = index[axes[0]];
+            out_map[out_idx * 2 + 1] = index[axes[0]];
+            dst = src;
+        } else if (std::fabs(src - dst) < epsilon) {
+            out_map[out_idx * 2 + 1] = index[axes[0]];
+        }
+    });
+
+    // update min/max idx
+    apply(out_shape, [&](gsl::span<const size_t> index) -> void {
+        auto out_idx = offset(out_strides, index);
+        output[out_idx] = select_last_idx ? out_map[out_idx * 2 + 0]
+                                          : out_map[out_idx * 2 + 1];
+    });
+
+    runtime_util->free(out_map);
+    runtime_util->free(ptr);
+}
+
+template <class Tin, class Tout>
+void reduce_arg(reduce_arg_op_t op, const Tin *input, Tout *output,
+                gsl::span<const size_t> in_shape,
+                gsl::span<const size_t> in_strides,
+                gsl::span<const size_t> out_strides,
+                gsl::span<const size_t> axes, bool keep_dims,
+                bool select_last_idx) noexcept {
+    auto out_shape = get_reduced_shape(in_shape, axes, keep_dims);
+    switch (op) {
+    case reduce_arg_op_t::arg_min:
+        return reduce_arg_impl([](Tin a, Tin b) { return a < b; },
+                               std::numeric_limits<Tin>::max(), input, output,
+                               in_shape, out_shape, in_strides, out_strides,
+                               axes, keep_dims, select_last_idx);
+    case reduce_arg_op_t::arg_max:
+        return reduce_arg_impl([](Tin a, Tin b) { return a > b; },
+                               std::numeric_limits<Tin>::lowest(), input,
+                               output, in_shape, out_shape, in_strides,
+                               out_strides, axes, keep_dims, select_last_idx);
+    }
+}
+
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 0140d2869c..c21c09be89 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -10,6 +10,7 @@
 #include <layernorm.h>
 #include <matmul.h>
 #include <reduce.h>
+#include <reduce_arg.h>
 #include <softmax.h>
 #include <tensor.h>
 #include <thread_context.h>
@@ -682,6 +683,16 @@ enum class sched_strategy_t : uint8_t { pin_block_tensor, normal };
 
 void set_sched_strategy([[maybe_unused]] sched_strategy_t sch) {}
 
+template <loc_t SrcLoc, loc_t DestLoc, class Tout>
+void reduce_arg(tensor<float, SrcLoc> &src, tensor<Tout, DestLoc> &dest,
+                int axis, bool keep_dims, bool select_last_idx,
+                reduce_arg_op_t op) {
+    auto axes = dims_t { (size_t)axis };
+    kernels::reduce_arg<float, Tout>(
+        op, src.cdata().data(), dest.data().data(), src.dimension(),
+        src.strides(), dest.strides(), axes, keep_dims, select_last_idx);
+}
+
 template <loc_t SrcLoc, loc_t DestLoc>
 void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest, int axis,
              thread_context &ctx,
diff --git a/python/common/pystreambuf.h b/python/common/pystreambuf.h
index 178a041e0c..e3aed5f907 100644
--- a/python/common/pystreambuf.h
+++ b/python/common/pystreambuf.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include <nncase/compiler_defs.h>
+#include <cstdint>
 #include <pybind11/pybind11.h>
 
 #include <iostream>
diff --git a/src/Nncase.Evaluator/Math/ReduceArg.cs b/src/Nncase.Evaluator/Math/ReduceArg.cs
index 4777f4435b..ad865c0e51 100644
--- a/src/Nncase.Evaluator/Math/ReduceArg.cs
+++ b/src/Nncase.Evaluator/Math/ReduceArg.cs
@@ -109,6 +109,37 @@ private IRType Visit(ITypeInferenceContext context, ReduceArg target, Distribute
             return rType;
         }
 
+        var inshape = distributedType.TensorType.Shape;
+        if (context.GetArgument(target, ReduceArg.Axis) is TensorConst axisValue &&
+            context.GetArgument(target, ReduceArg.KeepDims) is TensorConst keepDimsValue)
+        {
+            var axis = axisValue.Value.ToScalar<int>();
+            axis = axis >= 0 ? axis : inshape.Rank + axis;
+            var keepdim = keepDimsValue.Value.ToScalar<bool>();
+            var ndsbp = new SBP[distributedType.Placement.Rank];
+            for (int i = 0; i < ndsbp.Length; i++)
+            {
+                switch (distributedType.NdSBP[i])
+                {
+                    case SBPSplit { Axis: int saxis }:
+                        if (saxis == axis)
+                        {
+                            return new InvalidType("can't split on reduce axis.");
+                        }
+
+                        ndsbp[i] = keepdim ? SBP.S(saxis) : SBP.S(saxis > axis ? saxis - 1 : saxis);
+                        break;
+                    case SBPPartialSum:
+                        return new InvalidType("not support partial sum.");
+                    case SBPBroadCast:
+                        ndsbp[i] = SBP.B;
+                        break;
+                }
+            }
+
+            return distributedType with { NdSBP = new(ndsbp), TensorType = tensorType };
+        }
+
         if (!distributedType.NdSBP.All(sbp => sbp is SBPBroadCast))
         {
             return new InvalidType(string.Empty);
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 21d10262e7..464d47da7e 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -49,7 +49,9 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseReshape1))]
     // [ClassData(typeof(TilingCaseReshape2))]
     // [ClassData(typeof(TilingCaseMatmulUnary))]
-    [ClassData(typeof(TilingCaseConv2D))]
+    // [ClassData(typeof(TilingCaseConv2D))]
+    [ClassData(typeof(TilingCaseReduceArg))]
+    [ClassData(typeof(TilingCaseReduceArg2))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -520,6 +522,62 @@ public TilingCaseReshape2()
     }
 }
 
+internal sealed class TilingCaseReduceArg : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseReduceArg()
+    {
+        var inputShape = new[] { 1, 77 };
+        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64)), fin, 1, false, false);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("argmax", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}
+
+internal sealed class TilingCaseReduceArg2 : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseReduceArg2()
+    {
+        var inputShape = new[] { 32, 64, 128, 512 };
+        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64)), fin, 2, true, false);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("argmax2", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}
+
 internal sealed class TilingCaseConv2D : TheoryData<Function, Tensor[]>
 {
     public TilingCaseConv2D()

From 38257af2ed3d78393e2f115e51ae103fc8343510 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Thu, 12 Oct 2023 07:41:18 +0000
Subject: [PATCH 231/308] Apply code-format changes

---
 modules/cpu/src/runtime/cmodel/include/reduce_arg.h | 3 ++-
 modules/cpu/src/runtime/cmodel/include/tdma.h       | 2 +-
 python/common/pystreambuf.h                         | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/reduce_arg.h b/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
index a911c6b137..09dae04ef0 100644
--- a/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
+++ b/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
@@ -27,7 +27,8 @@ void reduce_arg_impl(TReducer &&reducer, T init_value, const T *input,
     });
 
     // collect all min/max indices
-    auto out_map = (TOutput *)runtime_util->malloc(output_size * 2 * sizeof(TOutput));
+    auto out_map =
+        (TOutput *)runtime_util->malloc(output_size * 2 * sizeof(TOutput));
     // std::unordered_map<size_t, std::vector<TOutput>> out_map;
     apply(in_shape, [&](gsl::span<const size_t> index) -> void {
         const auto src = input[offset(in_strides, index)];
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index cc36dd2c1d..c95e46f109 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -704,7 +704,7 @@ template <loc_t SrcLoc, loc_t DestLoc, class Tout>
 void reduce_arg(tensor<float, SrcLoc> &src, tensor<Tout, DestLoc> &dest,
                 int axis, bool keep_dims, bool select_last_idx,
                 reduce_arg_op_t op) {
-    auto axes = dims_t { (size_t)axis };
+    auto axes = dims_t{(size_t)axis};
     kernels::reduce_arg<float, Tout>(
         op, src.cdata().data(), dest.data().data(), src.dimension(),
         src.strides(), dest.strides(), axes, keep_dims, select_last_idx);
diff --git a/python/common/pystreambuf.h b/python/common/pystreambuf.h
index e3aed5f907..27581c1d75 100644
--- a/python/common/pystreambuf.h
+++ b/python/common/pystreambuf.h
@@ -1,8 +1,8 @@
 // https://gist.github.com/asford/544323a5da7dddad2c9174490eb5ed06
 #pragma once
 
-#include <nncase/compiler_defs.h>
 #include <cstdint>
+#include <nncase/compiler_defs.h>
 #include <pybind11/pybind11.h>
 
 #include <iostream>

From 962162f1a425eabb3eca78374b7838d5ef679e45 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Fri, 13 Oct 2023 09:24:23 +0800
Subject: [PATCH 232/308] fix to tir keep vars order

---
 .../Passes/Tile/TIRConvertVisitor.cs          |  2 +-
 .../src/runtime/cmodel/include/reduce_arg.h   | 11 +++---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 14 +++----
 src/Nncase.Compiler/Compiler.cs               |  1 +
 src/Nncase.Core/IR/Math/ReduceArg.cs          |  2 +-
 src/Nncase.Passes/Rules/Neutral/NormAxis.cs   | 17 ++++++++
 .../Targets/UnitTestCPUTargetTiling.cs        | 39 +++++++++++++++++--
 7 files changed, 68 insertions(+), 18 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 9c365b0c51..0ce265bb4a 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -27,7 +27,7 @@ public TIRConvertVisitor(List<Expr> mainBody)
 
     public IEnumerable<TIR.Buffer> OutputBuffers => _buffersMap.Values.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Output));
 
-    public IEnumerable<TIR.Buffer> InputBuffers => _buffersMap.Values.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Input));
+    public IEnumerable<TIR.Buffer> InputBuffers => VisitRootFusion.Parameters.ToArray().Select(p => _buffersMap[p]).OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Input));
 
     protected override Unit DefaultVisitLeaf(Expr expr)
     {
diff --git a/modules/cpu/src/runtime/cmodel/include/reduce_arg.h b/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
index a911c6b137..f4a6c97f11 100644
--- a/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
+++ b/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
@@ -23,17 +23,16 @@ void reduce_arg_impl(TReducer &&reducer, T init_value, const T *input,
     auto output_size = compute_size(out_shape);
     auto ptr = (T *)runtime_util->malloc(output_size * sizeof(T));
     apply(out_shape, [&](gsl::span<const size_t> index) -> void {
-        ptr[offset(out_strides, index)] = init_value;
+        auto out_idx = offset(out_strides, index);
+        ptr[out_idx] = init_value;
     });
 
     // collect all min/max indices
     auto out_map = (TOutput *)runtime_util->malloc(output_size * 2 * sizeof(TOutput));
-    // std::unordered_map<size_t, std::vector<TOutput>> out_map;
     apply(in_shape, [&](gsl::span<const size_t> index) -> void {
         const auto src = input[offset(in_strides, index)];
-        auto out_idx =
-            offset(out_strides, get_reduced_offset(index, axes, keep_dims));
-        auto &dst = ptr[out_idx];
+        auto out_idx = offset(out_strides, get_reduced_offset(index, axes, keep_dims));
+        T &dst = ptr[out_idx];
         auto ret = reducer(src, dst);
         if (ret) {
             out_map[out_idx * 2 + 0] = index[axes[0]];
@@ -59,10 +58,10 @@ template <class Tin, class Tout>
 void reduce_arg(reduce_arg_op_t op, const Tin *input, Tout *output,
                 gsl::span<const size_t> in_shape,
                 gsl::span<const size_t> in_strides,
+                gsl::span<const size_t> out_shape,
                 gsl::span<const size_t> out_strides,
                 gsl::span<const size_t> axes, bool keep_dims,
                 bool select_last_idx) noexcept {
-    auto out_shape = get_reduced_shape(in_shape, axes, keep_dims);
     switch (op) {
     case reduce_arg_op_t::arg_min:
         return reduce_arg_impl([](Tin a, Tin b) { return a < b; },
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index cc36dd2c1d..db3c3438d1 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -220,10 +220,10 @@ void reduce(tensor<T, ALoc> &input, tensor<T, BLoc> &output, reduce_op_t op,
                     keep_dims);
 }
 
-template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-void gather(tensor<T, ALoc> &input, tensor<int64_t, BLoc> &indices,
+template <typename T, typename IndicesT, loc_t ALoc, loc_t BLoc, loc_t CLoc>
+void gather(tensor<T, ALoc> &input, tensor<IndicesT, BLoc> &indices,
             tensor<T, CLoc> &output, int axis) {
-    kernels::gather<T, int64_t>(
+    kernels::gather<T, IndicesT>(
         input.cdata().data(), output.data().data(), input.dimension(),
         input.strides(), output.dimension(), output.strides(),
         indices.data().data(), indices.dimension(), axis);
@@ -700,14 +700,14 @@ enum class sched_strategy_t : uint8_t { pin_block_tensor, normal };
 
 void set_sched_strategy([[maybe_unused]] sched_strategy_t sch) {}
 
-template <loc_t SrcLoc, loc_t DestLoc, class Tout>
-void reduce_arg(tensor<float, SrcLoc> &src, tensor<Tout, DestLoc> &dest,
+template <loc_t SrcLoc, loc_t DestLoc, class Tin, class Tout>
+void reduce_arg(tensor<Tin, SrcLoc> &src, tensor<Tout, DestLoc> &dest,
                 int axis, bool keep_dims, bool select_last_idx,
                 reduce_arg_op_t op) {
     auto axes = dims_t { (size_t)axis };
-    kernels::reduce_arg<float, Tout>(
+    kernels::reduce_arg<Tin, Tout>(
         op, src.cdata().data(), dest.data().data(), src.dimension(),
-        src.strides(), dest.strides(), axes, keep_dims, select_last_idx);
+        src.strides(), dest.dimension(), dest.strides(), axes, keep_dims, select_last_idx);
 }
 
 template <loc_t SrcLoc, loc_t DestLoc>
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 07efb7b133..03c64ed13f 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -100,6 +100,7 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.Neutral.NormAxisConcat>();
             p.Add<Passes.Rules.Neutral.NormAxisReduce>();
             p.Add<Passes.Rules.Neutral.NormAxisReshape>();
+            p.Add<Passes.Rules.Neutral.NormAxisReduceArg>();
             p.Add<Passes.Rules.Neutral.SqueezeTransposeShape>();
             p.Add<Passes.Rules.Neutral.Squeeze5DTranspose>();
             p.Add<Passes.Rules.Neutral.SqueezeBinaryShape>();
diff --git a/src/Nncase.Core/IR/Math/ReduceArg.cs b/src/Nncase.Core/IR/Math/ReduceArg.cs
index 70e24cb1e5..2afd43010c 100644
--- a/src/Nncase.Core/IR/Math/ReduceArg.cs
+++ b/src/Nncase.Core/IR/Math/ReduceArg.cs
@@ -42,7 +42,7 @@ public sealed partial class ReduceArg : Op
 
     public ReduceArgOp ReduceArgOp { get; }
 
-    public DataType DestType { get; }
+    public PrimType DestType { get; }
 
     /// <inheritdoc/>
     public override string DisplayProperty() => $"ReduceArgOp.{ReduceArgOp}, DestType: {DestType}";
diff --git a/src/Nncase.Passes/Rules/Neutral/NormAxis.cs b/src/Nncase.Passes/Rules/Neutral/NormAxis.cs
index 8f20454a30..2b443edcf6 100644
--- a/src/Nncase.Passes/Rules/Neutral/NormAxis.cs
+++ b/src/Nncase.Passes/Rules/Neutral/NormAxis.cs
@@ -63,6 +63,23 @@ public sealed partial class NormAxisReduce : RewriteRule<CallPattern>
     }
 }
 
+[RuleGenerator]
+public sealed partial class NormAxisReduceArg : RewriteRule<CallPattern>
+{
+    /// <inheritdoc/>
+    public override CallPattern Pattern { get; } = IsReduceArg("reduce", "call", _ => true, IsWildcard("input") with { TypePattern = HasRank() }, IsTensorConst("axis"), IsWildcard("keepDims"), IsWildcard("selectLastIndex"));
+
+    private Expr? GetReplace(IR.Math.ReduceArg reduce, Call call, Expr input, int axis, Expr keepDims, Expr selectLastIndex)
+    {
+        if (axis < 0)
+        {
+            return IR.F.Tensors.ReduceArg(reduce.ReduceArgOp, reduce.DestType, input, axis + input.CheckedShape.Rank, keepDims, selectLastIndex);
+        }
+
+        return call;
+    }
+}
+
 [RuleGenerator]
 public sealed partial class NormAxisReshape : RewriteRule<CallPattern>
 {
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 095573d22e..6641ea8ea5 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -50,9 +50,10 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseReshape2))]
     // [ClassData(typeof(TilingCaseMatmulUnary))]
     // [ClassData(typeof(TilingCaseConv2D))]
-    [ClassData(typeof(TilingCaseReduceArg))]
-    [ClassData(typeof(TilingCaseReduceArg2))]
-    [ClassData(typeof(TilingCaseInstanceNorm))]
+    [ClassData(typeof(TilingCaseEncoderTail))]
+    // [ClassData(typeof(TilingCaseReduceArg))]
+    // [ClassData(typeof(TilingCaseReduceArg2))]
+    // [ClassData(typeof(TilingCaseInstanceNorm))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -74,6 +75,12 @@ public async Task TestCpuFunction(Function main, Tensor[] inputs)
 #endif
             await Compile(module);
             var output = Testing.RunKModel(File.ReadAllBytes(Path.Join(Diagnostics.DumpScope.Current.Directory, "test.kmodel")), Diagnostics.DumpScope.Current.Directory, inputs);
+#if DEBUG
+            using (var fs = Diagnostics.DumpScope.Current.OpenFile($"actual_0.bin"))
+            {
+                fs.Write(output.AsTensor().BytesBuffer);
+            }
+#endif
             var cos = Tests.Comparator.CosSimilarity(output, Value.FromTensor(inputs[^1]))[0];
             Assert.True(cos > 0.999);
         }
@@ -614,6 +621,32 @@ public TilingCaseReduceArg2()
     }
 }
 
+internal sealed class TilingCaseEncoderTail : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseEncoderTail()
+    {
+        var v_16 = new Var("v16", new TensorType(DataTypes.Int32, new[] { 1, 77 }));
+        var v_17 = new Var("v17", new TensorType(DataTypes.Float32, new[] { 1, 77, 768 }));
+        var v0 = IR.F.NN.LayerNorm(2, 1E-05f, v_17, IR.F.Tensors.ConstantOfShape(new[] { 768 }, 1.0f), IR.F.Tensors.ConstantOfShape(new[] { 768 }, 0.0f), true); // f32[1,77,768]
+        var v1 = IR.F.Tensors.Reshape(v0, new[] { 77, 768 }); // f32[77,768]
+        var v2 = IR.F.Tensors.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64, v_16, -1, false, false); // i64[1]
+        var v3 = IR.F.Math.Binary(BinaryOp.Add, v2, 1L); // i64[1]
+        var v4 = IR.F.Tensors.Gather(v1, 0, v3); // f32[1,768]
+        var main = new Function("encoderTail", v4, new[] { v_16, v_17 });
+
+        var input_16 = IR.F.Tensors.Cast(IR.F.Random.Uniform(DataTypes.Float32, 60, 1, 2, new[] { 1, 77 }), DataTypes.Int32).Evaluate().AsTensor();
+        var input_17 = IR.F.Random.Normal(DataTypes.Float32, 2, 4, 3, new[] { 1, 77, 768 }).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { v_16, Value.FromTensor(input_16) },
+            { v_17, Value.FromTensor(input_17) },
+        };
+        var output = main.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_16, input_17, output });
+    }
+}
+
 internal sealed class TilingCaseConv2D : TheoryData<Function, Tensor[]>
 {
     public TilingCaseConv2D()

From 03e3ae007e687fbcb67f305db0cdd67aafbf78d8 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Fri, 13 Oct 2023 01:33:37 +0000
Subject: [PATCH 233/308] Apply code-format changes

---
 .../cpu/src/runtime/cmodel/include/reduce_arg.h    |  6 ++++--
 modules/cpu/src/runtime/cmodel/include/tdma.h      | 14 +++++++-------
 .../Targets/UnitTestCPUTargetTiling.cs             |  1 +
 3 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/reduce_arg.h b/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
index f4a6c97f11..80b7b69f6e 100644
--- a/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
+++ b/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
@@ -28,10 +28,12 @@ void reduce_arg_impl(TReducer &&reducer, T init_value, const T *input,
     });
 
     // collect all min/max indices
-    auto out_map = (TOutput *)runtime_util->malloc(output_size * 2 * sizeof(TOutput));
+    auto out_map =
+        (TOutput *)runtime_util->malloc(output_size * 2 * sizeof(TOutput));
     apply(in_shape, [&](gsl::span<const size_t> index) -> void {
         const auto src = input[offset(in_strides, index)];
-        auto out_idx = offset(out_strides, get_reduced_offset(index, axes, keep_dims));
+        auto out_idx =
+            offset(out_strides, get_reduced_offset(index, axes, keep_dims));
         T &dst = ptr[out_idx];
         auto ret = reducer(src, dst);
         if (ret) {
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index db3c3438d1..02a2313aef 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -701,13 +701,13 @@ enum class sched_strategy_t : uint8_t { pin_block_tensor, normal };
 void set_sched_strategy([[maybe_unused]] sched_strategy_t sch) {}
 
 template <loc_t SrcLoc, loc_t DestLoc, class Tin, class Tout>
-void reduce_arg(tensor<Tin, SrcLoc> &src, tensor<Tout, DestLoc> &dest,
-                int axis, bool keep_dims, bool select_last_idx,
-                reduce_arg_op_t op) {
-    auto axes = dims_t { (size_t)axis };
-    kernels::reduce_arg<Tin, Tout>(
-        op, src.cdata().data(), dest.data().data(), src.dimension(),
-        src.strides(), dest.dimension(), dest.strides(), axes, keep_dims, select_last_idx);
+void reduce_arg(tensor<Tin, SrcLoc> &src, tensor<Tout, DestLoc> &dest, int axis,
+                bool keep_dims, bool select_last_idx, reduce_arg_op_t op) {
+    auto axes = dims_t{(size_t)axis};
+    kernels::reduce_arg<Tin, Tout>(op, src.cdata().data(), dest.data().data(),
+                                   src.dimension(), src.strides(),
+                                   dest.dimension(), dest.strides(), axes,
+                                   keep_dims, select_last_idx);
 }
 
 template <loc_t SrcLoc, loc_t DestLoc>
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 6641ea8ea5..84a7f4572c 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -51,6 +51,7 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseMatmulUnary))]
     // [ClassData(typeof(TilingCaseConv2D))]
     [ClassData(typeof(TilingCaseEncoderTail))]
+
     // [ClassData(typeof(TilingCaseReduceArg))]
     // [ClassData(typeof(TilingCaseReduceArg2))]
     // [ClassData(typeof(TilingCaseInstanceNorm))]

From 8a2116c4a6409e20eed8a121369b0a63d0333bbd Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 13 Oct 2023 10:03:49 +0800
Subject: [PATCH 234/308] add XPU resize

---
 .../CodeGen/CSourceConvertVisitor.cs          |   5 +
 .../CodeGen/CSourceExtensions.cs              |  26 ++++
 .../Evaluator/XPU/Resize.cs                   |  12 ++
 .../Evaluator/XPU/XPUModule.cs                |   2 +
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |   5 +
 modules/Nncase.Modules.CPU/IR/XPU/Resize.cs   |  34 +++++
 .../Tile/AutoDistributedConvertVisitor.cs     |   3 +
 .../Passes/Tile/TIRConvertVisitor.cs          |  14 ++
 .../cpu/src/runtime/cmodel/include/resize.h   | 141 ++++++++++++++++++
 .../src/runtime/cmodel/include/resize_util.h  | 121 +++++++++++++++
 .../runtime/cmodel/include/runtime_types.h    |  20 +++
 modules/cpu/src/runtime/cmodel/include/tdma.h |  35 +++++
 src/Nncase.Core/IR/Imaging/ResizeImage.cs     |   2 +-
 src/Nncase.Evaluator/Imaging/ResizeImage.cs   |  46 +++++-
 .../Targets/UnitTestCPUTargetTiling.cs        |  40 ++++-
 15 files changed, 499 insertions(+), 7 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Resize.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Resize.cs
 create mode 100644 modules/cpu/src/runtime/cmodel/include/resize.h
 create mode 100644 modules/cpu/src/runtime/cmodel/include/resize_util.h

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 123b2d4558..566075bbe4 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -495,6 +495,11 @@ protected override CSymbol VisitCall(Call expr)
                 case IR.XPU.ReduceArg reduceArg:
                     IndentScope.Writer.Write($"reduce_arg({Visit(args[0]).Name}, {Visit(args[1]).Name}, {reduceArg.Axis}, {reduceArg.KeepDims.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, {reduceArg.SelectLastIndex.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, reduce_arg_op_t::{reduceArg.ReduceArgOp.ToC()})");
                     break;
+                case IR.XPU.Resize resize:
+                    IndentScope.Writer.Write($"auto roi[] = {{{string.Join(",", resize.Roi.Select(p => p.ToString()))}}}");
+                    IndentScope.Writer.Write($"auto new_size[] = {{{string.Join(",", resize.NewSize.Select(p => p.ToString()))}}}");
+                    IndentScope.Writer.Write($"resize({Visit(args[0]).Name}, {Visit(args[1]).Name}, roi, new_size, {resize.CubicCoeffA.ToString()}, {resize.ExcludeOutsideValue.ToString()}, {resize.ExtrapolationValue.ToString()}, image_resize_mode_t::{resize.ResizeMode.ToC()}, image_resize_transformation_mode_t::{resize.TransformationMode.ToC()}, image_resize_nearest_mode_t::{resize.NearestMode.ToC()}, {resize.IsTFResize.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
+                    break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
             }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index 6eb03510ad..5e0065dbf1 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -51,6 +51,32 @@ public static string ToC(this PrimType primType) =>
         _ => throw new NotSupportedException(location.ToString()),
     };
 
+    public static string ToC(this ImageResizeMode mode) => mode switch
+    {
+        ImageResizeMode.Bilinear => "bilinear",
+        ImageResizeMode.NearestNeighbor => "nearest_neighbor",
+        _ => throw new NotImplementedException(),
+    };
+
+    public static string ToC(this ImageResizeTransformationMode mode) => mode switch
+    {
+        ImageResizeTransformationMode.HalfPixel => "half_pixel",
+        ImageResizeTransformationMode.PytorchHalfPixel => "pytorch_half_pixel",
+        ImageResizeTransformationMode.AlignCorners => "align_corners",
+        ImageResizeTransformationMode.Asymmetric => "asymmetric",
+        ImageResizeTransformationMode.TFCropAndResize => "tfcrop_and_resize",
+        _ => throw new NotImplementedException(),
+    };
+
+    public static string ToC(this ImageResizeNearestMode mode) => mode switch
+    {
+        ImageResizeNearestMode.RoundPreferFloor => "round_prefer_floor",
+        ImageResizeNearestMode.RoundPreferCeil => "round_prefer_ceil",
+        ImageResizeNearestMode.Floor => "floor",
+        ImageResizeNearestMode.Ceil => "ceil",
+        _ => throw new NotImplementedException(),
+    };
+
     public static string ToSlicing(this TensorType tensorType, string[] begins, IRArray<SBP> ndsbp, Placement placement)
     {
         var hstrides = TensorUtilities.GetStrides(placement.Hierarchy.ToArray());
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Resize.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Resize.cs
new file mode 100644
index 0000000000..14ba21bdef
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Resize.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class ResizeEvaluator : ITypeInferencer<Resize>
+{
+    public IRType Visit(ITypeInferenceContext context, Resize target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 662a552b48..a9eaf2cd38 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using DryIoc;
+using Nncase.Evaluator.Imaging;
 using Nncase.Evaluator.NN;
 using Nncase.Evaluator.Tensors;
 using Nncase.Hosting;
@@ -31,5 +32,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<GatherReduceScatterEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<Conv2DEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<ReduceArgEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<ResizeEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index c757ff2f7e..efa260ab73 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -91,4 +91,9 @@ public static Call ReduceArg(Expr input, Expr output, int axis, bool keepdims, b
     {
         return new Call(new ReduceArg(axis, keepdims, selectLastIndex, op, dataType), input, output);
     }
+
+    public static Call Resize(Expr input, Expr output, float[] roi, int[] newSize, float cubicCoeffA, int excludeOutside, float extrapolationValue, ImageResizeMode resizeMode, ImageResizeTransformationMode transformationMode, ImageResizeNearestMode nearestMode, bool isTFResize)
+    {
+        return new Call(new Resize(roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, resizeMode, transformationMode, nearestMode, isTFResize), input, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Resize.cs b/modules/Nncase.Modules.CPU/IR/XPU/Resize.cs
new file mode 100644
index 0000000000..913136afeb
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Resize.cs
@@ -0,0 +1,34 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Dynamic;
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Resize : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(Resize), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(Resize), 1, "output");
+
+    public IRArray<float> Roi { get; }
+
+    public IRArray<int> NewSize { get; }
+
+    public float CubicCoeffA { get; }
+
+    public int ExcludeOutsideValue { get; }
+
+    public float ExtrapolationValue { get; }
+
+    public ImageResizeMode ResizeMode { get; }
+
+    public ImageResizeTransformationMode TransformationMode { get; }
+
+    public ImageResizeNearestMode NearestMode { get; }
+
+    public bool IsTFResize { get; }
+
+    /// <inheritdoc/>
+    public override string DisplayProperty() => $"ImageResizeMode.{ResizeMode}, ImageResizeTransformationMode.{TransformationMode}, ImageResizeNearestMode.{NearestMode}, {IsTFResize}";
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
index 34402eb7a1..e69e4669de 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
@@ -130,6 +130,9 @@ private Dictionary<IRType, List<Expr>> VisitLeafArgument(ParameterKind parameter
                 case (ParameterKind.Attribute, TensorConst e):
                     updateBuckets(buckets, new[] { e.With() }); // remove all old users.
                     break;
+                case (ParameterKind.Attribute, None e):
+                    updateBuckets(buckets, new[] { e.With() });
+                    break;
                 default:
                     throw new InvalidOperationException();
             }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 9c365b0c51..b97dd9c2e1 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -4,6 +4,7 @@
 using System.Reactive;
 using NetFabric.Hyperlinq;
 using Nncase.IR;
+using Nncase.IR.Imaging;
 using Nncase.IR.Math;
 using Nncase.IR.NN;
 using Nncase.IR.Tensors;
@@ -86,6 +87,14 @@ protected override Unit VisitLeafCall(Call expr)
             case ReduceArg reduceArg:
                 GenerateReduceArg(reduceArg, arguments, ret, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), ((TensorConst)expr.Arguments[2]).Value.ToScalar<bool>(), ((TensorConst)expr.Arguments[3]).Value.ToScalar<bool>(), reduceArg.ReduceArgOp, reduceArg.DestType);
                 break;
+            case ResizeImage resize:
+                float[] roi = expr.Arguments[1] is null ? new[] { 0f, 0f, 1f, 1f } : ((TensorConst)expr.Arguments[1]).Value.ToArray<float>();
+                int[] newSize = ((TensorConst)expr.Arguments[2]).Value.ToArray<int>();
+                float cubicCoeffA = (TensorConst)expr.Arguments[3] is null ? -0.75f : ((TensorConst)expr.Arguments[3]).Value.ToScalar<float>();
+                int excludeOutside = (TensorConst)expr.Arguments[4] is null ? 0 : ((TensorConst)expr.Arguments[4]).Value.ToScalar<int>();
+                float extrapolationValue = (TensorConst)expr.Arguments[3] is null ? 0f : ((TensorConst)expr.Arguments[5]).Value.ToScalar<float>();
+                GenerateResize(resize, arguments, ret, roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, (DistributedType)expr.CheckedType);
+                break;
             default:
                 throw new NotSupportedException();
         }
@@ -200,6 +209,11 @@ private void GenerateReduceArg(ReduceArg reduceArg, Buffer[] arguments, Buffer r
         _mainBody.Add(IR.F.XPU.ReduceArg(arguments[0], ret, axis, keepdims, selectLastIndex, op, dataType));
     }
 
+    private void GenerateResize(ResizeImage resize, Buffer[] arguments, Buffer ret, float[] roi, int[] newSize, float cubicCoeffA, int excludeOutside, float extrapolationValue, DistributedType distributedType)
+    {
+        _mainBody.Add(IR.F.XPU.Resize(arguments[0], ret, roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, resize.ResizeMode, resize.TransformationMode, resize.NearestMode, resize.IsTFResize));
+    }
+
 #if false
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
diff --git a/modules/cpu/src/runtime/cmodel/include/resize.h b/modules/cpu/src/runtime/cmodel/include/resize.h
new file mode 100644
index 0000000000..f8a7fd3f32
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/resize.h
@@ -0,0 +1,141 @@
+#include "resize_util.h"
+#include "runtime_utils.h"
+#include <apply.h>
+#include <cmath>
+#ifdef __riscv_vector_
+#include <riscv_vector.h>
+#endif
+
+using namespace nncase::runtime::cpu;
+
+namespace kernels {
+namespace {
+template <class T>
+void resize_bilinear_impl(const T *input, T *output,
+                          gsl::span<const size_t> in_shape,
+                          gsl::span<const size_t> in_strides,
+                          gsl::span<const size_t> out_strides, int32_t out_h,
+                          int32_t out_w, bool align_corners,
+                          bool half_pixel_centers) noexcept {
+    auto [height_scale, width_scale] =
+        get_resize_scales(in_shape, out_h, out_w, align_corners);
+
+    const float rounding_offset =
+        std::numeric_limits<T>::is_integer ? .5f : .0f;
+    dims_t in_index(4), out_index(4);
+
+    auto get_input = [&](int32_t in_y, int32_t in_x) {
+        in_index[2] = in_y;
+        in_index[3] = in_x;
+        return input[offset(in_strides, in_index)];
+    };
+
+    for (size_t batch = 0; batch < in_shape[0]; batch++) {
+        in_index[0] = batch;
+        out_index[0] = batch;
+        for (size_t oc = 0; oc < in_shape[1]; oc++) {
+            in_index[1] = oc;
+            out_index[1] = oc;
+            for (size_t oy = 0; oy < (size_t)out_h; oy++) {
+                out_index[2] = oy;
+                float in_y;
+                int32_t in_y0, in_y1;
+                set_resize_bilinear(oy, height_scale, half_pixel_centers,
+                                    in_shape[2], in_y, in_y0, in_y1);
+
+                for (size_t ox = 0; ox < (size_t)out_w; ox++) {
+                    out_index[3] = ox;
+                    float in_x;
+                    int32_t in_x0, in_x1;
+                    set_resize_bilinear(ox, width_scale, half_pixel_centers,
+                                        in_shape[3], in_x, in_x0, in_x1);
+
+                    auto v0 = get_input(in_y0, in_x0);
+                    auto v1 = get_input(in_y1, in_x0);
+                    auto v2 = get_input(in_y0, in_x1);
+                    auto v3 = get_input(in_y1, in_x1);
+
+                    auto a0 = (1 - (in_y - in_y0)) * (1 - (in_x - in_x0));
+                    auto a1 = (in_y - in_y0) * (1 - (in_x - in_x0));
+                    auto a2 = (1 - (in_y - in_y0)) * (in_x - in_x0);
+                    auto a3 = (in_y - in_y0) * (in_x - in_x0);
+                    output[offset(out_strides, out_index)] =
+                        T(v0 * a0 + v1 * a1 + v2 * a2 + v3 * a3 +
+                          rounding_offset);
+                }
+            }
+        }
+    }
+    return;
+}
+
+template <class T>
+void resize_nearest_neighbor_impl(
+    const T *input, T *output, gsl::span<const size_t> in_shape,
+    gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides,
+    int32_t out_h, int32_t out_w, [[maybe_unused]] bool align_corners,
+    [[maybe_unused]] bool half_pixel_centers,
+    get_coordinate_func_t get_coordinate_func,
+    get_nearest_pixel_func_t get_nearset_func) noexcept {
+    auto [height_scale, width_scale] =
+        get_resize_scales(in_shape, out_h, out_w, align_corners);
+
+    dims_t in_index(4), out_index(4);
+    for (size_t batch = 0; batch < in_shape[0]; batch++) {
+        in_index[0] = batch;
+        out_index[0] = batch;
+        for (size_t oc = 0; oc < in_shape[1]; oc++) {
+            in_index[1] = oc;
+            out_index[1] = oc;
+            for (size_t oy = 0; oy < (size_t)out_h; oy++) {
+                auto iy = get_coordinate_func(oy, height_scale, out_h,
+                                              in_shape[2], 0, 0);
+                int64_t in_y = get_nearset_func(iy);
+                if (in_y < 0)
+                    in_y = 0;
+                if (in_y >= in_shape[2])
+                    in_y = in_shape[2] - 1;
+                in_index[2] = in_y;
+                out_index[2] = oy;
+
+                for (size_t ox = 0; ox < (size_t)out_w; ox++) {
+                    auto ix = get_coordinate_func(ox, width_scale, out_w,
+                                                  in_shape[3], 0, 0);
+                    int64_t in_x = get_nearset_func(ix);
+                    if (in_x < 0)
+                        in_x = 0;
+                    if (in_x >= in_shape[3])
+                        in_x = in_shape[3] - 1;
+                    in_index[3] = in_x;
+                    out_index[3] = ox;
+                    output[offset(out_strides, out_index)] =
+                        input[offset(in_strides, in_index)];
+                }
+            }
+        }
+    }
+    return;
+}
+} // namespace
+
+template <class T>
+void resize_bilinear(const T *input, T *output, dims_t in_shape,
+                     strides_t in_strides, strides_t out_strides, int32_t out_h,
+                     int32_t out_w, bool align_corners,
+                     bool half_pixel_centers) noexcept {
+    resize_bilinear_impl(input, output, in_shape, in_strides, out_strides,
+                         out_h, out_w, align_corners, half_pixel_centers);
+}
+
+template <class T>
+void resize_neareast_neighbor(
+    const T *input, T *output, dims_t in_shape, strides_t in_strides,
+    strides_t out_strides, int32_t out_h, int32_t out_w, bool align_corners,
+    bool half_pixel_centers,
+    get_coordinate_func_t get_coordinate_func,
+    get_nearest_pixel_func_t get_nearset_func) noexcept {
+    resize_nearest_neighbor_impl(
+        input, output, in_shape, in_strides, out_strides, out_h, out_w,
+        align_corners, half_pixel_centers, get_coordinate_func, get_nearset_func);
+}
+} // namespace kernels
diff --git a/modules/cpu/src/runtime/cmodel/include/resize_util.h b/modules/cpu/src/runtime/cmodel/include/resize_util.h
new file mode 100644
index 0000000000..1323595ac6
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/resize_util.h
@@ -0,0 +1,121 @@
+/* Copyright 2019-2023 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#include "runtime_utils.h"
+#include <runtime_types.h>
+
+using namespace nncase::runtime::cpu;
+
+using get_coordinate_func_t = float (*)(float, float, float, float, float,
+                                        float);
+using get_nearest_pixel_func_t = int64_t (*)(float);
+
+get_coordinate_func_t get_coordinate_from_resized(
+    image_resize_transformation_mode_t coordinate_transform_mode);
+
+get_nearest_pixel_func_t
+get_nearest_pixel_from_origin(image_resize_nearest_mode_t nearest_mode);
+
+inline get_coordinate_func_t get_coordinate_from_resized(
+    image_resize_transformation_mode_t coordinate_transform_mode) {
+    switch (coordinate_transform_mode) {
+    case image_resize_transformation_mode_t::asymmetric:
+        return [](float x_resized, float x_scale, float, float, float, float) {
+            return x_resized * x_scale;
+        };
+    case image_resize_transformation_mode_t::pytorch_half_pixel:
+        return [](float x_resized, float x_scale, float length_resized, float,
+                  float, float) {
+            return length_resized > 1 ? (x_resized + 0.5f) * x_scale - 0.5f
+                                      : 0.0f;
+        };
+    case image_resize_transformation_mode_t::align_corners:
+        return [](float x_resized, float, float length_resized,
+                  float length_original, float, float) {
+            return length_resized == 1 ? 0
+                                       : x_resized * (length_original - 1) /
+                                             (length_resized - 1);
+        };
+    case image_resize_transformation_mode_t::tfcrop_and_resize:
+        return [](float x_resized, float, float length_resized,
+                  float length_original, float roi_start, float roi_end) {
+            auto orig =
+                length_resized > 1
+                    ? roi_start * (length_original - 1) +
+                          (x_resized * (roi_end - roi_start) *
+                           (length_original - 1)) /
+                              (length_resized - 1)
+                    : 0.5 * (roi_start + roi_end) * (length_original - 1);
+            return static_cast<float>(orig);
+        };
+    default: // "image_resize_transformation_mode_t::half_pixel"
+        return [](float x_resized, float x_scale, float, float, float, float) {
+            return ((x_resized + 0.5f) * x_scale) - 0.5f;
+        };
+    }
+}
+
+inline get_nearest_pixel_func_t
+get_nearest_pixel_from_origin(image_resize_nearest_mode_t nearest_mode) {
+    switch (nearest_mode) {
+    case image_resize_nearest_mode_t::round_prefer_ceil:
+        return [](float x_original) -> int64_t {
+            return static_cast<int64_t>(nncase_mt->float_unary_round(x_original));
+        };
+    case image_resize_nearest_mode_t::floor:
+        return [](float x_original) -> int64_t{
+            return static_cast<int64_t>(nncase_mt->float_unary_floor(x_original));
+        };
+    case image_resize_nearest_mode_t::ceil:
+        return [](float x_original) -> int64_t{
+            return static_cast<int64_t>(nncase_mt->float_unary_ceil(x_original));
+        };
+    default: // default is round_prefer_floor
+        return [](float x_original) -> int64_t{
+            // for half way cases prefer floor
+            if (x_original == static_cast<int64_t>(x_original) + 0.5f) {
+                return static_cast<int64_t>(nncase_mt->float_unary_floor(x_original));
+            }
+            return static_cast<int64_t>(nncase_mt->float_unary_round(x_original));
+        };
+    }
+}
+
+inline std::tuple<float, float>
+get_resize_scales(gsl::span<const size_t> in_shape, int32_t out_h,
+                  int32_t out_w, bool align_corners) {
+    auto height_scale = (float)in_shape[2] / out_h;
+    auto width_scale = (float)in_shape[3] / out_w;
+    if (align_corners && out_h > 1)
+        height_scale = (float)(in_shape[2] - 1) / (out_h - 1);
+    if (align_corners && out_w > 1)
+        width_scale = (float)(in_shape[3] - 1) / (out_w - 1);
+    return std::make_tuple(height_scale, width_scale);
+}
+
+inline void set_resize_bilinear(size_t value, float scale,
+                                bool half_pixel_centers, size_t shape_size,
+                                float &scaled_value, int32_t &v0, int32_t &v1) {
+    if (half_pixel_centers) {
+        scaled_value = (value + 0.5f) * scale - 0.5f;
+    } else {
+        scaled_value = value * scale;
+    }
+    float scaled_value_floor = nncase_mt->float_unary_floor(scaled_value);
+    v0 = std::max(static_cast<int32_t>(scaled_value_floor), 0);
+    v1 = std::min(static_cast<int32_t>(nncase_mt->float_unary_ceil(scaled_value)),
+                  static_cast<int32_t>(shape_size - 1));
+}
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_types.h b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
index 8dd1ce6ad2..d7895327e0 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_types.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
@@ -5,6 +5,26 @@ using dims_t = itlib::small_vector<size_t, 8>;
 using strides_t = itlib::small_vector<size_t, 8>;
 using axes_t = itlib::small_vector<int64_t, 8>;
 
+enum class image_resize_mode_t : uint8_t {
+    bilinear = 0,
+    nearest_neighbor = 1,
+};
+
+enum class image_resize_transformation_mode_t : int32_t {
+    half_pixel = 0,
+    pytorch_half_pixel = 1,
+    align_corners = 2,
+    asymmetric = 3,
+    tfcrop_and_resize = 4,
+};
+
+enum class image_resize_nearest_mode_t : int32_t {
+    round_prefer_floor = 0,
+    round_prefer_ceil = 1,
+    floor = 2,
+    ceil = 3,
+};
+
 enum class unary_op_t : uint8_t {
     abs = 0,
     acos = 1,
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index c95e46f109..7e3c1db577 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -12,6 +12,7 @@
 #include <matmul.h>
 #include <reduce.h>
 #include <reduce_arg.h>
+#include <resize.h>
 #include <softmax.h>
 #include <tensor.h>
 #include <thread_context.h>
@@ -273,6 +274,40 @@ void instance_norm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
                            sum.strides(), gamma.strides(), eps, norm_size);
 }
 
+template <typename T, loc_t ALoc, loc_t BLoc>
+void resize(tensor<T, ALoc> &input, tensor<T, BLoc> &output,
+            [[maybe_unused]] float *roi, int32_t *new_size,
+            [[maybe_unused]] float cubic_coeff_a,
+            [[maybe_unused]] int exclude_outside_value,
+            [[maybe_unused]] float extrapolation_value,
+            image_resize_mode_t resize_mode,
+            image_resize_transformation_mode_t transformation_mode,
+            image_resize_nearest_mode_t nearest_mode,
+            [[maybe_unused]] bool is_tf_resize) {
+    if (resize_mode == image_resize_mode_t::bilinear) {
+        kernels::resize_bilinear(
+            input.cdata().data(), output.data().data(), input.dimension(),
+            input.strides(), output.strides(), new_size[2], new_size[3],
+            transformation_mode ==
+                image_resize_transformation_mode_t::align_corners,
+            transformation_mode ==
+                image_resize_transformation_mode_t::half_pixel);
+    } else {
+        get_coordinate_func_t get_coordinate_func =
+            get_coordinate_from_resized(transformation_mode);
+        get_nearest_pixel_func_t get_nearset_func =
+            get_nearest_pixel_from_origin(nearest_mode);
+        kernels::resize_neareast_neighbor(
+            input.cdata().data(), output.data().data(), input.dimension(),
+            input.strides(), output.strides(), new_size[2], new_size[3],
+            transformation_mode ==
+                image_resize_transformation_mode_t::align_corners,
+            transformation_mode ==
+                image_resize_transformation_mode_t::half_pixel,
+            get_coordinate_func, get_nearset_func);
+    }
+}
+
 template <typename T, loc_t ALoc>
 void reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
                     tensor<T, loc_t::local> &sum_sqr) {
diff --git a/src/Nncase.Core/IR/Imaging/ResizeImage.cs b/src/Nncase.Core/IR/Imaging/ResizeImage.cs
index 088651b511..ae48d48831 100644
--- a/src/Nncase.Core/IR/Imaging/ResizeImage.cs
+++ b/src/Nncase.Core/IR/Imaging/ResizeImage.cs
@@ -21,7 +21,7 @@ public sealed partial class ResizeImage : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(ResizeImage), 0, "input", HasRank(r => r >= 2, "RanK >= 2"));
+    public static readonly ParameterInfo Input = new(typeof(ResizeImage), 0, "input", HasRank(r => r >= 2, "RanK >= 2"), ParameterKind.Input);
 
     /// <summary>
     /// Gets roi.
diff --git a/src/Nncase.Evaluator/Imaging/ResizeImage.cs b/src/Nncase.Evaluator/Imaging/ResizeImage.cs
index eab837a460..eef38cf438 100644
--- a/src/Nncase.Evaluator/Imaging/ResizeImage.cs
+++ b/src/Nncase.Evaluator/Imaging/ResizeImage.cs
@@ -110,16 +110,56 @@ public IValue OnnxResize(IEvaluateContext context, ResizeImage target)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, ResizeImage target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, ResizeImage.Input);
+        var input = context.CheckArgumentType<IRType>(target, ResizeImage.Input);
         var newSize = context.GetArgument(target, ResizeImage.NewSize);
+
+        return input switch
+        {
+            TensorType t => Visit(t, newSize),
+            DistributedType d => Visit(d, newSize),
+            _ => new InvalidType(input.GetType().ToString()),
+        };
+    }
+
+    /// <inheritdoc/>
+    public IRType Visit(TensorType input, Expr newSize)
+    {
         return TypeInference.ResizeType(input, newSize, null);
     }
 
+    public IRType Visit(DistributedType input, Expr newSize)
+    {
+        if (Visit(input.TensorType, newSize) is not TensorType outType)
+        {
+            return new InvalidType(string.Empty);
+        }
+
+        var ndsbp = new SBP[input.Placement.Rank];
+
+        var invalid = new InvalidType($"{input}, not support");
+        for (int i = 0; i < input.Placement.Rank; i++)
+        {
+            switch (input.NdSBP[i])
+            {
+                case SBPSplit { Axis: int ix } when ix < 2:
+                    ndsbp[i] = SBP.S(ix);
+                    break;
+                case SBPBroadCast:
+                    ndsbp[i] = SBP.B;
+                    break;
+                default:
+                    return invalid;
+            }
+        }
+
+        return new DistributedType(input.TensorType, ndsbp, input.Placement);
+    }
+
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, ResizeImage target)
     {
-        var inputType = context.GetArgumentType<TensorType>(target, ResizeImage.Input);
-        var returnType = context.GetReturnType<TensorType>();
+        var inputType = context.GetArgumentType<IRType>(target, ResizeImage.Input);
+        var returnType = context.GetReturnType<IRType>();
         return new()
         {
             [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(inputType),
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 095573d22e..1c1a7fdffa 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -50,9 +50,10 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseReshape2))]
     // [ClassData(typeof(TilingCaseMatmulUnary))]
     // [ClassData(typeof(TilingCaseConv2D))]
-    [ClassData(typeof(TilingCaseReduceArg))]
-    [ClassData(typeof(TilingCaseReduceArg2))]
-    [ClassData(typeof(TilingCaseInstanceNorm))]
+    // [ClassData(typeof(TilingCaseReduceArg))]
+    // [ClassData(typeof(TilingCaseReduceArg2))]
+    // [ClassData(typeof(TilingCaseInstanceNorm))]
+    [ClassData(typeof(TilingCaseResize))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -649,3 +650,36 @@ public TilingCaseConv2D()
         Add(main, new[] { input_tensor, output });
     }
 }
+
+internal sealed class TilingCaseResize : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseResize()
+    {
+        var shape = new[] { 1, 512, 64, 64 };
+        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, shape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Imaging.ResizeImage(ImageResizeMode.NearestNeighbor, ImageResizeTransformationMode.Asymmetric, ImageResizeNearestMode.Floor, false)), fin, None.Default, new[] { 1, 512, 128, 128 }, None.Default, None.Default, None.Default);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("nearest_resize", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
+        {
+            fs.Write(input_tensor.BytesBuffer);
+        }
+
+        var feedDict = new Dictionary<Var, IValue>
+            {
+                { fin, Value.FromTensor(input_tensor) },
+            };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}

From 0335afd12869a10ce594d4535d97276284f3b901 Mon Sep 17 00:00:00 2001
From: xhuohai <xhuohai@users.noreply.github.com>
Date: Fri, 13 Oct 2023 02:08:59 +0000
Subject: [PATCH 235/308] Apply code-format changes

---
 .../cpu/src/runtime/cmodel/include/resize.h   | 10 +++----
 .../src/runtime/cmodel/include/resize_util.h  | 26 ++++++++++++-------
 src/Nncase.Evaluator/Imaging/ResizeImage.cs   |  2 +-
 3 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/resize.h b/modules/cpu/src/runtime/cmodel/include/resize.h
index f8a7fd3f32..157ff23653 100644
--- a/modules/cpu/src/runtime/cmodel/include/resize.h
+++ b/modules/cpu/src/runtime/cmodel/include/resize.h
@@ -131,11 +131,11 @@ template <class T>
 void resize_neareast_neighbor(
     const T *input, T *output, dims_t in_shape, strides_t in_strides,
     strides_t out_strides, int32_t out_h, int32_t out_w, bool align_corners,
-    bool half_pixel_centers,
-    get_coordinate_func_t get_coordinate_func,
+    bool half_pixel_centers, get_coordinate_func_t get_coordinate_func,
     get_nearest_pixel_func_t get_nearset_func) noexcept {
-    resize_nearest_neighbor_impl(
-        input, output, in_shape, in_strides, out_strides, out_h, out_w,
-        align_corners, half_pixel_centers, get_coordinate_func, get_nearset_func);
+    resize_nearest_neighbor_impl(input, output, in_shape, in_strides,
+                                 out_strides, out_h, out_w, align_corners,
+                                 half_pixel_centers, get_coordinate_func,
+                                 get_nearset_func);
 }
 } // namespace kernels
diff --git a/modules/cpu/src/runtime/cmodel/include/resize_util.h b/modules/cpu/src/runtime/cmodel/include/resize_util.h
index 1323595ac6..69533414e1 100644
--- a/modules/cpu/src/runtime/cmodel/include/resize_util.h
+++ b/modules/cpu/src/runtime/cmodel/include/resize_util.h
@@ -73,23 +73,28 @@ get_nearest_pixel_from_origin(image_resize_nearest_mode_t nearest_mode) {
     switch (nearest_mode) {
     case image_resize_nearest_mode_t::round_prefer_ceil:
         return [](float x_original) -> int64_t {
-            return static_cast<int64_t>(nncase_mt->float_unary_round(x_original));
+            return static_cast<int64_t>(
+                nncase_mt->float_unary_round(x_original));
         };
     case image_resize_nearest_mode_t::floor:
-        return [](float x_original) -> int64_t{
-            return static_cast<int64_t>(nncase_mt->float_unary_floor(x_original));
+        return [](float x_original) -> int64_t {
+            return static_cast<int64_t>(
+                nncase_mt->float_unary_floor(x_original));
         };
     case image_resize_nearest_mode_t::ceil:
-        return [](float x_original) -> int64_t{
-            return static_cast<int64_t>(nncase_mt->float_unary_ceil(x_original));
+        return [](float x_original) -> int64_t {
+            return static_cast<int64_t>(
+                nncase_mt->float_unary_ceil(x_original));
         };
     default: // default is round_prefer_floor
-        return [](float x_original) -> int64_t{
+        return [](float x_original) -> int64_t {
             // for half way cases prefer floor
             if (x_original == static_cast<int64_t>(x_original) + 0.5f) {
-                return static_cast<int64_t>(nncase_mt->float_unary_floor(x_original));
+                return static_cast<int64_t>(
+                    nncase_mt->float_unary_floor(x_original));
             }
-            return static_cast<int64_t>(nncase_mt->float_unary_round(x_original));
+            return static_cast<int64_t>(
+                nncase_mt->float_unary_round(x_original));
         };
     }
 }
@@ -116,6 +121,7 @@ inline void set_resize_bilinear(size_t value, float scale,
     }
     float scaled_value_floor = nncase_mt->float_unary_floor(scaled_value);
     v0 = std::max(static_cast<int32_t>(scaled_value_floor), 0);
-    v1 = std::min(static_cast<int32_t>(nncase_mt->float_unary_ceil(scaled_value)),
-                  static_cast<int32_t>(shape_size - 1));
+    v1 = std::min(
+        static_cast<int32_t>(nncase_mt->float_unary_ceil(scaled_value)),
+        static_cast<int32_t>(shape_size - 1));
 }
\ No newline at end of file
diff --git a/src/Nncase.Evaluator/Imaging/ResizeImage.cs b/src/Nncase.Evaluator/Imaging/ResizeImage.cs
index eef38cf438..98aec22ae5 100644
--- a/src/Nncase.Evaluator/Imaging/ResizeImage.cs
+++ b/src/Nncase.Evaluator/Imaging/ResizeImage.cs
@@ -129,7 +129,7 @@ public IRType Visit(TensorType input, Expr newSize)
 
     public IRType Visit(DistributedType input, Expr newSize)
     {
-        if (Visit(input.TensorType, newSize) is not TensorType outType)
+        if (Visit(input.TensorType, newSize) is not TensorType)
         {
             return new InvalidType(string.Empty);
         }

From dda05953196d431a2ebe041246c60b1355e429f6 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Fri, 13 Oct 2023 10:30:30 +0800
Subject: [PATCH 236/308] fix resize cpu kernel op

---
 .../Passes/Tile/TIRConvertVisitor.cs                   | 10 ++++++----
 src/Nncase.Core/IR/TypePattern.cs                      |  4 ++--
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 2f614d7e45..1eebf4d5b0 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -88,11 +88,11 @@ protected override Unit VisitLeafCall(Call expr)
                 GenerateReduceArg(reduceArg, arguments, ret, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), ((TensorConst)expr.Arguments[2]).Value.ToScalar<bool>(), ((TensorConst)expr.Arguments[3]).Value.ToScalar<bool>(), reduceArg.ReduceArgOp, reduceArg.DestType);
                 break;
             case ResizeImage resize:
-                float[] roi = expr.Arguments[1] is null ? new[] { 0f, 0f, 1f, 1f } : ((TensorConst)expr.Arguments[1]).Value.ToArray<float>();
+                float[] roi = expr.Arguments[1] is TensorConst tc ? tc.Value.ToArray<float>() : new[] { 0f, 0f, 1f, 1f };
                 int[] newSize = ((TensorConst)expr.Arguments[2]).Value.ToArray<int>();
-                float cubicCoeffA = (TensorConst)expr.Arguments[3] is null ? -0.75f : ((TensorConst)expr.Arguments[3]).Value.ToScalar<float>();
-                int excludeOutside = (TensorConst)expr.Arguments[4] is null ? 0 : ((TensorConst)expr.Arguments[4]).Value.ToScalar<int>();
-                float extrapolationValue = (TensorConst)expr.Arguments[3] is null ? 0f : ((TensorConst)expr.Arguments[5]).Value.ToScalar<float>();
+                float cubicCoeffA = expr.Arguments[3] is TensorConst tc1 ? tc1.Value.ToScalar<float>() : -0.75f;
+                int excludeOutside = expr.Arguments[4] is TensorConst tc2 ? tc2.Value.ToScalar<int>() : 0;
+                float extrapolationValue = expr.Arguments[5] is TensorConst tc3 ? tc3.Value.ToScalar<float>() : 0f;
                 GenerateResize(resize, arguments, ret, roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, (DistributedType)expr.CheckedType);
                 break;
             default:
@@ -304,6 +304,8 @@ private TIR.Buffer AllocOrGetBuffer(Expr expr)
                     break;
                 case IR.Tuple:
                     return null!;
+                case IR.None:
+                    return null!;
                 default:
                     throw new NotSupportedException();
             }
diff --git a/src/Nncase.Core/IR/TypePattern.cs b/src/Nncase.Core/IR/TypePattern.cs
index 3b4116d032..183ae381f7 100644
--- a/src/Nncase.Core/IR/TypePattern.cs
+++ b/src/Nncase.Core/IR/TypePattern.cs
@@ -57,12 +57,12 @@ public TypePattern(CallableType valueType)
     public T Check<T>(T valueType, string fieldName)
         where T : IRType
     {
-        if (valueType is TensorType tensorValueType && tensorValueType.Shape.IsUnranked)
+        if (valueType is TensorType { Shape: { IsUnranked: true } } || valueType is DistributedType { TensorType: { Shape: { IsUnranked: true } } })
         {
             return valueType;
         }
 
-        if (valueType == null || !MatchLeaf(valueType))
+        if (valueType == null || (valueType is TensorType t && !MatchLeaf(t)) || (valueType is DistributedType d && !MatchLeaf(d.TensorType)))
         {
             var cur = valueType is null ? "None" : CompilerServices.Print(valueType);
             throw new InvalidOperationException($"{fieldName} Requrie <{Reason}>, But {cur}!");

From 5a46c8325a64d235662fd177e6a17d944de5198b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 13 Oct 2023 10:57:48 +0800
Subject: [PATCH 237/308] fix Resize

---
 modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs       | 2 +-
 modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs | 4 ++--
 src/Nncase.Evaluator/Imaging/ResizeImage.cs                 | 5 ++---
 3 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
index 7f7249d3a9..f3f30f5205 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
@@ -135,7 +135,7 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
             // return $"-c \"export PATH=/data/huochenghai/toolchain/riscv64-unknown-linux_gnu_12.0.1/bin:$PATH && cd {sourcePath} && mkdir -p build && cd build && rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=riscv64-unknown-linux-gnu-gcc -DCMAKE_CXX_COMPILER=riscv64-unknown-linux-gnu-g++ -DCMAKE_SYSTEM_PROCESSOR=riscv64 && cmake --build .\"";
-            return $"-c \"cd {sourcePath} && /bin/mkdir -p build && cd build && /bin/rm -rf * && /root/miniconda3/envs/ci/bin/cmake .. -DCMAKE_BUILD_TYPE=Debug && /root/miniconda3/envs/ci/bin/cmake --build .\"";
+            return $"-c \"cd {sourcePath} && /bin/mkdir -p build && cd build && /bin/rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Debug && cmake --build .\"";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
         {
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 566075bbe4..82953593f7 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -496,8 +496,8 @@ protected override CSymbol VisitCall(Call expr)
                     IndentScope.Writer.Write($"reduce_arg({Visit(args[0]).Name}, {Visit(args[1]).Name}, {reduceArg.Axis}, {reduceArg.KeepDims.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, {reduceArg.SelectLastIndex.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, reduce_arg_op_t::{reduceArg.ReduceArgOp.ToC()})");
                     break;
                 case IR.XPU.Resize resize:
-                    IndentScope.Writer.Write($"auto roi[] = {{{string.Join(",", resize.Roi.Select(p => p.ToString()))}}}");
-                    IndentScope.Writer.Write($"auto new_size[] = {{{string.Join(",", resize.NewSize.Select(p => p.ToString()))}}}");
+                    IndentScope.Writer.Write($"float roi[{resize.Roi.Count}] = {{{string.Join(",", resize.Roi.Select(p => p.ToString()))}}};\n");
+                    IndentScope.Writer.Write($"int32_t new_size[{resize.NewSize.Count}] = {{{string.Join(",", resize.NewSize.Select(p => p.ToString()))}}};\n");
                     IndentScope.Writer.Write($"resize({Visit(args[0]).Name}, {Visit(args[1]).Name}, roi, new_size, {resize.CubicCoeffA.ToString()}, {resize.ExcludeOutsideValue.ToString()}, {resize.ExtrapolationValue.ToString()}, image_resize_mode_t::{resize.ResizeMode.ToC()}, image_resize_transformation_mode_t::{resize.TransformationMode.ToC()}, image_resize_nearest_mode_t::{resize.NearestMode.ToC()}, {resize.IsTFResize.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
                     break;
                 default:
diff --git a/src/Nncase.Evaluator/Imaging/ResizeImage.cs b/src/Nncase.Evaluator/Imaging/ResizeImage.cs
index 98aec22ae5..e25db7b8c0 100644
--- a/src/Nncase.Evaluator/Imaging/ResizeImage.cs
+++ b/src/Nncase.Evaluator/Imaging/ResizeImage.cs
@@ -121,7 +121,6 @@ public IRType Visit(ITypeInferenceContext context, ResizeImage target)
         };
     }
 
-    /// <inheritdoc/>
     public IRType Visit(TensorType input, Expr newSize)
     {
         return TypeInference.ResizeType(input, newSize, null);
@@ -129,7 +128,7 @@ public IRType Visit(TensorType input, Expr newSize)
 
     public IRType Visit(DistributedType input, Expr newSize)
     {
-        if (Visit(input.TensorType, newSize) is not TensorType)
+        if (Visit(input.TensorType, newSize) is not TensorType tensorType)
         {
             return new InvalidType(string.Empty);
         }
@@ -152,7 +151,7 @@ public IRType Visit(DistributedType input, Expr newSize)
             }
         }
 
-        return new DistributedType(input.TensorType, ndsbp, input.Placement);
+        return new DistributedType(tensorType, ndsbp, input.Placement);
     }
 
     /// <inheritdoc/>

From 54bca9408152377dd0767b4592d1c01ae5ecd0dc Mon Sep 17 00:00:00 2001
From: liuzhiming <liuzhiming@canaan-creative.com>
Date: Fri, 13 Oct 2023 06:24:08 +0000
Subject: [PATCH 238/308] Update layernom op for test

---
 .../src/runtime/cmodel/include/layernorm.h    | 191 +++++++++++-------
 1 file changed, 115 insertions(+), 76 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index d1962ed6c4..97c0f50531 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -1,7 +1,7 @@
 #include "runtime_utils.h"
 #include <apply.h>
 #include <cmath>
-#ifdef __riscv_vector_
+#ifdef __riscv_vector
 #include <riscv_vector.h>
 #endif
 
@@ -9,6 +9,119 @@ using namespace nncase::runtime::cpu;
 namespace kernels {
 
 namespace {
+
+#ifdef __riscv_vector
+static void layernor_restruct2(const float* input, float* output, int len, const float* gamma, const float* beta,
+ float mean, float sigma)
+{   
+    size_t vl;
+    if(gamma == NULL && beta == NULL)
+    {
+        for (size_t i = len; i > 0; i -= vl) {
+            vl = vsetvl_e32m8(i);
+            vfloat32m8_t vx = vle32_v_f32m8(input, vl);
+            vx = vfsub_vf_f32m8(vx, mean, vl);
+            vx = vfdiv_vf_f32m8(vx, sigma, vl);
+            vse32_v_f32m8(output, vx, vl);
+            input += vl;
+            output += vl;
+        }
+        return;
+    }
+    if(gamma == NULL)
+    {
+        for (size_t i = len; i > 0; i -= vl) {
+            vl = vsetvl_e32m8(i);
+            vfloat32m8_t vx = vle32_v_f32m8(input, vl);
+            vfloat32m8_t vbeta = vle32_v_f32m8(beta, vl);
+            vx = vfsub_vf_f32m8(vx, mean, vl);
+            vx = vfdiv_vf_f32m8(vx, sigma, vl);
+            vx = vfadd_vv_f32m8(vx, vbeta, vl);
+            vse32_v_f32m8(output, vx, vl);
+            input += vl;
+            output += vl;
+            beta += vl;
+        }
+        return;
+    }
+    if(beta == NULL)
+    {
+        for (size_t i = len; i > 0; i -= vl) {
+            vl = vsetvl_e32m8(i);
+            vfloat32m8_t vx = vle32_v_f32m8(input, vl);
+            vfloat32m8_t vgamma = vle32_v_f32m8(gamma, vl);
+            vx = vfsub_vf_f32m8(vx, mean, vl);
+            vx = vfdiv_vf_f32m8(vx, sigma, vl);
+            vx = vfmul_vv_f32m8(vx, vgamma, vl);
+            vse32_v_f32m8(output, vx, vl);
+            input += vl;
+            output += vl;
+            gamma += vl;
+        }
+        return;
+    }
+    
+    for (size_t i = len; i > 0; i -= vl) {
+        vl = vsetvl_e32m8(i);
+        vfloat32m8_t vx = vle32_v_f32m8(input, vl);
+        vfloat32m8_t vgamma = vle32_v_f32m8(gamma, vl);
+        vfloat32m8_t vbeta = vle32_v_f32m8(beta, vl);
+        vx = vfsub_vf_f32m8(vx, mean, vl);
+        vx = vfdiv_vf_f32m8(vx, sigma, vl);
+        vx = vfmacc_vv_f32m8(vbeta, vx, vgamma, vl);
+        vse32_v_f32m8(output, vx, vl);
+        input += vl;
+        output += vl;
+        beta += vl;
+        gamma += vl;
+    }
+}
+
+static int  get_offset_from_index(gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides, int index)
+{
+    strides_t x = get_default_strides(in_shape);
+    int __sum = 0;
+    for(size_t i = 0; i < x.size(); ++i)
+    {
+        __sum += index / x[i] * in_strides[i];
+        index = index % x[i];
+    }
+    return __sum;
+}
+
+template <typename T>
+void layernorm_naive_impl(const T *input, const T *sum, const T *sum_sqr, T *output,
+                          const T *gamma, const T *beta,
+                          gsl::span<const size_t> input_shape,
+                          gsl::span<const size_t> input_stride,
+                          gsl::span<const size_t> output_stride,
+                          [[maybe_unused]] gsl::span<const size_t> sum_strides,
+                          [[maybe_unused]] gsl::span<const size_t> gamma_strides, T eps,
+                          int32_t axis, int32_t norm_size,
+                          [[maybe_unused]] bool rms_norm = false) noexcept {
+
+    size_t outer_size = 1;
+    for (auto i = 0; i < axis; i++) {
+        outer_size *= input_shape[i];
+    }
+
+    size_t inner_size = 1;
+    for (int i = axis; i < (int)input_shape.size(); i++) {
+        inner_size *= input_shape[i];
+    }
+    gsl::span<const size_t> in_shape_outer(input_shape.begin(), input_shape.begin() + axis);
+    gsl::span<const size_t> in_shape_inner(input_shape.begin() + axis, input_shape.end());
+    for (size_t o = 0; o < outer_size; o++) {
+        int __ptr_output = get_offset_from_index(in_shape_outer, output_stride, o);
+        int __ptr_input = get_offset_from_index(in_shape_outer, input_stride, o);
+        int __ptr_sum = get_offset_from_index(in_shape_outer, sum_strides, o);
+        auto mean = sum[__ptr_sum] / norm_size;
+        if(rms_norm) mean = 0;
+        auto sigma = std::sqrt(sum_sqr[__ptr_sum] / norm_size - mean * mean + eps);
+        layernor_restruct2(input + __ptr_input, output + __ptr_output, inner_size, gamma, beta, mean, sigma);
+    }
+}
+#else
 template <typename T>
 void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *output,
                           T *gamma, T *beta,
@@ -60,81 +173,6 @@ void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *output,
     //     }
     // }
 }
-
-#ifdef __riscv_vector_
-template <typename T>
-void layernorm_rvv_impl(const T *input, const T *sum, T *sum_sqr, T *gamma,
-                        T *beta, gsl::span<const size_t> input_shape,
-                        [[maybe_unused]] gsl::span<const size_t> input_stride,
-                        T *eps, int32_t axis, int32_t norm_size) noexcept {
-    // only process continues float32 tensor for now
-    size_t outer_size = 1;
-    for (auto i = 0; i < axis; i++) {
-        outer_size *= input_shape[i];
-    }
-
-    size_t inner_size = 1;
-    for (auto i = axis; i < input_shape.size(); i++) {
-        inner_size *= input_shape[i];
-    }
-
-    size_t vl;
-    float r_norm_size = 1.f / norm_size;
-    float *sum_ptr = sum;
-    float *sum_sqr_ptr = sum_sqr;
-    std::vector<float> mean(outer_size, 0);
-    std::vector<float> sigma(outer_size, 0);
-    vfloat32m8_t vmean;
-    vfloat32m8_t vmean_sqr;
-    vfloat32m8_t vsigma;
-    size_t offset = 0;
-    for (size_t o = outer_size; o > 0; o -= vl) {
-        vl = vsetvl_e32m8(o);
-
-        // mean
-        vmean = vle32_v_f32m8(sum_ptr, vl);
-        vmean = vfmul_vf_f32m8(vmean, r_norm_size);
-        vmean_sqr = vfmul_vv_f32m8(vmean, vmean);
-        vse32_v_f32m8(mean.data() + offset, vmean, vl);
-
-        // sigma
-        vsigma = vle32_v_f32m8(sum_sqr_ptr, vl);
-        vsigma = vfmul_vf_f32m8(vsigma, r_norm_size);
-        vsigma = vfsub_vv_f32m8(vsigma, vmean_sqr);
-        vsigma = vfadd_vf_f32m8(vsigma, eps);
-        vsigma = vfsqrt_v_f32m8(vsigma);
-        vse32_v_f32m8(sigma.data() + offset, vsigma, vl);
-
-        sum_ptr += vl;
-        sum_sqr_ptr += vl;
-        offset += vl;
-    }
-
-    float *input_ptr = input;
-    float *gamma_ptr = gamma;
-    float *beta_ptr = beta;
-    vfloat32m8_t vx;
-    vfloat32m8_t vgamma;
-    vfloat32m8_t vbeta;
-    for (size_t i = inner_size; i < inner_size; i -= vl) {
-        vl = vsetvl_e32m8(i);
-
-        vgamma = vle32_v_f32m8(gamma_ptr, vl);
-        vbeta = vle32_v_f32m8(beta_ptr, vl);
-
-        for (size_t o = 0; o < outer_size; o++) {
-            vx = vle32_v_f32m8(input_ptr, vl);
-            vx = vfsub_vf_f32m8(vx, mean[o], vl);
-            vx = vfdiv_vf_f32m8(vx, sigma[o], vl);
-            vx = vfmacc_vv_f32m8(vbeta, vx, vgamma, vl);
-            input_ptr += inner_size;
-        }
-
-        gamma_ptr += vl;
-        beta_ptr += vl;
-        input_ptr = input + vl;
-    }
-}
 #endif
 
 } // namespace
@@ -145,6 +183,7 @@ void layernorm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
                strides_t output_strides, strides_t sum_strides,
                strides_t gamma_strides, T eps, int32_t axis, int32_t norm_size,
                bool rms_norm = false) {
+                // fafdaf
 #ifdef __riscv_vector_
     return layernorm_rvv_impl(
         input, sum, sum_sqr, gamma, beta,

From 69d27edf278c0b6f716febeff275e6e26896424e Mon Sep 17 00:00:00 2001
From: liuzm6217-jianan <liuzm6217-jianan@users.noreply.github.com>
Date: Fri, 13 Oct 2023 06:27:34 +0000
Subject: [PATCH 239/308] Apply code-format changes

---
 .../src/runtime/cmodel/include/layernorm.h    | 64 ++++++++++---------
 1 file changed, 33 insertions(+), 31 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index 97c0f50531..48ad9c408b 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -11,12 +11,11 @@ namespace kernels {
 namespace {
 
 #ifdef __riscv_vector
-static void layernor_restruct2(const float* input, float* output, int len, const float* gamma, const float* beta,
- float mean, float sigma)
-{   
+static void layernor_restruct2(const float *input, float *output, int len,
+                               const float *gamma, const float *beta,
+                               float mean, float sigma) {
     size_t vl;
-    if(gamma == NULL && beta == NULL)
-    {
+    if (gamma == NULL && beta == NULL) {
         for (size_t i = len; i > 0; i -= vl) {
             vl = vsetvl_e32m8(i);
             vfloat32m8_t vx = vle32_v_f32m8(input, vl);
@@ -28,8 +27,7 @@ static void layernor_restruct2(const float* input, float* output, int len, const
         }
         return;
     }
-    if(gamma == NULL)
-    {
+    if (gamma == NULL) {
         for (size_t i = len; i > 0; i -= vl) {
             vl = vsetvl_e32m8(i);
             vfloat32m8_t vx = vle32_v_f32m8(input, vl);
@@ -44,8 +42,7 @@ static void layernor_restruct2(const float* input, float* output, int len, const
         }
         return;
     }
-    if(beta == NULL)
-    {
+    if (beta == NULL) {
         for (size_t i = len; i > 0; i -= vl) {
             vl = vsetvl_e32m8(i);
             vfloat32m8_t vx = vle32_v_f32m8(input, vl);
@@ -60,7 +57,7 @@ static void layernor_restruct2(const float* input, float* output, int len, const
         }
         return;
     }
-    
+
     for (size_t i = len; i > 0; i -= vl) {
         vl = vsetvl_e32m8(i);
         vfloat32m8_t vx = vle32_v_f32m8(input, vl);
@@ -77,12 +74,12 @@ static void layernor_restruct2(const float* input, float* output, int len, const
     }
 }
 
-static int  get_offset_from_index(gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides, int index)
-{
+static int get_offset_from_index(gsl::span<const size_t> in_shape,
+                                 gsl::span<const size_t> in_strides,
+                                 int index) {
     strides_t x = get_default_strides(in_shape);
     int __sum = 0;
-    for(size_t i = 0; i < x.size(); ++i)
-    {
+    for (size_t i = 0; i < x.size(); ++i) {
         __sum += index / x[i] * in_strides[i];
         index = index % x[i];
     }
@@ -90,15 +87,13 @@ static int  get_offset_from_index(gsl::span<const size_t> in_shape, gsl::span<co
 }
 
 template <typename T>
-void layernorm_naive_impl(const T *input, const T *sum, const T *sum_sqr, T *output,
-                          const T *gamma, const T *beta,
-                          gsl::span<const size_t> input_shape,
-                          gsl::span<const size_t> input_stride,
-                          gsl::span<const size_t> output_stride,
-                          [[maybe_unused]] gsl::span<const size_t> sum_strides,
-                          [[maybe_unused]] gsl::span<const size_t> gamma_strides, T eps,
-                          int32_t axis, int32_t norm_size,
-                          [[maybe_unused]] bool rms_norm = false) noexcept {
+void layernorm_naive_impl(
+    const T *input, const T *sum, const T *sum_sqr, T *output, const T *gamma,
+    const T *beta, gsl::span<const size_t> input_shape,
+    gsl::span<const size_t> input_stride, gsl::span<const size_t> output_stride,
+    [[maybe_unused]] gsl::span<const size_t> sum_strides,
+    [[maybe_unused]] gsl::span<const size_t> gamma_strides, T eps, int32_t axis,
+    int32_t norm_size, [[maybe_unused]] bool rms_norm = false) noexcept {
 
     size_t outer_size = 1;
     for (auto i = 0; i < axis; i++) {
@@ -109,16 +104,23 @@ void layernorm_naive_impl(const T *input, const T *sum, const T *sum_sqr, T *out
     for (int i = axis; i < (int)input_shape.size(); i++) {
         inner_size *= input_shape[i];
     }
-    gsl::span<const size_t> in_shape_outer(input_shape.begin(), input_shape.begin() + axis);
-    gsl::span<const size_t> in_shape_inner(input_shape.begin() + axis, input_shape.end());
+    gsl::span<const size_t> in_shape_outer(input_shape.begin(),
+                                           input_shape.begin() + axis);
+    gsl::span<const size_t> in_shape_inner(input_shape.begin() + axis,
+                                           input_shape.end());
     for (size_t o = 0; o < outer_size; o++) {
-        int __ptr_output = get_offset_from_index(in_shape_outer, output_stride, o);
-        int __ptr_input = get_offset_from_index(in_shape_outer, input_stride, o);
+        int __ptr_output =
+            get_offset_from_index(in_shape_outer, output_stride, o);
+        int __ptr_input =
+            get_offset_from_index(in_shape_outer, input_stride, o);
         int __ptr_sum = get_offset_from_index(in_shape_outer, sum_strides, o);
         auto mean = sum[__ptr_sum] / norm_size;
-        if(rms_norm) mean = 0;
-        auto sigma = std::sqrt(sum_sqr[__ptr_sum] / norm_size - mean * mean + eps);
-        layernor_restruct2(input + __ptr_input, output + __ptr_output, inner_size, gamma, beta, mean, sigma);
+        if (rms_norm)
+            mean = 0;
+        auto sigma =
+            std::sqrt(sum_sqr[__ptr_sum] / norm_size - mean * mean + eps);
+        layernor_restruct2(input + __ptr_input, output + __ptr_output,
+                           inner_size, gamma, beta, mean, sigma);
     }
 }
 #else
@@ -183,7 +185,7 @@ void layernorm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
                strides_t output_strides, strides_t sum_strides,
                strides_t gamma_strides, T eps, int32_t axis, int32_t norm_size,
                bool rms_norm = false) {
-                // fafdaf
+    // fafdaf
 #ifdef __riscv_vector_
     return layernorm_rvv_impl(
         input, sum, sum_sqr, gamma, beta,

From 8c3a09be2dadf0428ab798a8dd6966a5b8c7fc05 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 16 Oct 2023 14:24:49 +0800
Subject: [PATCH 240/308] fix conv2d kernel

---
 .../CodeGen/CSourceCompiler.cs                |  2 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h | 29 +++++++++++--------
 modules/cpu/src/runtime/runtime_utils.h       |  2 ++
 3 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
index f3f30f5205..9df51c49d0 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
@@ -135,7 +135,7 @@ private string ArgumentsSpecific(string sourcePath, string outPath)
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
         {
             // return $"-c \"export PATH=/data/huochenghai/toolchain/riscv64-unknown-linux_gnu_12.0.1/bin:$PATH && cd {sourcePath} && mkdir -p build && cd build && rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=riscv64-unknown-linux-gnu-gcc -DCMAKE_CXX_COMPILER=riscv64-unknown-linux-gnu-g++ -DCMAKE_SYSTEM_PROCESSOR=riscv64 && cmake --build .\"";
-            return $"-c \"cd {sourcePath} && /bin/mkdir -p build && cd build && /bin/rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Debug && cmake --build .\"";
+            return $"-c \"cd {sourcePath} && /bin/mkdir -p build && cd build && /bin/rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Release && cmake --build .\"";
         }
         else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
         {
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 76ad1471cf..5991301b2b 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -124,8 +124,8 @@ T *im2col(tensor<T, InLoc> &input, dims_t filter, dims_t padding, dims_t stride,
     // todo: support dilated and group conv2d
     int32_t N = input.dimension()[0];
     int32_t C = input.dimension()[1];
-    int32_t H = input.dimension()[2] + padding[0] + padding[2];
-    int32_t W = input.dimension()[3] + padding[1] + padding[3];
+    int32_t H = input.dimension()[2] + padding[0] + padding[1];
+    int32_t W = input.dimension()[3] + padding[2] + padding[3];
 
     int32_t OH = (H - dilation[0] * (filter[0] - 1) - 1) / stride[0] + 1;
     int32_t OW = (W - dilation[1] * (filter[1] - 1) - 1) / stride[1] + 1;
@@ -140,17 +140,21 @@ T *im2col(tensor<T, InLoc> &input, dims_t filter, dims_t padding, dims_t stride,
                     for (auto s = 0; s < filter[1]; s++) {
                         auto row =
                             c * filter[0] * filter[1] + r * filter[0] + s;
+                        auto in_h = stride[0] * e + r * dilation[0];
+                        auto in_w = stride[1] * f + s * dilation[1];
                         for (auto b = 0; b < N; b++) {
                             auto col = e * OW * N + f * N + b;
                             auto out_index = row * (OH * OW * N) + col;
-                            auto in_index = b * input.strides()[0] +
-                                            c * input.strides()[1] +
-                                            (stride[0] * e + r * dilation[0]) *
-                                                input.strides()[2] +
-                                            (stride[1] * f + s * dilation[1]);
-                            if (row < padding[0] || col < padding[1]) {
+                            if (in_h < padding[0] || in_w < padding[2] ||
+                                in_h >= H - padding[1] ||
+                                in_w >= W - padding[3]) {
                                 cols[out_index] = 0;
                             } else {
+                                auto in_index =
+                                    b * input.strides()[0] +
+                                    c * input.strides()[1] +
+                                    (in_h - padding[0]) * input.strides()[2] +
+                                    (in_w - padding[2]);
                                 cols[out_index] =
                                     input.cdata().data()[in_index];
                             }
@@ -168,14 +172,14 @@ void conv2d(thread_context &ctx, tensor<T, InLoc> &input,
     // todo: support dilated and group conv2d
     size_t N = input.dimension()[0];
     size_t C = input.dimension()[1];
-    size_t H = input.dimension()[2] + padding[0] + padding[2];
-    size_t W = input.dimension()[3] + padding[1] + padding[3];
+    size_t H = input.dimension()[2] + padding[0] + padding[1];
+    size_t W = input.dimension()[3] + padding[2] + padding[3];
 
     size_t M = weight.dimension()[0];
     dims_t filter = {weight.dimension()[2], weight.dimension()[3]};
 
-    int32_t OH = (H - dilation[0] * (filter[0] - 1) - 1) / stride[0] + 1;
-    int32_t OW = (W - dilation[1] * (filter[1] - 1) - 1) / stride[1] + 1;
+    size_t OH = (H - dilation[0] * (filter[0] - 1) - 1) / stride[0] + 1;
+    size_t OW = (W - dilation[1] * (filter[1] - 1) - 1) / stride[1] + 1;
 
     auto input_cols =
         im2col<T, InLoc>(input, filter, padding, stride, dilation, groups);
@@ -188,6 +192,7 @@ void conv2d(thread_context &ctx, tensor<T, InLoc> &input,
         gsl::make_span(dims_t{OH * OW * N, 1}),
         gsl::make_span(dims_t{M, OH * OW * N}),
         gsl::make_span(dims_t{OH * OW * N, 1}));
+    delete[] input_cols;
 
     switch (strategy) {
     case reduce_strategy_t::by_thread:
diff --git a/modules/cpu/src/runtime/runtime_utils.h b/modules/cpu/src/runtime/runtime_utils.h
index 41e96ced88..a242dcc2f9 100644
--- a/modules/cpu/src/runtime/runtime_utils.h
+++ b/modules/cpu/src/runtime/runtime_utils.h
@@ -28,6 +28,8 @@ inline void join_thread(pthread_t &pt) { pthread_join(pt, NULL); }
 
 inline void rt_assert([[maybe_unused]] bool condition,
                       [[maybe_unused]] char *message) {
+    if (!condition)
+        printf("%s\n", message);
     assert(condition && message);
 }
 END_NS_NNCASE_RT_MODULE
\ No newline at end of file

From d75c2e64e1f25e7f846a9f54a0afc52fdb69dfc1 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 16 Oct 2023 14:30:16 +0800
Subject: [PATCH 241/308] fix boxing with reshape

---
 .../CodeGen/CSourceConvertVisitor.cs          | 36 ++++++++++++++++---
 1 file changed, 31 insertions(+), 5 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 82953593f7..36dab1b0cb 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -318,7 +318,8 @@ protected override CSymbol VisitCall(Call expr)
                                     IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
                                 }
 
-                                IndentScope.Writer.IndWrite($"layernorm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({layernorm.Epsilon}), {layernorm.Axis}, {layernorm.DistType.TensorType.Shape[layernorm.Axis]}, {(!layernorm.UseMean).ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)});\n"); break;
+                                IndentScope.Writer.IndWrite($"layernorm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({layernorm.Epsilon}), {layernorm.Axis}, {layernorm.DistType.TensorType.Shape[layernorm.Axis]}, {(!layernorm.UseMean).ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)});\n");
+                                break;
                             case 2:
                                 IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
                                 IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
@@ -475,7 +476,22 @@ protected override CSymbol VisitCall(Call expr)
 
                     if (reshard)
                     {
-                        IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}), {ret_name}_tmp{((TensorType)args[1].CheckedType).ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)});\n");
+                        var splitAxis = Enumerable.Range(0, grs.ReducePosition.Count).Select(i => grs.ReducePosition[i].SBP is SBPSplit { Axis: int axis } ? (axis, grs.Placement.Hierarchy[i]) : (0, 1)).ToArray();
+                        var inputShape = args[1].CheckedShape.ToValueArray();
+                        foreach (var sa in splitAxis)
+                        {
+                            inputShape[sa.Item1] *= sa.Item2;
+                        }
+
+                        if (Enumerable.SequenceEqual(inputShape, args[0].CheckedShape.ToValueArray()))
+                        {
+                            IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}), {ret_name}_tmp{((TensorType)args[1].CheckedType).ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)});\n");
+                        }
+                        else
+                        {
+                            IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> {ret_name}_tmp_view = view({ret_name}_tmp, {{{string.Join(",", inputShape)}}});\n");
+                            IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}),std::move({ret_name}_tmp_view{((TensorType)args[1].CheckedType).ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)}));\n");
+                        }
                     }
 
                     break;
@@ -496,13 +512,23 @@ protected override CSymbol VisitCall(Call expr)
                     IndentScope.Writer.Write($"reduce_arg({Visit(args[0]).Name}, {Visit(args[1]).Name}, {reduceArg.Axis}, {reduceArg.KeepDims.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, {reduceArg.SelectLastIndex.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, reduce_arg_op_t::{reduceArg.ReduceArgOp.ToC()})");
                     break;
                 case IR.XPU.Resize resize:
-                    IndentScope.Writer.Write($"float roi[{resize.Roi.Count}] = {{{string.Join(",", resize.Roi.Select(p => p.ToString()))}}};\n");
-                    IndentScope.Writer.Write($"int32_t new_size[{resize.NewSize.Count}] = {{{string.Join(",", resize.NewSize.Select(p => p.ToString()))}}};\n");
-                    IndentScope.Writer.Write($"resize({Visit(args[0]).Name}, {Visit(args[1]).Name}, roi, new_size, {resize.CubicCoeffA.ToString()}, {resize.ExcludeOutsideValue.ToString()}, {resize.ExtrapolationValue.ToString()}, image_resize_mode_t::{resize.ResizeMode.ToC()}, image_resize_transformation_mode_t::{resize.TransformationMode.ToC()}, image_resize_nearest_mode_t::{resize.NearestMode.ToC()}, {resize.IsTFResize.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
+                    using (_ = new IndentScope())
+                    {
+                        IndentScope.Writer.IndWrite($"{{\n");
+
+                        IndentScope.Writer.IndWrite($"float roi[{resize.Roi.Count}] = {{{string.Join(",", resize.Roi.Select(p => p.ToString()))}}};\n");
+                        IndentScope.Writer.IndWrite($"int32_t new_size[{resize.NewSize.Count}] = {{{string.Join(",", resize.NewSize.Select(p => p.ToString()))}}};\n");
+                        IndentScope.Writer.IndWrite($"resize({Visit(args[0]).Name}, {Visit(args[1]).Name}, roi, new_size, {resize.CubicCoeffA.ToString()}, {resize.ExcludeOutsideValue.ToString()}, {resize.ExtrapolationValue.ToString()}, image_resize_mode_t::{resize.ResizeMode.ToC()}, image_resize_transformation_mode_t::{resize.TransformationMode.ToC()}, image_resize_nearest_mode_t::{resize.NearestMode.ToC()}, {resize.IsTFResize.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)});\n");
+
+                        IndentScope.Writer.IndWrite("}\n");
+                    }
+
                     break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
             }
+
+            IndentScope.Writer.Write($";runtime_util->printf(\"%d\\n\", {count++})");
         }
         else
         {

From effa32e4e0ddf9b5a6930fe3fc03bfae9f38cd3d Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 16 Oct 2023 14:45:29 +0800
Subject: [PATCH 242/308] fix build

---
 modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs | 2 --
 src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs           | 4 ++--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 36dab1b0cb..9e25792836 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -527,8 +527,6 @@ protected override CSymbol VisitCall(Call expr)
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
             }
-
-            IndentScope.Writer.Write($";runtime_util->printf(\"%d\\n\", {count++})");
         }
         else
         {
diff --git a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
index 88bd52bc31..1697d3ce3a 100644
--- a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
@@ -118,7 +118,7 @@ public void TestInferMatmulProduct()
 #if DEBUG
         using (var f = Dumpper.OpenFile("types.txt"))
 #else
-        using (var f = new StreamWriter(MemoryStream.Null))
+        using (var f = MemoryStream.Null)
 #endif
         {
             using var wr = new StreamWriter(f);
@@ -156,7 +156,7 @@ public void TestInferGather()
 #if DEBUG
         using (var f = Dumpper.OpenFile("types.txt"))
 #else
-        using (var f = new StreamWriter(MemoryStream.Null))
+        using (var f = MemoryStream.Null)
 #endif
         {
             using var wr = new StreamWriter(f);

From 1d000dd6da0f92797897949b622d3fad9d7171bd Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 16 Oct 2023 17:37:21 +0800
Subject: [PATCH 243/308] fix pytest compare

---
 tests/test_runner.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_runner.py b/tests/test_runner.py
index 227d7f77c8..2207ffefda 100644
--- a/tests/test_runner.py
+++ b/tests/test_runner.py
@@ -278,7 +278,7 @@ def run(self, model_file: Union[List[str], str]):
                             if not judge:
                                 if test_utils.in_ci():
                                     self.clear(self.case_dir)
-                                assert f"Fault result in {stage} + {result}"
+                                assert (judge), f"Fault result in {stage} + {result}"
 
         if test_utils.in_ci():
             self.clear(self.case_dir)

From eda8f68d2b60a84a991fa0a1ce56c6a26f4556f0 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 16 Oct 2023 17:57:28 +0800
Subject: [PATCH 244/308] add gelu kernels

---
 modules/cpu/src/runtime/cmodel/include/runtime_types.h | 3 ++-
 modules/cpu/src/runtime/cmodel/include/unary.h         | 4 ++++
 modules/cpu/src/runtime/method_table_def.h             | 1 +
 modules/cpu/src/runtime/method_table_impl.h            | 1 +
 4 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_types.h b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
index d7895327e0..b9b8e02aec 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_types.h
+++ b/modules/cpu/src/runtime/cmodel/include/runtime_types.h
@@ -48,7 +48,8 @@ enum class unary_op_t : uint8_t {
     tanh = 19,
     bitwise_not = 20,
     logical_not = 21,
-    swish = 22
+    swish = 22,
+    gelu = 23
 };
 
 enum class binary_op_t : uint8_t {
diff --git a/modules/cpu/src/runtime/cmodel/include/unary.h b/modules/cpu/src/runtime/cmodel/include/unary.h
index 67072f4372..fc883077f3 100644
--- a/modules/cpu/src/runtime/cmodel/include/unary.h
+++ b/modules/cpu/src/runtime/cmodel/include/unary.h
@@ -68,6 +68,10 @@ void unary_impl(unary_op_t op, const T *input, T *output,
             UNARY_IMPL_OP(swish, [](float x) {
                 return x / (1 + nncase_mt->float_unary_exp(-x));
             });
+            UNARY_IMPL_OP(gelu, [](float x) {
+                return 0.5f * (x) *
+                               (1.f + nncase_mt->float_unary_erf( x / nncase_mt->float_unary_sqrt(2.f)));
+            });
         default:
             runtime_util->rt_assert(false, (char *)"Unsupported Unary Op!");
         }
diff --git a/modules/cpu/src/runtime/method_table_def.h b/modules/cpu/src/runtime/method_table_def.h
index 207352b638..e7d4030b61 100644
--- a/modules/cpu/src/runtime/method_table_def.h
+++ b/modules/cpu/src/runtime/method_table_def.h
@@ -28,6 +28,7 @@ typedef struct nncase_method_table {
     float (*float_unary_sqrt)(float);
     float (*float_unary_square)(float);
     float (*float_unary_tanh)(float);
+    float (*float_unary_erf)(float);
     // float bianry
     float (*float_binary_add)(float, float);
     float (*float_binary_sub)(float, float);
diff --git a/modules/cpu/src/runtime/method_table_impl.h b/modules/cpu/src/runtime/method_table_impl.h
index 68e1db09a8..1f42976b2d 100644
--- a/modules/cpu/src/runtime/method_table_impl.h
+++ b/modules/cpu/src/runtime/method_table_impl.h
@@ -129,6 +129,7 @@ matmul_unit_impl([[maybe_unused]] const float *input_a,
     sqrtf,
     float_unary_square,
     tanhf,
+    erff,
     float_binary_add,
     float_binary_sub,
     float_binary_mul,

From 41afedf1cafcdae809d870f3e94a0903706df7ad Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 16 Oct 2023 19:49:23 +0800
Subject: [PATCH 245/308] add xpu cast

---
 .../CodeGen/CSourceConvertVisitor.cs          |  3 ++
 .../Nncase.Modules.CPU/Evaluator/XPU/Cast.cs  | 12 +++++
 .../Evaluator/XPU/XPUModule.cs                |  1 +
 modules/Nncase.Modules.CPU/IR/XPU/Cast.cs     | 18 +++++++
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  5 ++
 .../Passes/Tile/TIRConvertVisitor.cs          |  8 +++
 modules/cpu/src/runtime/cmodel/include/cast.h | 49 +++++++++++++++++++
 modules/cpu/src/runtime/cmodel/include/tdma.h | 10 ++++
 src/Nncase.Core/IR/Tensors/Cast.cs            |  2 +-
 src/Nncase.Evaluator/Tensors/Cast.cs          | 30 ++++++++++--
 .../Targets/UnitTestCPUTargetTiling.cs        | 36 +++++++++++++-
 11 files changed, 168 insertions(+), 6 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Cast.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Cast.cs
 create mode 100644 modules/cpu/src/runtime/cmodel/include/cast.h

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 9e25792836..51fa1cebec 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -523,6 +523,9 @@ protected override CSymbol VisitCall(Call expr)
                         IndentScope.Writer.IndWrite("}\n");
                     }
 
+                    break;
+                case IR.XPU.Cast cast:
+                    IndentScope.Writer.Write($"cast({Visit(args[0]).Name}, {Visit(args[1]).Name})");
                     break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Cast.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Cast.cs
new file mode 100644
index 0000000000..3280ea0857
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Cast.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class CastEvaluator : ITypeInferencer<Cast>
+{
+    public IRType Visit(ITypeInferenceContext context, Cast target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index a9eaf2cd38..89e425b50e 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -33,5 +33,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<Conv2DEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<ReduceArgEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<ResizeEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<CastEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Cast.cs b/modules/Nncase.Modules.CPU/IR/XPU/Cast.cs
new file mode 100644
index 0000000000..ca9e3658c7
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Cast.cs
@@ -0,0 +1,18 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Cast : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(Cast), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(Cast), 1, "output");
+
+    public DataType NewType { get; }
+
+    public CastMode CastMode { get; }
+
+    /// <inheritdoc/>
+    public override string DisplayProperty() => $"{NewType.GetCSharpName()}, CastMode.{CastMode}";
+}
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index efa260ab73..4a97a99c51 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -96,4 +96,9 @@ public static Call Resize(Expr input, Expr output, float[] roi, int[] newSize, f
     {
         return new Call(new Resize(roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, resizeMode, transformationMode, nearestMode, isTFResize), input, output);
     }
+
+    public static Call Cast(Expr input, Expr output, DataType dataType, CastMode castMode)
+    {
+        return new Call(new Cast(dataType, castMode), input, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 1eebf4d5b0..b5aa9fe9d6 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -95,6 +95,9 @@ protected override Unit VisitLeafCall(Call expr)
                 float extrapolationValue = expr.Arguments[5] is TensorConst tc3 ? tc3.Value.ToScalar<float>() : 0f;
                 GenerateResize(resize, arguments, ret, roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, (DistributedType)expr.CheckedType);
                 break;
+            case Cast cast:
+                GenerateCast(cast.NewType, cast.CastMode, arguments, ret);
+                break;
             default:
                 throw new NotSupportedException();
         }
@@ -214,6 +217,11 @@ private void GenerateResize(ResizeImage resize, Buffer[] arguments, Buffer ret,
         _mainBody.Add(IR.F.XPU.Resize(arguments[0], ret, roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, resize.ResizeMode, resize.TransformationMode, resize.NearestMode, resize.IsTFResize));
     }
 
+    private void GenerateCast(DataType dataType, CastMode castMode, ReadOnlySpan<Buffer> arguments, Buffer ret)
+    {
+        _mainBody.Add(IR.F.XPU.Cast(arguments[0], ret, dataType, castMode));
+    }
+
 #if false
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
diff --git a/modules/cpu/src/runtime/cmodel/include/cast.h b/modules/cpu/src/runtime/cmodel/include/cast.h
new file mode 100644
index 0000000000..e2abd7a983
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/cast.h
@@ -0,0 +1,49 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "../../gsl-lite.hpp"
+#include <apply.h>
+#include <runtime_utils.h>
+
+using namespace nncase::runtime::cpu;
+namespace kernels {
+namespace {
+template <class TInput, class TOutput>
+void cast_impl(const TInput *input, TOutput *output,
+               gsl::span<const size_t> in_shape,
+               gsl::span<const size_t> in_strides,
+               gsl::span<const size_t> out_strides) noexcept {
+    if (is_scalar(in_shape)) {
+        output[0] = static_cast<TOutput>(input[0]);
+        return;
+    }
+    return apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        auto value = input[offset(in_strides, index)];
+        output[offset(out_strides, index)] = static_cast<TOutput>(value);
+        return;
+    });
+}
+} // namespace
+
+template <class TI, class TO>
+void cast(const TI *input, TO *output, gsl::span<const size_t> in_shape,
+          gsl::span<const size_t> in_strides,
+          gsl::span<const size_t> out_strides) {
+    // TODO: support other cast mode
+    // TODO: support float32->bfloat16 or float32->float16
+    cast_impl(input, output, in_shape, in_strides, out_strides);
+    return;
+}
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index 5991301b2b..ae95de6e82 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -4,6 +4,7 @@
 #include <binary.h>
 #include <cassert>
 #include <concat.h>
+#include "cast.h"
 #include <functional>
 #include <gather.h>
 #include <hardware_context.h>
@@ -807,4 +808,13 @@ void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest, int axis,
                         dest.dimension(), dest.strides(), tmp_sum.dimension(),
                         tmp_sum.strides(), dest.dimension(), dest.strides());
     }
+}
+
+template <class TI, class TO, loc_t ALoc, loc_t BLoc>
+void cast(tensor<TI, ALoc> &in, tensor<TO, BLoc> &out) {
+    kernels::cast(
+        in.cdata().data(), out.data().data(),
+        gsl::make_span(in.dimension()).template as_span<const size_t>(),
+        gsl::make_span(in.strides()).template as_span<const size_t>(),
+        gsl::make_span(out.strides()).template as_span<const size_t>());
 }
\ No newline at end of file
diff --git a/src/Nncase.Core/IR/Tensors/Cast.cs b/src/Nncase.Core/IR/Tensors/Cast.cs
index 5345cac153..1bc618f786 100644
--- a/src/Nncase.Core/IR/Tensors/Cast.cs
+++ b/src/Nncase.Core/IR/Tensors/Cast.cs
@@ -20,7 +20,7 @@ public sealed partial class Cast : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Cast), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Cast), 0, "input", ParameterKind.Input);
 
     public DataType NewType { get; }
 
diff --git a/src/Nncase.Evaluator/Tensors/Cast.cs b/src/Nncase.Evaluator/Tensors/Cast.cs
index c7e285d060..6f32939c3c 100644
--- a/src/Nncase.Evaluator/Tensors/Cast.cs
+++ b/src/Nncase.Evaluator/Tensors/Cast.cs
@@ -24,8 +24,13 @@ public IValue Visit(IEvaluateContext context, Cast cast)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Cast target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Cast.Input);
-        return Visit(target, input);
+        var input = context.CheckArgumentType<IRType>(target, Cast.Input);
+        return input switch
+        {
+            TensorType t => Visit(target, t),
+            DistributedType d => Visit(target, d),
+            _ => new InvalidType(input.GetType().ToString()),
+        };
     }
 
     /// <inheritdoc/>
@@ -37,10 +42,10 @@ public string Visit(IIRPrinterContext context, Cast target, bool iLmode)
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Cast target)
     {
-        var input = context.GetArgumentType<TensorType>(target, Cast.Input);
+        var input = context.GetArgumentType<IRType>(target, Cast.Input);
         return new()
         {
-            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(input.DType),
+            [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(input),
             [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(target.NewType),
             [CostFactorNames.CPUCycles] = CostUtility.GetCPUCycles(target.NewType, 1),
         };
@@ -61,4 +66,21 @@ private IRType Visit(Cast target, TensorType input)
     {
         return new TensorType(target.NewType, input.Shape);
     }
+
+    private IRType Visit(Cast target, DistributedType inType)
+    {
+        var invalid = new InvalidType(inType.ToString());
+        var ndsbp = new SBP[inType.Placement.Rank];
+        for (int i = 0; i < inType.Placement.Rank; i++)
+        {
+            if (inType.NdSBP[i] is SBPPartialSum)
+            {
+                return invalid;
+            }
+
+            ndsbp[i] = inType.NdSBP[i];
+        }
+
+        return new DistributedType(new TensorType(target.NewType, inType.TensorType.Shape), ndsbp, inType.Placement);
+    }
 }
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 8014c97462..be32239812 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -54,7 +54,8 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseReduceArg2))]
     // [ClassData(typeof(TilingCaseInstanceNorm))]
     // [ClassData(typeof(TilingCaseEncoderTail))]
-    [ClassData(typeof(TilingCaseResize))]
+    // [ClassData(typeof(TilingCaseResize))]
+    [ClassData(typeof(TilingCaseCast))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -716,3 +717,36 @@ public TilingCaseResize()
         Add(main, new[] { input_tensor, output });
     }
 }
+
+internal sealed class TilingCaseCast : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseCast()
+    {
+        var shape = new[] { 1, 2 };
+        var input = new Var("input", new TensorType(DataTypes.Int64, shape));
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Int64, shape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Cast(DataTypes.Float32, CastMode.KDefault)), fin);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("cast", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Uniform(DataTypes.Int64, 100, 1, 2, shape).Evaluate().AsTensor();
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
+        {
+            fs.Write(input_tensor.BytesBuffer);
+        }
+
+        var feedDict = new Dictionary<Var, IValue>
+            {
+                { fin, Value.FromTensor(input_tensor) },
+            };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}

From e0c45043752f5ccf535b16b169216d2c42d571b6 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 17 Oct 2023 12:13:57 +0800
Subject: [PATCH 246/308] fix swish type infer

---
 src/Nncase.Evaluator/NN/Activations.cs | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/Nncase.Evaluator/NN/Activations.cs b/src/Nncase.Evaluator/NN/Activations.cs
index 2712d960d4..aef4860dbd 100644
--- a/src/Nncase.Evaluator/NN/Activations.cs
+++ b/src/Nncase.Evaluator/NN/Activations.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
+using System.Linq;
 using Nncase.CostModel;
 using Nncase.IR;
 using Nncase.IR.NN;
@@ -561,6 +562,11 @@ public Metric Visit(IMetricEvaluateContext context, Swish target)
 
     private IRType Visit(IRType input)
     {
+        if (input is DistributedType d && d.NdSBP.Any(s => s is SBPPartialSum))
+        {
+            return new InvalidType("swish with partial sum is not supported");
+        }
+
         return input;
     }
 }
@@ -583,14 +589,14 @@ public IValue Visit(IEvaluateContext context, Gelu gelu)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Gelu target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Gelu.Input);
+        var input = context.CheckArgumentType<IRType>(target, Gelu.Input);
         return Visit(input);
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Gelu target)
     {
-        var outputType = context.GetReturnType<TensorType>();
+        var outputType = context.GetReturnType<IRType>();
         return new()
         {
             [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(outputType),
@@ -611,8 +617,13 @@ public Metric Visit(IMetricEvaluateContext context, Gelu target)
 
     public Expr Visit(IShapeEvaluateContext context, Gelu target) => context.GetArgumentShape(target, Gelu.Input);
 
-    private IRType Visit(TensorType input)
+    private IRType Visit(IRType input)
     {
+        if (input is DistributedType d && d.NdSBP.Any(s => s is SBPPartialSum))
+        {
+            return new InvalidType("gelu with partial sum is not supported");
+        }
+
         return input;
     }
 }

From b3f76d65a122853b4cd9384d333ffbce002b5ff5 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 17 Oct 2023 14:14:33 +0800
Subject: [PATCH 247/308] support xpu expand

---
 .../CodeGen/CSourceConvertVisitor.cs          |  3 ++
 .../Evaluator/XPU/Expand.cs                   | 12 +++++
 .../Evaluator/XPU/XPUModule.cs                |  1 +
 modules/Nncase.Modules.CPU/IR/XPU/Expand.cs   | 15 ++++++
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  5 ++
 .../Passes/Tile/TIRConvertVisitor.cs          |  8 ++++
 .../cpu/src/runtime/cmodel/include/expand.h   | 46 +++++++++++++++++++
 modules/cpu/src/runtime/cmodel/include/tdma.h | 15 +++++-
 src/Nncase.Core/CostModel/Cost.cs             |  2 +-
 src/Nncase.Core/IR/Tensors/Expand.cs          |  2 +-
 src/Nncase.Evaluator/Tensors/Expand.cs        | 40 +++++++++++++++-
 .../Targets/UnitTestCPUTargetTiling.cs        | 37 ++++++++++++++-
 12 files changed, 179 insertions(+), 7 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Expand.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Expand.cs
 create mode 100644 modules/cpu/src/runtime/cmodel/include/expand.h

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 51fa1cebec..3beccf98ca 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -527,6 +527,9 @@ protected override CSymbol VisitCall(Call expr)
                 case IR.XPU.Cast cast:
                     IndentScope.Writer.Write($"cast({Visit(args[0]).Name}, {Visit(args[1]).Name})");
                     break;
+                case IR.XPU.Expand expand:
+                    IndentScope.Writer.Write($"expand({Visit(args[0]).Name}, {Visit(args[1]).Name})");
+                    break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
             }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Expand.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Expand.cs
new file mode 100644
index 0000000000..79286ba8c1
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Expand.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class ExpandEvaluator : ITypeInferencer<Expand>
+{
+    public IRType Visit(ITypeInferenceContext context, Expand target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 89e425b50e..b33311202a 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -34,5 +34,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<ReduceArgEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<ResizeEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<CastEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<ExpandEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Expand.cs b/modules/Nncase.Modules.CPU/IR/XPU/Expand.cs
new file mode 100644
index 0000000000..3866fe78d1
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Expand.cs
@@ -0,0 +1,15 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Expand : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(Expand), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(Expand), 1, "output");
+
+    public IRArray<int> Shape { get; }
+
+    public IRArray<SBP> NdSbp { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 4a97a99c51..4d5aa448bf 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -101,4 +101,9 @@ public static Call Cast(Expr input, Expr output, DataType dataType, CastMode cas
     {
         return new Call(new Cast(dataType, castMode), input, output);
     }
+
+    public static Call Expand(int[] shape, DistributedType distributedType, Expr input, Expr output)
+    {
+        return new Call(new Expand(shape, distributedType.NdSBP), input, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index b5aa9fe9d6..4f5bc239c5 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -98,6 +98,9 @@ protected override Unit VisitLeafCall(Call expr)
             case Cast cast:
                 GenerateCast(cast.NewType, cast.CastMode, arguments, ret);
                 break;
+            case Expand expand:
+                GenerateExpand(((TensorConst)expr.Arguments[1]).Value.ToArray<int>(), (DistributedType)expr.CheckedType, arguments, ret);
+                break;
             default:
                 throw new NotSupportedException();
         }
@@ -222,6 +225,11 @@ private void GenerateCast(DataType dataType, CastMode castMode, ReadOnlySpan<Buf
         _mainBody.Add(IR.F.XPU.Cast(arguments[0], ret, dataType, castMode));
     }
 
+    private void GenerateExpand(int[] shape, DistributedType distributedType, ReadOnlySpan<Buffer> arguments, Buffer ret)
+    {
+        _mainBody.Add(IR.F.XPU.Expand(shape, distributedType, arguments[0], ret));
+    }
+
 #if false
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
diff --git a/modules/cpu/src/runtime/cmodel/include/expand.h b/modules/cpu/src/runtime/cmodel/include/expand.h
new file mode 100644
index 0000000000..2e932be748
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/expand.h
@@ -0,0 +1,46 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "../../gsl-lite.hpp"
+#include <apply.h>
+#include <runtime_utils.h>
+
+using namespace nncase::runtime::cpu;
+namespace kernels {
+namespace {
+template <class T>
+void expand_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
+                 gsl::span<const size_t> input_strides,
+                 gsl::span<const size_t> out_shape,
+                 gsl::span<const size_t> out_strides) noexcept {
+    return apply(out_shape, [&](gsl::span<const size_t> index) -> void {
+        const auto in_index = get_reduced_offset(index, in_shape);
+        output[offset(out_strides, index)] =
+            input[offset(input_strides, in_index)];
+        return;
+    });
+}
+} // namespace
+
+template <class T>
+void expand(const T *input, T *output, gsl::span<const size_t> input_shape,
+            gsl::span<const size_t> input_strides,
+            gsl::span<const size_t> out_shape,
+            gsl::span<const size_t> out_strides) {
+    expand_impl(input, output, input_shape, input_strides, out_shape,
+                out_strides);
+    return;
+}
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index ae95de6e82..364c596f1e 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -1,10 +1,11 @@
 #pragma once
+#include "cast.h"
 #include "runtime_utils.h"
 #include <apply.h>
 #include <binary.h>
 #include <cassert>
 #include <concat.h>
-#include "cast.h"
+#include <expand.h>
 #include <functional>
 #include <gather.h>
 #include <hardware_context.h>
@@ -817,4 +818,14 @@ void cast(tensor<TI, ALoc> &in, tensor<TO, BLoc> &out) {
         gsl::make_span(in.dimension()).template as_span<const size_t>(),
         gsl::make_span(in.strides()).template as_span<const size_t>(),
         gsl::make_span(out.strides()).template as_span<const size_t>());
-}
\ No newline at end of file
+}
+
+template <class T, loc_t ALoc, loc_t BLoc>
+void expand(tensor<T, ALoc> &in, tensor<T, BLoc> &out) {
+    kernels::expand(
+        in.cdata().data(), out.data().data(),
+        gsl::make_span(in.dimension()).template as_span<const size_t>(),
+        gsl::make_span(in.strides()).template as_span<const size_t>(),
+        gsl::make_span(out.dimension()).template as_span<const size_t>(),
+        gsl::make_span(out.strides()).template as_span<const size_t>());
+}
diff --git a/src/Nncase.Core/CostModel/Cost.cs b/src/Nncase.Core/CostModel/Cost.cs
index e1835ad33a..e60414a613 100644
--- a/src/Nncase.Core/CostModel/Cost.cs
+++ b/src/Nncase.Core/CostModel/Cost.cs
@@ -330,7 +330,7 @@ public static Cost GetActivationCost(TensorType ret, uint macPerElement)
     }
 
     // cost for op similar to broadcast
-    public static Cost GetBroadcastCost(TensorType input, TensorType ret)
+    public static Cost GetBroadcastCost(IRType input, IRType ret)
     {
         return new()
         {
diff --git a/src/Nncase.Core/IR/Tensors/Expand.cs b/src/Nncase.Core/IR/Tensors/Expand.cs
index 3b74de6740..91a0d53e26 100644
--- a/src/Nncase.Core/IR/Tensors/Expand.cs
+++ b/src/Nncase.Core/IR/Tensors/Expand.cs
@@ -21,7 +21,7 @@ public sealed partial class Expand : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Expand), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Expand), 0, "input", ParameterKind.Input);
 
     /// <summary>
     /// Gets shape.
diff --git a/src/Nncase.Evaluator/Tensors/Expand.cs b/src/Nncase.Evaluator/Tensors/Expand.cs
index cea0603bfd..e06241f90c 100644
--- a/src/Nncase.Evaluator/Tensors/Expand.cs
+++ b/src/Nncase.Evaluator/Tensors/Expand.cs
@@ -30,8 +30,8 @@ public IValue Visit(IEvaluateContext context, Expand expand)
 
     public Cost Visit(ICostEvaluateContext context, Expand target)
     {
-        var input = context.GetArgumentType<TensorType>(target, Expand.Input);
-        var ret = context.GetReturnType<TensorType>();
+        var input = context.GetArgumentType<IRType>(target, Expand.Input);
+        var ret = context.GetReturnType<IRType>();
 
         return CostUtility.GetBroadcastCost(input, ret);
     }
@@ -53,6 +53,18 @@ public Metric Visit(IMetricEvaluateContext context, Expand target)
         };
     }
 
+    public IRType Visit(ITypeInferenceContext context, Expand target)
+    {
+        var input = context.CheckArgumentType<IRType>(target, Expand.Input);
+        var shape = context.CheckArgumentType<TensorType>(target, Expand.Shape);
+        return input switch
+        {
+            TensorType t => Visit(context, target, t, shape),
+            DistributedType d => Visit(context, target, d, shape),
+            _ => new InvalidType(input.GetType().ToString()),
+        };
+    }
+
     private IRType Visit(ITypeInferenceContext context, Expand target, TensorType input, TensorType shape)
     {
         var shape_expr = context.GetArgument(target, Expand.Shape);
@@ -65,4 +77,28 @@ private IRType Visit(ITypeInferenceContext context, Expand target, TensorType in
             return input with { Shape = TypeInference.ReshapeTo(shape) };
         }
     }
+
+    private IRType Visit(ITypeInferenceContext context, Expand target, DistributedType input, TensorType shape)
+    {
+        var invalid = new InvalidType(input.ToString());
+        var shape_expr = context.GetArgument(target, Expand.Shape);
+        if (shape_expr is TensorConst constShape)
+        {
+            var newShape = constShape.Value.ToArray<int>();
+            var ndsbp = new SBP[input.Placement.Rank];
+            for (int i = 0; i < input.Placement.Rank; i++)
+            {
+                if (input.NdSBP[i] is SBPSplit sbp && newShape[sbp.Axis] != input.TensorType.Shape[sbp.Axis])
+                {
+                    return invalid;
+                }
+
+                ndsbp[i] = input.NdSBP[i];
+            }
+
+            return new DistributedType(new TensorType(input.TensorType.DType, new Shape(newShape)), ndsbp, input.Placement);
+        }
+
+        return invalid;
+    }
 }
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index be32239812..44e8937220 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -55,7 +55,8 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseInstanceNorm))]
     // [ClassData(typeof(TilingCaseEncoderTail))]
     // [ClassData(typeof(TilingCaseResize))]
-    [ClassData(typeof(TilingCaseCast))]
+    // [ClassData(typeof(TilingCaseCast))]
+    [ClassData(typeof(TilingCaseExpand))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -750,3 +751,37 @@ public TilingCaseCast()
         Add(main, new[] { input_tensor, output });
     }
 }
+
+internal sealed class TilingCaseExpand : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseExpand()
+    {
+        var shape = new[] { 1, 32, 1 };
+        var input = new Var("input", new TensorType(DataTypes.Int64, shape));
+        var newShape = new[] { 2, 32, 32 };
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Int64, shape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Expand()), fin, newShape);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("expand", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Uniform(DataTypes.Int64, 100, 1, 2, shape).Evaluate().AsTensor();
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
+        {
+            fs.Write(input_tensor.BytesBuffer);
+        }
+
+        var feedDict = new Dictionary<Var, IValue>
+            {
+                { fin, Value.FromTensor(input_tensor) },
+            };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}

From e4f43425b6e5b16fa48c0389ad469d0707db9722 Mon Sep 17 00:00:00 2001
From: liuzhiming <liuzhiming@canaan-creative.com>
Date: Tue, 17 Oct 2023 08:58:09 +0000
Subject: [PATCH 248/308] Update layernorm rvv codes

---
 .../src/runtime/cmodel/include/layernorm.h    | 20 +++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/cpu/src/runtime/cmodel/include/layernorm.h
index 48ad9c408b..2595057923 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/cpu/src/runtime/cmodel/include/layernorm.h
@@ -87,7 +87,7 @@ static int get_offset_from_index(gsl::span<const size_t> in_shape,
 }
 
 template <typename T>
-void layernorm_naive_impl(
+void layernorm_rvv_impl(
     const T *input, const T *sum, const T *sum_sqr, T *output, const T *gamma,
     const T *beta, gsl::span<const size_t> input_shape,
     gsl::span<const size_t> input_stride, gsl::span<const size_t> output_stride,
@@ -186,12 +186,20 @@ void layernorm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
                strides_t gamma_strides, T eps, int32_t axis, int32_t norm_size,
                bool rms_norm = false) {
     // fafdaf
-#ifdef __riscv_vector_
-    return layernorm_rvv_impl(
-        input, sum, sum_sqr, gamma, beta,
+#ifdef __riscv_vector
+    // return layernorm_rvv_impl(
+    //     input, sum, sum_sqr, gamma, beta,
+    //     gsl::make_span(input_dims).template as_span<const size_t>(),
+    //     gsl::make_span(input_strides).template as_span<const size_t>(), eps,
+    //     axis, norm_size);
+        return layernorm_rvv_impl(
+        input, sum, sum_sqr, output, gamma, beta,
         gsl::make_span(input_dims).template as_span<const size_t>(),
-        gsl::make_span(input_strides).template as_span<const size_t>(), eps,
-        axis, norm_size);
+        gsl::make_span(input_strides).template as_span<const size_t>(),
+        gsl::make_span(output_strides).template as_span<const size_t>(),
+        gsl::make_span(sum_strides).template as_span<const size_t>(),
+        gsl::make_span(gamma_strides).template as_span<const size_t>(), eps,
+        axis, norm_size, rms_norm);
 #else
     return layernorm_naive_impl(
         input, sum, sum_sqr, output, gamma, beta,

From 7daebdb6822eda7a322b9dfddf9602e7d0c7d33f Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Wed, 18 Oct 2023 12:10:33 +0800
Subject: [PATCH 249/308] fix binary broadcast with distributed broadcast

---
 .../CodeGen/CSourceConvertVisitor.cs          |  75 ++++++++-
 .../CodeGen/CSourceExtensions.cs              |   8 +-
 .../Evaluator/CPU/Boxing.cs                   |   7 +-
 .../Evaluator/XPU/SwishB.cs                   |  18 +++
 .../Evaluator/XPU/XPUModule.cs                |   1 +
 .../Nncase.Modules.CPU/IR/CPU/Functional.cs   |   5 -
 modules/Nncase.Modules.CPU/IR/XPU/Binary.cs   |   6 +
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |   9 +-
 modules/Nncase.Modules.CPU/IR/XPU/SwishB.cs   |  13 ++
 .../Passes/Tile/TIRConvertVisitor.cs          |  16 +-
 modules/cpu/src/runtime/cmodel/include/tdma.h |  11 +-
 .../cpu/src/runtime/cmodel/include/unary.h    |  13 +-
 .../Distributed/UnitTestKernels.cs            | 138 +++++++++++++++++
 .../Targets/UnitTestCPUTargetTiling.cs        | 144 +++++++++++++++++-
 14 files changed, 436 insertions(+), 28 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/SwishB.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/SwishB.cs
 create mode 100644 src/Nncase.Tests/Distributed/UnitTestKernels.cs

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 51fa1cebec..5b445e3702 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -252,11 +252,11 @@ protected override CSymbol VisitCall(Call expr)
                             fullShape[s.Item1] *= s.Item2;
                         }
 
-                        IndentScope.Writer.Write($"tdma_boxing_load_sync({Visit(args[0]).Name}, {{{string.Join(',', fullShape)}}}, {tensorType.ToSlicing(load.NdSbp, load.Placement)[1..^1]}, ctx)");
+                        IndentScope.Writer.Write($"tdma_boxing_load_sync({Visit(args[0]).Name}, {{{string.Join(',', fullShape)}}}, {tensorType.Shape.ToSlicing(load.NdSbp, load.Placement)[1..^1]}, ctx)");
                     }
                     else
                     {
-                        IndentScope.Writer.Write($"tdma_load_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{((TensorType)args[0].CheckedType).ToSlicing(load.NdSbp, load.Placement)})");
+                        IndentScope.Writer.Write($"tdma_load_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{args[0].CheckedShape.ToSlicing(load.NdSbp, load.Placement)})");
                     }
 
                     break;
@@ -271,19 +271,80 @@ protected override CSymbol VisitCall(Call expr)
                             fullShape[s.Item1] *= s.Item2;
                         }
 
-                        IndentScope.Writer.Write($"tdma_boxing_store_sync({Visit(args[0]).Name}, {{{string.Join(',', fullShape)}}}, {tensorType.ToSlicing(store.NdSbp, store.Placement)[1..^1]}, ctx)");
+                        IndentScope.Writer.Write($"tdma_boxing_store_sync({Visit(args[0]).Name}, {{{string.Join(',', fullShape)}}}, {tensorType.Shape.ToSlicing(store.NdSbp, store.Placement)[1..^1]}, ctx)");
                     }
                     else
                     {
-                        IndentScope.Writer.Write($"tdma_store_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{((TensorType)args[0].CheckedType).ToSlicing(store.NdSbp, store.Placement)})");
+                        IndentScope.Writer.Write($"tdma_store_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{args[0].CheckedShape.ToSlicing(store.NdSbp, store.Placement)})");
                     }
 
                     break;
                 case IR.XPU.Unary unary:
                     IndentScope.Writer.Write($"unary({Visit(args[0]).Name}, {Visit(args[1]).Name}, unary_op_t::{unary.UnaryOp})");
                     break;
+                case IR.XPU.SwishB swishb:
+                    IndentScope.Writer.Write($"swishb({Visit(args[0]).Name}, {Visit(args[1]).Name}, {swishb.Beta})");
+                    break;
                 case IR.XPU.Binary binary:
-                    IndentScope.Writer.Write($"binary({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, binary_op_t::{binary.BinaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
+                    {
+                        var ltype = (TensorType)args[0].CheckedType;
+                        var rtype = (TensorType)args[1].CheckedType;
+                        var outtype = (TensorType)args[2].CheckedType;
+                        var lshape = ltype.Shape;
+                        var rshape = rtype.Shape;
+                        var outshape = outtype.Shape;
+                        var lpad = outtype.Shape.Rank - lshape.Rank;
+                        var rpad = outtype.Shape.Rank - rshape.Rank;
+                        var lsbp = Enumerable.Repeat<SBP>(SBP.B, binary.LhsType.Placement.Rank).ToArray();
+                        var rsbp = Enumerable.Repeat<SBP>(SBP.B, binary.RhsType.Placement.Rank).ToArray();
+
+                        var lnewShape = ltype.Shape.ToValueArray();
+                        var rnewShape = rtype.Shape.ToValueArray();
+                        for (int i = 0; i < binary.RhsType.Placement.Rank; i++)
+                        {
+                            switch (binary.LhsType.NdSBP[i], binary.RhsType.NdSBP[i])
+                            {
+                                case (SBPSplit s, SBPBroadCast):
+                                    var baxis = s.Axis - lshape.Rank + rshape.Rank;
+                                    if (outshape[s.Axis + lpad] == lshape[s.Axis] && baxis < rshape.Rank && baxis >= 0 && lshape[s.Axis] != rshape[baxis] && rshape[baxis] != 1)
+                                    {
+                                        rsbp[i] = SBP.S(baxis);
+                                        rnewShape[baxis] /= binary.RhsType.Placement.Hierarchy[i];
+                                    }
+
+                                    break;
+                                case (SBPBroadCast, SBPSplit s):
+                                    var aaxis = s.Axis - rshape.Rank + lshape.Rank;
+                                    if (outshape[s.Axis + rpad] == rshape[s.Axis] && aaxis < lshape.Rank && aaxis >= 0 && rshape[s.Axis] != lshape[aaxis] && lshape[aaxis] != 1)
+                                    {
+                                        lsbp[i] = SBP.S(aaxis);
+                                        lnewShape[aaxis] /= binary.RhsType.Placement.Hierarchy[i];
+                                    }
+
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+
+                        string lhsStr = Visit(args[0]).Name;
+                        string rhsStr = Visit(args[1]).Name;
+                        if (lsbp.Any(s => s is SBPSplit))
+                        {
+                            var slice = new Shape(lnewShape).ToSlicing(lsbp, binary.LhsType.Placement);
+                            IndentScope.Writer.Write($"auto {lhsStr}_ = {lhsStr}{slice};\n");
+                            lhsStr += "_";
+                        }
+
+                        if (rsbp.Any(s => s is SBPSplit))
+                        {
+                            var slice = new Shape(rnewShape).ToSlicing(rsbp, binary.RhsType.Placement);
+                            IndentScope.Writer.Write($"auto {rhsStr}_ = {rhsStr}{slice};\n");
+                            rhsStr += "_";
+                        }
+
+                        IndentScope.Writer.Write($"binary({lhsStr}, {rhsStr}, {Visit(args[2]).Name}, binary_op_t::{binary.BinaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
+                    }
                     break;
                 case IR.XPU.Matmul matmul:
                     IndentScope.Writer.Write($"matmul({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name})");
@@ -485,12 +546,12 @@ protected override CSymbol VisitCall(Call expr)
 
                         if (Enumerable.SequenceEqual(inputShape, args[0].CheckedShape.ToValueArray()))
                         {
-                            IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}), {ret_name}_tmp{((TensorType)args[1].CheckedType).ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)});\n");
+                            IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}), {ret_name}_tmp{(args[1].CheckedShape).ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)});\n");
                         }
                         else
                         {
                             IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> {ret_name}_tmp_view = view({ret_name}_tmp, {{{string.Join(",", inputShape)}}});\n");
-                            IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}),std::move({ret_name}_tmp_view{((TensorType)args[1].CheckedType).ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)}));\n");
+                            IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}),std::move({ret_name}_tmp_view{args[1].CheckedShape.ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)}));\n");
                         }
                     }
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
index 5e0065dbf1..b4b503aba2 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
@@ -77,7 +77,7 @@ public static string ToC(this PrimType primType) =>
         _ => throw new NotImplementedException(),
     };
 
-    public static string ToSlicing(this TensorType tensorType, string[] begins, IRArray<SBP> ndsbp, Placement placement)
+    public static string ToSlicing(this Shape shape, string[] begins, IRArray<SBP> ndsbp, Placement placement)
     {
         var hstrides = TensorUtilities.GetStrides(placement.Hierarchy.ToArray());
         var splits = Enumerable.Range(0, begins.Length).Select(_ => new List<(int H, SBPSplit S)>()).ToArray();
@@ -99,14 +99,14 @@ public static string ToSlicing(this TensorType tensorType, string[] begins, IRAr
             var sp = splits[i];
             if (sp.Count > 0)
             {
-                begins[i] += " + " + sp.Skip(1).Aggregate($"{placement.Name[sp[0].H]}id", (acc, p) => $"({acc} + {TensorUtilities.GetProduct(placement.Hierarchy[(p.H + 1)..])} * {placement.Name[p.H]}id)") + $" * {tensorType.Shape[i]}";
+                begins[i] += " + " + sp.Skip(1).Aggregate($"{placement.Name[sp[0].H]}id", (acc, p) => $"({acc} + {TensorUtilities.GetProduct(placement.Hierarchy[(p.H + 1)..])} * {placement.Name[p.H]}id)") + $" * {shape[i]}";
             }
         }
 
-        return $"({{{string.Join(',', begins)}}}, {{{string.Join(",", tensorType.Shape)}}})";
+        return $"({{{string.Join(',', begins)}}}, {{{string.Join(",", shape)}}})";
     }
 
-    public static string ToSlicing(this TensorType tensorType, IRArray<SBP> ndsbp, Placement placement) => ToSlicing(tensorType, Enumerable.Repeat("0", tensorType.Shape.Rank).ToArray(), ndsbp, placement);
+    public static string ToSlicing(this Shape shape, IRArray<SBP> ndsbp, Placement placement) => ToSlicing(shape, Enumerable.Repeat("0", shape.Rank).ToArray(), ndsbp, placement);
 
     public static string ToC(this BinaryOp binaryOp) => binaryOp switch
     {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
index 1e0ad2c6cc..4b9901dc12 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
@@ -11,7 +11,7 @@
 
 namespace Nncase.Evaluator.CPU;
 
-public sealed class BoxingEvaluator : ITypeInferencer<Boxing>, ICostEvaluator<Boxing>
+public sealed class BoxingEvaluator : ITypeInferencer<Boxing>, ICostEvaluator<Boxing>, IEvaluator<Boxing>
 {
     private const int _burstLength = 256;
 
@@ -133,4 +133,9 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
 
         return cost;
     }
+
+    public IValue Visit(IEvaluateContext context, Boxing target)
+    {
+        return context.GetArgumentValue(target, Boxing.Input);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/SwishB.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/SwishB.cs
new file mode 100644
index 0000000000..bb42e69481
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/SwishB.cs
@@ -0,0 +1,18 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.Evaluator;
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase;
+
+public sealed class SwishBEvaluator : ITypeInferencer<SwishB>
+{
+    public IRType Visit(ITypeInferenceContext context, SwishB target)
+    {
+        context.CheckArgumentType<TensorType>(target, SwishB.Input);
+        context.CheckArgumentType<TensorType>(target, SwishB.Output);
+        return TupleType.Void;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 89e425b50e..464f291792 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -19,6 +19,7 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<TDMALoadEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<TDMAStoreEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<UnaryEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<SwishBEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<BinaryEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<MatmulEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<LayerNormEvaluator>(reuse: Reuse.Singleton);
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
index 3451b2df3a..c985e554e9 100644
--- a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
@@ -25,11 +25,6 @@ public static Call CPUKernel(Op target, params Expr[] inputs)
 
     public static Call Boxing(Expr input, IRType type)
     {
-        if (input.CheckedType == type)
-        {
-            throw new NotSupportedException();
-        }
-
         return new Call(new Boxing(type), input);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs b/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs
index 40e6f55312..d10bfb863f 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs
@@ -13,6 +13,12 @@ public sealed partial class Binary : XPUKernelOp
 
     public BinaryOp BinaryOp { get; }
 
+    public DistributedType LhsType { get; }
+
+    public DistributedType RhsType { get; }
+
+    public DistributedType OutType { get; }
+
     /// <inheritdoc/>
     public override string DisplayProperty()
     {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index 4a97a99c51..0288a6f91c 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -27,9 +27,9 @@ public static Call Unary(string unaryOp, Expr input, Expr output)
         return new Call(new Unary(unaryOp), input, output);
     }
 
-    public static Call Binary(BinaryOp binaryOp, Expr lhs, Expr rhs, Expr output)
+    public static Call Binary(BinaryOp binaryOp, DistributedType ltype, DistributedType rtype, DistributedType outtype, Expr lhs, Expr rhs, Expr output)
     {
-        return new Call(new Binary(binaryOp), lhs, rhs, output);
+        return new Call(new Binary(binaryOp, ltype, rtype, outtype), lhs, rhs, output);
     }
 
     public static Call Matmul(Expr lhs, Expr rhs, Expr output)
@@ -77,6 +77,11 @@ public static Call ReShape(Expr input, Expr output)
         return new Call(new IR.XPU.ReShape(), input, output);
     }
 
+    public static Call SwishB(Expr input, Expr output, float beta)
+    {
+        return new Call(new IR.XPU.SwishB(beta), input, output);
+    }
+
     public static Call GatherReduceScatter(Expr input, Expr output, (int, SBP)[] reducePosition, Placement placement)
     {
         return new Call(new GatherReduceScatter(reducePosition, placement), input, output);
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/SwishB.cs b/modules/Nncase.Modules.CPU/IR/XPU/SwishB.cs
new file mode 100644
index 0000000000..21e4b3906f
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/SwishB.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class SwishB : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(SwishB), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(SwishB), 1, "output");
+
+    public float Beta { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index b5aa9fe9d6..daa1889093 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -46,7 +46,7 @@ protected override Unit VisitLeafCall(Call expr)
                 GenerateUnary(unary.UnaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture), arguments, ret);
                 break;
             case Binary binary:
-                GenerateBinary(binary, arguments, ret);
+                GenerateBinary(binary, arguments, ret, expr);
                 break;
             case MatMul matmul:
                 GenerateMatmul(matmul, arguments, ret);
@@ -76,7 +76,7 @@ protected override Unit VisitLeafCall(Call expr)
                 GenerateReshape(arguments[0], ret);
                 break;
             case Swish:
-                GenerateUnary("swish", arguments, ret);
+                GenerateSwishB(arguments[0], ret, ((TensorConst)expr.Arguments[1]).Value.ToScalar<float>());
                 break;
             case IR.CPU.Boxing boxing:
                 GenerateBoxing(boxing, arguments, ret, expr);
@@ -105,6 +105,11 @@ protected override Unit VisitLeafCall(Call expr)
         return default;
     }
 
+    private void GenerateSwishB(Buffer input, Buffer ret, float beta)
+    {
+        _mainBody.Add(IR.F.XPU.SwishB(input, ret, beta));
+    }
+
     private void GenerateReshape(Buffer input, Buffer ret)
     {
         _mainBody.Add(IR.F.XPU.ReShape(input, ret));
@@ -167,9 +172,12 @@ private void GenerateUnary(string unaryOp, ReadOnlySpan<Buffer> arguments, Buffe
         _mainBody.Add(IR.F.XPU.Unary(unaryOp, input, ret));
     }
 
-    private void GenerateBinary(Binary binary, Buffer[] arguments, Buffer ret)
+    private void GenerateBinary(Binary binary, Buffer[] arguments, Buffer ret, Call expr)
     {
-        _mainBody.Add(IR.F.XPU.Binary(binary.BinaryOp, arguments[0], arguments[1], ret));
+        var lhs = (DistributedType)expr[Binary.Lhs].CheckedType;
+        var rhs = (DistributedType)expr[Binary.Rhs].CheckedType;
+        var outtype = (DistributedType)expr.CheckedType;
+        _mainBody.Add(IR.F.XPU.Binary(binary.BinaryOp, lhs, rhs, outtype, arguments[0], arguments[1], ret));
     }
 
     private void GenerateMatmul(MatMul matmul, Buffer[] arguments, Buffer ret)
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index ae95de6e82..f15468478c 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -1,10 +1,10 @@
 #pragma once
+#include "cast.h"
 #include "runtime_utils.h"
 #include <apply.h>
 #include <binary.h>
 #include <cassert>
 #include <concat.h>
-#include "cast.h"
 #include <functional>
 #include <gather.h>
 #include <hardware_context.h>
@@ -111,6 +111,15 @@ void unary(tensor<T, ALoc> &a, tensor<T, BLoc> &out, unary_op_t op) {
         gsl::make_span(out.strides()).template as_span<const size_t>());
 }
 
+template <loc_t ALoc, loc_t BLoc>
+void swishb(tensor<float, ALoc> &a, tensor<float, BLoc> &out, float beta) {
+    kernels::swishb(
+        a.cdata().data(), out.data().data(), beta,
+        gsl::make_span(a.strides()).template as_span<const size_t>(),
+        gsl::make_span(out.dimension()).template as_span<const size_t>(),
+        gsl::make_span(out.strides()).template as_span<const size_t>());
+}
+
 template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
 void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &c) {
     kernels::matmul(a.cdata().data(), b.cdata().data(), c.data().data(),
diff --git a/modules/cpu/src/runtime/cmodel/include/unary.h b/modules/cpu/src/runtime/cmodel/include/unary.h
index fc883077f3..ad1e506d63 100644
--- a/modules/cpu/src/runtime/cmodel/include/unary.h
+++ b/modules/cpu/src/runtime/cmodel/include/unary.h
@@ -70,7 +70,8 @@ void unary_impl(unary_op_t op, const T *input, T *output,
             });
             UNARY_IMPL_OP(gelu, [](float x) {
                 return 0.5f * (x) *
-                               (1.f + nncase_mt->float_unary_erf( x / nncase_mt->float_unary_sqrt(2.f)));
+                       (1.f + nncase_mt->float_unary_erf(
+                                  x / nncase_mt->float_unary_sqrt(2.f)));
             });
         default:
             runtime_util->rt_assert(false, (char *)"Unsupported Unary Op!");
@@ -90,4 +91,14 @@ void unary(unary_op_t op, const T *input, T *output,
     unary_impl(op, input, output, in_strides, out_shape, out_strides);
 }
 
+void swishb(const float *input, float *output, float beta,
+                gsl::span<const size_t> input_strides,
+                gsl::span<const size_t> out_shape,
+                gsl::span<const size_t> out_strides) noexcept {
+    unary_impl(
+        [&beta](float x) {
+            return x * (1 / (1 + nncase_mt->float_unary_exp(-(x * beta))));
+        },
+        input, output, input_strides, out_shape, out_strides);
+}
 } // namespace kernels
\ No newline at end of file
diff --git a/src/Nncase.Tests/Distributed/UnitTestKernels.cs b/src/Nncase.Tests/Distributed/UnitTestKernels.cs
new file mode 100644
index 0000000000..ca301bd61a
--- /dev/null
+++ b/src/Nncase.Tests/Distributed/UnitTestKernels.cs
@@ -0,0 +1,138 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using NetFabric.Hyperlinq;
+using Nncase.CodeGen;
+using Nncase.IR;
+using Nncase.IR.Tensors;
+using Nncase.Runtime.Interop;
+using Nncase.Targets;
+using Nncase.Tests.TestFixture;
+using Nncase.Utilities;
+using Xunit;
+
+namespace Nncase.Tests.DistributedTest;
+
+public interface IDistributedKernelCase
+{
+    string Name { get; }
+
+    Fusion Fusion { get; }
+
+    IReadOnlyList<Var> Vars { get; }
+
+    IReadOnlyList<Tensor> Inputs { get; }
+}
+
+[AutoSetupTestMethod(InitSession = true)]
+public sealed class UnitTestKernels : TestClassBase
+{
+    public static readonly TheoryData<IDistributedKernelCase> Cases = new()
+    {
+        new BinaryCase1(),
+    };
+
+    public UnitTestKernels()
+    {
+#if DEBUG
+        CompileOptions.DumpFlags = Diagnostics.DumpFlags.PassIR | Diagnostics.DumpFlags.Rewrite | Diagnostics.DumpFlags.CodeGen | Diagnostics.DumpFlags.EGraphCost | Diagnostics.DumpFlags.Tiling;
+#endif
+    }
+
+    [Theory]
+    [MemberData(nameof(Cases))]
+    internal async Task Run(IDistributedKernelCase kernelCase)
+    {
+        using var dumpScope = new Diagnostics.DumpScope(kernelCase.Name, CompileOptions.DumpFlags);
+
+        // convert fusion to prim func
+        var primBody = new List<Expr>();
+        var visitor = new Passes.Tile.TIRConvertVisitor(primBody);
+        visitor.Visit(kernelCase.Fusion);
+        var primFunc = TIR.T.PrimFunc(kernelCase.Fusion.Name, kernelCase.Fusion.ModuleKind, visitor.InputBuffers.Concat(visitor.OutputBuffers).ToArray()).Body(primBody.ToArray()).Build();
+        var primWrapper = new PrimFunctionWrapper(primFunc, primFunc.Parameters.Length - 1);
+        var main = new Function(new Call(primWrapper, kernelCase.Vars.ToArray()), kernelCase.Vars.ToArray());
+
+        var module = new IR.IRModule(main);
+        module.Add(primWrapper);
+        module.Add(primFunc);
+        var inputs = kernelCase.Inputs.ToArray();
+        var output = kernelCase.Fusion.Body.Evaluate(kernelCase.Vars.Zip(inputs).ToDictionary(p => p.First, p => (IValue)Value.FromTensor(p.Second))).AsTensor();
+
+#if DEBUG
+        for (var i = 0; i < inputs.Length; i++)
+        {
+            using (var fs = Diagnostics.DumpScope.Current.OpenFile($"input_{i}.bin"))
+            {
+                fs.Write(inputs[i].BytesBuffer);
+            }
+        }
+
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile($"output_0.bin"))
+        {
+            fs.Write(output.BytesBuffer);
+        }
+#endif
+        await Compile(module);
+        var (kmodel_path, kmodel) = Testing.BuildKModel("test", module, CompileSession);
+        var actual = Testing.RunKModel(kmodel, Diagnostics.DumpScope.Current.Directory, inputs).AsTensor();
+#if DEBUG
+        using (var fs = Diagnostics.DumpScope.Current.OpenFile($"actual_0.bin"))
+        {
+            fs.Write(actual.BytesBuffer);
+        }
+#endif
+        var cos = Comparator.CosSimilarity(output, actual);
+        Assert.True(cos > 0.999);
+    }
+
+    private async Task Compile(IRModule module)
+    {
+        var pmgr = CompileSession.CreatePassManager("pmgr");
+        CompileSession.Target.RegisterTargetDependentAfterQuantPass(pmgr, CompileSession.CompileOptions);
+        CompileSession.Target.RegisterTargetDependentBeforeCodeGen(pmgr, CompileSession.CompileOptions);
+        await pmgr.RunAsync(module);
+    }
+}
+
+internal sealed class BinaryCase1 : IDistributedKernelCase
+{
+    public BinaryCase1()
+    {
+        var type = new TensorType(DataTypes.Float32, new[] { 1, 16, 768 });
+        var place = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+        var lhs = new Var(type);
+        var rhs = new Var(type);
+        {
+            var l0 = IR.F.CPU.Boxing(lhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.B }, place));
+            var r0 = IR.F.CPU.Boxing(rhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.S(2) }, place));
+            Fusion = new Fusion(Name + "_fusion", CPUTarget.Kind, IR.F.CPU.Boxing(l0 + r0, type), new[] { lhs, rhs });
+        }
+
+        Vars = new[] { lhs, rhs };
+    }
+
+    public string Name => "BinaryCase1";
+
+    public Fusion Fusion { get; }
+
+    public IReadOnlyList<Var> Vars { get; }
+
+    public IReadOnlyList<Tensor> Inputs
+    {
+        get
+        {
+            return Vars.Select(v => IR.F.Random.Uniform(v.CheckedDataType, 30, 0, 1, v.CheckedShape).Evaluate().AsTensor()).ToArray();
+        }
+    }
+
+    public override string ToString() => Name;
+}
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index be32239812..41f467d22d 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -55,7 +55,11 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseInstanceNorm))]
     // [ClassData(typeof(TilingCaseEncoderTail))]
     // [ClassData(typeof(TilingCaseResize))]
-    [ClassData(typeof(TilingCaseCast))]
+    // [ClassData(typeof(TilingCaseCast))]
+    // [ClassData(typeof(TilingCaseBinaryAdd))]
+    // [ClassData(typeof(TilingCaseGatherBinary))]
+    // [ClassData(typeof(TilingCaseLayerNormBinary))]
+    [ClassData(typeof(TilingCaseSDMHA))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -225,6 +229,29 @@ public TilingCaseMHA()
     }
 }
 
+internal sealed class TilingCaseBinaryAdd : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseBinaryAdd()
+    {
+        var lhsShape = new[] { 1, 77, 768 };
+        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, lhsShape));
+        var rhsShape = new[] { 1, 77, 768 };
+        var rhs = new Var("lhs", new TensorType(DataTypes.Float32, rhsShape));
+        var main = new Function("binary_add", lhs + rhs, new[] { lhs, rhs });
+
+        var lhs_tensor = IR.F.Random.Uniform(DataTypes.Float32, 1, 0, 2, lhsShape).Evaluate().AsTensor();
+        var rhs_tensor = IR.F.Random.Uniform(DataTypes.Float32, 1, 0, 2, rhsShape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { lhs, Value.FromTensor(lhs_tensor) },
+            { rhs, Value.FromTensor(rhs_tensor) },
+        };
+        var output = main.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { lhs_tensor, rhs_tensor, output });
+    }
+}
+
 internal sealed class TilingCaseBinaryMul : TheoryData<Function, Tensor[]>
 {
     public TilingCaseBinaryMul()
@@ -373,11 +400,39 @@ public TilingCaseLayerNorm()
         var main = new Function("layernorm", new Call(fusion, input), new[] { input });
 
         var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
+        var feedDict = new Dictionary<Var, IValue>
         {
-            fs.Write(input_tensor.BytesBuffer);
+            { fin, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}
+
+internal sealed class TilingCaseLayerNormBinary : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseLayerNormBinary()
+    {
+        var shape = new[] { 1, 77, 768 };
+        int axis = 2;
+        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
+        var scale = IR.F.Random.Normal(DataTypes.Float32, new[] { shape[2] }).Evaluate().AsTensor();
+        var bias = IR.F.Random.Normal(DataTypes.Float32, new[] { shape[2] }).Evaluate().AsTensor();
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, shape));
+            var v0 = new Call(new IR.NN.LayerNorm(axis, 1e-5f, true), fin, scale, bias);
+            var v1 = IR.F.NN.Swish(v0, 1.602f);
+            var v2 = IR.F.Math.Binary(BinaryOp.Add, fin, v1);
+            fusion = new Fusion("cpu", v2, fin);
         }
 
+        var main = new Function("layernorm_binary", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, shape).Evaluate().AsTensor();
         var feedDict = new Dictionary<Var, IValue>
         {
             { fin, Value.FromTensor(input_tensor) },
@@ -454,6 +509,38 @@ public TilingCaseGather()
     }
 }
 
+internal sealed class TilingCaseGatherBinary : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseGatherBinary()
+    {
+        var inputShape = new[] { 49408, 768 };
+        var indicesShape = new[] { 1, 77 };
+        int axis = 0;
+        var input = Const.FromValue(IR.F.Random.Normal(DataTypes.Float32, 1, 0, 2, inputShape).Evaluate());
+        var indices = new Var("indices", new TensorType(DataTypes.Int32, indicesShape));
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("indices", new TensorType(DataTypes.Int32, indicesShape));
+            var v0 = new Call(new IR.Tensors.Gather(axis), input, fin);
+            var v1 = new Call(new IR.Math.Binary(BinaryOp.Add), v0, IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 77, 768 }).Evaluate().AsTensor());
+            fusion = new Fusion("cpu", v1, fin);
+        }
+
+        var main = new Function("gather_binary", new Call(fusion, indices), new[] { indices });
+
+        var input_tensor = IR.F.Random.Uniform(DataTypes.Int32, 1, 0, 2, indicesShape).Evaluate().AsTensor();
+        var feedDict = new Dictionary<Var, IValue>
+        {
+            { fin, Value.FromTensor(input_tensor) },
+        };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}
+
 internal sealed class TilingCaseSoftmax : TheoryData<Function, Tensor[]>
 {
     public TilingCaseSoftmax()
@@ -750,3 +837,54 @@ public TilingCaseCast()
         Add(main, new[] { input_tensor, output });
     }
 }
+
+internal sealed class TilingCaseSDMHA : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseSDMHA()
+    {
+        var fin = new Var("var_4", new TensorType(DataTypes.Float32, new[] { 1, 77, 768 }));
+
+        Fusion fusion;
+        {
+            var v0 = IR.F.NN.LayerNorm(2, 1E-05f, fin, IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), true); // f32[1,77,768]
+            var v1 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v2 = IR.F.Math.Binary(BinaryOp.Add, v1, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v3 = IR.F.Math.Binary(BinaryOp.Mul, v2, new[] { 0.125f }); // f32[12,77,64]
+            var v4 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v5 = IR.F.Math.Binary(BinaryOp.Add, v4, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v6 = IR.F.Tensors.Transpose(v5, new[] { 0, 2, 1 }); // f32[12,64,77]
+            var v7 = IR.F.Math.MatMul(v3, v6); // f32[12,77,77]
+            var v8 = IR.F.Math.Binary(BinaryOp.Add, v7, IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 77, 77 }).Evaluate().AsTensor()); // f32[12,77,77]
+            var v9 = IR.F.NN.Softmax(v8, 2); // f32[12,77,77]
+            var v10 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v11 = IR.F.Math.Binary(BinaryOp.Add, v10, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v12 = IR.F.Math.MatMul(v9, v11); // f32[12,77,64]
+            var v13 = IR.F.Tensors.Transpose(v12, new[] { 1, 0, 2 }); // f32[77,12,64]
+            var v14 = IR.F.Tensors.Reshape(v13, new[] { 1L, 77L, 768L }); // f32[1,77,768]
+            var v15 = IR.F.Math.MatMul(v14, IR.F.Random.Normal(DataTypes.Float32, new[] { 768, 768 }).Evaluate().AsTensor()); // f32[1,77,768]
+            var v16 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), v15); // f32[1,77,768]
+            var v17 = IR.F.Math.Binary(BinaryOp.Add, fin, v16); // f32[1,77,768]
+            var v18 = IR.F.NN.LayerNorm(2, 1E-05f, v17, IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), true); // f32[1,77,768]
+            var v19 = IR.F.Math.MatMul(v18, IR.F.Random.Normal(DataTypes.Float32, new[] { 768, 3072 }).Evaluate().AsTensor()); // f32[1,77,3072]
+            var v20 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, new[] { 3072 }).Evaluate().AsTensor(), v19); // f32[1,77,3072]
+            var v21 = IR.F.NN.Swish(v20, 1.702f); // f32[1,77,3072]
+            var v22 = IR.F.Math.MatMul(v21, IR.F.Random.Normal(DataTypes.Float32, new[] { 3072, 768 }).Evaluate().AsTensor()); // f32[1,77,768]
+            var v23 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), v22); // f32[1,77,768]
+            var v24 = IR.F.Math.Binary(BinaryOp.Add, v17, v23); // f32[1,77,768]
+            fusion = new Fusion("cpu", v24, new[] { fin });
+        }
+
+        var input = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 77, 768 }));
+        var main = new Function("sd_mha", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 77, 768 }).Evaluate().AsTensor();
+
+        var feedDict = new Dictionary<Var, IValue>
+            {
+                { fin, Value.FromTensor(input_tensor) },
+            };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}

From 42a835b32fc9b33c9c727933b171e288e7f1b0a4 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Wed, 18 Oct 2023 17:13:49 +0800
Subject: [PATCH 250/308] support multi outputs

---
 .../Tile/AutoDistributedConvertVisitor.cs     |  7 +-
 .../Passes/Tile/TIRConvertVisitor.cs          | 33 ++++++++-
 .../Targets/UnitTestCPUTargetTiling.cs        | 73 ++++++++++---------
 3 files changed, 72 insertions(+), 41 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
index e69e4669de..80901c11b5 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
@@ -3,6 +3,7 @@
 
 using System.Reactive;
 using System.Runtime.CompilerServices;
+using NetFabric.Hyperlinq;
 using Nncase.IR;
 using Nncase.IR.CPU;
 using Nncase.IR.Tensors;
@@ -32,7 +33,11 @@ public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement p
 
     public Expr Convert(Expr body)
     {
-        var equivalents = Visit(body).Select(g => IR.F.CPU.Boxing(g.Value[0], body.CheckedType)).ToArray();
+        var equivalents = Visit(body).Select(g => g.Value[0] switch
+        {
+            IR.Tuple tp => new IR.Tuple(tp.Fields.ToArray().Select((f, i) => IR.F.CPU.Boxing(f, ((IR.Tuple)body).Fields[i].CheckedType)).ToArray()),
+            Expr e => (Expr)IR.F.CPU.Boxing(e, body.CheckedType),
+        }).ToArray();
         using (new ExprPinner(equivalents))
         {
             BranchCut();
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 3e057e9bcf..cf9c79d27e 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -18,15 +18,17 @@ public sealed class TIRConvertVisitor : ExprVisitor<Unit, Unit>
 {
     private readonly Dictionary<Expr, TIR.Buffer> _buffersMap = new(ReferenceEqualityComparer.Instance);
     private readonly List<Expr> _mainBody;
+    private readonly List<(int, TIR.Buffer)> _outputbuffers;
 
     public TIRConvertVisitor(List<Expr> mainBody)
     {
         _mainBody = mainBody;
+        _outputbuffers = new();
     }
 
     public Fusion VisitRootFusion => (Fusion)VisitRoot!;
 
-    public IEnumerable<TIR.Buffer> OutputBuffers => _buffersMap.Values.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Output));
+    public IEnumerable<TIR.Buffer> OutputBuffers => _outputbuffers.OrderBy(p => p.Item1).Select(p => p.Item2);
 
     public IEnumerable<TIR.Buffer> InputBuffers => VisitRootFusion.Parameters.ToArray().Select(p => _buffersMap[p]).OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Input));
 
@@ -313,12 +315,13 @@ private TIR.Buffer AllocOrGetBuffer(Expr expr)
             {
                 case Call c:
                     var (type, loc) = GetTypeAndLocation(c.CheckedType);
-                    if (ReferenceEquals(c, VisitRootFusion.Body))
+                    var index = CheckRootCall(c, ref loc);
+                    buffer = T.AttachBuffer(type, loc, out _, out _, name);
+                    if (index != -1)
                     {
-                        loc = MemoryLocation.Output;
+                        _outputbuffers.Add((index, buffer));
                     }
 
-                    buffer = T.AttachBuffer(type, loc, out _, out _, name);
                     break;
                 case Var v:
                     buffer = T.AttachBuffer((TensorType)v.CheckedType, MemoryLocation.Input, out _, out _, name);
@@ -340,6 +343,28 @@ private TIR.Buffer AllocOrGetBuffer(Expr expr)
         return buffer;
     }
 
+    private int CheckRootCall(Call c, ref MemoryLocation loc)
+    {
+        var index = -1;
+        if (VisitRootFusion.Body is Call rootCall && ReferenceEquals(c, rootCall))
+        {
+            loc = MemoryLocation.Output;
+        }
+        else if (VisitRootFusion.Body is IR.Tuple tp)
+        {
+            for (int i = 0; i < tp.Fields.Length; i++)
+            {
+                if (ReferenceEquals(tp.Fields[i], c))
+                {
+                    index = i;
+                    loc = MemoryLocation.Output;
+                }
+            }
+        }
+
+        return index;
+    }
+
     private Tuple<TensorType, MemoryLocation> GetTypeAndLocation(IRType type)
     {
         MemoryLocation location = MemoryLocation.Data;
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 4b86e23c58..ddfc2f7f1a 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -64,10 +64,11 @@ public UnitTestCPUTargetTiling()
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
+        var parameterLength = main.Parameters.Length;
         using (new Diagnostics.DumpScope(main.Name, CompileOptions.DumpFlags))
         {
 #if DEBUG
-            for (var i = 0; i < inputs.Length - 1; i++)
+            for (var i = 0; i < parameterLength; i++)
             {
                 using (var fs = Diagnostics.DumpScope.Current.OpenFile($"input_{i}.bin"))
                 {
@@ -75,21 +76,30 @@ public async Task TestCpuFunction(Function main, Tensor[] inputs)
                 }
             }
 
-            using (var fs = Diagnostics.DumpScope.Current.OpenFile($"output_0.bin"))
+            for (var i = 0; i < inputs.Length - parameterLength; i++)
             {
-                fs.Write(inputs[^1].BytesBuffer);
+                using (var fs = Diagnostics.DumpScope.Current.OpenFile($"output_{i}.bin"))
+                {
+                    fs.Write(inputs[parameterLength + i].BytesBuffer);
+                }
             }
 #endif
             await Compile(module);
-            var output = Testing.RunKModel(File.ReadAllBytes(Path.Join(Diagnostics.DumpScope.Current.Directory, "test.kmodel")), Diagnostics.DumpScope.Current.Directory, inputs);
+            var outputs = Testing.RunKModel(File.ReadAllBytes(Path.Join(Diagnostics.DumpScope.Current.Directory, "test.kmodel")), Diagnostics.DumpScope.Current.Directory, inputs).AsTensors();
 #if DEBUG
-            using (var fs = Diagnostics.DumpScope.Current.OpenFile($"actual_0.bin"))
+            for (int i = 0; i < outputs.Length; i++)
             {
-                fs.Write(output.AsTensor().BytesBuffer);
+                using (var fs = Diagnostics.DumpScope.Current.OpenFile($"actual_{i}.bin"))
+                {
+                    fs.Write(outputs[i].BytesBuffer);
+                }
             }
 #endif
-            var cos = Tests.Comparator.CosSimilarity(output, Value.FromTensor(inputs[^1]))[0];
-            Assert.True(cos > 0.999);
+            var cos = Tests.Comparator.CosSimilarity(outputs, inputs[parameterLength..]);
+            for (int i = 0; i < cos.Length; i++)
+            {
+                Assert.True(cos[i] > 0.999, $"the outputs[{i}] cos is {cos[i]}!");
+            }
         }
     }
 
@@ -847,50 +857,45 @@ public TilingCaseSDMHA()
 
         Fusion fusion;
         {
-            var v0 = IR.F.NN.LayerNorm(2, 1E-05f, fin, IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), true); // f32[1,77,768]
-            var v1 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
-            var v2 = IR.F.Math.Binary(BinaryOp.Add, v1, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v0 = IR.F.NN.LayerNorm(2, 1E-05f, fin, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), true); // f32[1,77,768]
+            var v1 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v2 = IR.F.Math.Binary(BinaryOp.Add, v1, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
             var v3 = IR.F.Math.Binary(BinaryOp.Mul, v2, new[] { 0.125f }); // f32[12,77,64]
-            var v4 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
-            var v5 = IR.F.Math.Binary(BinaryOp.Add, v4, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v4 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v5 = IR.F.Math.Binary(BinaryOp.Add, v4, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
             var v6 = IR.F.Tensors.Transpose(v5, new[] { 0, 2, 1 }); // f32[12,64,77]
             var v7 = IR.F.Math.MatMul(v3, v6); // f32[12,77,77]
-            var v8 = IR.F.Math.Binary(BinaryOp.Add, v7, IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 77, 77 }).Evaluate().AsTensor()); // f32[12,77,77]
+            var v8 = IR.F.Math.Binary(BinaryOp.Add, v7, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 1, 77, 77 }).Evaluate().AsTensor()); // f32[12,77,77]
             var v9 = IR.F.NN.Softmax(v8, 2); // f32[12,77,77]
-            var v10 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
-            var v11 = IR.F.Math.Binary(BinaryOp.Add, v10, IR.F.Random.Normal(DataTypes.Float32, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v10 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
+            var v11 = IR.F.Math.Binary(BinaryOp.Add, v10, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
             var v12 = IR.F.Math.MatMul(v9, v11); // f32[12,77,64]
             var v13 = IR.F.Tensors.Transpose(v12, new[] { 1, 0, 2 }); // f32[77,12,64]
             var v14 = IR.F.Tensors.Reshape(v13, new[] { 1L, 77L, 768L }); // f32[1,77,768]
-            var v15 = IR.F.Math.MatMul(v14, IR.F.Random.Normal(DataTypes.Float32, new[] { 768, 768 }).Evaluate().AsTensor()); // f32[1,77,768]
-            var v16 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), v15); // f32[1,77,768]
+            var v15 = IR.F.Math.MatMul(v14, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768, 768 }).Evaluate().AsTensor()); // f32[1,77,768]
+            var v16 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), v15); // f32[1,77,768]
             var v17 = IR.F.Math.Binary(BinaryOp.Add, fin, v16); // f32[1,77,768]
-            var v18 = IR.F.NN.LayerNorm(2, 1E-05f, v17, IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), true); // f32[1,77,768]
-            var v19 = IR.F.Math.MatMul(v18, IR.F.Random.Normal(DataTypes.Float32, new[] { 768, 3072 }).Evaluate().AsTensor()); // f32[1,77,3072]
-            var v20 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, new[] { 3072 }).Evaluate().AsTensor(), v19); // f32[1,77,3072]
+            var v18 = IR.F.NN.LayerNorm(2, 1E-05f, v17, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), true); // f32[1,77,768]
+            var v19 = IR.F.Math.MatMul(v18, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768, 3072 }).Evaluate().AsTensor()); // f32[1,77,3072]
+            var v20 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 3072 }).Evaluate().AsTensor(), v19); // f32[1,77,3072]
             var v21 = IR.F.NN.Swish(v20, 1.702f); // f32[1,77,3072]
-            var v22 = IR.F.Math.MatMul(v21, IR.F.Random.Normal(DataTypes.Float32, new[] { 3072, 768 }).Evaluate().AsTensor()); // f32[1,77,768]
-            var v23 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, new[] { 768 }).Evaluate().AsTensor(), v22); // f32[1,77,768]
+            var v22 = IR.F.Math.MatMul(v21, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 3072, 768 }).Evaluate().AsTensor()); // f32[1,77,768]
+            var v23 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), v22); // f32[1,77,768]
             var v24 = IR.F.Math.Binary(BinaryOp.Add, v17, v23); // f32[1,77,768]
-            fusion = new Fusion("cpu", v24, new[] { fin });
+            fusion = new Fusion("cpu", new IR.Tuple(v17, v23, v24), new[] { fin });
         }
 
         var input = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 77, 768 }));
         var main = new Function("sd_mha", new Call(fusion, input), new[] { input });
 
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 77, 768 }).Evaluate().AsTensor();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
-        {
-            fs.Write(input_tensor.BytesBuffer);
-        }
-
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, new[] { 1, 77, 768 }).Evaluate().AsTensor();
         var feedDict = new Dictionary<Var, IValue>
             {
                 { fin, Value.FromTensor(input_tensor) },
             };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+        var outputs = fusion.Body.Evaluate(feedDict).AsTensors();
 
-        Add(main, new[] { input_tensor, output });
+        Add(main, new[] { input_tensor }.Concat(outputs).ToArray());
     }
 }
 
@@ -913,10 +918,6 @@ public TilingCaseExpand()
         var main = new Function("expand", new Call(fusion, input), new[] { input });
 
         var input_tensor = IR.F.Random.Uniform(DataTypes.Int64, 100, 1, 2, shape).Evaluate().AsTensor();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
-        {
-            fs.Write(input_tensor.BytesBuffer);
-        }
 
         var feedDict = new Dictionary<Var, IValue>
             {

From 4c99d157c47e1c706842152571a13fcfdde303e6 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Wed, 18 Oct 2023 17:17:32 +0800
Subject: [PATCH 251/308] fix single output

---
 modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index cf9c79d27e..43dff3ad7b 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -348,6 +348,7 @@ private int CheckRootCall(Call c, ref MemoryLocation loc)
         var index = -1;
         if (VisitRootFusion.Body is Call rootCall && ReferenceEquals(c, rootCall))
         {
+            index = 0;
             loc = MemoryLocation.Output;
         }
         else if (VisitRootFusion.Body is IR.Tuple tp)

From 1044a52b014f15d03e4b756a41dfc9d9f9c52a80 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 18 Oct 2023 19:06:43 +0800
Subject: [PATCH 252/308] fix new linked section

---
 modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs          | 6 +++++-
 modules/Nncase.Modules.K210/CodeGen/K210/KPULinkedModule.cs | 4 ++--
 .../CodeGen/StackVM/StackVMLinkedModule.cs                  | 6 +++---
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs b/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
index ddda156d4b..fb642bf446 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
@@ -15,7 +15,11 @@ internal sealed class LinkedModule : ILinkedModule
     public LinkedModule(IReadOnlyList<ILinkedFunction> functions, Stream text, Stream rdata)
     {
         Functions = functions;
-        Sections = new[] { new LinkedSection(text, WellknownSectionNames.Text, 0, 8, (uint)text.Length), new LinkedSection(rdata, WellknownSectionNames.Rdata, 0, 8, (uint)rdata.Length) };
+        Sections = new[]
+        {
+            new LinkedSection(text, WellknownSectionNames.Text, 0, 8, (ulong)text.Length),
+            new LinkedSection(rdata, WellknownSectionNames.Rdata, 0, 8, (ulong)rdata.Length),
+        };
     }
 
     public string ModuleKind => Targets.CPUTarget.Kind;
diff --git a/modules/Nncase.Modules.K210/CodeGen/K210/KPULinkedModule.cs b/modules/Nncase.Modules.K210/CodeGen/K210/KPULinkedModule.cs
index 7018e7c7bd..4c4aeb20da 100644
--- a/modules/Nncase.Modules.K210/CodeGen/K210/KPULinkedModule.cs
+++ b/modules/Nncase.Modules.K210/CodeGen/K210/KPULinkedModule.cs
@@ -17,8 +17,8 @@ public KPULinkedModule(IReadOnlyList<LinkedFunction> functions, byte[] text, byt
         Functions = functions;
         Sections = new[]
         {
-            new LinkedSection(text, ".text", 0, 8, (uint)text.Length),
-            new LinkedSection(rdata, ".rdata", 0, 8, (uint)(rdata?.Length ?? 0)),
+            new LinkedSection(text, ".text", 0, 8, (ulong)text.Length),
+            new LinkedSection(rdata, ".rdata", 0, 8, (ulong)(rdata?.Length ?? 0)),
         };
     }
 
diff --git a/modules/Nncase.Modules.StackVM/CodeGen/StackVM/StackVMLinkedModule.cs b/modules/Nncase.Modules.StackVM/CodeGen/StackVM/StackVMLinkedModule.cs
index 3bfb985fd8..93c8d9c6b6 100644
--- a/modules/Nncase.Modules.StackVM/CodeGen/StackVM/StackVMLinkedModule.cs
+++ b/modules/Nncase.Modules.StackVM/CodeGen/StackVM/StackVMLinkedModule.cs
@@ -17,9 +17,9 @@ public StackVMLinkedModule(IReadOnlyList<LinkedFunction> functions, Stream text,
         Functions = functions;
         Sections = new[]
         {
-            new LinkedSection(text, ".text", 0, 8, (uint)text.Length),
-            new LinkedSection(rdata, ".rdata", 0, 8, (uint)(rdata?.Length ?? 0)),
-            new LinkedSection(custom_calls, ".custom_calls", 0, 8, (uint)(custom_calls?.Length ?? 0)),
+            new LinkedSection(text, ".text", 0, 8, (ulong)text.Length),
+            new LinkedSection(rdata, ".rdata", 0, 8, (ulong)(rdata?.Length ?? 0)),
+            new LinkedSection(custom_calls, ".custom_calls", 0, 8, (ulong)(custom_calls?.Length ?? 0)),
         };
     }
 

From db1db390fd7e83c325e62d3bac6e1016f3b03cca Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 18 Oct 2023 19:07:38 +0800
Subject: [PATCH 253/308] fuse Unet

---
 .../Passes/Rules/UnetFusion.cs                | 334 ++++++++++++++++++
 .../Passes/Tile/TIRConvertVisitor.cs          |   3 +
 src/Nncase.Compiler/Compiler.cs               |   3 +
 src/Nncase.Evaluator/Math/Binary.cs           |  12 +
 src/Nncase.Evaluator/Math/MatMul.cs           |  12 +
 src/Nncase.Evaluator/Tensors/Concat.cs        |   9 +-
 src/Nncase.Evaluator/Tensors/Reshape.cs       |  37 +-
 7 files changed, 390 insertions(+), 20 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
new file mode 100644
index 0000000000..9ba268e927
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
@@ -0,0 +1,334 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive;
+using System.Text;
+using System.Threading.Tasks;
+using DryIoc.ImTools;
+using Google.OrTools.LinearSolver;
+using Nncase.IR;
+using Nncase.IR.CPU;
+using Nncase.IR.Math;
+using Nncase.IR.NN;
+using Nncase.IR.Tensors;
+using Nncase.Passes.Rules.Neutral;
+using Nncase.PatternMatch;
+using Nncase.Targets;
+using static Nncase.PatternMatch.F.Imaging;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.F.NN;
+using static Nncase.PatternMatch.F.Tensors;
+using static Nncase.PatternMatch.Utility;
+using static Nncase.Utilities.ReplaceUtility;
+
+namespace Nncase.Passes.Rules;
+
+/// <summary>
+/// Unet Merger for all.
+/// </summary>
+public sealed class UnetMerger : ExprCloner<Unit>
+{
+    private readonly IReadOnlyDictionary<Expr, Var> _multiVarMap;
+
+    public UnetMerger(IReadOnlyDictionary<Expr, Var> multiVarMap)
+    {
+        _multiVarMap = multiVarMap;
+    }
+
+    protected override Expr VisitCall(Call expr, Unit context)
+    {
+        if (_multiVarMap.TryGetValue(expr, out var newVar))
+        {
+            return newVar;
+        }
+
+        return base.VisitCall(expr, context);
+    }
+
+    protected override Expr VisitLeafCall(Call expr, Unit context)
+    {
+        var target = Clone(expr.Target, context);
+        var arguments = CloneArray(expr.Arguments, context);
+        if (target is Binary)
+        {
+            arguments = arguments.Select(e => e switch { TensorConst { Value: Tensor { Shape.IsScalar: true } } tc => Const.FromTensor(Tensor.FromBytes(tc.ValueType.DType, tc.Value.BytesBuffer.ToArray(), new[] { 1 })), _ => e }).ToArray();
+        }
+
+        return expr.With(target: target, arguments: arguments);
+    }
+
+    protected override Expr VisitLeafVar(Var expr, Unit context)
+    {
+        if (_multiVarMap.TryGetValue(expr, out var newVar))
+        {
+            return newVar;
+        }
+
+        throw new InvalidOperationException();
+    }
+}
+
+/// <summary>
+/// stable-disffusion Unet spatial transformer.
+/// </summary>
+[RuleGenerator]
+public sealed partial class FuseUnetSpatialTransformer : FusionMaker
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern => CreatePattern();
+
+    private static Pattern CreatePattern()
+    {
+        // resIn
+        var v37 = IsWildcard("input");
+        var v38 = IsReshape(v37, IsTensorConst());
+        var v39 = IsInstanceNormalization(v38, IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v40 = IsReshape(v39, IsTensorConst());
+        var v41 = IsBinary(BinaryOp.Mul, v40, IsTensorConst());
+        var v42 = IsBinary(BinaryOp.Add, v41, IsTensorConst());
+        var v43 = IsConv2D(PadMode.Constant, v42, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+
+        // self attention
+        var v44 = IsTranspose(v43, IsTensorConst());
+        var v45 = IsReshape(v44, IsTensorConst());
+        var v46 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v45, IsTensorConst(), IsTensorConst());
+        var v47 = IsMatMul(v46, IsTensorConst());
+        var v48 = IsReshape(v47, IsTensorConst());
+        var v49 = IsTranspose(v48, IsTensorConst());
+        var v50 = IsReshape(v49, IsTensorConst());
+        var v51 = IsMatMul(v46, IsTensorConst());
+        var v52 = IsReshape(v51, IsTensorConst());
+        var v53 = IsTranspose(v52, IsTensorConst());
+        var v54 = IsReshape(v53, IsTensorConst());
+        var v55 = IsTranspose(v54, IsTensorConst());
+        var v56 = IsMatMul(v50, v55);
+        var v57 = IsBinary(BinaryOp.Mul, v56, IsTensorConst());
+        var v58 = IsBinary(BinaryOp.Add, v57, IsTensorConst());
+        var v59 = IsSoftmax(v58, IsTensorConst());
+        var v60 = IsMatMul(v46, IsTensorConst());
+        var v61 = IsReshape(v60, IsTensorConst());
+        var v62 = IsTranspose(v61, IsTensorConst());
+        var v63 = IsReshape(v62, IsTensorConst());
+        var v64 = IsMatMul(v59, v63);
+        var v65 = IsReshape(v64, IsTensorConst());
+        var v66 = IsTranspose(v65, IsTensorConst());
+        var v67 = IsReshape(v66, IsTensorConst());
+        var v68 = IsMatMul(v67, IsTensorConst());
+        var v69 = IsBinary(BinaryOp.Add, IsTensorConst(), v68);
+        var v70 = IsBinary(BinaryOp.Add, v69, v45);
+
+        // cross attention
+        var v71 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v70, IsTensorConst(), IsTensorConst());
+        var v72 = IsMatMul(v71, IsTensorConst());
+        var v73 = IsReshape(v72, IsTensorConst());
+        var v74 = IsTranspose(v73, IsTensorConst());
+        var v75 = IsReshape(v74, IsTensorConst());
+        var vencoderHiddenStates = IsWildcard("encoderHiddenStates");
+        var v76 = IsMatMul(vencoderHiddenStates, IsTensorConst());
+        var v77 = IsReshape(v76, IsTensorConst());
+        var v78 = IsTranspose(v77, IsTensorConst());
+        var v79 = IsReshape(v78, IsTensorConst());
+        var v80 = IsTranspose(v79, IsTensorConst());
+        var v81 = IsMatMul(v75, v80);
+        var v82 = IsBinary(BinaryOp.Mul, v81, IsTensorConst());
+        var v83 = IsBinary(BinaryOp.Add, v82, IsTensorConst());
+        var v84 = IsSoftmax(v83, IsTensorConst());
+        var v85 = IsMatMul(vencoderHiddenStates, IsTensorConst());
+        var v86 = IsReshape(v85, IsTensorConst());
+        var v87 = IsTranspose(v86, IsTensorConst());
+        var v88 = IsReshape(v87, IsTensorConst());
+        var v89 = IsMatMul(v84, v88);
+
+        // FF
+        var v90 = IsReshape(v89, IsTensorConst());
+        var v91 = IsTranspose(v90, IsTensorConst());
+        var v92 = IsReshape(v91, IsTensorConst());
+        var v93 = IsMatMul(v92, IsTensorConst());
+        var v94 = IsBinary(BinaryOp.Add, IsTensorConst(), v93);
+        var v95 = IsBinary(BinaryOp.Add, v94, v70);
+        var v96 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v95, IsTensorConst(), IsTensorConst());
+        var v97 = IsMatMul(v96, IsTensorConst());
+        var v98 = IsBinary(BinaryOp.Add, IsTensorConst(), v97);
+        var v99 = IsSlice(v98, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v100 = IsSlice(v98, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v101 = IsGelu(v100, IsTensorConst());
+        var v102 = IsBinary(BinaryOp.Mul, v99, v101);
+        var v103 = IsMatMul(v102, IsTensorConst());
+        var v104 = IsBinary(BinaryOp.Add, IsTensorConst(), v103);
+        var v105 = IsBinary(BinaryOp.Add, v104, v95);
+        var v106 = IsReshape(v105, IsTensorConst());
+        var v107 = IsTranspose(v106, IsTensorConst());
+
+        // res with result of ResBlock
+        var v108 = IsConv2D(PadMode.Constant, v107, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var root = IsBinary(null, "root", BinaryOp.Add, v108, v37);
+
+        return root!;
+    }
+
+    private Call? GetReplace(Call root, Expr input, Expr encoderHiddenStates)
+    {
+        var newInputs = new List<Expr>
+        {
+            new Var(input.CheckedType!),
+            new Var(encoderHiddenStates.CheckedType!),
+        };
+
+        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
+        {
+            { input, (Var)newInputs[0] },
+            { encoderHiddenStates, (Var)newInputs[1] },
+        };
+        var merger = new UnetMerger(multiVarMap);
+        var clonedRoot = merger.Clone(root, default);
+
+        var callFusion = new Call(new Fusion("UnetSpatialTransformer", $"{nameof(FuseUnetSpatialTransformer)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        return callFusion;
+    }
+}
+
+/// <summary>
+/// stable-disffusion Unet res block.
+/// </summary>
+[RuleGenerator]
+public sealed partial class FuseUnetResBlock : FusionMaker
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern => CreatePattern();
+
+    private static Pattern CreatePattern()
+    {
+        // 1st part with conv
+        var vIn = IsWildcard("input");
+        var vIn2 = IsWildcard("input2");
+        var resizeIn = IsResizeImage(ImageResizeMode.NearestNeighbor, ImageResizeTransformationMode.Asymmetric, ImageResizeNearestMode.Floor, false, vIn, IsWildcard(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var convIn = IsConv2D(PadMode.Constant, IsAlt(resizeIn, vIn2), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var vtuple1 = IsTuple(IsVArgs(vIn, IsAlt(convIn, vIn2)));
+        var vtuple2 = IsTuple(IsVArgs(convIn, vIn2));
+        var vConcat = IsConcat(Axis: 1, IsAlt(vtuple2, vtuple1));
+        var conv0 = IsConv2D(PadMode.Constant, vConcat, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var conv1 = IsConv2D(PadMode.Constant, vIn, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var conv2 = IsConv2D(PadMode.Constant, conv1, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v1 = IsReshape(IsAlt(vConcat, conv1, vIn), IsTensorConst());
+        var v2 = IsInstanceNormalization(v1, IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v3 = IsReshape(v2, IsTensorConst());
+        var v4 = IsBinary(BinaryOp.Mul, v3, IsTensorConst());
+        var v5 = IsBinary(BinaryOp.Add, v4, IsTensorConst());
+        var v6 = IsSwish(v5, IsTensorConst());
+        var v7 = IsConv2D(PadMode.Constant, v6, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+
+        // 2nd part with emb
+        var v25 = IsWildcard("emb");
+        var v26 = IsMatMul(v25, IsTensorConst());
+        var v27 = IsBinary(BinaryOp.Add, v26, IsTensorConst());
+        var v28 = IsReshape(v27, IsTensorConst());
+
+        // 1st + 2nd
+        var v29 = IsBinary(BinaryOp.Add, v7, v28);
+
+        // res
+        var v30 = IsReshape(v29, IsTensorConst());
+        var v31 = IsInstanceNormalization(v30, IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v32 = IsReshape(v31, IsTensorConst());
+        var v33 = IsBinary(BinaryOp.Mul, v32, IsTensorConst());
+        var v34 = IsBinary(BinaryOp.Add, v33, IsTensorConst());
+        var v35 = IsSwish(v34, IsTensorConst());
+        var v36 = IsConv2D(PadMode.Constant, v35, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v37 = IsBinary(null, "root", BinaryOp.Add, conv0, v36);
+        var v38 = IsBinary(null, "root", BinaryOp.Add, conv2, v36);
+        var v39 = IsBinary(null, "root", BinaryOp.Add, conv1, v36);
+        var v40 = IsBinary(null, "root", BinaryOp.Add, vIn, v36);
+        var root = IsAlt(v37, v38, v39, v40);
+
+        return root!;
+    }
+
+    private Call? GetReplace(Call root, IMatchResult result)
+    {
+        var oldInputs = new List<Expr> {
+            (Expr)result["input"],
+            (Expr)result["emb"],
+        };
+        if (result["input2"] is Expr expr)
+        {
+            oldInputs.Add(expr);
+        }
+
+        var newInputs = new List<Expr>();
+        foreach (var i in oldInputs)
+        {
+            newInputs.Add(new Var(i.CheckedType!));
+        }
+
+        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance);
+        for (var i = 0; i < newInputs.Count; i++)
+        {
+            multiVarMap.Add(oldInputs[i], (Var)newInputs[i]);
+        }
+
+        var merger = new UnetMerger(multiVarMap);
+        var clonedRoot = merger.Clone(root, default);
+
+        var callFusion = new Call(new Fusion("UnetResBlock", $"{nameof(FuseUnetResBlock)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), oldInputs.ToArray());
+        return callFusion;
+    }
+}
+
+/// <summary>
+/// stable-disffusion Unet TimeStep Embedding.
+/// </summary>
+[RuleGenerator]
+public sealed partial class FuseUnetTimeEmb : FusionMaker
+{
+    public override string ModuleKind { get; } = CPUTarget.Kind;
+
+    public override Pattern Pattern => CreatePattern();
+
+    private static Pattern CreatePattern()
+    {
+        var vtimestep = IsWildcard("input");
+        var v8 = IsExpand(vtimestep, IsTensorConst());
+        var v9 = IsReshape(v8, IsTensorConst());
+        var v10 = IsCast(DataTypes.Float32, CastMode.KDefault, v9);
+        var v11 = IsBinary(BinaryOp.Mul, v10, IsTensorConst());
+        var v12 = IsUnary(UnaryOp.Sin, v11);
+        var v13 = IsUnary(UnaryOp.Cos, v11);
+        var v14 = IsTuple(IsVArgs(v12, v13));
+        var v15 = IsConcat(Axis: 1, v14);
+        var v16 = IsSlice(v15, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v17 = IsSlice(v15, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
+        var v18 = IsTuple(IsVArgs(v16, v17));
+        var v19 = IsConcat(Axis: 1, v18);
+        var v20 = IsMatMul(v19, IsTensorConst());
+        var v21 = IsBinary(BinaryOp.Add, v20, IsTensorConst());
+        var v22 = IsSwish(v21, IsTensorConst());
+        var v23 = IsMatMul(v22, IsTensorConst());
+        var v24 = IsBinary(BinaryOp.Add, v23, IsTensorConst());
+        var root = IsSwish(null, "root", v24, IsTensorConst());
+
+        return root!;
+    }
+
+    private Call? GetReplace(Call root, Expr input)
+    {
+        var newInputs = new List<Expr>
+        {
+            new Var(input.CheckedType!),
+        };
+
+        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
+        {
+            { input, (Var)newInputs[0] },
+        };
+        var merger = new UnetMerger(multiVarMap);
+        var clonedRoot = merger.Clone(root, default);
+
+        var callFusion = new Call(new Fusion("UnetTimeEmb", $"{nameof(FuseUnetTimeEmb)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        return callFusion;
+    }
+}
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 43dff3ad7b..bc529cc3fa 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -80,6 +80,9 @@ protected override Unit VisitLeafCall(Call expr)
             case Swish:
                 GenerateSwishB(arguments[0], ret, ((TensorConst)expr.Arguments[1]).Value.ToScalar<float>());
                 break;
+            case Gelu:
+                GenerateUnary("gelu", arguments, ret);
+                break;
             case IR.CPU.Boxing boxing:
                 GenerateBoxing(boxing, arguments, ret, expr);
                 break;
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 03c64ed13f..63e6cef1d6 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -196,6 +196,9 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.FuseMHA1>();
             p.Add<Passes.Rules.FuseMHA2>();
             p.Add<Passes.Rules.FuseMHA3>();
+            p.Add<Passes.Rules.FuseUnetSpatialTransformer>();
+            p.Add<Passes.Rules.FuseUnetResBlock>();
+            p.Add<Passes.Rules.FuseUnetTimeEmb>();
             p.Add<Passes.Rules.FuseVAEDecRes>();
             p.Add<Passes.Rules.FuseVAEDecHead>();
             p.Add<Passes.Rules.FuseVAEDecMHA>();
diff --git a/src/Nncase.Evaluator/Math/Binary.cs b/src/Nncase.Evaluator/Math/Binary.cs
index 2e12f8b228..7be3546234 100755
--- a/src/Nncase.Evaluator/Math/Binary.cs
+++ b/src/Nncase.Evaluator/Math/Binary.cs
@@ -158,9 +158,21 @@ private IRType Visit(Binary target, DistributedType a, DistributedType b)
                     ndsbp[i] = SBP.S(padA + sa.Axis);
                     break;
                 case (SBPSplit s1, SBPBroadCast):
+                    // invalid (S, B) if B is not broacast
+                    if (s1.Axis + padA - padB >= 0 && b.TensorType.Shape[s1.Axis + padA - padB] != 1)
+                    {
+                        return new InvalidType($"lhs rhs sbp at {i} not broadcast");
+                    }
+
                     ndsbp[i] = SBP.S(padA + s1.Axis);
                     break;
                 case (SBPBroadCast, SBPSplit s2):
+                    // invalid (B, S) if A is not broacast
+                    if (s2.Axis + padB - padA >= 0 && a.TensorType.Shape[s2.Axis + padB - padA] != 1)
+                    {
+                        return new InvalidType($"lhs rhs sbp at {i} not broadcast");
+                    }
+
                     ndsbp[i] = SBP.S(padB + s2.Axis);
                     break;
                 case (SBPBroadCast, SBPBroadCast):
diff --git a/src/Nncase.Evaluator/Math/MatMul.cs b/src/Nncase.Evaluator/Math/MatMul.cs
index 15503eb2d3..4269b23854 100644
--- a/src/Nncase.Evaluator/Math/MatMul.cs
+++ b/src/Nncase.Evaluator/Math/MatMul.cs
@@ -72,6 +72,12 @@ public static IRType VisitDistributedType(DistributedType a, DistributedType b)
                         return invalid;
                     }
 
+                    // invalid (S, B) if B is not broacast matmul
+                    if (ax < aRank - 2 && !(bRank <= 2 || (ax + aPad - bPad >= 0 && b.TensorType.Shape[ax + aPad - bPad] == 1)))
+                    {
+                        return invalid;
+                    }
+
                     ndsbp[i] = SBP.S(ax + aPad);
                     break;
                 case (SBPBroadCast, SBPSplit { Axis: int bx }):
@@ -80,6 +86,12 @@ public static IRType VisitDistributedType(DistributedType a, DistributedType b)
                         return invalid;
                     }
 
+                    // invalid (B, S) if A is not broacast matmul
+                    if (bx < bRank - 2 && !(aRank <= 2 || (bx + bPad - aPad >= 0 && a.TensorType.Shape[bx + bPad - aPad] == 1)))
+                    {
+                        return invalid;
+                    }
+
                     ndsbp[i] = SBP.S(bx + bPad);
                     break;
                 default:
diff --git a/src/Nncase.Evaluator/Tensors/Concat.cs b/src/Nncase.Evaluator/Tensors/Concat.cs
index 631623f5a4..6cce7d2b66 100644
--- a/src/Nncase.Evaluator/Tensors/Concat.cs
+++ b/src/Nncase.Evaluator/Tensors/Concat.cs
@@ -202,15 +202,16 @@ private IRType Visit(TupleType inputs, int axis)
                 return new InvalidType("not support distribute with partialsum");
             }
 
-            if (sbps.OfType<SBPSplit>().ToHashSet() is HashSet<SBPSplit> set)
+            if (sbps.OfType<SBPSplit>().ToHashSet() is HashSet<SBPSplit> setSplit &&
+            sbps.OfType<SBPSplit>().ToHashSet() is HashSet<SBPSplit> setBroadcast)
             {
-                switch (set.Count)
+                switch (setSplit.Count)
                 {
                     case 0:
                         ndsbp[i] = SBP.B;
                         break;
-                    case 1:
-                        ndsbp[i] = set.First();
+                    case 1 when setBroadcast.Count == 0:
+                        ndsbp[i] = setSplit.First();
                         break;
                     default:
                         return new InvalidType("not support distribute with different axis");
diff --git a/src/Nncase.Evaluator/Tensors/Reshape.cs b/src/Nncase.Evaluator/Tensors/Reshape.cs
index d5d201bd5b..8f3ce698ae 100644
--- a/src/Nncase.Evaluator/Tensors/Reshape.cs
+++ b/src/Nncase.Evaluator/Tensors/Reshape.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using NetFabric.Hyperlinq;
 using Nncase.CostModel;
@@ -148,15 +149,17 @@ private IRType Visit(ITypeInferenceContext context, Reshape target, DistributedT
         {
             if (oldShape.Length < newShape.Length)
             {
-                var upAxis = 0;
-                foreach (var axis in Enumerable.Range(0, oldShape.Rank + 1))
+                var axis = 0;
+                var axisMap = new Dictionary<int, int>();
+                for (var n = 0; n < newShape.Length; n++)
                 {
-                    var oldShapeList = oldShape.ToList();
-                    oldShapeList.Insert(axis, 1);
-                    if (Enumerable.SequenceEqual(oldShapeList, newShape))
+                    if (newShape[n] == oldShape[axis])
                     {
-                        upAxis = axis;
-                        break;
+                        axisMap.Add(axis++, n);
+                        if (axis >= oldShape.Length)
+                        {
+                            break;
+                        }
                     }
                 }
 
@@ -165,7 +168,7 @@ private IRType Visit(ITypeInferenceContext context, Reshape target, DistributedT
                 {
                     ndsbp[i] = inputType.NdSBP[i] switch
                     {
-                        SBPSplit { Axis: int sx } => sx >= upAxis ? SBPSplit.S(sx + 1) : SBPSplit.S(sx),
+                        SBPSplit { Axis: int sx } => SBPSplit.S(axisMap[sx]),
                         SBP sbp => sbp,
                     };
                 }
@@ -174,15 +177,17 @@ private IRType Visit(ITypeInferenceContext context, Reshape target, DistributedT
             }
             else if (oldShape.Length > newShape.Length)
             {
-                var downAxis = 0;
-                foreach (var axis in Enumerable.Range(0, oldShape.Rank + 1))
+                var axis = 0;
+                var axisMap = new Dictionary<int, int>();
+                for (var o = 0; o < oldShape.Length; o++)
                 {
-                    var oldShapeList = oldShape.ToList();
-                    oldShapeList.RemoveAt(axis);
-                    if (Enumerable.SequenceEqual(oldShapeList, newShape))
+                    if (oldShape[o] == newShape[axis])
                     {
-                        downAxis = axis;
-                        break;
+                        axisMap.Add(o, axis++);
+                        if (axis >= newShape.Length)
+                        {
+                            break;
+                        }
                     }
                 }
 
@@ -191,7 +196,7 @@ private IRType Visit(ITypeInferenceContext context, Reshape target, DistributedT
                 {
                     ndsbp[i] = inputType.NdSBP[i] switch
                     {
-                        SBPSplit { Axis: int sx } => sx >= downAxis ? SBPSplit.S(sx - 1) : SBPSplit.S(sx),
+                        SBPSplit { Axis: int sx } => SBPSplit.S(axisMap[sx]),
                         SBP sbp => sbp,
                     };
                 }

From 02219e3b43ea5440c50b2aca6beac6247c7dbd02 Mon Sep 17 00:00:00 2001
From: zhengqihang <597323109@qq.com>
Date: Wed, 18 Oct 2023 19:16:49 +0800
Subject: [PATCH 254/308] add cos dump

---
 src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index ddfc2f7f1a..f87b3581c2 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -96,10 +96,7 @@ public async Task TestCpuFunction(Function main, Tensor[] inputs)
             }
 #endif
             var cos = Tests.Comparator.CosSimilarity(outputs, inputs[parameterLength..]);
-            for (int i = 0; i < cos.Length; i++)
-            {
-                Assert.True(cos[i] > 0.999, $"the outputs[{i}] cos is {cos[i]}!");
-            }
+            Assert.True(cos.All(c => c > 0.999), string.Join("\n", cos.Select((c, i) => $"the outputs[{i}] cos is {c}!")));
         }
     }
 

From 5027cc4e729047afdfe5b6348afb1ec4a20d957b Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 18 Oct 2023 19:17:18 +0800
Subject: [PATCH 255/308] fix build

---
 modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index dd32a0baf3..e0286de4fd 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -345,6 +345,7 @@ protected override CSymbol VisitCall(Call expr)
 
                         IndentScope.Writer.Write($"binary({lhsStr}, {rhsStr}, {Visit(args[2]).Name}, binary_op_t::{binary.BinaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
                     }
+
                     break;
                 case IR.XPU.Matmul matmul:
                     IndentScope.Writer.Write($"matmul({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name})");
@@ -546,7 +547,7 @@ protected override CSymbol VisitCall(Call expr)
 
                         if (Enumerable.SequenceEqual(inputShape, args[0].CheckedShape.ToValueArray()))
                         {
-                            IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}), {ret_name}_tmp{(args[1].CheckedShape).ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)});\n");
+                            IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}), {ret_name}_tmp{args[1].CheckedShape.ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)});\n");
                         }
                         else
                         {

From a15e7f6c906df94e01f26c4c1dac4235f1a822c5 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 18 Oct 2023 19:50:08 +0800
Subject: [PATCH 256/308] speed up onnx external data load

---
 tests/onnx_test_runner.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/onnx_test_runner.py b/tests/onnx_test_runner.py
index 97be07a2fd..823ffed48b 100644
--- a/tests/onnx_test_runner.py
+++ b/tests/onnx_test_runner.py
@@ -50,9 +50,12 @@ def run(self, model_file):
                 if external_data_helper.uses_external_data(tensor):
                     info = external_data_helper.ExternalDataInfo(tensor)
                     file_location = external_data_helper._sanitize_path(info.location)
-                    external_data_file_path = os.path.join(
+                    external_data_src_path = os.path.join(
                         os.path.dirname(model_file), file_location)
-                    shutil.copy(external_data_file_path, self.case_dir)
+                    external_data_dst_path = os.path.join(
+                        self.case_dir, file_location)
+                    if not os.path.exists(external_data_dst_path):
+                        os.symlink(external_data_src_path, external_data_dst_path)
             model_file = new_file
 
         if not self.inputs:

From 8292ad09d9bc3672259ea028716c66a375227f68 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 19 Oct 2023 11:55:33 +0800
Subject: [PATCH 257/308] add typeinfer case for binary/matmul

---
 src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
index 1697d3ce3a..2ea8d31c86 100644
--- a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
@@ -45,7 +45,12 @@ public sealed class UnitTestTypeInfer : TestClassBase
         { BinaryOp.Add,
           new DistributedType(new(DataTypes.Float32, new[] { 3072 }), new SBP[] { SBP.S(0), SBP.S(0) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
           new DistributedType(new(DataTypes.Float32, new[] { 1, 77, 3072 }), new SBP[] { SBP.B, SBP.B }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 77, 3072 }), new SBP[] { SBP.S(2), SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt"))
+          new InvalidType(string.Empty)
+        },
+        { BinaryOp.Add,
+          new DistributedType(new(DataTypes.Float32, new[] { 16, 32, 32 }), new SBP[] { SBP.S(0), SBP.B }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 16, 32, 32 }), new SBP[] { SBP.B, SBP.S(0) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
+          new InvalidType(string.Empty)
         },
     };
 
@@ -135,7 +140,7 @@ public void TestInferMatmulProduct()
             }
         }
 
-        Assert.Equal(64, count);
+        Assert.Equal(16, count);
     }
 
     [Fact]
@@ -200,6 +205,10 @@ public InferMatmulData()
                 new(new(DataTypes.Float32, lhs), new SBP[] { SBP.S(1), SBP.S(1) }, placement),
                 new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(0), SBP.S(0) }, placement),
                 new DistributedType(new(DataTypes.Float32, o), new SBP[] { SBP.S(1), SBP.S(1) }, placement));
+            Add(
+            new(new(DataTypes.Float32, lhs), new SBP[] { SBP.S(1), SBP.B }, placement),
+            new(new(DataTypes.Float32, rhs), new SBP[] { SBP.B, SBP.S(0) }, placement),
+            new InvalidType(string.Empty));
         }
 
         {

From 8208c71a32fa01aa3cf83399d9de1259f5512573 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 19 Oct 2023 11:56:43 +0800
Subject: [PATCH 258/308] move matmul rvv to kernels

---
 .../cpu/src/runtime/cmodel/include/matmul.h   | 41 ++++++++++++++---
 modules/cpu/src/runtime/method_table_def.h    |  5 ---
 modules/cpu/src/runtime/method_table_impl.h   | 44 -------------------
 3 files changed, 36 insertions(+), 54 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/cpu/src/runtime/cmodel/include/matmul.h
index 04ae5c4165..3b896109d6 100644
--- a/modules/cpu/src/runtime/cmodel/include/matmul.h
+++ b/modules/cpu/src/runtime/cmodel/include/matmul.h
@@ -1,4 +1,7 @@
 #include "runtime_utils.h"
+#ifdef __riscv_vector
+#include <riscv_vector.h>
+#endif
 
 namespace kernels {
 
@@ -26,6 +29,35 @@ void matmul_unit_impl(const T *input_a, const T *input_b, T *output,
     }
 }
 
+#ifdef __riscv_vector
+inline void matmul_rvv_impl(const float *input_a, const float *input_b,
+                            float *output, size_t size_m, size_t size_k,
+                            size_t size_n, size_t lda, size_t ldb, size_t ldc) {
+    size_t vl;
+    for (size_t m = 0; m < size_m; ++m) {
+        const float *b_n_ptr = input_b;
+        float *c_n_ptr = output;
+        for (size_t c_n_count = size_n; c_n_count; c_n_count -= vl) {
+            vl = vsetvl_e32m1(c_n_count);
+            const float *a_k_ptr = input_a;
+            const float *b_k_ptr = b_n_ptr;
+            vfloat32m1_t acc = vle32_v_f32m1(c_n_ptr, vl);
+            for (size_t k = 0; k < size_k; ++k) {
+                vfloat32m1_t b_n_data = vle32_v_f32m1(b_k_ptr, vl);
+                acc = vfmacc_vf_f32m1(acc, *a_k_ptr, b_n_data, vl);
+                b_k_ptr += ldb;
+                a_k_ptr++;
+            }
+            vse32_v_f32m1(c_n_ptr, acc, vl);
+            c_n_ptr += vl;
+            b_n_ptr += vl;
+        }
+        input_a += lda;
+        output += ldc;
+    }
+}
+#endif
+
 template <typename T>
 void contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                             gsl::span<const size_t> in_a_shape,
@@ -60,7 +92,7 @@ void contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                 auto ah = new_a_shape[2] == 1 ? 0 : h;
                 auto bh = new_b_shape[2] == 1 ? 0 : h;
 #ifdef __riscv_vector
-                nncase_mt->matmul_unit_impl(
+                matmul_rvv_impl(
                     input_a + an * ab_size + ac * ah_size + ah * a_unit_size,
                     input_b + bn * bb_size + bc * bh_size + bh * b_unit_size,
                     output + n * ob_size + c * oh_size + h * out_unit_size,
@@ -108,10 +140,9 @@ void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
                 T *out_ptr = output + n * new_out_stride[0] +
                              c * new_out_stride[1] + h * new_out_stride[2];
 #ifdef __riscv_vector
-                nncase_mt->matmul_unit_impl(in_a_ptr, in_b_ptr, out_ptr,
-                                            new_a_shape[3], new_a_shape[4],
-                                            new_b_shape[4], new_a_stride[3],
-                                            new_b_stride[3], new_b_stride[3]);
+                matmul_rvv_impl(in_a_ptr, in_b_ptr, out_ptr, new_a_shape[3],
+                                new_a_shape[4], new_b_shape[4], new_a_stride[3],
+                                new_b_stride[3], new_b_stride[3]);
 #else
                 for (size_t m = 0; m < new_a_shape[3]; m++) {
                     T *values =
diff --git a/modules/cpu/src/runtime/method_table_def.h b/modules/cpu/src/runtime/method_table_def.h
index e7d4030b61..f7c823ed40 100644
--- a/modules/cpu/src/runtime/method_table_def.h
+++ b/modules/cpu/src/runtime/method_table_def.h
@@ -68,11 +68,6 @@ typedef struct nncase_method_table {
     void *(*thread_start)(void *(*callable)(void *), void *user,
                           size_t user_size);
     void *(*thread_end)();
-
-    // rvv impl
-    void (*matmul_unit_impl)(const float *input_a, const float *input_b,
-                             float *output, size_t size_m, size_t size_k,
-                             size_t size_n, size_t lda, size_t ldb, size_t ldc);
 } nncase_mt_t;
 
 typedef struct buffer {
diff --git a/modules/cpu/src/runtime/method_table_impl.h b/modules/cpu/src/runtime/method_table_impl.h
index 1f42976b2d..98d6ccc14a 100644
--- a/modules/cpu/src/runtime/method_table_impl.h
+++ b/modules/cpu/src/runtime/method_table_impl.h
@@ -9,9 +9,6 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
-#ifdef __riscv_vector
-#include <riscv_vector.h>
-#endif
 
 BEGIN_NS_NNCASE_RT_MODULE(cpu)
 
@@ -67,46 +64,6 @@ inline bool bool_binary_logical_and(bool x, bool y) { return x && y; }
 inline bool bool_binary_logical_or(bool x, bool y) { return x || y; }
 inline bool bool_binary_logical_xor(bool x, bool y) { return x ^ y; }
 
-#ifdef __riscv_vector
-inline void matmul_unit_impl(const float *input_a, const float *input_b,
-                             float *output, size_t size_m, size_t size_k,
-                             size_t size_n, size_t lda, size_t ldb,
-                             size_t ldc) {
-    size_t vl;
-    for (size_t m = 0; m < size_m; ++m) {
-        const float *b_n_ptr = input_b;
-        float *c_n_ptr = output;
-        for (size_t c_n_count = size_n; c_n_count; c_n_count -= vl) {
-            vl = vsetvl_e32m1(c_n_count);
-            const float *a_k_ptr = input_a;
-            const float *b_k_ptr = b_n_ptr;
-            vfloat32m1_t acc = vle32_v_f32m1(c_n_ptr, vl);
-            for (size_t k = 0; k < size_k; ++k) {
-                vfloat32m1_t b_n_data = vle32_v_f32m1(b_k_ptr, vl);
-                acc = vfmacc_vf_f32m1(acc, *a_k_ptr, b_n_data, vl);
-                b_k_ptr += ldb;
-                a_k_ptr++;
-            }
-            vse32_v_f32m1(c_n_ptr, acc, vl);
-            c_n_ptr += vl;
-            b_n_ptr += vl;
-        }
-        input_a += lda;
-        output += ldc;
-    }
-}
-#else
-inline void
-matmul_unit_impl([[maybe_unused]] const float *input_a,
-                 [[maybe_unused]] const float *input_b,
-                 [[maybe_unused]] float *output, [[maybe_unused]] size_t size_m,
-                 [[maybe_unused]] size_t size_k, [[maybe_unused]] size_t size_n,
-                 [[maybe_unused]] size_t lda, [[maybe_unused]] size_t ldb,
-                 [[maybe_unused]] size_t ldc) {
-    throw std::runtime_error("not supported");
-}
-#endif
-
 [[maybe_unused]] static nncase_mt_t nncase_mt = {
     fabsf,
     acosf,
@@ -162,7 +119,6 @@ matmul_unit_impl([[maybe_unused]] const float *input_a,
     bool_binary_logical_xor,
     thread_pool::thread_start,
     thread_pool::thread_end,
-    matmul_unit_impl,
 };
 
 inline void *rt_malloc(size_t size) { return (void *)new uint8_t[size](); }

From b4fbc0c7d20d67e671bd1da724f74af7ada9cea6 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 19 Oct 2023 13:51:49 +0800
Subject: [PATCH 259/308] fix conv2d kernel

---
 modules/cpu/src/runtime/cmodel/include/tdma.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index d1fa7273c6..a56bc4909f 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -132,7 +132,7 @@ template <typename T, loc_t InLoc>
 T *im2col(tensor<T, InLoc> &input, dims_t filter, dims_t padding, dims_t stride,
           [[maybe_unused]] dims_t dilation = {1, 1},
           [[maybe_unused]] int32_t groups = 1) {
-    // todo: support dilated and group conv2d
+    // todo: support group conv2d
     int32_t N = input.dimension()[0];
     int32_t C = input.dimension()[1];
     int32_t H = input.dimension()[2] + padding[0] + padding[1];
@@ -180,7 +180,7 @@ void conv2d(thread_context &ctx, tensor<T, InLoc> &input,
             tensor<T, OutLoc> &output, dims_t stride, dims_t padding,
             dims_t dilation = {1, 1}, int32_t groups = 1,
             reduce_strategy_t strategy = reduce_strategy_t::none) {
-    // todo: support dilated and group conv2d
+    // todo: support group conv2d
     size_t N = input.dimension()[0];
     size_t C = input.dimension()[1];
     size_t H = input.dimension()[2] + padding[0] + padding[1];
@@ -203,7 +203,7 @@ void conv2d(thread_context &ctx, tensor<T, InLoc> &input,
         gsl::make_span(dims_t{OH * OW * N, 1}),
         gsl::make_span(dims_t{M, OH * OW * N}),
         gsl::make_span(dims_t{OH * OW * N, 1}));
-    delete[] input_cols;
+    runtime_util->free(input_cols);
 
     switch (strategy) {
     case reduce_strategy_t::by_thread:

From 40c9e7fd3568ef4dc3d8441ffbfe005f30b3dec5 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 19 Oct 2023 18:54:44 +0800
Subject: [PATCH 260/308] fix Unet Fusion

---
 modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
index 9ba268e927..fbf7b2f0b1 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
@@ -186,7 +186,7 @@ private static Pattern CreatePattern()
         var merger = new UnetMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("UnetSpatialTransformer", $"{nameof(FuseUnetSpatialTransformer)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        var callFusion = new Call(new Fusion("UnetSpatialTransformer", $"{nameof(FuseUnetSpatialTransformer)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input, encoderHiddenStates);
         return callFusion;
     }
 }

From ee3d00f7eac1f2d81900c7d16f2ff80746822f09 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Thu, 19 Oct 2023 18:57:36 +0800
Subject: [PATCH 261/308] optimize dynamic onnx

---
 tests/onnx_test_runner.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/onnx_test_runner.py b/tests/onnx_test_runner.py
index 823ffed48b..22081c346e 100644
--- a/tests/onnx_test_runner.py
+++ b/tests/onnx_test_runner.py
@@ -169,7 +169,7 @@ def is_dynamic(output):
         outputs = onnx_model.graph.output
         self.dynamic = any(is_dynamic(output) for output in outputs)
         # make a static model for infer output
-        if self.dynamic:
+        if self.dynamic and onnx_model.ByteSize() < 2147483648:
             input_shapes = list(map(lambda input: {input['name']: input['shape']}, self.inputs))
             input_shapes = dict(ChainMap(*input_shapes))
             (onnx_model, _) = onnxsim.simplify(onnx_model, input_shapes=input_shapes)

From 68a81939d4ce1104638a732fadfc2f3628bf9239 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 20 Oct 2023 16:17:06 +0800
Subject: [PATCH 262/308] change fusion counter

---
 modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs | 10 +++++-----
 .../Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs    |  2 +-
 .../Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs    | 12 ++++++++----
 modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs |  6 +++---
 src/Nncase.Passes/Rules/Neutral/FusionMaker.cs       |  4 +---
 5 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index 3fb857a4bd..74ca6d7929 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -136,7 +136,7 @@ private static Pattern CreatePattern()
             new Var(mask.CheckedType!),
         };
 
-        var callFusion = new Call(new Fusion("MHABertBase", $"{nameof(FuseMHA1)}_{Count}", ModuleKind, root, newInputs.OfType<Var>().ToArray()), x, mask);
+        var callFusion = new Call(new Fusion("MHABertBase", $"{nameof(FuseMHA1)}_{Count++}", ModuleKind, root, newInputs.OfType<Var>().ToArray()), x, mask);
         return callFusion;
     }
 }
@@ -251,7 +251,7 @@ private static Pattern CreatePattern()
         var merger = new MHAMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("MHALLaMA65B", $"{nameof(FuseMHA2)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), hidden_in, position_ids, attn_mask);
+        var callFusion = new Call(new Fusion("MHALLaMA65B", $"{nameof(FuseMHA2)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), hidden_in, position_ids, attn_mask);
         return callFusion;
     }
 }
@@ -311,7 +311,7 @@ private static Pattern CreatePattern()
         var merger = new MHAMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("SDTextEncoderMHA", $"{nameof(FuseMHA3)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        var callFusion = new Call(new Fusion("SDTextEncoderMHA", $"{nameof(FuseMHA3)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
         return callFusion;
     }
 }
@@ -348,7 +348,7 @@ private static Pattern CreatePattern()
         var merger = new MHAMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("SDTextEncoderHeader", $"{nameof(FuseSDTextEncoderHeader)}_{Count}", ModuleKind, clonedRoot, newInputs.ToArray()), input);
+        var callFusion = new Call(new Fusion("SDTextEncoderHeader", $"{nameof(FuseSDTextEncoderHeader)}_{Count++}", ModuleKind, clonedRoot, newInputs.ToArray()), input);
         return callFusion;
     }
 }
@@ -392,7 +392,7 @@ private static Pattern CreatePattern()
         var merger = new MHAMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("SDTextEncoderTail", $"{nameof(FuseSDTextEncoderTail)}_{Count}", ModuleKind, clonedRoot, newInputs), input_ids, input);
+        var callFusion = new Call(new Fusion("SDTextEncoderTail", $"{nameof(FuseSDTextEncoderTail)}_{Count++}", ModuleKind, clonedRoot, newInputs), input_ids, input);
         return callFusion;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
index 54e6eb725f..617c829c51 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
@@ -40,7 +40,7 @@ internal sealed partial class CPUFusion : FusionMaker
         }
 
         var newCall = new Call(op, newInputs.ToArray());
-        var callFusion = new Call(new Fusion($"{op.Target.GetType().Name}_{Count}", ModuleKind, newCall, newInputs.OfType<Var>().ToArray()), newInputs.Select((e, i) => (e, i)).Where(p => p.e is Var).Select(p => callParams[p.i]).ToArray());
+        var callFusion = new Call(new Fusion($"{op.Target.GetType().Name}_{Count++}", ModuleKind, newCall, newInputs.OfType<Var>().ToArray()), newInputs.Select((e, i) => (e, i)).Where(p => p.e is Var).Select(p => callParams[p.i]).ToArray());
         return callFusion;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
index fbf7b2f0b1..dcf179d0e9 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
@@ -186,7 +186,8 @@ private static Pattern CreatePattern()
         var merger = new UnetMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("UnetSpatialTransformer", $"{nameof(FuseUnetSpatialTransformer)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input, encoderHiddenStates);
+        var callFusion = new Call(new Fusion("UnetSpatialTransformer", $"{nameof(FuseUnetSpatialTransformer)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input, encoderHiddenStates);
+        CompilerServices.DumpCSharpIR(((Fusion)callFusion.Target).Body, $"st{Count-1}", "/data/huochenghai/GNNE/rebuild-ir/nncase/tests_output");
         return callFusion;
     }
 }
@@ -243,7 +244,8 @@ private static Pattern CreatePattern()
         var v38 = IsBinary(null, "root", BinaryOp.Add, conv2, v36);
         var v39 = IsBinary(null, "root", BinaryOp.Add, conv1, v36);
         var v40 = IsBinary(null, "root", BinaryOp.Add, vIn, v36);
-        var root = IsAlt(v37, v38, v39, v40);
+        // var root = IsAlt(v37, v38, v39, v40);
+        var root = IsTuple("root", IsVArgs(v6, v7, conv1));
 
         return root!;
     }
@@ -274,7 +276,8 @@ private static Pattern CreatePattern()
         var merger = new UnetMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("UnetResBlock", $"{nameof(FuseUnetResBlock)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), oldInputs.ToArray());
+        var callFusion = new Call(new Fusion("UnetResBlock", $"{nameof(FuseUnetResBlock)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), oldInputs.ToArray());
+        CompilerServices.DumpCSharpIR(((Fusion)callFusion.Target).Body, $"res{Count-1}", "/data/huochenghai/GNNE/rebuild-ir/nncase/tests_output");
         return callFusion;
     }
 }
@@ -328,7 +331,8 @@ private static Pattern CreatePattern()
         var merger = new UnetMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("UnetTimeEmb", $"{nameof(FuseUnetTimeEmb)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        var callFusion = new Call(new Fusion("UnetTimeEmb", $"{nameof(FuseUnetTimeEmb)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        CompilerServices.DumpCSharpIR(((Fusion)callFusion.Target).Body, $"emb{Count-1}", "/data/huochenghai/GNNE/rebuild-ir/nncase/tests_output");
         return callFusion;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
index a223e9333d..b43271a7b6 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
@@ -123,7 +123,7 @@ private static Pattern CreatePattern()
         var merger = new VAEMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("VAEDecRes", $"{nameof(FuseVAEDecRes)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        var callFusion = new Call(new Fusion("VAEDecRes", $"{nameof(FuseVAEDecRes)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
         return callFusion;
     }
 }
@@ -166,7 +166,7 @@ private static Pattern CreatePattern()
         var merger = new VAEMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("VAEDecHead", $"{nameof(FuseVAEDecHead)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        var callFusion = new Call(new Fusion("VAEDecHead", $"{nameof(FuseVAEDecHead)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
         return callFusion;
     }
 }
@@ -225,7 +225,7 @@ private static Pattern CreatePattern()
         var merger = new VAEMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
-        var callFusion = new Call(new Fusion("VAEDecMHA", $"{nameof(FuseVAEDecMHA)}_{Count}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
+        var callFusion = new Call(new Fusion("VAEDecMHA", $"{nameof(FuseVAEDecMHA)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
         return callFusion;
     }
 }
diff --git a/src/Nncase.Passes/Rules/Neutral/FusionMaker.cs b/src/Nncase.Passes/Rules/Neutral/FusionMaker.cs
index 7d64ddd81f..9b77082ecf 100644
--- a/src/Nncase.Passes/Rules/Neutral/FusionMaker.cs
+++ b/src/Nncase.Passes/Rules/Neutral/FusionMaker.cs
@@ -22,9 +22,7 @@ namespace Nncase.Passes.Rules.Neutral;
 
 public abstract class FusionMaker : RewriteRule<Pattern>
 {
-    private int _count;
-
-    public int Count { get => _count++; }
+    public int Count { get; set; }
 
     public virtual string Name { get; } = "FusionMaker";
 

From 91604cdf1f03bb84d6afa70a76338b4dc180a6bd Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Fri, 20 Oct 2023 16:17:36 +0800
Subject: [PATCH 263/308] fix conv2d if split is partial

---
 modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index bc529cc3fa..43e6950352 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -220,7 +220,9 @@ private void GenerateTranspose(Transpose transpose, int[] perm, Buffer[] argumen
 
     private void GenerateConv2D(Conv2D conv, Buffer[] arguments, Buffer ret, int[] stride, int[] padding, int[] dilation, int groups, TensorConst fusedClamp, DistributedType distributedType)
     {
-        _mainBody.Add(IR.F.XPU.Conv2D(arguments[0], arguments[1], arguments[2], ret, stride, padding, dilation, groups, fusedClamp, distributedType));
+        // conv2d kernel can handle partial itself
+        var ndsbp = distributedType.NdSBP.Select(sbp => sbp is SBPPartialSum ? SBP.B : sbp).ToArray();
+        _mainBody.Add(IR.F.XPU.Conv2D(arguments[0], arguments[1], arguments[2], ret, stride, padding, dilation, groups, fusedClamp, distributedType with { NdSBP = ndsbp }));
     }
 
     private void GenerateReduceArg(ReduceArg reduceArg, Buffer[] arguments, Buffer ret, int axis, bool keepdims, bool selectLastIndex, ReduceArgOp op, DataType dataType)

From 33b3ebd6fd386b0e45cb55aff0992e9bc0393a9f Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 23 Oct 2023 11:09:09 +0800
Subject: [PATCH 264/308] split conv to conv+bias+clamp, and add xpu clamp

---
 .../CodeGen/CSourceConvertVisitor.cs          |  5 +++
 .../Nncase.Modules.CPU/Evaluator/XPU/Clamp.cs | 12 +++++
 .../Evaluator/XPU/XPUModule.cs                |  1 +
 modules/Nncase.Modules.CPU/IR/XPU/Clamp.cs    | 17 +++++++
 .../Nncase.Modules.CPU/IR/XPU/Functional.cs   |  5 +++
 .../Passes/Rules/UnetFusion.cs                | 17 ++++---
 .../Passes/Tile/TIRConvertVisitor.cs          | 12 +++--
 .../cpu/src/runtime/cmodel/include/clamp.h    | 44 +++++++++++++++++++
 modules/cpu/src/runtime/cmodel/include/tdma.h | 44 ++++++++++++-------
 src/Nncase.Core/IR/Math/Clamp.cs              |  2 +-
 src/Nncase.Evaluator/Math/Clamp.cs            | 29 ++++++++----
 11 files changed, 153 insertions(+), 35 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Evaluator/XPU/Clamp.cs
 create mode 100644 modules/Nncase.Modules.CPU/IR/XPU/Clamp.cs
 create mode 100644 modules/cpu/src/runtime/cmodel/include/clamp.h

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index e0286de4fd..41621adeb3 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -592,6 +592,11 @@ protected override CSymbol VisitCall(Call expr)
                 case IR.XPU.Expand expand:
                     IndentScope.Writer.Write($"expand({Visit(args[0]).Name}, {Visit(args[1]).Name})");
                     break;
+                case IR.XPU.Clamp clamp:
+                    string min = clamp.Min is float.NegativeInfinity ? float.MinValue.ToString() : clamp.Min.ToString();
+                    string max = clamp.Max is float.PositiveInfinity ? float.MaxValue.ToString() : clamp.Max.ToString();
+                    IndentScope.Writer.Write($"clamp({Visit(args[0]).Name}, {Visit(args[1]).Name}, (float){min}, (float){max})");
+                    break;
                 default:
                     throw new NotSupportedException(xpuOp.ToString());
             }
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Clamp.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/Clamp.cs
new file mode 100644
index 0000000000..dcc443729d
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/Clamp.cs
@@ -0,0 +1,12 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using Nncase.IR;
+using Nncase.IR.XPU;
+
+namespace Nncase.Evaluator.XPU;
+
+public sealed class ClampEvaluator : ITypeInferencer<Clamp>
+{
+    public IRType Visit(ITypeInferenceContext context, Clamp target) => TupleType.Void;
+}
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
index 927565adc0..f42826df09 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
@@ -36,5 +36,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<ResizeEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<CastEvaluator>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<ExpandEvaluator>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<ClampEvaluator>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Clamp.cs b/modules/Nncase.Modules.CPU/IR/XPU/Clamp.cs
new file mode 100644
index 0000000000..88a0cc2655
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Clamp.cs
@@ -0,0 +1,17 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System.Dynamic;
+
+namespace Nncase.IR.XPU;
+
+public sealed partial class Clamp : XPUKernelOp
+{
+    public static readonly ParameterInfo Input = new(typeof(Clamp), 0, "input");
+
+    public static readonly ParameterInfo Output = new(typeof(Clamp), 1, "output");
+
+    public float Min { get; }
+
+    public float Max { get; }
+}
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
index af6cb88813..150eab38d6 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
@@ -111,4 +111,9 @@ public static Call Expand(int[] shape, DistributedType distributedType, Expr inp
     {
         return new Call(new Expand(shape, distributedType.NdSBP), input, output);
     }
+
+    public static Call Clamp(Expr input, Expr output, float min, float max)
+    {
+        return new Call(new IR.XPU.Clamp(min, max), input, output);
+    }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
index dcf179d0e9..ae382f985b 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net.Http.Headers;
 using System.Reactive;
 using System.Text;
 using System.Threading.Tasks;
@@ -57,6 +58,16 @@ protected override Expr VisitLeafCall(Call expr, Unit context)
             arguments = arguments.Select(e => e switch { TensorConst { Value: Tensor { Shape.IsScalar: true } } tc => Const.FromTensor(Tensor.FromBytes(tc.ValueType.DType, tc.Value.BytesBuffer.ToArray(), new[] { 1 })), _ => e }).ToArray();
         }
 
+        if (target is Conv2D conv)
+        {
+            var bias = (TensorConst)arguments[2];
+            var fusedClamp = ((TensorConst)arguments[7]).Value.ToArray<float>();
+            var newConv = IR.F.NN.Conv2D(arguments[0], arguments[1], Tensor.Zeros<float>(bias.CheckedShape), arguments[3], arguments[4], arguments[5], conv.PadMode, arguments[6], new[] { float.NegativeInfinity, float.PositiveInfinity });
+            var newBias = IR.F.Math.Add(newConv, Tensor.FromBytes(bias.CheckedDataType, bias.Value.BytesBuffer.ToArray(), new[] { bias.CheckedShape[0].FixedValue, 1, 1 }));
+            var newClamp = IR.F.Math.Clamp(newBias, fusedClamp[0], fusedClamp[1]);
+            return newClamp;
+        }
+
         return expr.With(target: target, arguments: arguments);
     }
 
@@ -187,7 +198,6 @@ private static Pattern CreatePattern()
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("UnetSpatialTransformer", $"{nameof(FuseUnetSpatialTransformer)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input, encoderHiddenStates);
-        CompilerServices.DumpCSharpIR(((Fusion)callFusion.Target).Body, $"st{Count-1}", "/data/huochenghai/GNNE/rebuild-ir/nncase/tests_output");
         return callFusion;
     }
 }
@@ -244,8 +254,7 @@ private static Pattern CreatePattern()
         var v38 = IsBinary(null, "root", BinaryOp.Add, conv2, v36);
         var v39 = IsBinary(null, "root", BinaryOp.Add, conv1, v36);
         var v40 = IsBinary(null, "root", BinaryOp.Add, vIn, v36);
-        // var root = IsAlt(v37, v38, v39, v40);
-        var root = IsTuple("root", IsVArgs(v6, v7, conv1));
+        var root = IsAlt(v37, v38, v39, v40);
 
         return root!;
     }
@@ -277,7 +286,6 @@ private static Pattern CreatePattern()
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("UnetResBlock", $"{nameof(FuseUnetResBlock)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), oldInputs.ToArray());
-        CompilerServices.DumpCSharpIR(((Fusion)callFusion.Target).Body, $"res{Count-1}", "/data/huochenghai/GNNE/rebuild-ir/nncase/tests_output");
         return callFusion;
     }
 }
@@ -332,7 +340,6 @@ private static Pattern CreatePattern()
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("UnetTimeEmb", $"{nameof(FuseUnetTimeEmb)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
-        CompilerServices.DumpCSharpIR(((Fusion)callFusion.Target).Body, $"emb{Count-1}", "/data/huochenghai/GNNE/rebuild-ir/nncase/tests_output");
         return callFusion;
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
index 43e6950352..ac1ce1fbb5 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
@@ -106,6 +106,9 @@ protected override Unit VisitLeafCall(Call expr)
             case Expand expand:
                 GenerateExpand(((TensorConst)expr.Arguments[1]).Value.ToArray<int>(), (DistributedType)expr.CheckedType, arguments, ret);
                 break;
+            case Clamp clamp:
+                GenerateClamp(arguments, ret, ((TensorConst)expr.Arguments[1]).Value.ToArray<float>()[0], ((TensorConst)expr.Arguments[2]).Value.ToArray<float>()[0]);
+                break;
             default:
                 throw new NotSupportedException();
         }
@@ -220,9 +223,7 @@ private void GenerateTranspose(Transpose transpose, int[] perm, Buffer[] argumen
 
     private void GenerateConv2D(Conv2D conv, Buffer[] arguments, Buffer ret, int[] stride, int[] padding, int[] dilation, int groups, TensorConst fusedClamp, DistributedType distributedType)
     {
-        // conv2d kernel can handle partial itself
-        var ndsbp = distributedType.NdSBP.Select(sbp => sbp is SBPPartialSum ? SBP.B : sbp).ToArray();
-        _mainBody.Add(IR.F.XPU.Conv2D(arguments[0], arguments[1], arguments[2], ret, stride, padding, dilation, groups, fusedClamp, distributedType with { NdSBP = ndsbp }));
+        _mainBody.Add(IR.F.XPU.Conv2D(arguments[0], arguments[1], arguments[2], ret, stride, padding, dilation, groups, fusedClamp, distributedType));
     }
 
     private void GenerateReduceArg(ReduceArg reduceArg, Buffer[] arguments, Buffer ret, int axis, bool keepdims, bool selectLastIndex, ReduceArgOp op, DataType dataType)
@@ -245,6 +246,11 @@ private void GenerateExpand(int[] shape, DistributedType distributedType, ReadOn
         _mainBody.Add(IR.F.XPU.Expand(shape, distributedType, arguments[0], ret));
     }
 
+    private void GenerateClamp(ReadOnlySpan<Buffer> arguments, Buffer ret, float min, float max)
+    {
+        _mainBody.Add(IR.F.XPU.Clamp(arguments[0], ret, min, max));
+    }
+
 #if false
         private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
         {
diff --git a/modules/cpu/src/runtime/cmodel/include/clamp.h b/modules/cpu/src/runtime/cmodel/include/clamp.h
new file mode 100644
index 0000000000..de3a5a1ad9
--- /dev/null
+++ b/modules/cpu/src/runtime/cmodel/include/clamp.h
@@ -0,0 +1,44 @@
+/* Copyright 2019-2021 Canaan Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "../../gsl-lite.hpp"
+#include <apply.h>
+#include <runtime_utils.h>
+
+using namespace nncase::runtime::cpu;
+namespace kernels {
+namespace {
+template <class T>
+void clamp_impl(const T *input, T min, T max, T *output,
+                gsl::span<const size_t> in_shape,
+                gsl::span<const size_t> in_strides,
+                gsl::span<const size_t> out_strides) {
+    return apply(in_shape, [&](gsl::span<const size_t> index) -> void {
+        const auto v = input[offset(index, in_strides)];
+        output[offset(index, out_strides)] = static_cast<T>(
+            std::min(std::max(static_cast<float>(v), static_cast<float>(min)),
+                     static_cast<float>(max)));
+        return;
+    });
+}
+} // namespace
+
+template <class T>
+void clamp(const T *input, T *output, T min, T max,
+           gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
+           gsl::span<const size_t> out_strides) {
+    clamp_impl(input, min, max, output, in_shape, in_strides, out_strides);
+}
+} // namespace kernels
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index a56bc4909f..fbf8a4e824 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -1,5 +1,6 @@
 #pragma once
 #include "cast.h"
+#include "clamp.h"
 #include "runtime_utils.h"
 #include <apply.h>
 #include <binary.h>
@@ -205,23 +206,23 @@ void conv2d(thread_context &ctx, tensor<T, InLoc> &input,
         gsl::make_span(dims_t{OH * OW * N, 1}));
     runtime_util->free(input_cols);
 
-    switch (strategy) {
-    case reduce_strategy_t::by_thread:
-        tdma_reduce_async(mm, mm, reduce_op_t::sum, ctx);
-        break;
-    case reduce_strategy_t::by_block:
-    case reduce_strategy_t::all:
-        tdma_all_reduce_async(mm, mm, reduce_op_t::sum, strategy, ctx);
-        break;
-    default:
-        break;
-    }
-    kernels::binary(binary_op_t::add, mm.cdata().data(), bias.cdata().data(),
-                    mm.data().data(), gsl::make_span(dims_t{M, OH * OW * N}),
-                    gsl::make_span(dims_t{OH * OW * N, 1}),
-                    gsl::make_span(dims_t{M, 1}), gsl::make_span(dims_t{1, 1}),
-                    gsl::make_span(dims_t{M, OH * OW * N}),
-                    gsl::make_span(dims_t{OH * OW * N, 1}));
+    // switch (strategy) {
+    // case reduce_strategy_t::by_thread:
+    //     tdma_reduce_async(mm, mm, reduce_op_t::sum, ctx);
+    //     break;
+    // case reduce_strategy_t::by_block:
+    // case reduce_strategy_t::all:
+    //     tdma_all_reduce_async(mm, mm, reduce_op_t::sum, strategy, ctx);
+    //     break;
+    // default:
+    //     break;
+    // }
+    // kernels::binary(binary_op_t::add, mm.cdata().data(), bias.cdata().data(),
+    //                 mm.data().data(), gsl::make_span(dims_t{M, OH * OW * N}),
+    //                 gsl::make_span(dims_t{OH * OW * N, 1}),
+    //                 gsl::make_span(dims_t{M, 1}), gsl::make_span(dims_t{1,
+    //                 1}), gsl::make_span(dims_t{M, OH * OW * N}),
+    //                 gsl::make_span(dims_t{OH * OW * N, 1}));
     kernels::transpose(mm.cdata().data(), output.data().data(),
                        gsl::make_span(dims_t{M, OH, OW, N}),
                        gsl::make_span(dims_t{3, 0, 1, 2}),
@@ -838,3 +839,12 @@ void expand(tensor<T, ALoc> &in, tensor<T, BLoc> &out) {
         gsl::make_span(out.dimension()).template as_span<const size_t>(),
         gsl::make_span(out.strides()).template as_span<const size_t>());
 }
+
+template <class T, loc_t ALoc, loc_t BLoc>
+void clamp(tensor<T, ALoc> &in, tensor<T, BLoc> &out, T min, T max) {
+    kernels::clamp(
+        in.cdata().data(), out.data().data(), min, max,
+        gsl::make_span(in.dimension()).template as_span<const size_t>(),
+        gsl::make_span(in.strides()).template as_span<const size_t>(),
+        gsl::make_span(out.strides()).template as_span<const size_t>());
+}
\ No newline at end of file
diff --git a/src/Nncase.Core/IR/Math/Clamp.cs b/src/Nncase.Core/IR/Math/Clamp.cs
index 9f14cf287d..b8409f375c 100644
--- a/src/Nncase.Core/IR/Math/Clamp.cs
+++ b/src/Nncase.Core/IR/Math/Clamp.cs
@@ -21,7 +21,7 @@ public sealed partial class Clamp : Op
     /// <summary>
     /// Gets input.
     /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Clamp), 0, "input");
+    public static readonly ParameterInfo Input = new(typeof(Clamp), 0, "input", ParameterKind.Input);
 
     /// <summary>
     /// Gets min.
diff --git a/src/Nncase.Evaluator/Math/Clamp.cs b/src/Nncase.Evaluator/Math/Clamp.cs
index c2da8bb94c..383e2dd509 100644
--- a/src/Nncase.Evaluator/Math/Clamp.cs
+++ b/src/Nncase.Evaluator/Math/Clamp.cs
@@ -29,25 +29,25 @@ public IValue Visit(IEvaluateContext context, Clamp clamp)
     /// <inheritdoc/>
     public IRType Visit(ITypeInferenceContext context, Clamp target)
     {
-        var input = context.CheckArgumentType<TensorType>(target, Clamp.Input);
+        var input = context.CheckArgumentType<IRType>(target, Clamp.Input);
         var min = context.CheckArgumentType<TensorType>(target, Clamp.Min);
         var max = context.CheckArgumentType<TensorType>(target, Clamp.Max);
-        if (input.DType != min.DType || input.DType != max.DType || min.DType != max.DType)
-        {
-            return new InvalidType(
-                $"clamp type is not equal, input:{input.DType}, min:${min.DType}, max:${max.DType}");
-        }
 
-        return Visit(input, min, max);
+        return input switch
+        {
+            TensorType t => Visit(t, min, max),
+            DistributedType d => Visit(d, min, max),
+            _ => new InvalidType("Wrong Clamp Type!"),
+        };
     }
 
     /// <inheritdoc/>
     public Cost Visit(ICostEvaluateContext context, Clamp target)
     {
-        var inputType = context.GetArgumentType<TensorType>(target, Clamp.Input);
+        var inputType = context.GetArgumentType<IRType>(target, Clamp.Input);
         var minType = context.GetArgumentType<TensorType>(target, Clamp.Min);
         var maxType = context.GetArgumentType<TensorType>(target, Clamp.Max);
-        var outputType = context.GetReturnType<TensorType>();
+        var outputType = context.GetReturnType<IRType>();
 
         return new()
         {
@@ -71,6 +71,12 @@ public Metric Visit(IMetricEvaluateContext context, Clamp target)
 
     private IRType Visit(TensorType input, TensorType min, TensorType max)
     {
+        if (input.DType != min.DType || input.DType != max.DType || min.DType != max.DType)
+        {
+            return new InvalidType(
+                $"clamp type is not equal, input:{input.DType}, min:${min.DType}, max:${max.DType}");
+        }
+
         if (TypeInference.BroadcastType(input, min) is InvalidType invalidMin)
         {
             return invalidMin;
@@ -88,4 +94,9 @@ private IRType Visit(TensorType input, TensorType min, TensorType max)
 
         return input;
     }
+
+    private IRType Visit(DistributedType input, TensorType min, TensorType max)
+    {
+        return input;
+    }
 }

From aafa155ebbf4eb0d81d03f55e09d73618ce9733c Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 23 Oct 2023 11:29:39 +0800
Subject: [PATCH 265/308] update fusion merger

---
 .../Passes/Rules/FusionMerger.cs              | 81 +++++++++++++++++++
 .../Passes/Rules/MHAFusion.cs                 | 53 +-----------
 .../Passes/Rules/UnetFusion.cs                | 61 +-------------
 .../Passes/Rules/VAEFusion.cs                 | 51 +-----------
 4 files changed, 91 insertions(+), 155 deletions(-)
 create mode 100644 modules/Nncase.Modules.CPU/Passes/Rules/FusionMerger.cs

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/FusionMerger.cs b/modules/Nncase.Modules.CPU/Passes/Rules/FusionMerger.cs
new file mode 100644
index 0000000000..0b1d9923ab
--- /dev/null
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/FusionMerger.cs
@@ -0,0 +1,81 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http.Headers;
+using System.Reactive;
+using System.Text;
+using System.Threading.Tasks;
+using DryIoc.ImTools;
+using Google.OrTools.LinearSolver;
+using Nncase.IR;
+using Nncase.IR.CPU;
+using Nncase.IR.Math;
+using Nncase.IR.NN;
+using Nncase.IR.Tensors;
+using Nncase.Passes.Rules.Neutral;
+using Nncase.PatternMatch;
+using Nncase.Targets;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.Utility;
+using static Nncase.Utilities.ReplaceUtility;
+
+namespace Nncase.Passes.Rules;
+
+/// <summary>
+/// Unet Merger for all.
+/// </summary>
+public sealed class FusionMerger : ExprCloner<Unit>
+{
+    private readonly IReadOnlyDictionary<Expr, Var> _multiVarMap;
+
+    public FusionMerger(IReadOnlyDictionary<Expr, Var> multiVarMap)
+    {
+        _multiVarMap = multiVarMap;
+    }
+
+    protected override Expr VisitCall(Call expr, Unit context)
+    {
+        if (_multiVarMap.TryGetValue(expr, out var newVar))
+        {
+            return newVar;
+        }
+
+        return base.VisitCall(expr, context);
+    }
+
+    protected override Expr VisitLeafCall(Call expr, Unit context)
+    {
+        var target = Clone(expr.Target, context);
+        var arguments = CloneArray(expr.Arguments, context);
+        if (target is Binary)
+        {
+            arguments = arguments.Select(e => e switch { TensorConst { Value: Tensor { Shape.IsScalar: true } } tc => Const.FromTensor(Tensor.FromBytes(tc.ValueType.DType, tc.Value.BytesBuffer.ToArray(), new[] { 1 })), _ => e }).ToArray();
+        }
+
+        if (target is Conv2D conv)
+        {
+            var bias = (TensorConst)arguments[2];
+            var fusedClamp = ((TensorConst)arguments[7]).Value.ToArray<float>();
+            var newConv = IR.F.NN.Conv2D(arguments[0], arguments[1], Tensor.Zeros<float>(bias.CheckedShape), arguments[3], arguments[4], arguments[5], conv.PadMode, arguments[6], new[] { float.NegativeInfinity, float.PositiveInfinity });
+            var newBias = IR.F.Math.Add(newConv, Tensor.FromBytes(bias.CheckedDataType, bias.Value.BytesBuffer.ToArray(), new[] { bias.CheckedShape[0].FixedValue, 1, 1 }));
+            var newClamp = IR.F.Math.Clamp(newBias, fusedClamp[0], fusedClamp[1]);
+            return newClamp;
+        }
+
+        return expr.With(target: target, arguments: arguments);
+    }
+
+    protected override Expr VisitLeafVar(Var expr, Unit context)
+    {
+        if (_multiVarMap.TryGetValue(expr, out var newVar))
+        {
+            return newVar;
+        }
+
+        throw new InvalidOperationException();
+    }
+}
+
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index 74ca6d7929..cd1d6040a7 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -23,51 +23,6 @@
 
 namespace Nncase.Passes.Rules;
 
-/// <summary>
-/// MHA Merger for all.
-/// </summary>
-public sealed class MHAMerger : ExprCloner<Unit>
-{
-    private readonly IReadOnlyDictionary<Expr, Var> _multiVarMap;
-
-    public MHAMerger(IReadOnlyDictionary<Expr, Var> multiVarMap)
-    {
-        _multiVarMap = multiVarMap;
-    }
-
-    protected override Expr VisitCall(Call expr, Unit context)
-    {
-        if (_multiVarMap.TryGetValue(expr, out var newVar))
-        {
-            return newVar;
-        }
-
-        return base.VisitCall(expr, context);
-    }
-
-    protected override Expr VisitLeafCall(Call expr, Unit context)
-    {
-        var target = Clone(expr.Target, context);
-        var arguments = CloneArray(expr.Arguments, context);
-        if (target is Binary)
-        {
-            arguments = arguments.Select(e => e switch { TensorConst { Value: Tensor { Shape.IsScalar: true } } tc => Const.FromTensor(Tensor.FromBytes(tc.ValueType.DType, tc.Value.BytesBuffer.ToArray(), new[] { 1 })), _ => e }).ToArray();
-        }
-
-        return expr.With(target: target, arguments: arguments);
-    }
-
-    protected override Expr VisitLeafVar(Var expr, Unit context)
-    {
-        if (_multiVarMap.TryGetValue(expr, out var newVar))
-        {
-            return newVar;
-        }
-
-        throw new InvalidOperationException();
-    }
-}
-
 // pattern from BERT base
 [RuleGenerator]
 public sealed partial class FuseMHA1 : FusionMaker
@@ -248,7 +203,7 @@ private static Pattern CreatePattern()
             { position_ids, (Var)newInputs[1] },
             { attn_mask, (Var)newInputs[2] },
         };
-        var merger = new MHAMerger(multiVarMap);
+        var merger = new FusionMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("MHALLaMA65B", $"{nameof(FuseMHA2)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), hidden_in, position_ids, attn_mask);
@@ -308,7 +263,7 @@ private static Pattern CreatePattern()
         {
             { input, (Var)newInputs[0] },
         };
-        var merger = new MHAMerger(multiVarMap);
+        var merger = new FusionMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("SDTextEncoderMHA", $"{nameof(FuseMHA3)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
@@ -345,7 +300,7 @@ private static Pattern CreatePattern()
         {
             { input, newInputs[0] },
         };
-        var merger = new MHAMerger(multiVarMap);
+        var merger = new FusionMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("SDTextEncoderHeader", $"{nameof(FuseSDTextEncoderHeader)}_{Count++}", ModuleKind, clonedRoot, newInputs.ToArray()), input);
@@ -389,7 +344,7 @@ private static Pattern CreatePattern()
             { input, newInputs[1] },
         };
 
-        var merger = new MHAMerger(multiVarMap);
+        var merger = new FusionMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("SDTextEncoderTail", $"{nameof(FuseSDTextEncoderTail)}_{Count++}", ModuleKind, clonedRoot, newInputs), input_ids, input);
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
index ae382f985b..ae30765b80 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
@@ -27,61 +27,6 @@
 
 namespace Nncase.Passes.Rules;
 
-/// <summary>
-/// Unet Merger for all.
-/// </summary>
-public sealed class UnetMerger : ExprCloner<Unit>
-{
-    private readonly IReadOnlyDictionary<Expr, Var> _multiVarMap;
-
-    public UnetMerger(IReadOnlyDictionary<Expr, Var> multiVarMap)
-    {
-        _multiVarMap = multiVarMap;
-    }
-
-    protected override Expr VisitCall(Call expr, Unit context)
-    {
-        if (_multiVarMap.TryGetValue(expr, out var newVar))
-        {
-            return newVar;
-        }
-
-        return base.VisitCall(expr, context);
-    }
-
-    protected override Expr VisitLeafCall(Call expr, Unit context)
-    {
-        var target = Clone(expr.Target, context);
-        var arguments = CloneArray(expr.Arguments, context);
-        if (target is Binary)
-        {
-            arguments = arguments.Select(e => e switch { TensorConst { Value: Tensor { Shape.IsScalar: true } } tc => Const.FromTensor(Tensor.FromBytes(tc.ValueType.DType, tc.Value.BytesBuffer.ToArray(), new[] { 1 })), _ => e }).ToArray();
-        }
-
-        if (target is Conv2D conv)
-        {
-            var bias = (TensorConst)arguments[2];
-            var fusedClamp = ((TensorConst)arguments[7]).Value.ToArray<float>();
-            var newConv = IR.F.NN.Conv2D(arguments[0], arguments[1], Tensor.Zeros<float>(bias.CheckedShape), arguments[3], arguments[4], arguments[5], conv.PadMode, arguments[6], new[] { float.NegativeInfinity, float.PositiveInfinity });
-            var newBias = IR.F.Math.Add(newConv, Tensor.FromBytes(bias.CheckedDataType, bias.Value.BytesBuffer.ToArray(), new[] { bias.CheckedShape[0].FixedValue, 1, 1 }));
-            var newClamp = IR.F.Math.Clamp(newBias, fusedClamp[0], fusedClamp[1]);
-            return newClamp;
-        }
-
-        return expr.With(target: target, arguments: arguments);
-    }
-
-    protected override Expr VisitLeafVar(Var expr, Unit context)
-    {
-        if (_multiVarMap.TryGetValue(expr, out var newVar))
-        {
-            return newVar;
-        }
-
-        throw new InvalidOperationException();
-    }
-}
-
 /// <summary>
 /// stable-disffusion Unet spatial transformer.
 /// </summary>
@@ -194,7 +139,7 @@ private static Pattern CreatePattern()
             { input, (Var)newInputs[0] },
             { encoderHiddenStates, (Var)newInputs[1] },
         };
-        var merger = new UnetMerger(multiVarMap);
+        var merger = new FusionMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("UnetSpatialTransformer", $"{nameof(FuseUnetSpatialTransformer)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input, encoderHiddenStates);
@@ -282,7 +227,7 @@ private static Pattern CreatePattern()
             multiVarMap.Add(oldInputs[i], (Var)newInputs[i]);
         }
 
-        var merger = new UnetMerger(multiVarMap);
+        var merger = new FusionMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("UnetResBlock", $"{nameof(FuseUnetResBlock)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), oldInputs.ToArray());
@@ -336,7 +281,7 @@ private static Pattern CreatePattern()
         {
             { input, (Var)newInputs[0] },
         };
-        var merger = new UnetMerger(multiVarMap);
+        var merger = new FusionMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("UnetTimeEmb", $"{nameof(FuseUnetTimeEmb)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
index b43271a7b6..59e22d2587 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
@@ -24,51 +24,6 @@
 
 namespace Nncase.Passes.Rules;
 
-/// <summary>
-/// VAE Merger for all.
-/// </summary>
-public sealed class VAEMerger : ExprCloner<Unit>
-{
-    private readonly IReadOnlyDictionary<Expr, Var> _multiVarMap;
-
-    public VAEMerger(IReadOnlyDictionary<Expr, Var> multiVarMap)
-    {
-        _multiVarMap = multiVarMap;
-    }
-
-    protected override Expr VisitCall(Call expr, Unit context)
-    {
-        if (_multiVarMap.TryGetValue(expr, out var newVar))
-        {
-            return newVar;
-        }
-
-        return base.VisitCall(expr, context);
-    }
-
-    protected override Expr VisitLeafCall(Call expr, Unit context)
-    {
-        var target = Clone(expr.Target, context);
-        var arguments = CloneArray(expr.Arguments, context);
-        if (target is Binary)
-        {
-            arguments = arguments.Select(e => e switch { TensorConst { Value: Tensor { Shape.IsScalar: true } } tc => Const.FromTensor(Tensor.FromBytes(tc.ValueType.DType, tc.Value.BytesBuffer.ToArray(), new[] { 1 })), _ => e }).ToArray();
-        }
-
-        return expr.With(target: target, arguments: arguments);
-    }
-
-    protected override Expr VisitLeafVar(Var expr, Unit context)
-    {
-        if (_multiVarMap.TryGetValue(expr, out var newVar))
-        {
-            return newVar;
-        }
-
-        throw new InvalidOperationException();
-    }
-}
-
 /// <summary>
 /// stable-disffusion VAE Decoder res-block.
 /// </summary>
@@ -120,7 +75,7 @@ private static Pattern CreatePattern()
         {
             { input, (Var)newInputs[0] },
         };
-        var merger = new VAEMerger(multiVarMap);
+        var merger = new FusionMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("VAEDecRes", $"{nameof(FuseVAEDecRes)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
@@ -163,7 +118,7 @@ private static Pattern CreatePattern()
         {
             { input, (Var)newInputs[0] },
         };
-        var merger = new VAEMerger(multiVarMap);
+        var merger = new FusionMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("VAEDecHead", $"{nameof(FuseVAEDecHead)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
@@ -222,7 +177,7 @@ private static Pattern CreatePattern()
         {
             { input, (Var)newInputs[0] },
         };
-        var merger = new VAEMerger(multiVarMap);
+        var merger = new FusionMerger(multiVarMap);
         var clonedRoot = merger.Clone(root, default);
 
         var callFusion = new Call(new Fusion("VAEDecMHA", $"{nameof(FuseVAEDecMHA)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);

From 035aa97c384d4f4f827c2766dd9baa3a5603ae0a Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Mon, 23 Oct 2023 11:57:57 +0800
Subject: [PATCH 266/308] fix slice with negative axis

---
 .../CodeGen/CSourceConvertVisitor.cs          |  2 +-
 .../Evaluator/CPU/Boxing.cs                   |  9 ++++-
 .../Passes/Rules/FusionMerger.cs              |  1 -
 .../Targets/UnitTestCPUTargetTiling.cs        | 36 ++++++++++++++++++-
 4 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index 41621adeb3..c8fedc0fa3 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -451,7 +451,7 @@ protected override CSymbol VisitCall(Call expr)
                 case IR.XPU.Slice slice:
                     var begins = ((TensorConst)expr.Arguments[2]).Value.ToArray<int>();
                     var ends = ((TensorConst)expr.Arguments[3]).Value.ToArray<int>();
-                    var axes = ((TensorConst)expr.Arguments[4]).Value.ToArray<int>().ToList();
+                    var axes = ((TensorConst)expr.Arguments[4]).Value.ToArray<int>().Select(a => a >= 0 ? a : a + ((TensorType)args[0].CheckedType).Shape.Rank).ToList();
                     var retType = (TensorType)expr.Arguments[1].CheckedType;
 
                     var newbegins = Enumerable.Repeat(0, retType.Shape.Rank).ToArray();
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
index 4b9901dc12..c1e8aa5af6 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
@@ -136,6 +136,13 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
 
     public IValue Visit(IEvaluateContext context, Boxing target)
     {
-        return context.GetArgumentValue(target, Boxing.Input);
+        var input = context.GetArgumentValue(target, Boxing.Input).AsTensor();
+        var shape = target.NewType switch
+        {
+            TensorType t => t.Shape,
+            DistributedType d => d.TensorType.Shape,
+            _ => throw new NotSupportedException(),
+        };
+        return Value.FromTensor(Tensor.FromBytes(input.ElementType, input.BytesBuffer.ToArray(), shape));
     }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/FusionMerger.cs b/modules/Nncase.Modules.CPU/Passes/Rules/FusionMerger.cs
index 0b1d9923ab..f3791efba5 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/FusionMerger.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/FusionMerger.cs
@@ -78,4 +78,3 @@ protected override Expr VisitLeafVar(Var expr, Unit context)
         throw new InvalidOperationException();
     }
 }
-
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index f87b3581c2..5ac9099449 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -12,6 +12,10 @@
 using NetFabric.Hyperlinq;
 using Nncase.CodeGen;
 using Nncase.IR;
+using Nncase.IR.F;
+using Nncase.IR.Imaging;
+using Nncase.IR.Math;
+using Nncase.IR.NN;
 using Nncase.IR.Tensors;
 using Nncase.Runtime.Interop;
 using Nncase.Targets;
@@ -60,7 +64,8 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseGatherBinary))]
     // [ClassData(typeof(TilingCaseLayerNormBinary))]
     // [ClassData(typeof(TilingCaseExpand))]
-    [ClassData(typeof(TilingCaseSDMHA))]
+    // [ClassData(typeof(TilingCaseSDMHA))]
+    [ClassData(typeof(TilingCaseClamp))]
     public async Task TestCpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
@@ -925,3 +930,32 @@ public TilingCaseExpand()
         Add(main, new[] { input_tensor, output });
     }
 }
+
+internal sealed class TilingCaseClamp : TheoryData<Function, Tensor[]>
+{
+    public TilingCaseClamp()
+    {
+        var shape = new[] { 1, 32, 32 };
+        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
+
+        Fusion fusion;
+        Var fin;
+        {
+            fin = new Var("input", new TensorType(DataTypes.Float32, shape));
+            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Clamp()), fin, float.NegativeInfinity, float.PositiveInfinity);
+            fusion = new Fusion("cpu", v0, fin);
+        }
+
+        var main = new Function("clamp", new Call(fusion, input), new[] { input });
+
+        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
+
+        var feedDict = new Dictionary<Var, IValue>
+            {
+                { fin, Value.FromTensor(input_tensor) },
+            };
+        var output = fusion.Body.Evaluate(feedDict).AsTensor();
+
+        Add(main, new[] { input_tensor, output });
+    }
+}
\ No newline at end of file

From 6ab3a9519e148ab9f2f9d828415b611ee2d12422 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Mon, 23 Oct 2023 04:04:18 +0000
Subject: [PATCH 267/308] llama-4-decoder pass (x86/rv64)

---
 cmake/dependencies.cmake                      |   5 +-
 conanfile.py                                  |   3 +-
 .../Passes/Rules/MHAFusion.cs                 | 108 +++++++--------
 modules/cpu/src/runtime/elfloader.cpp         |  42 ++++++
 src/Native/src/CMakeLists.txt                 |  15 ++-
 src/Native/src/runtime/CMakeLists.txt         |   7 +-
 src/Native/src/test_cli.cpp                   |   3 +-
 src/Nncase.Compiler/Compiler.cs               |   1 +
 .../Neutral/FoldPrePostReshapeSoftmax.cs      |  38 ++++++
 tests/importer/onnx_/model/test_llama.py      | 127 ++++++++++++++++++
 10 files changed, 285 insertions(+), 64 deletions(-)
 create mode 100644 src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
 create mode 100644 tests/importer/onnx_/model/test_llama.py

diff --git a/cmake/dependencies.cmake b/cmake/dependencies.cmake
index 85e8e1213e..a504dd889e 100644
--- a/cmake/dependencies.cmake
+++ b/cmake/dependencies.cmake
@@ -9,7 +9,10 @@ endif ()
 
 if (NOT BUILDING_RUNTIME)
     find_package(absl REQUIRED)
-    find_package(nethost REQUIRED)
+    if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "riscv64")
+    else()
+        find_package(nethost REQUIRED)
+    endif()
     find_package(fmt REQUIRED)
     find_package(magic_enum REQUIRED)
     find_package(spdlog REQUIRED)
diff --git a/conanfile.py b/conanfile.py
index 8a3a0c72b7..1a178fb4d9 100644
--- a/conanfile.py
+++ b/conanfile.py
@@ -58,7 +58,8 @@ def requirements(self):
 
         if not self.options.runtime:
             self.requires('abseil/20220623.1')
-            self.requires('nethost/6.0.11')
+            if self.settings.arch != 'riscv64':
+                self.requires('nethost/6.0.11')
             self.requires('fmt/7.1.3')
             self.requires('magic_enum/0.7.0')
             self.requires('spdlog/1.8.2')
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index 3fb857a4bd..02d3eb0f94 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -151,64 +151,63 @@ public sealed partial class FuseMHA2 : FusionMaker
 
     private static Pattern CreatePattern()
     {
-        var v0 = IsWildcard("hidden_in");
+        var v1 = IsWildcard("hidden_in");
 
-        var v1 = IsTensorConst("v1");
         var v2 = IsTensorConst("v2");
-        var v3 = IsCall("v3", IsOp<LayerNorm>(), IsVArgs(v0, v1, v2));
-        var v4 = IsTensorConst("v4");
-        var v5 = IsCall("v5", IsOp<Unsqueeze>(), IsVArgs(v3, v4));
-        var v6 = IsTensorConst("v6");
-        var v7 = IsCall("v7", IsOp<MatMul>(), IsVArgs(v5, v6));
-        var v8 = IsTensorConst("v8");
+        var v3 = IsTensorConst("v3");
+        var v4 = IsCall("v4", IsOp<LayerNorm>(), IsVArgs(v1, v2, v3));
+        var v5 = IsTensorConst("v5");
+        var v6 = IsCall("v6", IsOp<Unsqueeze>(), IsVArgs(v4, v5));
+        var v7 = IsTensorConst("v7");
+        var v8 = IsCall("v8", IsOp<MatMul>(), IsVArgs(v6, v7));
         var v9 = IsTensorConst("v9");
         var v10 = IsWildcard("position_ids");
 
-        var v11 = IsCall("v11", IsOp<Gather>(_ => true), IsVArgs(v8, v10));
+        var v11 = IsCall("v11", IsOp<Gather>(), IsVArgs(v9, v10));
         var v12 = IsTensorConst("v12");
         var v13 = IsCall("v13", IsOp<Reshape>(), IsVArgs(v11, v12));
-        var v14 = IsCall("v14", IsOp<Binary>(), IsVArgs(v7, v13));
+        var v14 = IsCall("v14", IsOp<Binary>(), IsVArgs(v8, v13));
         var v15 = IsTensorConst("v15");
         var v16 = IsTensorConst("v16");
         var v17 = IsTensorConst("v17");
         var v18 = IsTensorConst("v18");
-        var v19 = IsCall("v19", IsOp<Slice>(), IsVArgs(v7, v15, v16, v17, v18));
-        var v20 = IsCall("v20", IsOp<IR.Math.Unary>(), IsVArgs(v19));
+        var v19 = IsCall("v19", IsOp<Slice>(), IsVArgs(v8, v15, v16, v17, v18));
+        var v20 = IsCall("v20", IsOp<Unary>(), IsVArgs(v19));
         var v21 = IsTensorConst("v21");
-        var v22 = IsCall("v22", IsOp<Slice>(), IsVArgs(v7, v21, v15, v17, v18));
+        var v22 = IsCall("v22", IsOp<Slice>(), IsVArgs(v8, v21, v15, v17, v18));
         var v23 = IsTuple("v23", IsVArgs(v20, v22));
 
-        var v24 = IsTensorConst("v24");
-        var v25 = IsCall("v25", IsOp<Concat>(_ => true), IsVArgs(v23));
-        var v26 = IsTensorConst("v26");
-        var v27 = IsCall("v27", IsOp<Gather>(_ => true), IsVArgs(v26, v10));
-        var v28 = IsCall("v28", IsOp<Reshape>(), IsVArgs(v27, v12));
-        var v29 = IsCall("v29", IsOp<Binary>(), IsVArgs(v25, v28));
-        var v30 = IsCall("v30", IsOp<Binary>(), IsVArgs(v14, v29));
-        var v31 = IsTensorConst("v31");
-        var v32 = IsCall("v32", IsOp<Unsqueeze>(), IsVArgs(v3, v31));
-        var v33 = IsTensorConst("v33");
-        var v34 = IsCall("v34", IsOp<MatMul>(), IsVArgs(v32, v33));
-        var v35 = IsCall("v35", IsOp<Binary>(), IsVArgs(v34, v13));
-        var v36 = IsCall("v36", IsOp<Slice>(), IsVArgs(v34, v15, v16, v17, v18));
-        var v37 = IsCall("v37", IsOp<IR.Math.Unary>(), IsVArgs(v36));
-        var v38 = IsCall("v38", IsOp<Slice>(), IsVArgs(v34, v21, v15, v17, v18));
-        var v39 = IsTuple("v39", IsVArgs(v37, v38));
-
-        var v40 = IsCall("v40", IsOp<Concat>(_ => true), IsVArgs(v39));
-        var v41 = IsCall("v41", IsOp<Binary>(), IsVArgs(v40, v28));
-        var v42 = IsCall("v42", IsOp<Binary>(), IsVArgs(v35, v41));
-        var v43 = IsTensorConst("v43");
-        var v44 = IsCall("v44", IsOp<Transpose>(), IsVArgs(v42, v43));
-        var v45 = IsCall("v45", IsOp<MatMul>(), IsVArgs(v30, v44));
-        var v46 = IsTensorConst("v46");
-        var v47 = IsCall("v47", IsOp<Binary>(), IsVArgs(v45, v46));
-        var v48 = IsWildcard("attn_mask");
-
-        var v49 = IsCall("v49", IsOp<Binary>(), IsVArgs(v47, v48));
-        var v50 = IsCall("v50", IsOp<Softmax>(), IsVArgs(v49, v24));
+        var v24 = IsCall("v24", IsOp<Concat>(), IsVArgs(v23));
+        var v25 = IsTensorConst("v25");
+        var v26 = IsCall("v26", IsOp<Gather>(), IsVArgs(v25, v10));
+        var v27 = IsCall("v27", IsOp<Reshape>(), IsVArgs(v26, v12));
+        var v28 = IsCall("v28", IsOp<Binary>(), IsVArgs(v24, v27));
+        var v29 = IsCall("v29", IsOp<Binary>(), IsVArgs(v14, v28));
+        var v30 = IsTensorConst("v30");
+        var v31 = IsCall("v31", IsOp<Unsqueeze>(), IsVArgs(v4, v30));
+        var v32 = IsTensorConst("v32");
+        var v33 = IsCall("v33", IsOp<MatMul>(), IsVArgs(v31, v32));
+        var v34 = IsCall("v34", IsOp<Binary>(), IsVArgs(v33, v13));
+        var v35 = IsCall("v35", IsOp<Slice>(), IsVArgs(v33, v15, v16, v17, v18));
+        var v36 = IsCall("v36", IsOp<Unary>(), IsVArgs(v35));
+        var v37 = IsCall("v37", IsOp<Slice>(), IsVArgs(v33, v21, v15, v17, v18));
+        var v38 = IsTuple("v38", IsVArgs(v36, v37));
+
+        var v39 = IsCall("v39", IsOp<Concat>(), IsVArgs(v38));
+        var v40 = IsCall("v40", IsOp<Binary>(), IsVArgs(v39, v27));
+        var v41 = IsCall("v41", IsOp<Binary>(), IsVArgs(v34, v40));
+        var v42 = IsTensorConst("v42");
+        var v43 = IsCall("v43", IsOp<Transpose>(), IsVArgs(v41, v42));
+        var v44 = IsCall("v44", IsOp<MatMul>(), IsVArgs(v29, v43));
+        var v45 = IsTensorConst("v45");
+        var v46 = IsCall("v46", IsOp<Binary>(), IsVArgs(v44, v45));
+        var v47 = IsWildcard("attn_mask");
+
+        var v48 = IsCall("v48", IsOp<Binary>(), IsVArgs(v46, v47));
+        var v49 = IsTensorConst("v49");
+        var v50 = IsCall("v50", IsOp<Softmax>(), IsVArgs(v48, v49));
         var v51 = IsTensorConst("v51");
-        var v52 = IsCall("v52", IsOp<Unsqueeze>(), IsVArgs(v3, v51));
+        var v52 = IsCall("v52", IsOp<Unsqueeze>(), IsVArgs(v4, v51));
         var v53 = IsTensorConst("v53");
         var v54 = IsCall("v54", IsOp<MatMul>(), IsVArgs(v52, v53));
         var v55 = IsCall("v55", IsOp<MatMul>(), IsVArgs(v50, v54));
@@ -218,19 +217,20 @@ private static Pattern CreatePattern()
         var v59 = IsCall("v59", IsOp<Reshape>(), IsVArgs(v57, v58));
         var v60 = IsTensorConst("v60");
         var v61 = IsCall("v61", IsOp<MatMul>(), IsVArgs(v59, v60));
-        var v62 = IsCall("v62", IsOp<Binary>(), IsVArgs(v0, v61));
-        var v63 = IsCall("v63", IsOp<LayerNorm>(), IsVArgs(v62, v1, v2));
+        var v62 = IsCall("v62", IsOp<Binary>(), IsVArgs(v1, v61));
+        var v63 = IsCall("v63", IsOp<LayerNorm>(), IsVArgs(v62, v2, v3));
         var v64 = IsTensorConst("v64");
         var v65 = IsCall("v65", IsOp<MatMul>(), IsVArgs(v63, v64));
-        var v66 = IsCall("v66", IsOp<Swish>(), IsVArgs(v65));
-        var v67 = IsTensorConst("v67");
-        var v68 = IsCall("v68", IsOp<MatMul>(), IsVArgs(v63, v67));
-        var v69 = IsCall("v69", IsOp<Binary>(), IsVArgs(v66, v68));
-        var v70 = IsTensorConst("v70");
-        var v71 = IsCall("v71", IsOp<MatMul>(), IsVArgs(v69, v70));
-        var v72 = IsCall("root", IsOp<Binary>(), IsVArgs(v62, v71));
-
-        return v72;
+        var v66 = IsTensorConst("v66");
+        var v67 = IsCall("v67", IsOp<Swish>(), IsVArgs(v65, v66));
+        var v68 = IsTensorConst("v68");
+        var v69 = IsCall("v69", IsOp<MatMul>(), IsVArgs(v63, v68));
+        var v70 = IsCall("v70", IsOp<Binary>(), IsVArgs(v67, v69));
+        var v71 = IsTensorConst("v71");
+        var v72 = IsCall("v72", IsOp<MatMul>(), IsVArgs(v70, v71));
+        var v73 = IsCall("root", IsOp<Binary>(), IsVArgs(v62, v72));
+
+        return v73;
     }
 
     private Call? GetReplace(Call root, Expr hidden_in, Expr position_ids, Expr attn_mask)
diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/cpu/src/runtime/elfloader.cpp
index d8e1afc0aa..fbd5b7fdfa 100644
--- a/modules/cpu/src/runtime/elfloader.cpp
+++ b/modules/cpu/src/runtime/elfloader.cpp
@@ -35,8 +35,50 @@ int elfloader::invoke_elf(hardware_context_mt *hw_ctx_impl,
     // printf("Binary entrypoint is %" PRIxPTR "; invoking %p\n",
     //        (uintptr_t)ctx_.ehdr.e_entry, (void *)epaddr);
 
+#if defined(__riscv)
+    Elf_Shdr sym_shdr;
+    for (size_t i = 0; i < ctx_.ehdr.e_shnum; i++)
+    {
+        memcpy(&sym_shdr, (void*)((uintptr_t)ctx_.elf + ctx_.ehdr.e_shoff + ctx_.ehdr.e_shentsize*i), ctx_.ehdr.e_shentsize);
+        if (sym_shdr.sh_type == SHT_SYMTAB) {
+            break;
+        }
+    }
+    
+    Elf_Shdr str_shdr;
+    memcpy(&str_shdr, (void*)((uintptr_t)ctx_.elf + ctx_.ehdr.e_shoff + ctx_.ehdr.e_shentsize*sym_shdr.sh_link), ctx_.ehdr.e_shentsize);
+    
+    size_t sym_num = sym_shdr.sh_size / sym_shdr.sh_entsize;
+    Elf_Sym symbol;
+    for (size_t i = 0; i < sym_num; i++)
+    {
+        memcpy(&symbol, (void*)((uintptr_t)ctx_.elf + sym_shdr.sh_offset + sym_shdr.sh_entsize*i), sym_shdr.sh_entsize);
+        if (!strncmp((char*)((uintptr_t)ctx_.elf + str_shdr.sh_offset + symbol.st_name), "__global_pointer$", 19)) {
+            break;
+        }
+    }
+    asm volatile (
+        "addi sp, sp, -8;\
+        sd gp, 0(sp);\
+        mv gp, %0\
+        "
+        :
+        :"r"(symbol.st_value + (uintptr_t)buf_)
+        :
+    );
+#endif
     ep(hw_ctx_impl, rt_util_mt, nncase_mt_impl, inputs, rdata);
+#if defined(__riscv)
 
+    asm volatile (
+        "ld gp, 0(sp);\
+        addi sp, sp, 8;\
+        "
+        :
+        :
+        :
+    );
+#endif
     free(ptr_);
 
     return 0;
diff --git a/src/Native/src/CMakeLists.txt b/src/Native/src/CMakeLists.txt
index c4d7796400..6d0ca5d0b5 100644
--- a/src/Native/src/CMakeLists.txt
+++ b/src/Native/src/CMakeLists.txt
@@ -21,16 +21,19 @@ endif ()
 set_property(TARGET nncasebase PROPERTY POSITION_INDEPENDENT_CODE ON)
 target_link_libraries(nncasebase PUBLIC gsl::gsl-lite)
 
-add_subdirectory(compiler)
+if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "riscv64")
+else()
+    add_subdirectory(compiler)
+endif()
 add_subdirectory(runtime)
 add_subdirectory(kernels)
 
 if (NOT BUILDING_RUNTIME)
-    add_executable(nncasetest test.cpp)
-    target_link_libraries(nncasetest PRIVATE nncaseruntime)
-    if (${CMAKE_BUILD_TYPE} STREQUAL "RelWithDebInfo" AND MSVC)
-        set_target_properties(nncasetest PROPERTIES LINK_FLAGS "/PROFILE")
-    endif()
+    # add_executable(nncasetest test.cpp)
+    # target_link_libraries(nncasetest PRIVATE nncaseruntime)
+    # if (${CMAKE_BUILD_TYPE} STREQUAL "RelWithDebInfo" AND MSVC)
+    #     set_target_properties(nncasetest PROPERTIES LINK_FLAGS "/PROFILE")
+    # endif()
 
     add_executable(nncasetest_cli test_cli.cpp)
     target_link_libraries(nncasetest_cli PRIVATE nncaseruntime)
diff --git a/src/Native/src/runtime/CMakeLists.txt b/src/Native/src/runtime/CMakeLists.txt
index b892beded3..2f66042641 100644
--- a/src/Native/src/runtime/CMakeLists.txt
+++ b/src/Native/src/runtime/CMakeLists.txt
@@ -54,6 +54,7 @@ else()
     add_library(simulator OBJECT ${SRCS})
     target_include_directories(simulator PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
     target_link_libraries(simulator PUBLIC gsl::gsl-lite)
+    target_link_libraries(simulator PUBLIC fmt::fmt)
     target_link_libraries(simulator PRIVATE kernels)
     target_compile_definitions(simulator PUBLIC -DNNCASE_DLL -DNNCASE_SIMULATOR)
     if (DEFAULT_BUILTIN_RUNTIMES)
@@ -65,7 +66,11 @@ else()
     set_property(TARGET simulator PROPERTY POSITION_INDEPENDENT_CODE ON)
     
     add_library(nncaseruntime SHARED dummy.cpp)
-    target_link_libraries(nncaseruntime PRIVATE nncasebase kernels simulator compiler simulator_stackvm fmt::fmt)
+    if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "riscv64")
+      target_link_libraries(nncaseruntime PRIVATE nncasebase kernels simulator simulator_stackvm fmt::fmt)
+    else()
+      target_link_libraries(nncaseruntime PRIVATE nncasebase kernels simulator compiler simulator_stackvm fmt::fmt)
+    endif()
     target_link_libraries(nncaseruntime PUBLIC gsl::gsl-lite)
     set_target_properties(nncaseruntime PROPERTIES
                                         OUTPUT_NAME "Nncase.Runtime.Native")
diff --git a/src/Native/src/test_cli.cpp b/src/Native/src/test_cli.cpp
index 1dd265f39a..5858d3cb0c 100644
--- a/src/Native/src/test_cli.cpp
+++ b/src/Native/src/test_cli.cpp
@@ -20,7 +20,8 @@
 
 using namespace nncase;
 using namespace nncase::runtime;
-constexpr size_t loop_count = 10;
+// constexpr size_t loop_count = 10;
+constexpr size_t loop_count = 1;
 
 #define TRY(x)                                                                 \
     if (x)                                                                     \
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 03c64ed13f..b3ae68135f 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -131,6 +131,7 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.Neutral.FoldNopCast>();
             p.Add<Passes.Rules.Neutral.FoldNopReshape>();
             p.Add<Passes.Rules.Neutral.FoldNopSlice>();
+            p.Add<Passes.Rules.Neutral.FoldPrePostReshapeSoftmax>();
             p.Add<Passes.Rules.Neutral.FoldSqueezeUnsqueeze>();
             p.Add<Passes.Rules.Neutral.FoldUnsqueezeSqueeze>();
             p.Add<Passes.Rules.Neutral.FoldTwoTransposes>();
diff --git a/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs b/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
new file mode 100644
index 0000000000..ae0c04ab6d
--- /dev/null
+++ b/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
@@ -0,0 +1,38 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Nncase.IR;
+using Nncase.IR.NN;
+using Nncase.PatternMatch;
+using static Nncase.IR.F.NN;
+using static Nncase.IR.F.Tensors;
+using static Nncase.PatternMatch.F.Math;
+using static Nncase.PatternMatch.F.NN;
+using static Nncase.IR.TypePatternUtility;
+using static Nncase.PatternMatch.F.Tensors;
+using static Nncase.PatternMatch.Utility;
+
+namespace Nncase.Passes.Rules.Neutral;
+
+/// <summary>
+/// Fold nop <see cref="IR.Tensors.Concat"/>.
+/// </summary>
+[RuleGenerator]
+public sealed partial class FoldPrePostReshapeSoftmax : IRewriteRule
+{
+    /// <inheritdoc/>
+    public IPattern Pattern { get; } = IsReshape(
+        "reshape",
+        "reshapeCall",
+        _ => true,
+        IsSoftmax("softmax", IsReshape("rehsape2", "reshapeCall2", _ => true, IsWildcard("input"), IsTensorConst("shape2"))),
+        IsTensorConst("shape1"));
+
+    private Expr? GetReplace(Expr input)
+    {
+        return Softmax(input, 3);
+    }
+}
diff --git a/tests/importer/onnx_/model/test_llama.py b/tests/importer/onnx_/model/test_llama.py
new file mode 100644
index 0000000000..25c769a933
--- /dev/null
+++ b/tests/importer/onnx_/model/test_llama.py
@@ -0,0 +1,127 @@
+# Copyright 2019-2021 Canaan Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""System test: test demo"""
+# pylint: disable=invalid-name, unused-argument, import-outside-toplevel
+
+# from lzma import MODE_FAST
+# from xml.parsers.expat import model
+import pytest
+from onnx_test_runner import OnnxTestRunner
+
+
+def test_demo(request):
+    runner = OnnxTestRunner("demo1", "/root/Workspace/config/llama_config.toml")
+    # model_file = r'/data/huochenghai/onnx_model/shufflenet-9.onnx'
+    # model_file = '/compiler/huochenghai/GNNE/nncase_demo/examples/release_isp_object_detect_nncase/data/yolov5sFocus_320x3.onnx'
+    # model_file = '/data/huochenghai/GNNE/nncase_demo/examples/release_isp_retinaface_mb_320_nncase/data/retinaface_mobile0.25_320.onnx'
+    # model_file = '/data/huochenghai/GNNE/nncase_demo/examples/release_isp_face_landmarks106_nncase/data/retinaface_mobile0.25_320.onnx'
+    # model_file = '/data/huochenghai/GNNE/nncase_demo/examples/release_isp_face_landmarks106_nncase/data/v3.onnx'
+    # model_file = '/data/huochenghai/fixed_input.onnx'
+    # model_file = '/data/huochenghai/GNNE/nncase_demo/examples/release_isp_face_alignment_from_box_nncase/data/mb1_120x120.onnx'
+    # model_file = '/data/huochenghai/GNNE/nncase_demo/examples/release_isp_face_recog_mbface_nncase/data/mbface.onnx'
+    # model_file = '/data/huochenghai/GNNE/k510-gnne-compiler-tests/zhoumeng-model/resnet50v1/model_f32.onnx'
+    # model_file = '/data/huochenghai/deploy_modify.onnx'
+    # model_file = '/data/huochenghai/nanodet_mobilenetv2_416.onnx'
+    # model_file = '/data/huochenghai/yolov5_face_n0.5_256x256.onnx'
+    # model_file = '/data/huochenghai/yolov5s_0.5_640_dropact.onnx'
+    # model_file = '/data/huochenghai/GNNE/nncase_demo/examples/release_isp_object_detect_nncase/data/yolov5sFocus_320x3.onnx'
+    # model_file = '/data/huochenghai/nanodet_yolov5s_0.5_head_nospp_640.onnx'
+    # model_file = '/data/huochenghai/dw_21x21_model.onnx'
+    # model_file = '/compiler/huochenghai/GNNE/nncase/tests_output/test_decoder_part/simplified.onnx'
+    # model_file = '/data/huochenghai/onnx_model/yolop_self.onnx'
+    # model_file = '/data/huochenghai/yolov5s_640x640_sigmoid_weights.onnx'
+    # model_file = '/data/huochenghai/models/yolov5s_640_sigmoid.onnx'
+    # model_file = '/data/huochenghai/best_batchsize16_300'
+    # model_file = '/data/huochenghai/candy-9.onnx'
+    # model_file = '/data/huochenghai/glint360k_cosface_r18_fp16_0.1.onnx'
+    # model_file = '/data/huochenghai/cls_fixed2.onnx'
+    # model_file = '/data/huochenghai/stereo_ranpara.onnx'
+    # model_file = '/data/huochenghai/stereoNet.onnx'
+    # model_file = '/data/huochenghai/deploy_modify.onnx'
+    # model_file = '/data/huochenghai/model.onnx'
+    # model_file = "/data/huochenghai/onnx_model/lite-transformer-encoder.onnx"
+    # model_file = '/data/huochenghai/onnx_model/lite-transformer-decoder.onnx'
+    # model_file = '/data/huochenghai/pose_vgg_half_030.onnx'
+    # model_file = '/data/huochenghai/pose1040.onnx'
+    # model_file = '/data/huochenghai/net.onnx'
+    # model_file = '/data/huochenghai/face_expression.onnx'
+    # model_file = '/data/huochenghai/model_fixed_input_size.onnx'
+    # model_file = '/data/huochenghai/model_none_lstm.onnx'
+    # model_file = '/data/huochenghai/squeezenet1_1.onnx'
+    # model_file = '/data/huochenghai/resnet_tom.onnx'
+    # model_file = '/data/huochenghai/Ultralight-Nano-SimplePose.onnx'
+    # model_file = "/data/huochenghai/yolov5sface_640x640_6output.onnx"
+    # model_file = "/data/huochenghai/model-y1.onnx"
+    # model_file = "/data/huochenghai/sim_5.onnx"
+    # model_file = "/data/huochenghai/person_yolov5s_0.5_nospp_640_nncase.onnx"
+    # model_file = "/data/huochenghai/rec_2_layer_lstm.onnx"
+    # model_file = "/compiler/huochenghai/east_128_640.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/CRNN/ocr_rec_model_32-608.onnx"
+    # model_file = "/data/huochenghai/scrfd_person_2.5g_fixed_input_size_simplify.onnx"
+    # model_file = "/data/huochenghai/models/model_128-640-11.onnx"
+    # model_file = "/data/huochenghai/GNNE/nncase/tests_output/simplified.onnx"
+    # model_file = "/data/huochenghai/dw_deconv.onnx"
+    # model_file = "/data/huochenghai/GNNE/nncase/tests_output/test_exchannel_rhs_shape0-lhs_shape0_/simplified.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/lite-transformer/lite_transformer_encoder_L10.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/lite-transformer/lite_transformer_decoder_L10.onnx"
+    # model_file = "/data/huochenghai/lite_transformer_decoder_L10.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/yolov5s/yolov5s_640_sigmoid.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/efficientnet/efficientnet_b0_224x224.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/mobile-facenet/mbface_sim_224.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/mobile-retinaface/retinaface_mobile0.25_320_simplified.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/mobilenet-v1-ssd/ssd_mobilenetv1_300x300.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/mobilenetv2-yolov3/yolov3_mobilenetv2_no_postprocess.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/mobilenet-v2-ssd/ssd_mobilenetv2_300x300.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/yolov5m/yolov5_m_320x320_with_sigmoid.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/yolov5s_face/yolov5sface_640x640_6output.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/yolox/yolox_s.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/Ultralight-SimplePose/Ultralight-SimplePose.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/reid/osnet_x1_0.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/yolov7/0_yolov7-tiny-silu_320x320.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/reid/osnet_ain_x1_0.onnx"
+    # model_file = "/data/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/reid/osnet_ibn_x1_0.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/wzm/wzm_stereo6g.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/wzm/wzm_stereo.onnx"
+    # model_file = "/data/huochenghai/GNNE/nncase/tests_output/test_matmul_constant-in_shape0_/simplified.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/lite-transformer/youdaonmt/encoder_model.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/lite-transformer/youdaonmt/decoder_model.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/resnetv1_50/onnx/resnet50v1.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-ccompiler-tests/benchmark-test/lite-transformer/lite_transformer_encoder_L10.onnx"
+    # model_file = "/compiler/huochenghai/can3_10.0s_20221011084724.onnx"
+    # model_file = "/compiler/huochenghai/lstm_256.onnx"
+    # model_file = "/compiler/huochenghai/weilai/simplified_det.onnx"
+    # model_file = "/compiler/huochenghai/models/daniu_nmt_enc.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/centersnap/CenterSnap.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/nncase/tests_output/daniu_enc.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/yolop/yolop_self.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/daniu/e2z/dec.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/daniu/z2e/enc.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/daniu/TTS/zho/fix.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/CRNN/ocr_rec_model_32-608.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/nncase/tests_output/crnn_part.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/benchmark-test/mobile-facenet/mbface_sim_224.onnx"
+    # model_file = "/compiler/huochenghai/GNNE/k230-gnne-compiler-tests/FasterTransformer/LongFormer/longformer-base-4096.onnx"
+    # model_file = '/data/huochenghai/GNNE/k230-gnne-compiler-tests/StableDiffusion/onnx-stable-diffusion-v1-5/vae_decoder/model.onnx'
+    # model_file = "/data/huochenghai/llama_scrach/65B/decoder-merge-0.onnx"
+    # model_file = "/root/Downloads/decoder-merge-0.onnx"
+    model_file = "/root/Downloads/64B-4-layers/decoder-merge-all.onnx"
+
+    # runner.set_shape_var({"batch_size": 1, "num_channels_latent": 4, "height_latent": 64, "width_latent": 64})
+    runner.set_shape_var({"N": 384})
+    runner.run(model_file)
+
+
+if __name__ == "__main__":
+    pytest.main(
+        ['-vvs', __file__])
\ No newline at end of file

From 16b2c66e115982218d3e36f8caf47ec6d385bdf1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Mon, 23 Oct 2023 08:26:00 +0000
Subject: [PATCH 268/308] text encoder/vae decoder pass (x86/rv64)

---
 .../CodeGen/CSourceBuiltn.cs                  | 36 ++++++++++++++++-
 .../Passes/Rules/MHAFusion.cs                 |  7 ++--
 .../src/runtime/cmodel/include/reduce_arg.h   |  4 +-
 .../importer/onnx_/model/test_text_encoder.py | 39 +++++++++++++++++++
 .../importer/onnx_/model/test_vae_decoder.py  | 39 +++++++++++++++++++
 5 files changed, 119 insertions(+), 6 deletions(-)
 create mode 100644 tests/importer/onnx_/model/test_text_encoder.py
 create mode 100644 tests/importer/onnx_/model/test_vae_decoder.py

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
index 130f432953..f3afac0e3a 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
@@ -214,6 +214,37 @@ cpu_cmodel STATIC
   PUBLIC {solutionPath}/modules/cpu/src/runtime/)
 set_target_properties(cpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
+# add_definitions(-D__riscv_vector)
+foreach(LIBRARY_PATH ${{CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}})
+    # Construct the full path to the library file
+    set(CRTI_LIB_PATH ""${{LIBRARY_PATH}}/crti.o"")
+
+    # Check if the library file exists
+    if(EXISTS ${{CRTI_LIB_PATH}})
+        message(""crti.o Library found at: ${{CRTI_LIB_PATH}}"")
+        break()  # Stop searching if found
+    endif()
+endforeach()
+
+if(NOT CRTI_LIB_PATH)
+    message(""crti.o Library not found"")
+endif()
+
+foreach(LIBRARY_PATH ${{CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}})
+    # Construct the full path to the library file
+    set(CRT1_LIB_PATH ""${{LIBRARY_PATH}}/crt1.o"")
+
+    # Check if the library file exists
+    if(EXISTS ${{CRT1_LIB_PATH}})
+        message(""crt1.o Library found at: ${{CRT1_LIB_PATH}}"")
+        break()  # Stop searching if found
+    endif()
+endforeach()
+
+if(NOT CRT1_LIB_PATH)
+    message(""crt1.o Library not found"")
+endif()
+
 if(CMAKE_BUILD_TYPE STREQUAL ""Release"")
   add_compile_options(-O1)
 endif()
@@ -227,7 +258,7 @@ cpu_cmodel STATIC
   -Wl,-e,_Z6_startPN6nncase7runtime3cpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPhS8_
 )
 add_executable({name} ""main.cpp"")
-target_link_libraries({name} cpu_cmodel)
+target_link_libraries({name} cpu_cmodel ${{CRT1_LIB_PATH}} ${{CRTI_LIB_PATH}})
 ";
     }
 
@@ -278,6 +309,9 @@ public static string MakeMain(TIR.PrimFunction primFunction, IEnumerable<TIR.Buf
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
+int main() {{}}
+extern ""C"" {{void __libc_csu_fini(){{}} void __libc_csu_init(){{}}}}
+
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
             nncase_mt_t *nncase_mt_impl, uint8_t **inputs, uint8_t *rdata) {{
     runtime_util = rt_util_mt;
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index 033ea17288..f1ce5cd884 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -326,11 +326,12 @@ private static Pattern CreatePattern()
         var v15 = IsReshape(v14, IsTensorConst()); // f32[77,768]
         var v16 = IsReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64, vinput_ids, IsTensorConst(), IsTensorConst(), IsTensorConst()); // i64[1]
         var v17 = IsBinary(BinaryOp.Add, v16, IsTensorConst()); // i64[1]
-        var v18 = IsGather(null, "root", Axis: 0, v15, v17); // f32[1,768]
-        return v18;
+        var v18 = IsGather( Axis: 0, v15, v17); // f32[1,768]
+        var v19 = IsTuple("root", IsVArgs(v14, v18));
+        return v19;
     }
 
-    private Call? GetReplace(Call root, Expr input_ids, Expr input)
+    private Call? GetReplace(IR.Tuple root, Expr input_ids, Expr input)
     {
         var newInputs = new Var[]
         {
diff --git a/modules/cpu/src/runtime/cmodel/include/reduce_arg.h b/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
index 80b7b69f6e..2a6337a7c1 100644
--- a/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
+++ b/modules/cpu/src/runtime/cmodel/include/reduce_arg.h
@@ -48,8 +48,8 @@ void reduce_arg_impl(TReducer &&reducer, T init_value, const T *input,
     // update min/max idx
     apply(out_shape, [&](gsl::span<const size_t> index) -> void {
         auto out_idx = offset(out_strides, index);
-        output[out_idx] = select_last_idx ? out_map[out_idx * 2 + 0]
-                                          : out_map[out_idx * 2 + 1];
+        output[out_idx] = select_last_idx ? out_map[out_idx * 2 + 1]
+                                          : out_map[out_idx * 2 + 0];
     });
 
     runtime_util->free(out_map);
diff --git a/tests/importer/onnx_/model/test_text_encoder.py b/tests/importer/onnx_/model/test_text_encoder.py
new file mode 100644
index 0000000000..00a79aa70a
--- /dev/null
+++ b/tests/importer/onnx_/model/test_text_encoder.py
@@ -0,0 +1,39 @@
+# Copyright 2019-2021 Canaan Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""System test: test demo"""
+# pylint: disable=invalid-name, unused-argument, import-outside-toplevel
+
+# from lzma import MODE_FAST
+# from xml.parsers.expat import model
+import pytest
+from onnx_test_runner import OnnxTestRunner
+
+
+def test_demo(request):
+    # runner = OnnxTestRunner(request.node.name, "/root/Workspace/nncase/tests/importer/onnx_/model/llama_config.toml")
+    runner = OnnxTestRunner("text_encoder", "/root/Workspace/config/text_config.toml")
+    # runner = OnnxTestRunner("text_encoder")
+    #
+    model_file = "/root/Downloads/Models/text_encoder_model.onnx"
+
+    # runner.set_shape_var({"batch_size": 1, "num_channels_latent": 4, "height_latent": 64, "width_latent": 64})
+    # runner.set_shape_var({"N": 384})
+    runner.set_shape_var({"batch_size":1, "sequence_length":77})
+    # runner.set_shape_var({"batch_size:1", "sequence_length:77"})
+    runner.run(model_file)
+
+
+if __name__ == "__main__":
+    pytest.main(
+        ['-vvs', __file__])
\ No newline at end of file
diff --git a/tests/importer/onnx_/model/test_vae_decoder.py b/tests/importer/onnx_/model/test_vae_decoder.py
new file mode 100644
index 0000000000..fa3daa82a9
--- /dev/null
+++ b/tests/importer/onnx_/model/test_vae_decoder.py
@@ -0,0 +1,39 @@
+# Copyright 2019-2021 Canaan Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""System test: test demo"""
+# pylint: disable=invalid-name, unused-argument, import-outside-toplevel
+
+# from lzma import MODE_FAST
+# from xml.parsers.expat import model
+import pytest
+from onnx_test_runner import OnnxTestRunner
+
+
+def test_demo(request):
+    runner = OnnxTestRunner("test_vae_decoder", 
+                            "/root/Workspace/config/vae_config.toml")
+    # runner = OnnxTestRunner("test_vae_decoder")
+    model_file = "/root/Downloads/Models/vae_decoder.onnx"
+    # model_file = "/root/Downloads/Models/modified_modified_vae_decoder.onnx"
+    # model_file = "/root/Downloads/Models/modified_vae_decoder.onnx"
+    # model_file = "/root/Downloads/Models/model_sim_huo.onnx"
+
+    runner.set_shape_var({"batch_size": 1, "num_channels_latent": 4, "height_latent": 64, "width_latent": 64})
+    # runner.set_shape_var({"N": 384})
+    runner.run(model_file)
+
+
+if __name__ == "__main__":
+    pytest.main(
+        ['-vvs', __file__])
\ No newline at end of file

From 15716b7fd2d9d6042eb166a34caaf793a91ad76f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Mon, 23 Oct 2023 08:37:18 +0000
Subject: [PATCH 269/308] fix conan config

---
 conanfile.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/conanfile.py b/conanfile.py
index 1a178fb4d9..c532864648 100644
--- a/conanfile.py
+++ b/conanfile.py
@@ -58,7 +58,8 @@ def requirements(self):
 
         if not self.options.runtime:
             self.requires('abseil/20220623.1')
-            if self.settings.arch != 'riscv64':
+            # if self.settings.arch != 'riscv64':
+            if self.settings.arch in ['x86_64']:
                 self.requires('nethost/6.0.11')
             self.requires('fmt/7.1.3')
             self.requires('magic_enum/0.7.0')

From d5cae5386368708cb394bf9a08a50f9253c026b7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Mon, 23 Oct 2023 08:51:02 +0000
Subject: [PATCH 270/308] Fix cpu/test compile

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt | 32 ++++++++++++++++++-
 .../cmodel/tests/decoder_layer/main.cpp       |  3 ++
 .../src/runtime/cmodel/tests/embed/main.cpp   |  3 ++
 .../src/runtime/cmodel/tests/head/main.cpp    |  3 ++
 .../src/runtime/cmodel/tests/norm/main.cpp    |  3 ++
 .../src/runtime/cmodel/tests/unary/main.cpp   |  3 ++
 .../Neutral/FoldPrePostReshapeSoftmax.cs      |  2 +-
 7 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index 2e5ddae39c..c7962cff8c 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -25,6 +25,36 @@ set_target_properties(cpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
 #   OUTPUT_NAME "nncase.simulator.cpu.c")
 # install(TARGETS cpu_cmodel_cli COMPONENT nncase-runtime)
 
+# add_definitions(-D__riscv_vector)
+foreach(LIBRARY_PATH ${{CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}})
+    # Construct the full path to the library file
+    set(CRTI_LIB_PATH ""${{LIBRARY_PATH}}/crti.o"")
+
+    # Check if the library file exists
+    if(EXISTS ${{CRTI_LIB_PATH}})
+        message(""crti.o Library found at: ${{CRTI_LIB_PATH}}"")
+        break()  # Stop searching if found
+    endif()
+endforeach()
+
+if(NOT CRTI_LIB_PATH)
+    message(""crti.o Library not found"")
+endif()
+
+foreach(LIBRARY_PATH ${{CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}})
+    # Construct the full path to the library file
+    set(CRT1_LIB_PATH ""${{LIBRARY_PATH}}/crt1.o"")
+
+    # Check if the library file exists
+    if(EXISTS ${{CRT1_LIB_PATH}})
+        message(""crt1.o Library found at: ${{CRT1_LIB_PATH}}"")
+        break()  # Stop searching if found
+    endif()
+endforeach()
+
+if(NOT CRT1_LIB_PATH)
+    message(""crt1.o Library not found"")
+endif()
 
 function(add_test name test_path)
   if (CMAKE_BUILD_TYPE STREQUAL "Release")
@@ -32,7 +62,7 @@ function(add_test name test_path)
   endif()
   add_link_options(-no-pie -nostartfiles -fPIC -fno-stack-protector -static -Wl,-e,_Z6_startPN6nncase7runtime3cpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPh)
   add_executable(${name} "${test_path}/main.cpp")
-  target_link_libraries(${name} cpu_cmodel)
+  target_link_libraries({name} cpu_cmodel ${{CRT1_LIB_PATH}} ${{CRTI_LIB_PATH}})
 endfunction(add_test)
 
 # add_test(demo1 tests/demo1)
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
index ce3eddb25d..9d36b8b9a5 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
@@ -88,6 +88,9 @@ DEFINE_BFUNC(7)
     tdma_fill_async<float>(*block##i::shared::V40, 0);                         \
     tdma_fill_async<float>(*block##i::shared::V42, 0);
 
+int main() {}
+extern "C" {void __libc_csu_fini(){} void __libc_csu_init(){}}
+
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
             nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp b/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
index a1f07bfa11..d307a5bdf7 100644
--- a/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
@@ -27,6 +27,9 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
+int main() {}
+extern "C" {void __libc_csu_fini(){} void __libc_csu_init(){}}
+
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
             nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
index b981599f2f..424619bec1 100644
--- a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/head/main.cpp
@@ -30,6 +30,9 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
+int main() {}
+extern "C" {void __libc_csu_fini(){} void __libc_csu_init(){}}
+
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
             nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp b/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
index 8f5faebbe3..259ea16446 100644
--- a/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
@@ -25,6 +25,9 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
+int main() {}
+extern "C" {void __libc_csu_fini(){} void __libc_csu_init(){}}
+
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
             nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp b/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp
index 720aec388c..1ad53c5695 100755
--- a/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp
+++ b/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp
@@ -25,6 +25,9 @@ DEFINE_BFUNC(5)
 DEFINE_BFUNC(6)
 DEFINE_BFUNC(7)
 
+int main() {}
+extern "C" {void __libc_csu_fini(){} void __libc_csu_init(){}}
+
 void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
             nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
     global_hardware_init(hw_ctx_impl);
diff --git a/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs b/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
index ae0c04ab6d..e74e12cdb9 100644
--- a/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
+++ b/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
@@ -11,8 +11,8 @@
 using static Nncase.IR.F.Tensors;
 using static Nncase.PatternMatch.F.Math;
 using static Nncase.PatternMatch.F.NN;
-using static Nncase.IR.TypePatternUtility;
 using static Nncase.PatternMatch.F.Tensors;
+using static Nncase.IR.TypePatternUtility;
 using static Nncase.PatternMatch.Utility;
 
 namespace Nncase.Passes.Rules.Neutral;

From cd191ee7f35a7e2ef085ed135ee5f3dd7d328e26 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Mon, 23 Oct 2023 08:59:04 +0000
Subject: [PATCH 271/308] fix cmake config

---
 modules/cpu/src/runtime/cmodel/CMakeLists.txt | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
index c7962cff8c..1340d2981c 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/cpu/src/runtime/cmodel/CMakeLists.txt
@@ -26,34 +26,34 @@ set_target_properties(cpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
 # install(TARGETS cpu_cmodel_cli COMPONENT nncase-runtime)
 
 # add_definitions(-D__riscv_vector)
-foreach(LIBRARY_PATH ${{CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}})
+foreach(LIBRARY_PATH ${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES})
     # Construct the full path to the library file
-    set(CRTI_LIB_PATH ""${{LIBRARY_PATH}}/crti.o"")
+    set(CRTI_LIB_PATH "${LIBRARY_PATH}/crti.o")
 
     # Check if the library file exists
-    if(EXISTS ${{CRTI_LIB_PATH}})
-        message(""crti.o Library found at: ${{CRTI_LIB_PATH}}"")
+    if(EXISTS ${CRTI_LIB_PATH})
+        message("crti.o Library found at: ${CRTI_LIB_PATH}")
         break()  # Stop searching if found
     endif()
 endforeach()
 
 if(NOT CRTI_LIB_PATH)
-    message(""crti.o Library not found"")
+    message("crti.o Library not found")
 endif()
 
-foreach(LIBRARY_PATH ${{CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}})
+foreach(LIBRARY_PATH ${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES})
     # Construct the full path to the library file
-    set(CRT1_LIB_PATH ""${{LIBRARY_PATH}}/crt1.o"")
+    set(CRT1_LIB_PATH "${LIBRARY_PATH}/crt1.o")
 
     # Check if the library file exists
-    if(EXISTS ${{CRT1_LIB_PATH}})
-        message(""crt1.o Library found at: ${{CRT1_LIB_PATH}}"")
+    if(EXISTS ${CRT1_LIB_PATH})
+        message("crt1.o Library found at: ${CRT1_LIB_PATH}")
         break()  # Stop searching if found
     endif()
 endforeach()
 
 if(NOT CRT1_LIB_PATH)
-    message(""crt1.o Library not found"")
+    message("crt1.o Library not found")
 endif()
 
 function(add_test name test_path)
@@ -62,7 +62,7 @@ function(add_test name test_path)
   endif()
   add_link_options(-no-pie -nostartfiles -fPIC -fno-stack-protector -static -Wl,-e,_Z6_startPN6nncase7runtime3cpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPh)
   add_executable(${name} "${test_path}/main.cpp")
-  target_link_libraries({name} cpu_cmodel ${{CRT1_LIB_PATH}} ${{CRTI_LIB_PATH}})
+  target_link_libraries(${name} cpu_cmodel ${CRT1_LIB_PATH} ${CRTI_LIB_PATH})
 endfunction(add_test)
 
 # add_test(demo1 tests/demo1)

From 856794da926447c4f3a1e125232be6912554bed8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Mon, 23 Oct 2023 09:04:39 +0000
Subject: [PATCH 272/308] fix synax err

---
 src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs b/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
index e74e12cdb9..05c8331a04 100644
--- a/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
+++ b/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
@@ -9,10 +9,10 @@
 using Nncase.PatternMatch;
 using static Nncase.IR.F.NN;
 using static Nncase.IR.F.Tensors;
+using static Nncase.IR.TypePatternUtility;
 using static Nncase.PatternMatch.F.Math;
 using static Nncase.PatternMatch.F.NN;
 using static Nncase.PatternMatch.F.Tensors;
-using static Nncase.IR.TypePatternUtility;
 using static Nncase.PatternMatch.Utility;
 
 namespace Nncase.Passes.Rules.Neutral;

From 38d96ea75c7acdd20a908a159d99de1cf49e29fc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Mon, 23 Oct 2023 09:20:24 +0000
Subject: [PATCH 273/308] fix synax err

---
 modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs | 2 +-
 src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
index f1ce5cd884..56c9035e05 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
@@ -326,7 +326,7 @@ private static Pattern CreatePattern()
         var v15 = IsReshape(v14, IsTensorConst()); // f32[77,768]
         var v16 = IsReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64, vinput_ids, IsTensorConst(), IsTensorConst(), IsTensorConst()); // i64[1]
         var v17 = IsBinary(BinaryOp.Add, v16, IsTensorConst()); // i64[1]
-        var v18 = IsGather( Axis: 0, v15, v17); // f32[1,768]
+        var v18 = IsGather(Axis: 0, v15, v17); // f32[1,768]
         var v19 = IsTuple("root", IsVArgs(v14, v18));
         return v19;
     }
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
index 5ac9099449..850efef9f5 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
@@ -958,4 +958,4 @@ public TilingCaseClamp()
 
         Add(main, new[] { input_tensor, output });
     }
-}
\ No newline at end of file
+}

From 75215a19e9f8b819756c1e3dc6a5ec3695526785 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 24 Oct 2023 10:32:01 +0800
Subject: [PATCH 274/308] normallize axes of slice

---
 .../CodeGen/CSourceConvertVisitor.cs            |  2 +-
 src/Nncase.Compiler/Compiler.cs                 |  1 +
 src/Nncase.Passes/Rules/Neutral/NormAxis.cs     | 17 +++++++++++++++++
 3 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
index c8fedc0fa3..41621adeb3 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
@@ -451,7 +451,7 @@ protected override CSymbol VisitCall(Call expr)
                 case IR.XPU.Slice slice:
                     var begins = ((TensorConst)expr.Arguments[2]).Value.ToArray<int>();
                     var ends = ((TensorConst)expr.Arguments[3]).Value.ToArray<int>();
-                    var axes = ((TensorConst)expr.Arguments[4]).Value.ToArray<int>().Select(a => a >= 0 ? a : a + ((TensorType)args[0].CheckedType).Shape.Rank).ToList();
+                    var axes = ((TensorConst)expr.Arguments[4]).Value.ToArray<int>().ToList();
                     var retType = (TensorType)expr.Arguments[1].CheckedType;
 
                     var newbegins = Enumerable.Repeat(0, retType.Shape.Rank).ToArray();
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 203b4ebe44..4dbf6274d6 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -101,6 +101,7 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.Neutral.NormAxisReduce>();
             p.Add<Passes.Rules.Neutral.NormAxisReshape>();
             p.Add<Passes.Rules.Neutral.NormAxisReduceArg>();
+            p.Add<Passes.Rules.Neutral.NormAxisSlice>();
             p.Add<Passes.Rules.Neutral.SqueezeTransposeShape>();
             p.Add<Passes.Rules.Neutral.Squeeze5DTranspose>();
             p.Add<Passes.Rules.Neutral.SqueezeBinaryShape>();
diff --git a/src/Nncase.Passes/Rules/Neutral/NormAxis.cs b/src/Nncase.Passes/Rules/Neutral/NormAxis.cs
index 2b443edcf6..13e3c0d30b 100644
--- a/src/Nncase.Passes/Rules/Neutral/NormAxis.cs
+++ b/src/Nncase.Passes/Rules/Neutral/NormAxis.cs
@@ -96,3 +96,20 @@ public sealed partial class NormAxisReshape : RewriteRule<CallPattern>
         return null;
     }
 }
+
+[RuleGenerator]
+public sealed partial class NormAxisSlice : RewriteRule<CallPattern>
+{
+    /// <inheritdoc/>
+    public override CallPattern Pattern { get; } = IsSlice("slice", "call", IsWildcard("input") with { TypePattern = HasFixedShape() }, IsTensorConst("begins"), IsTensorConst("ends"), IsTensorConst("axes"), IsTensorConst("strides")) with { TypePattern = HasFixedShape() };
+
+    private Expr? GetReplace(Call call, Expr input, Expr begins, Expr ends, int[] axes, Expr strides)
+    {
+        if (axes.Any(dim => dim < 0))
+        {
+            return IR.F.Tensors.Slice(input, begins, ends, axes.Select(dim => dim < 0 ? dim + input.CheckedShape.Rank : dim).ToArray(), strides);
+        }
+
+        return null;
+    }
+}

From fa43840d38e972dee50ee1e4506351b0835f7524 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Tue, 24 Oct 2023 03:51:36 +0000
Subject: [PATCH 275/308] disable module cpu on windows

---
 CMakeLists.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6b746d454b..c91151fd6b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -263,5 +263,7 @@ if(BUILD_TESTING)
 endif()
 
 # Modules
+if (NOT MSVC)
 add_subdirectory(modules/cpu)
+endif()
 #add_subdirectory(modules/vulkan)

From 3ef9a9d212e62991ca7c82c03dd4475b558dd506 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Tue, 24 Oct 2023 20:07:19 +0800
Subject: [PATCH 276/308] donot split softmax on axis

---
 .../Evaluator/CPU/Boxing.cs                   | 13 +++++-------
 modules/cpu/src/runtime/cmodel/include/tdma.h | 20 ++++++++++++++++---
 src/Nncase.Evaluator/NN/Softmax.cs            | 11 +++++-----
 3 files changed, 28 insertions(+), 16 deletions(-)

diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs b/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
index c1e8aa5af6..407ba98771 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
+++ b/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
@@ -78,6 +78,10 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
                                 break;
                             case (SBPBroadCast, SBPBroadCast or SBPSplit):
                                 // no cost.
+                                cost += new Cost()
+                                {
+                                    [CostFactorNames.CPUCycles] = 1,
+                                };
                                 break;
                             case (SBPPartialSum, SBP sbpout):
                                 switch (sbpout)
@@ -136,13 +140,6 @@ public Cost Visit(ICostEvaluateContext context, Boxing target)
 
     public IValue Visit(IEvaluateContext context, Boxing target)
     {
-        var input = context.GetArgumentValue(target, Boxing.Input).AsTensor();
-        var shape = target.NewType switch
-        {
-            TensorType t => t.Shape,
-            DistributedType d => d.TensorType.Shape,
-            _ => throw new NotSupportedException(),
-        };
-        return Value.FromTensor(Tensor.FromBytes(input.ElementType, input.BytesBuffer.ToArray(), shape));
+        return context.GetArgumentValue(target, Boxing.Input);
     }
 }
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/cpu/src/runtime/cmodel/include/tdma.h
index fbf8a4e824..a4f36b8826 100644
--- a/modules/cpu/src/runtime/cmodel/include/tdma.h
+++ b/modules/cpu/src/runtime/cmodel/include/tdma.h
@@ -572,7 +572,14 @@ void reduce_async_visit_func2([[maybe_unused]] int visit, thread_context &ctx,
                       CORES * gather_tensor.strides()[0]),
                   new_dims, gather_tensor.strides());
 
-    reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
+    T init_value = (T)0;
+    if (reduce_op == reduce_op_t::min) {
+        init_value = std::numeric_limits<T>::max();
+    }
+    if (reduce_op == reduce_op_t::max) {
+        init_value = std::numeric_limits<T>::lowest();
+    }
+    reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(init_value),
            dims_t({0}), false);
 }
 
@@ -642,8 +649,15 @@ void all_reduce_async_visit_func2_all(int visit,
         tensor<T> reduced_tensor =
             tensor<T>(gsl::make_span(reduced_span, compute_size(reduced_shape)),
                       reduced_shape);
-        reduce(gather_tensor, reduced_tensor, reduce_op, (T)0, dims_t({0}),
-               false);
+        T init_value = (T)0;
+        if (reduce_op == reduce_op_t::min) {
+            init_value = std::numeric_limits<T>::max();
+        }
+        if (reduce_op == reduce_op_t::max) {
+            init_value = std::numeric_limits<T>::lowest();
+        }
+        reduce(gather_tensor, reduced_tensor, reduce_op, init_value,
+               dims_t({0}), false);
         runtime_util->free(gather_span);
         global_hardware_ctx.global_var = reduced_span;
     }
diff --git a/src/Nncase.Evaluator/NN/Softmax.cs b/src/Nncase.Evaluator/NN/Softmax.cs
index 7a183b0c6c..c7640de82f 100644
--- a/src/Nncase.Evaluator/NN/Softmax.cs
+++ b/src/Nncase.Evaluator/NN/Softmax.cs
@@ -128,11 +128,12 @@ private IRType Visit(TensorType input)
 
     private IRType Visit(DistributedType input, Expr axisExpr)
     {
-        // var axis = ((TensorConst)axisExpr).Value.ToScalar<int>();
-        // if (input.NdSBP.Any(sbp => sbp is SBPSplit s && s.Axis == axis))
-        // {
-        //     return new InvalidType("Not support split on Axis for Softmax now.");
-        // }
+        var axis = ((TensorConst)axisExpr).Value.ToScalar<int>();
+        if (input.NdSBP.Any(sbp => sbp is SBPSplit s && s.Axis == axis))
+        {
+            return new InvalidType("Not support split on Axis for Softmax now.");
+        }
+
         return input;
     }
 }

From d6b44ee0333ca9081b1cee8cc6e1136871a18ffc Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 25 Oct 2023 09:54:17 +0800
Subject: [PATCH 277/308] add softmax kernel test

---
 .../Distributed/UnitTestKernels.cs            | 48 +++++++++++++++++--
 1 file changed, 44 insertions(+), 4 deletions(-)

diff --git a/src/Nncase.Tests/Distributed/UnitTestKernels.cs b/src/Nncase.Tests/Distributed/UnitTestKernels.cs
index ca301bd61a..ec65c36e52 100644
--- a/src/Nncase.Tests/Distributed/UnitTestKernels.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestKernels.cs
@@ -38,6 +38,7 @@ public sealed class UnitTestKernels : TestClassBase
     public static readonly TheoryData<IDistributedKernelCase> Cases = new()
     {
         new BinaryCase1(),
+        new SoftmaxCase1(),
     };
 
     public UnitTestKernels()
@@ -56,8 +57,9 @@ internal async Task Run(IDistributedKernelCase kernelCase)
         // convert fusion to prim func
         var primBody = new List<Expr>();
         var visitor = new Passes.Tile.TIRConvertVisitor(primBody);
-        visitor.Visit(kernelCase.Fusion);
-        var primFunc = TIR.T.PrimFunc(kernelCase.Fusion.Name, kernelCase.Fusion.ModuleKind, visitor.InputBuffers.Concat(visitor.OutputBuffers).ToArray()).Body(primBody.ToArray()).Build();
+        var fusion = kernelCase.Fusion;
+        visitor.Visit(fusion);
+        var primFunc = TIR.T.PrimFunc(fusion.Name, fusion.ModuleKind, visitor.InputBuffers.Concat(visitor.OutputBuffers).ToArray()).Body(primBody.ToArray()).Build();
         var primWrapper = new PrimFunctionWrapper(primFunc, primFunc.Parameters.Length - 1);
         var main = new Function(new Call(primWrapper, kernelCase.Vars.ToArray()), kernelCase.Vars.ToArray());
 
@@ -65,7 +67,7 @@ internal async Task Run(IDistributedKernelCase kernelCase)
         module.Add(primWrapper);
         module.Add(primFunc);
         var inputs = kernelCase.Inputs.ToArray();
-        var output = kernelCase.Fusion.Body.Evaluate(kernelCase.Vars.Zip(inputs).ToDictionary(p => p.First, p => (IValue)Value.FromTensor(p.Second))).AsTensor();
+        var output = fusion.Body.Evaluate(kernelCase.Vars.Zip(inputs).ToDictionary(p => p.First, p => (IValue)Value.FromTensor(p.Second))).AsTensor();
 
 #if DEBUG
         for (var i = 0; i < inputs.Length; i++)
@@ -112,7 +114,7 @@ public BinaryCase1()
         var lhs = new Var(type);
         var rhs = new Var(type);
         {
-            var l0 = IR.F.CPU.Boxing(lhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.B }, place));
+            var l0 = IR.F.CPU.Boxing(lhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.S(2) }, place));
             var r0 = IR.F.CPU.Boxing(rhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.S(2) }, place));
             Fusion = new Fusion(Name + "_fusion", CPUTarget.Kind, IR.F.CPU.Boxing(l0 + r0, type), new[] { lhs, rhs });
         }
@@ -136,3 +138,41 @@ public IReadOnlyList<Tensor> Inputs
 
     public override string ToString() => Name;
 }
+
+internal sealed class SoftmaxCase1 : IDistributedKernelCase
+{
+    public SoftmaxCase1()
+    {
+        var type = new TensorType(DataTypes.Float32, new[] { 16, 1024, 1024 });
+        var input = new Var(type);
+        Vars = new[] { input };
+    }
+
+    public string Name => "SoftmaxCase1";
+
+    public Fusion Fusion
+    {
+        get
+        {
+            var type = new TensorType(DataTypes.Float32, new[] { 16, 1024, 1024 });
+            var place = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+            var axis = 2L;
+            {
+                var input0 = IR.F.CPU.Boxing(Vars[0], new DistributedType(type, new SBP[] { SBP.S(0), SBP.S(1) }, place));
+                return new Fusion(Name + "_fusion", CPUTarget.Kind, IR.F.CPU.Boxing(IR.F.NN.Softmax(input0, axis), type), new[] { Vars[0] });
+            }
+        }
+    }
+
+    public IReadOnlyList<Var> Vars { get; }
+
+    public IReadOnlyList<Tensor> Inputs
+    {
+        get
+        {
+            return Vars.Select(v => IR.F.Random.Uniform(v.CheckedDataType, 30, 0, 1, v.CheckedShape).Evaluate().AsTensor()).ToArray();
+        }
+    }
+
+    public override string ToString() => Name;
+}

From 80b10769ae6bd61524c9413b43d2c970d34fa863 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 25 Oct 2023 14:30:24 +0800
Subject: [PATCH 278/308] add rvv instance norm

---
 .../runtime/cmodel/include/instance_norm.h    | 84 ++++++++++++++++++-
 1 file changed, 82 insertions(+), 2 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/instance_norm.h b/modules/cpu/src/runtime/cmodel/include/instance_norm.h
index 9c00517226..8daaf04243 100644
--- a/modules/cpu/src/runtime/cmodel/include/instance_norm.h
+++ b/modules/cpu/src/runtime/cmodel/include/instance_norm.h
@@ -1,7 +1,6 @@
 #include "runtime_utils.h"
 #include <apply.h>
-#include <cmath>
-#ifdef __riscv_vector_
+#ifdef __riscv_vector
 #include <riscv_vector.h>
 #endif
 
@@ -9,6 +8,74 @@ using namespace nncase::runtime::cpu;
 namespace kernels {
 
 namespace {
+#ifdef __riscv_vector
+static void instance_norm_restruct2(const float *input, float *output, int len,
+                                    const float gamma, const float beta,
+                                    float mean, float sigma) {
+    size_t vl;
+    for (size_t i = len; i > 0; i -= vl) {
+        vl = vsetvl_e32m8(i);
+        vfloat32m8_t vx = vle32_v_f32m8(input, vl);
+        vx = vfsub_vf_f32m8(vx, mean, vl);
+        vx = vfdiv_vf_f32m8(vx, sigma, vl);
+        vx = vfmul_vf_f32m8(vx, gamma, vl);
+        vx = vfadd_vf_f32m8(vx, beta, vl);
+        vse32_v_f32m8(output, vx, vl);
+        input += vl;
+        output += vl;
+    }
+}
+
+template <typename T>
+void instance_norm_rvv_impl(
+    const T *input, const T *sum, const T *sum_sqr, T *output, const T *gamma,
+    const T *beta, gsl::span<const size_t> input_shape,
+    gsl::span<const size_t> input_stride, gsl::span<const size_t> output_stride,
+    [[maybe_unused]] gsl::span<const size_t> sum_strides,
+    [[maybe_unused]] gsl::span<const size_t> gamma_strides, T eps,
+    int32_t norm_size) noexcept {
+
+    auto get_offset_from_index = [](gsl::span<const size_t> in_shape,
+                                    gsl::span<const size_t> in_strides,
+                                    int index) -> int {
+        strides_t x = get_default_strides(in_shape);
+        int __sum = 0;
+        for (size_t i = 0; i < x.size(); ++i) {
+            __sum += index / x[i] * in_strides[i];
+            index = index % x[i];
+        }
+        return __sum;
+    };
+
+    size_t outer_size = 1;
+    for (auto i = 0; i < 2; i++) {
+        outer_size *= input_shape[i];
+    }
+
+    size_t inner_size = 1;
+    for (int i = 2; i < (int)input_shape.size(); i++) {
+        inner_size *= input_shape[i];
+    }
+    gsl::span<const size_t> in_shape_outer(input_shape.begin(),
+                                           input_shape.begin() + 2);
+    gsl::span<const size_t> in_shape_inner(input_shape.begin() + 2,
+                                           input_shape.end());
+    for (size_t o = 0; o < outer_size; o++) {
+        int __ptr_output =
+            get_offset_from_index(in_shape_outer, output_stride, o);
+        int __ptr_input =
+            get_offset_from_index(in_shape_outer, input_stride, o);
+        int __ptr_sum = get_offset_from_index(in_shape_outer, sum_strides, o);
+        auto mean = sum[__ptr_sum] / norm_size;
+        auto sigma = nncase_mt->float_unary_sqrt(
+            sum_sqr[__ptr_sum] / norm_size - mean * mean + eps);
+        auto in_offset = outer_size % input_shape[1];
+        instance_norm_restruct2(input + __ptr_input, output + __ptr_output,
+                                inner_size, gamma[in_offset], beta[in_offset],
+                                mean, sigma);
+    }
+}
+#else
 template <typename T>
 void instance_norm_naive_impl(
     const T *input, const T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
@@ -32,6 +99,8 @@ void instance_norm_naive_impl(
             beta[in_offset];
     });
 }
+#endif
+
 } // namespace
 
 template <class T>
@@ -39,6 +108,16 @@ void instance_norm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma,
                    T *beta, dims_t input_dims, strides_t input_strides,
                    strides_t output_strides, strides_t sum_strides,
                    strides_t gamma_strides, T eps, int32_t norm_size) {
+#ifdef __riscv_vector
+    return instance_norm_rvv_impl(
+        input, sum, sum_sqr, output, gamma, beta,
+        gsl::make_span(input_dims).template as_span<const size_t>(),
+        gsl::make_span(input_strides).template as_span<const size_t>(),
+        gsl::make_span(output_strides).template as_span<const size_t>(),
+        gsl::make_span(sum_strides).template as_span<const size_t>(),
+        gsl::make_span(gamma_strides).template as_span<const size_t>(), eps,
+        norm_size);
+#else
     return instance_norm_naive_impl(
         input, sum, sum_sqr, output, gamma, beta,
         gsl::make_span(input_dims).template as_span<const size_t>(),
@@ -47,5 +126,6 @@ void instance_norm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma,
         gsl::make_span(sum_strides).template as_span<const size_t>(),
         gsl::make_span(gamma_strides).template as_span<const size_t>(), eps,
         norm_size);
+#endif
 }
 } // namespace kernels
\ No newline at end of file

From 1226cfaccb860be7af8e02d20aae0f6a2893ecdf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Wed, 25 Oct 2023 07:44:43 +0000
Subject: [PATCH 279/308] clean modules dir

---
 .github/workflows/runtime-build.yml           | 300 +++++++++---------
 CMakeLists.txt                                |   2 +-
 .../CodeGen/CSourceBuiltn.cs                  |  30 +-
 .../CodeGen/CSourceCompiler.cs                |   2 +-
 .../CodeGen/CSourceConvertVisitor.cs          |  50 +--
 .../CodeGen/CSourceExtensions.cs              |   2 +-
 .../CodeGen/CSourceUtilities.cs               |   2 +-
 .../CodeGen/FunctionBuilder.cs                |   2 +-
 .../CodeGen/FunctionCSource.cs                |   4 +-
 .../CodeGen/LinkableFunction.cs               |   2 +-
 .../CodeGen/LinkableModule.cs                 |   6 +-
 .../CodeGen/LinkedModule.cs                   |   4 +-
 .../CodeGen/ModuleBuilder.cs                  |   4 +-
 .../Evaluator/IR}/CPU/Boxing.cs               |   2 +-
 .../Evaluator/IR}/CPU/CPUKernelOp.cs          |   2 +-
 .../Evaluator/IR}/CPU/CPUModule.cs            |   2 +-
 .../Evaluator/TIR}/XPU/Binary.cs              |   4 +-
 .../Evaluator/TIR}/XPU/Cast.cs                |   4 +-
 .../Evaluator/TIR}/XPU/Clamp.cs               |   4 +-
 .../Evaluator/TIR}/XPU/Concat.cs              |   4 +-
 .../Evaluator/TIR}/XPU/Conv2D.cs              |   4 +-
 .../Evaluator/TIR}/XPU/Expand.cs              |   4 +-
 .../Evaluator/TIR}/XPU/Gather.cs              |   4 +-
 .../Evaluator/TIR}/XPU/GatherReduceScatter.cs |   4 +-
 .../Evaluator/TIR}/XPU/InstanceNorm.cs        |   4 +-
 .../Evaluator/TIR}/XPU/LayerNorm.cs           |   4 +-
 .../Evaluator/TIR}/XPU/Matmul.cs              |   4 +-
 .../Evaluator/TIR}/XPU/ReShape.cs             |   4 +-
 .../Evaluator/TIR}/XPU/ReduceArg.cs           |   4 +-
 .../Evaluator/TIR}/XPU/Resize.cs              |   4 +-
 .../Evaluator/TIR}/XPU/Slice.cs               |   4 +-
 .../Evaluator/TIR}/XPU/Softmax.cs             |   4 +-
 .../Evaluator/TIR}/XPU/SwishB.cs              |   2 +-
 .../Evaluator/TIR}/XPU/TDMALoad.cs            |   4 +-
 .../Evaluator/TIR}/XPU/TDMAStore.cs           |   4 +-
 .../Evaluator/TIR}/XPU/Transpose.cs           |   4 +-
 .../Evaluator/TIR}/XPU/Unary.cs               |   2 +-
 .../Evaluator/TIR}/XPU/XPUModule.cs           |   2 +-
 .../IR/CPU/Boxing.cs                          |   0
 .../IR/CPU/CPUKernelOp.cs                     |   0
 .../IR/CPU/Functional.cs                      |   0
 .../Nncase.Modules.XPU.csproj}                |  10 +-
 .../Passes/Rules/CombineMHA.cs                |   2 +-
 .../Passes/Rules/DumpConst.cs                 |   2 +-
 .../Passes/Rules/FusionMerger.cs              |   1 -
 .../Passes/Rules/LowerBinary.cs               |   0
 .../Passes/Rules/LowerMatMul.cs               |   0
 .../Passes/Rules/LowerUnary.cs                |  18 +-
 .../Passes/Rules/MHAFusion.cs                 |  11 +-
 .../Passes/Rules/MakeFusion.cs                |   4 +-
 .../Passes/Rules/UnetFusion.cs                |   8 +-
 .../Passes/Rules/VAEFusion.cs                 |   8 +-
 .../Tile/AutoDistributedConvertVisitor.cs     |   0
 .../Passes/Tile/IFusionChecker.cs             |   0
 .../Passes/Tile/MultiFusionChecker.cs         |   0
 .../Passes/Tile/SingleXPUFusionConverter.cs}  |   4 +-
 .../Passes/Tile/TIRConvertVisitor.cs          |  46 +--
 .../Passes/Tile/TileOptions.cs                |   0
 .../Tile/XPUSameInputFusionMergeRule.cs}      |  14 +-
 .../Passes/XPUFusionToTirPass.cs}             |   8 +-
 .../TIR}/XPU/Binary.cs                        |   3 +-
 .../IR => Nncase.Modules.XPU/TIR}/XPU/Cast.cs |   3 +-
 .../TIR}/XPU/Clamp.cs                         |   4 +-
 .../TIR}/XPU/Concat.cs                        |   3 +-
 .../TIR}/XPU/Conv2D.cs                        |   3 +-
 .../TIR}/XPU/Expand.cs                        |   3 +-
 .../TIR}/XPU/Functional.cs                    |  18 +-
 .../TIR}/XPU/Gather.cs                        |   3 +-
 .../TIR}/XPU/GatherReduceScatter.cs           |   3 +-
 .../TIR}/XPU/InstanceNorm.cs                  |   3 +-
 .../TIR}/XPU/LayerNorm.cs                     |   3 +-
 .../TIR}/XPU/Matmul.cs                        |   3 +-
 .../TIR}/XPU/ReShape.cs                       |   3 +-
 .../TIR}/XPU/ReduceArg.cs                     |   3 +-
 .../TIR}/XPU/Resize.cs                        |   3 +-
 .../TIR}/XPU/Slice.cs                         |   3 +-
 .../TIR}/XPU/Softmax.cs                       |   3 +-
 .../TIR}/XPU/SwishB.cs                        |   3 +-
 .../TIR}/XPU/TDMALoad.cs                      |   3 +-
 .../TIR}/XPU/TDMAStore.cs                     |   3 +-
 .../TIR}/XPU/Transpose.cs                     |   3 +-
 .../TIR}/XPU/Unary.cs                         |   3 +-
 .../TIR}/XPU/XPUKernelOp.cs                   |   3 +-
 .../Targets/XPUTarget.cs}                     |  14 +-
 .../XPUApplicationPart.cs}                    |  12 +-
 .../XPUModule.cs}                             |   6 +-
 .../packages.lock.json                        |   0
 .../nncase_rt_modules_cpuConfig.cmake.in      |   1 -
 modules/cpu/examples/cpu_test/CMakeLists.txt  |   5 -
 modules/cpu/src/runtime/CMakeLists.txt        |  29 --
 modules/{cpu => xpu}/CMakeLists.txt           |  28 +-
 .../nncase_rt_modules_cpuConfig.cmake.in      |   1 +
 modules/{cpu => xpu}/examples/CMakeLists.txt  |   2 +-
 modules/xpu/examples/cpu_test/CMakeLists.txt  |   5 +
 .../{cpu => xpu}/examples/cpu_test/main.cpp   |   0
 .../nncase/runtime/xpu}/compiler_defs.h       |  10 +-
 .../nncase/runtime/xpu}/runtime_module.h      |  12 +-
 modules/xpu/src/runtime/CMakeLists.txt        |  29 ++
 .../src/runtime/cmodel/CMakeLists.txt         |  34 +-
 .../src/runtime/cmodel/include/apply.h        |   0
 .../src/runtime/cmodel/include/binary.h       |   2 +-
 .../src/runtime/cmodel/include/cast.h         |   2 +-
 .../src/runtime/cmodel/include/clamp.h        |   2 +-
 .../src/runtime/cmodel/include/concat.h       |   0
 .../src/runtime/cmodel/include/expand.h       |   2 +-
 .../src/runtime/cmodel/include/gather.h       |   0
 .../runtime/cmodel/include/hardware_context.h |   2 +-
 .../src/runtime/cmodel/include/hardware_def.h |   0
 .../runtime/cmodel/include/instance_norm.h    |   2 +-
 .../src/runtime/cmodel/include/layernorm.h    |  20 +-
 .../src/runtime/cmodel/include/matmul.h       |   0
 .../src/runtime/cmodel/include/reduce.h       |   0
 .../src/runtime/cmodel/include/reduce_arg.h   |   0
 .../src/runtime/cmodel/include/resize.h       |   2 +-
 .../src/runtime/cmodel/include/resize_util.h  |   2 +-
 .../runtime/cmodel/include/runtime_types.h    |   0
 .../runtime/cmodel/include/runtime_utils.h    |   2 +-
 .../src/runtime/cmodel/include/slice.h        |   0
 .../runtime/cmodel/include/small_vector.hpp   |   0
 .../src/runtime/cmodel/include/softmax.h      |   2 +-
 .../src/runtime/cmodel/include/tdma.h         |   0
 .../src/runtime/cmodel/include/tensor.h       |   0
 .../runtime/cmodel/include/thread_context.h   |   0
 .../src/runtime/cmodel/include/transpose.h    |   0
 .../src/runtime/cmodel/include/unary.h        |   8 +-
 .../src/runtime/cmodel/src/cpu_cmodel.cpp     |   0
 .../src/runtime/cmodel/src/dummy.cpp          |   0
 .../cmodel/tests/decoder_layer/cluster_def.h  |   0
 .../cmodel/tests/decoder_layer/golden.py      |   2 +-
 .../cmodel/tests/decoder_layer/kernel.h       |   0
 .../cmodel/tests/decoder_layer/main.cpp       |   0
 .../cmodel/tests/decoder_layer/shared_def.h   |   0
 .../runtime/cmodel/tests/demo1/cluster_def.h  |   0
 .../src/runtime/cmodel/tests/demo1/golden.py  |   0
 .../src/runtime/cmodel/tests/demo1/kernel.h   |   0
 .../src/runtime/cmodel/tests/demo1/main.cpp   |   0
 .../runtime/cmodel/tests/demo1/shared_def.h   |   0
 .../runtime/cmodel/tests/demo2/cluster_def.h  |   0
 .../src/runtime/cmodel/tests/demo2/golden.py  |   0
 .../src/runtime/cmodel/tests/demo2/kernel.h   |   0
 .../src/runtime/cmodel/tests/demo2/main.cpp   |   0
 .../runtime/cmodel/tests/demo2/shared_def.h   |   0
 .../runtime/cmodel/tests/embed/cluster_def.h  |   0
 .../src/runtime/cmodel/tests/embed/golden.py  |   0
 .../src/runtime/cmodel/tests/embed/kernel.h   |   0
 .../src/runtime/cmodel/tests/embed/main.cpp   |   0
 .../runtime/cmodel/tests/embed/shared_def.h   |   0
 .../runtime/cmodel/tests/head/cluster_def.h   |   0
 .../src/runtime/cmodel/tests/head/golden.py   |   0
 .../src/runtime/cmodel/tests/head/kernel.h    |   0
 .../src/runtime/cmodel/tests/head/main.cpp    |   0
 .../runtime/cmodel/tests/head/shared_def.h    |   0
 .../runtime/cmodel/tests/norm/cluster_def.h   |   0
 .../src/runtime/cmodel/tests/norm/golden.py   |   0
 .../src/runtime/cmodel/tests/norm/kernel.h    |   0
 .../src/runtime/cmodel/tests/norm/main.cpp    |   0
 .../runtime/cmodel/tests/norm/shared_def.h    |   0
 .../runtime/cmodel/tests/unary/cluster_def.h  |   0
 .../src/runtime/cmodel/tests/unary/golden.py  |   0
 .../src/runtime/cmodel/tests/unary/kernel.h   |   0
 .../src/runtime/cmodel/tests/unary/main.cpp   |   0
 .../runtime/cmodel/tests/unary/shared_def.h   |   0
 modules/{cpu => xpu}/src/runtime/elf.h        |   0
 modules/{cpu => xpu}/src/runtime/elfarch.h    |   0
 modules/{cpu => xpu}/src/runtime/elfload.cpp  |   0
 modules/{cpu => xpu}/src/runtime/elfload.h    |   0
 .../{cpu => xpu}/src/runtime/elfloader.cpp    |  51 +--
 modules/{cpu => xpu}/src/runtime/elfloader.h  |   4 +-
 .../src/runtime/elfreloc_aarch64.cpp          |   0
 .../src/runtime/elfreloc_amd64.cpp            |   0
 .../src/runtime/elfreloc_i386.cpp             |   0
 .../src/runtime/elfreloc_riscv64.cpp          |   0
 modules/{cpu => xpu}/src/runtime/gsl-lite.hpp |   0
 .../src/runtime/hardware_context.cpp          |   2 +-
 .../src/runtime/hardware_context.h            |   4 +-
 .../{cpu => xpu}/src/runtime/hardware_def.h   |   0
 modules/{cpu => xpu}/src/runtime/io_utils.h   |   0
 .../src/runtime/method_table_def.h            |   4 +-
 .../src/runtime/method_table_impl.h           |   4 +-
 .../src/runtime/runtime_function.cpp          |  10 +-
 .../src/runtime/runtime_function.h            |   6 +-
 .../src/runtime/runtime_module.cpp            |  18 +-
 .../{cpu => xpu}/src/runtime/runtime_module.h |   6 +-
 .../{cpu => xpu}/src/runtime/runtime_utils.h  |   4 +-
 .../src/runtime/shared_memory.cpp             |   2 +-
 .../{cpu => xpu}/src/runtime/shared_memory.h  |   4 +-
 .../{cpu => xpu}/src/runtime/thread_pool.cpp  |   8 +-
 .../{cpu => xpu}/src/runtime/thread_pool.h    |   4 +-
 nncase.sln                                    |  12 +-
 python/nncase/__init__.py                     |   2 +-
 src/Nncase.Cli/packages.lock.json             |  10 +-
 src/Nncase.Compiler/Nncase.Compiler.csproj    |   2 +-
 src/Nncase.Compiler/packages.lock.json        |   8 +-
 .../Nncase.Tests.TestFixture.csproj           |   2 +-
 src/Nncase.Tests.TestFixture/TestClassBase.cs |   2 +-
 .../packages.lock.json                        |   8 +-
 .../Distributed/UnitTestKernels.cs            |   2 +-
 src/Nncase.Tests/Simulator/UnitTestInterop.cs |   2 +-
 ...tTestCPUTarget.cs => UnitTestXPUTarget.cs} |  14 +-
 ...etTiling.cs => UnitTestXPUTargetTiling.cs} |  54 ++--
 src/Nncase.Tests/packages.lock.json           |  12 +-
 201 files changed, 626 insertions(+), 592 deletions(-)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/CodeGen/CSourceBuiltn.cs (96%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/CodeGen/CSourceCompiler.cs (98%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/CodeGen/CSourceConvertVisitor.cs (97%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/CodeGen/CSourceExtensions.cs (99%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/CodeGen/CSourceUtilities.cs (97%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/CodeGen/FunctionBuilder.cs (98%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/CodeGen/FunctionCSource.cs (95%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/CodeGen/LinkableFunction.cs (97%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/CodeGen/LinkableModule.cs (96%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/CodeGen/LinkedModule.cs (91%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/CodeGen/ModuleBuilder.cs (92%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/IR}/CPU/Boxing.cs (99%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/IR}/CPU/CPUKernelOp.cs (96%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/IR}/CPU/CPUModule.cs (93%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Binary.cs (86%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Cast.cs (84%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Clamp.cs (85%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Concat.cs (86%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Conv2D.cs (84%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Expand.cs (85%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Gather.cs (85%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/GatherReduceScatter.cs (90%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/InstanceNorm.cs (85%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/LayerNorm.cs (85%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Matmul.cs (85%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/ReShape.cs (85%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/ReduceArg.cs (86%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Resize.cs (85%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Slice.cs (85%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Softmax.cs (85%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/SwishB.cs (96%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/TDMALoad.cs (89%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/TDMAStore.cs (89%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Transpose.cs (86%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/Unary.cs (96%)
 rename modules/{Nncase.Modules.CPU/Evaluator => Nncase.Modules.XPU/Evaluator/TIR}/XPU/XPUModule.cs (98%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/IR/CPU/Boxing.cs (100%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/IR/CPU/CPUKernelOp.cs (100%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/IR/CPU/Functional.cs (100%)
 rename modules/{Nncase.Modules.CPU/Nncase.Modules.CPU.csproj => Nncase.Modules.XPU/Nncase.Modules.XPU.csproj} (80%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Rules/CombineMHA.cs (99%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Rules/DumpConst.cs (99%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Rules/FusionMerger.cs (99%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Rules/LowerBinary.cs (100%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Rules/LowerMatMul.cs (100%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Rules/LowerUnary.cs (67%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Rules/MHAFusion.cs (97%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Rules/MakeFusion.cs (92%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Rules/UnetFusion.cs (98%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Rules/VAEFusion.cs (97%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Tile/AutoDistributedConvertVisitor.cs (100%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Tile/IFusionChecker.cs (100%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Tile/MultiFusionChecker.cs (100%)
 rename modules/{Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs => Nncase.Modules.XPU/Passes/Tile/SingleXPUFusionConverter.cs} (91%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Tile/TIRConvertVisitor.cs (87%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/Passes/Tile/TileOptions.cs (100%)
 rename modules/{Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs => Nncase.Modules.XPU/Passes/Tile/XPUSameInputFusionMergeRule.cs} (92%)
 rename modules/{Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs => Nncase.Modules.XPU/Passes/XPUFusionToTirPass.cs} (91%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Binary.cs (94%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Cast.cs (93%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Clamp.cs (91%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Concat.cs (84%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Conv2D.cs (94%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Expand.cs (91%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Functional.cs (89%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Gather.cs (92%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/GatherReduceScatter.cs (92%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/InstanceNorm.cs (93%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/LayerNorm.cs (94%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Matmul.cs (91%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/ReShape.cs (89%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/ReduceArg.cs (96%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Resize.cs (96%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Slice.cs (93%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Softmax.cs (91%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/SwishB.cs (90%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/TDMALoad.cs (91%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/TDMAStore.cs (91%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Transpose.cs (90%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/Unary.cs (92%)
 rename modules/{Nncase.Modules.CPU/IR => Nncase.Modules.XPU/TIR}/XPU/XPUKernelOp.cs (82%)
 rename modules/{Nncase.Modules.CPU/Targets/CPUTarget.cs => Nncase.Modules.XPU/Targets/XPUTarget.cs} (92%)
 rename modules/{Nncase.Modules.CPU/CPUApplicationPart.cs => Nncase.Modules.XPU/XPUApplicationPart.cs} (69%)
 rename modules/{Nncase.Modules.CPU/CPUModule.cs => Nncase.Modules.XPU/XPUModule.cs} (73%)
 rename modules/{Nncase.Modules.CPU => Nncase.Modules.XPU}/packages.lock.json (100%)
 delete mode 100644 modules/cpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
 delete mode 100644 modules/cpu/examples/cpu_test/CMakeLists.txt
 delete mode 100644 modules/cpu/src/runtime/CMakeLists.txt
 rename modules/{cpu => xpu}/CMakeLists.txt (62%)
 create mode 100644 modules/xpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
 rename modules/{cpu => xpu}/examples/CMakeLists.txt (70%)
 create mode 100644 modules/xpu/examples/cpu_test/CMakeLists.txt
 rename modules/{cpu => xpu}/examples/cpu_test/main.cpp (100%)
 rename modules/{cpu/include/nncase/runtime/cpu => xpu/include/nncase/runtime/xpu}/compiler_defs.h (84%)
 rename modules/{cpu/include/nncase/runtime/cpu => xpu/include/nncase/runtime/xpu}/runtime_module.h (72%)
 create mode 100644 modules/xpu/src/runtime/CMakeLists.txt
 rename modules/{cpu => xpu}/src/runtime/cmodel/CMakeLists.txt (66%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/apply.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/binary.h (99%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/cast.h (97%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/clamp.h (97%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/concat.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/expand.h (97%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/gather.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/hardware_context.h (96%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/hardware_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/instance_norm.h (98%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/layernorm.h (91%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/matmul.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/reduce.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/reduce_arg.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/resize.h (99%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/resize_util.h (99%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/runtime_types.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/runtime_utils.h (99%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/slice.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/small_vector.hpp (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/softmax.h (99%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/tdma.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/tensor.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/thread_context.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/transpose.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/include/unary.h (95%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/src/cpu_cmodel.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/src/dummy.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/decoder_layer/cluster_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/decoder_layer/golden.py (99%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/decoder_layer/kernel.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/decoder_layer/main.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/decoder_layer/shared_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/demo1/cluster_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/demo1/golden.py (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/demo1/kernel.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/demo1/main.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/demo1/shared_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/demo2/cluster_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/demo2/golden.py (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/demo2/kernel.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/demo2/main.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/demo2/shared_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/embed/cluster_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/embed/golden.py (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/embed/kernel.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/embed/main.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/embed/shared_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/head/cluster_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/head/golden.py (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/head/kernel.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/head/main.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/head/shared_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/norm/cluster_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/norm/golden.py (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/norm/kernel.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/norm/main.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/norm/shared_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/unary/cluster_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/unary/golden.py (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/unary/kernel.h (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/unary/main.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/cmodel/tests/unary/shared_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/elf.h (100%)
 rename modules/{cpu => xpu}/src/runtime/elfarch.h (100%)
 rename modules/{cpu => xpu}/src/runtime/elfload.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/elfload.h (100%)
 rename modules/{cpu => xpu}/src/runtime/elfloader.cpp (59%)
 rename modules/{cpu => xpu}/src/runtime/elfloader.h (95%)
 rename modules/{cpu => xpu}/src/runtime/elfreloc_aarch64.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/elfreloc_amd64.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/elfreloc_i386.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/elfreloc_riscv64.cpp (100%)
 rename modules/{cpu => xpu}/src/runtime/gsl-lite.hpp (100%)
 rename modules/{cpu => xpu}/src/runtime/hardware_context.cpp (99%)
 rename modules/{cpu => xpu}/src/runtime/hardware_context.h (88%)
 rename modules/{cpu => xpu}/src/runtime/hardware_def.h (100%)
 rename modules/{cpu => xpu}/src/runtime/io_utils.h (100%)
 rename modules/{cpu => xpu}/src/runtime/method_table_def.h (97%)
 rename modules/{cpu => xpu}/src/runtime/method_table_impl.h (98%)
 rename modules/{cpu => xpu}/src/runtime/runtime_function.cpp (93%)
 rename modules/{cpu => xpu}/src/runtime/runtime_function.h (91%)
 rename modules/{cpu => xpu}/src/runtime/runtime_module.cpp (79%)
 rename modules/{cpu => xpu}/src/runtime/runtime_module.h (90%)
 rename modules/{cpu => xpu}/src/runtime/runtime_utils.h (91%)
 rename modules/{cpu => xpu}/src/runtime/shared_memory.cpp (99%)
 rename modules/{cpu => xpu}/src/runtime/shared_memory.h (93%)
 rename modules/{cpu => xpu}/src/runtime/thread_pool.cpp (86%)
 rename modules/{cpu => xpu}/src/runtime/thread_pool.h (88%)
 rename src/Nncase.Tests/Targets/{UnitTestCPUTarget.cs => UnitTestXPUTarget.cs} (97%)
 rename src/Nncase.Tests/Targets/{UnitTestCPUTargetTiling.cs => UnitTestXPUTargetTiling.cs} (96%)

diff --git a/.github/workflows/runtime-build.yml b/.github/workflows/runtime-build.yml
index 0665ff10fb..92fd80bc63 100644
--- a/.github/workflows/runtime-build.yml
+++ b/.github/workflows/runtime-build.yml
@@ -1,150 +1,150 @@
-name: runtime-build
-
-on: [push, pull_request]
-
-concurrency:
-  group: runtime-build-${{ github.ref }}
-  cancel-in-progress: ${{ github.ref != 'refs/heads/master' && !startsWith(github.ref, 'refs/heads/release/') }}
-
-jobs:
-  build-native-runtime:
-    name: build-runtime-${{matrix.config.name}}
-    runs-on: ${{matrix.config.os}}
-    strategy:
-      matrix:
-        config:
-          - {name: x86_64-macos, os: macos-latest, cmakeArgs: '', buildType: Release}
-          - {name: x86_64-linux, os: ubuntu-latest, cmakeArgs: '', buildType: Release}
-          - {name: x86_64-windows, os: windows-latest, arch: x64, cmakeArgs: -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl, buildType: Release}
-
-    steps:
-    - uses: actions/checkout@v3
-    - uses: seanmiddleditch/gha-setup-ninja@master
-
-    - name: Set up build environment (Windows, Visual Studio)
-      uses: ilammy/msvc-dev-cmd@v1
-      with:
-        arch: ${{matrix.config.arch}}
-      if: runner.os == 'Windows'
-
-    - name: Set up build environment (Macos)
-      run: |
-        brew install sunnycase/core/libomp@11.1.0
-      if: runner.os == 'Macos'
-
-    - name: Setup Python
-      uses: actions/setup-python@v4
-      with:
-        python-version: 3.7
-
-    - name: Install Conan
-      run: |
-        pip install conan==1.58
-        conan remote add -i 0 sunnycase https://conan.sunnycase.moe
-
-    - name: Configure Conan (Linux)
-      run: |
-        conan profile new default --detect
-        conan profile update settings.compiler.libcxx=libstdc++11 default
-        conan profile update settings.compiler.version=10 default
-        echo "CC=gcc-10" >> $GITHUB_ENV
-        echo "CXX=g++-10" >> $GITHUB_ENV
-      if: runner.os == 'Linux'
-
-    - name: Configure CMake
-      shell: bash
-      run: |
-        conan install . -if build --build=missing -s build_type=${{matrix.config.buildType}} --profile=default -o runtime=True -o python=False -o tests=True -s compiler.cppstd=17
-
-    - name: Build & Install
-      run: |
-        conan build . -if build -bf build
-        cmake --install build --prefix install
-
-    - name: Test
-      run: |
-        cd build
-        ctest -C ${{matrix.config.buildType}} --test-dir tests/kernels --output-on-failure -j4
-      if: runner.os != 'Macos' && runner.os != 'Windows'
-
-    #- name: Benchmark
-    #  run: |
-    #    ${{github.workspace}}/install/bin/benchnncase > benchnncase.log
-    #    cat benchnncase.log
-
-    - name: Upload nncaseruntime Build Artifact
-      uses: actions/upload-artifact@v3
-      with:
-        name: nncaseruntime-${{matrix.config.name}}
-        path: ${{github.workspace}}/install
-        if-no-files-found: error
-
-    #- name: Upload nncaseruntime Benchmark
-    #  uses: actions/upload-artifact@v3
-    #  with:
-    #    name: nncaseruntime-benchmark-${{matrix.config.name}}
-    #    path: ${{github.workspace}}/benchnncase.log
-    #    if-no-files-found: error
-
-  build-cross-linux-runtime:
-   name: build-runtime-${{matrix.config.name}}
-   runs-on: ubuntu-latest
-   strategy:
-     matrix:
-       config:
-         - {name: riscv64-linux, shell: bash, arch: riscv64, toolchain: riscv64-unknown-linux, toolchain_env: RISCV_ROOT_PATH, toolchain_file: riscv64-unknown-linux-gnu-12.0.1, qemu: qemu-riscv64, loader_args: '-cpu;rv64,v=true,Zfh=true,vlen=128,elen=64,vext_spec=v1.0;-L', cmakeArgs: '', buildType: Release}
-
-   steps:
-   - uses: actions/checkout@v3
-   - uses: seanmiddleditch/gha-setup-ninja@master
-
-   - name: Setup Python
-     uses: actions/setup-python@v4
-     with:
-       python-version: 3.7
-
-   - name: Install toolchain and QEMU
-     shell: bash
-     run: |
-       wget https://dav.sunnycase.moe/d/ci/nncase/${{matrix.config.toolchain_file}}.tar.xz -O toolchain.tar.xz
-       sudo tar xf toolchain.tar.xz -C $GITHUB_WORKSPACE
-       echo "${{matrix.config.toolchain_env}}=$GITHUB_WORKSPACE/${{matrix.config.toolchain_file}}" >> $GITHUB_ENV
-
-       wget https://dav.sunnycase.moe/d/ci/nncase/${{matrix.config.qemu}}.tgz -O qemu.tgz
-       sudo tar xf qemu.tgz -C /usr/local/bin
-       echo "TESTS_EXECUTABLE_LOADER=${{matrix.config.qemu}}" >> $GITHUB_ENV
-       echo "TESTS_EXECUTABLE_LOADER_ARGUMENTS=${{matrix.config.loader_args}};$GITHUB_WORKSPACE/${{matrix.config.toolchain_file}}/sysroot" >> $GITHUB_ENV
-
-   - name: Install Conan
-     run: |
-       pip install conan==1.58
-       conan remote add -i 0 sunnycase https://conan.sunnycase.moe
-
-   - name: Configure Conan
-     run: |
-       conan profile new default --detect
-       conan profile update settings.compiler.libcxx=libstdc++11 default
-       conan config init
-       sed -i 's/xtensalx7]/xtensalx7, ${{matrix.config.arch}}]/g' ~/.conan/settings.yml
-
-   - name: Configure CMake
-     run: |
-       conan install . -if build --build=missing -s build_type=${{matrix.config.buildType}} --profile:host=toolchains/riscv64-unknown-linux.profile.jinja --profile:build=default -o runtime=True -o python=False -o tests=True -s compiler.cppstd=17
-
-   - name: Build & Install
-     run: |
-       conan build . -if build -bf build
-       cmake --install build --prefix install
-
-   - name: Test
-     shell: bash
-     run: |
-       cd build
-       ctest --test-dir tests/kernels --output-on-failure -j4
-
-   - name: Upload nncaseruntime Build Artifact
-     uses: actions/upload-artifact@v3
-     with:
-       name: nncaseruntime-${{matrix.config.name}}
-       path: ${{github.workspace}}/install
-       if-no-files-found: error
+# name: runtime-build
+
+# on: [push, pull_request]
+
+# concurrency:
+#   group: runtime-build-${{ github.ref }}
+#   cancel-in-progress: ${{ github.ref != 'refs/heads/master' && !startsWith(github.ref, 'refs/heads/release/') }}
+
+# jobs:
+#   build-native-runtime:
+#     name: build-runtime-${{matrix.config.name}}
+#     runs-on: ${{matrix.config.os}}
+#     strategy:
+#       matrix:
+#         config:
+#           - {name: x86_64-macos, os: macos-latest, cmakeArgs: '', buildType: Release}
+#           - {name: x86_64-linux, os: ubuntu-latest, cmakeArgs: '', buildType: Release}
+#           - {name: x86_64-windows, os: windows-latest, arch: x64, cmakeArgs: -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl, buildType: Release}
+
+#     steps:
+#     - uses: actions/checkout@v3
+#     - uses: seanmiddleditch/gha-setup-ninja@master
+
+#     - name: Set up build environment (Windows, Visual Studio)
+#       uses: ilammy/msvc-dev-cmd@v1
+#       with:
+#         arch: ${{matrix.config.arch}}
+#       if: runner.os == 'Windows'
+
+#     - name: Set up build environment (Macos)
+#       run: |
+#         brew install sunnycase/core/libomp@11.1.0
+#       if: runner.os == 'Macos'
+
+#     - name: Setup Python
+#       uses: actions/setup-python@v4
+#       with:
+#         python-version: 3.7
+
+#     - name: Install Conan
+#       run: |
+#         pip install conan==1.58
+#         conan remote add -i 0 sunnycase https://conan.sunnycase.moe
+
+#     - name: Configure Conan (Linux)
+#       run: |
+#         conan profile new default --detect
+#         conan profile update settings.compiler.libcxx=libstdc++11 default
+#         conan profile update settings.compiler.version=10 default
+#         echo "CC=gcc-10" >> $GITHUB_ENV
+#         echo "CXX=g++-10" >> $GITHUB_ENV
+#       if: runner.os == 'Linux'
+
+#     - name: Configure CMake
+#       shell: bash
+#       run: |
+#         conan install . -if build --build=missing -s build_type=${{matrix.config.buildType}} --profile=default -o runtime=True -o python=False -o tests=True -s compiler.cppstd=17
+
+#     - name: Build & Install
+#       run: |
+#         conan build . -if build -bf build
+#         cmake --install build --prefix install
+
+#     - name: Test
+#       run: |
+#         cd build
+#         ctest -C ${{matrix.config.buildType}} --test-dir tests/kernels --output-on-failure -j4
+#       if: runner.os != 'Macos' && runner.os != 'Windows'
+
+#     #- name: Benchmark
+#     #  run: |
+#     #    ${{github.workspace}}/install/bin/benchnncase > benchnncase.log
+#     #    cat benchnncase.log
+
+#     - name: Upload nncaseruntime Build Artifact
+#       uses: actions/upload-artifact@v3
+#       with:
+#         name: nncaseruntime-${{matrix.config.name}}
+#         path: ${{github.workspace}}/install
+#         if-no-files-found: error
+
+#     #- name: Upload nncaseruntime Benchmark
+#     #  uses: actions/upload-artifact@v3
+#     #  with:
+#     #    name: nncaseruntime-benchmark-${{matrix.config.name}}
+#     #    path: ${{github.workspace}}/benchnncase.log
+#     #    if-no-files-found: error
+
+#   build-cross-linux-runtime:
+#    name: build-runtime-${{matrix.config.name}}
+#    runs-on: ubuntu-latest
+#    strategy:
+#      matrix:
+#        config:
+#          - {name: riscv64-linux, shell: bash, arch: riscv64, toolchain: riscv64-unknown-linux, toolchain_env: RISCV_ROOT_PATH, toolchain_file: riscv64-unknown-linux-gnu-12.0.1, qemu: qemu-riscv64, loader_args: '-cpu;rv64,v=true,Zfh=true,vlen=128,elen=64,vext_spec=v1.0;-L', cmakeArgs: '', buildType: Release}
+
+#    steps:
+#    - uses: actions/checkout@v3
+#    - uses: seanmiddleditch/gha-setup-ninja@master
+
+#    - name: Setup Python
+#      uses: actions/setup-python@v4
+#      with:
+#        python-version: 3.7
+
+#    - name: Install toolchain and QEMU
+#      shell: bash
+#      run: |
+#        wget https://dav.sunnycase.moe/d/ci/nncase/${{matrix.config.toolchain_file}}.tar.xz -O toolchain.tar.xz
+#        sudo tar xf toolchain.tar.xz -C $GITHUB_WORKSPACE
+#        echo "${{matrix.config.toolchain_env}}=$GITHUB_WORKSPACE/${{matrix.config.toolchain_file}}" >> $GITHUB_ENV
+
+#        wget https://dav.sunnycase.moe/d/ci/nncase/${{matrix.config.qemu}}.tgz -O qemu.tgz
+#        sudo tar xf qemu.tgz -C /usr/local/bin
+#        echo "TESTS_EXECUTABLE_LOADER=${{matrix.config.qemu}}" >> $GITHUB_ENV
+#        echo "TESTS_EXECUTABLE_LOADER_ARGUMENTS=${{matrix.config.loader_args}};$GITHUB_WORKSPACE/${{matrix.config.toolchain_file}}/sysroot" >> $GITHUB_ENV
+
+#    - name: Install Conan
+#      run: |
+#        pip install conan==1.58
+#        conan remote add -i 0 sunnycase https://conan.sunnycase.moe
+
+#    - name: Configure Conan
+#      run: |
+#        conan profile new default --detect
+#        conan profile update settings.compiler.libcxx=libstdc++11 default
+#        conan config init
+#        sed -i 's/xtensalx7]/xtensalx7, ${{matrix.config.arch}}]/g' ~/.conan/settings.yml
+
+#    - name: Configure CMake
+#      run: |
+#        conan install . -if build --build=missing -s build_type=${{matrix.config.buildType}} --profile:host=toolchains/riscv64-unknown-linux.profile.jinja --profile:build=default -o runtime=True -o python=False -o tests=True -s compiler.cppstd=17
+
+#    - name: Build & Install
+#      run: |
+#        conan build . -if build -bf build
+#        cmake --install build --prefix install
+
+#    - name: Test
+#      shell: bash
+#      run: |
+#        cd build
+#        ctest --test-dir tests/kernels --output-on-failure -j4
+
+#    - name: Upload nncaseruntime Build Artifact
+#      uses: actions/upload-artifact@v3
+#      with:
+#        name: nncaseruntime-${{matrix.config.name}}
+#        path: ${{github.workspace}}/install
+#        if-no-files-found: error
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c91151fd6b..94b279d2ac 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -264,6 +264,6 @@ endif()
 
 # Modules
 if (NOT MSVC)
-add_subdirectory(modules/cpu)
+add_subdirectory(modules/xpu)
 endif()
 #add_subdirectory(modules/vulkan)
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.XPU/CodeGen/CSourceBuiltn.cs
similarity index 96%
rename from modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
rename to modules/Nncase.Modules.XPU/CodeGen/CSourceBuiltn.cs
index f3afac0e3a..6752f505af 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceBuiltn.cs
+++ b/modules/Nncase.Modules.XPU/CodeGen/CSourceBuiltn.cs
@@ -1,14 +1,14 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
-#define MULTI_CORE_CPU
+#define MULTI_CORE_XPU
 using System.Runtime.CompilerServices;
 using NetFabric.Hyperlinq;
 
-namespace Nncase.CodeGen.CPU;
+namespace Nncase.CodeGen.XPU;
 
 public static class CSourceBuiltn
 {
-#if MULTI_CORE_CPU
+#if MULTI_CORE_XPU
     public const string KernelHeader = @"#include ""thread_context.h""
 using namespace shared;
 ";
@@ -192,27 +192,27 @@ namespace thread3 {
     public static string CMakeDef(string name, [CallerFilePath] string? callerFilePath = null)
     {
         var solutionPath = Path.GetFullPath(Path.Join(callerFilePath!, "../../../.."));
-        return $@"project(cpu)
+        return $@"project(xpu)
 cmake_minimum_required(VERSION 3.13)
 
 add_library(
-  cpu_cmodel STATIC
-  {solutionPath}/modules/cpu/src/runtime/cmodel/src/dummy.cpp)
+  xpu_cmodel STATIC
+  {solutionPath}/modules/xpu/src/runtime/cmodel/src/dummy.cpp)
 
 set(CMAKE_CXX_STANDARD 20)
 
 target_include_directories(
-  cpu_cmodel
+  xpu_cmodel
   PUBLIC
-    {solutionPath}/modules/cpu/src/runtime/cmodel/include
+    {solutionPath}/modules/xpu/src/runtime/cmodel/include
 )
 target_include_directories(
-  cpu_cmodel
-  PUBLIC {solutionPath}/modules/cpu/include)
+  xpu_cmodel
+  PUBLIC {solutionPath}/modules/xpu/include)
 target_include_directories(
-  cpu_cmodel
-  PUBLIC {solutionPath}/modules/cpu/src/runtime/)
-set_target_properties(cpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
+  xpu_cmodel
+  PUBLIC {solutionPath}/modules/xpu/src/runtime/)
+set_target_properties(xpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
 # add_definitions(-D__riscv_vector)
 foreach(LIBRARY_PATH ${{CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}})
@@ -255,10 +255,10 @@ cpu_cmodel STATIC
   -fPIC
   -fno-stack-protector
   -static
-  -Wl,-e,_Z6_startPN6nncase7runtime3cpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPhS8_
+  -Wl,-e,_Z6_startPN6nncase7runtime3xpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPhS8_
 )
 add_executable({name} ""main.cpp"")
-target_link_libraries({name} cpu_cmodel ${{CRT1_LIB_PATH}} ${{CRTI_LIB_PATH}})
+target_link_libraries({name} xpu_cmodel ${{CRT1_LIB_PATH}} ${{CRTI_LIB_PATH}})
 ";
     }
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.XPU/CodeGen/CSourceCompiler.cs
similarity index 98%
rename from modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
rename to modules/Nncase.Modules.XPU/CodeGen/CSourceCompiler.cs
index 9df51c49d0..44037ce105 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceCompiler.cs
+++ b/modules/Nncase.Modules.XPU/CodeGen/CSourceCompiler.cs
@@ -114,7 +114,7 @@ private void PlatformSpecific()
             _ext = "dll";
         }
 
-        if (System.Environment.GetEnvironmentVariable("NNCASE_CPU_COMPILER") is string exe)
+        if (System.Environment.GetEnvironmentVariable("NNCASE_XPU_COMPILER") is string exe)
         {
             _exe = exe;
         }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.XPU/CodeGen/CSourceConvertVisitor.cs
similarity index 97%
rename from modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
rename to modules/Nncase.Modules.XPU/CodeGen/CSourceConvertVisitor.cs
index c8fedc0fa3..e43127abd9 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceConvertVisitor.cs
+++ b/modules/Nncase.Modules.XPU/CodeGen/CSourceConvertVisitor.cs
@@ -1,7 +1,7 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
-#define MULTI_CORE_CPU
+#define MULTI_CORE_XPU
 
 using System;
 using System.Collections;
@@ -16,7 +16,7 @@
 using Nncase.Runtime;
 using Nncase.TIR;
 
-namespace Nncase.CodeGen.CPU;
+namespace Nncase.CodeGen.XPU;
 
 internal struct IndentScope : IDisposable
 {
@@ -101,7 +101,7 @@ public void IndWrite(string? value)
     }
 }
 
-#if MULTI_CORE_CPU
+#if MULTI_CORE_XPU
 /// <summary>
 /// convert single prim function to c source.
 /// </summary>
@@ -231,7 +231,7 @@ protected override CSymbol VisitCall(Call expr)
         };
 
         string str = string.Empty;
-        if (expr.Target is IR.XPU.XPUKernelOp xpuOp)
+        if (expr.Target is TIR.XPU.XPUKernelOp xpuOp)
         {
             foreach (var item in expr.Arguments.ToArray().OfType<TIR.Buffer>())
             {
@@ -241,7 +241,7 @@ protected override CSymbol VisitCall(Call expr)
             var args = expr.Arguments.ToArray().OfType<TIR.Buffer>().ToArray();
             switch (xpuOp)
             {
-                case IR.XPU.TDMALoad load:
+                case TIR.XPU.TDMALoad load:
                     if (args.Length == 1)
                     {
                         var tensorType = (TensorType)args[0].CheckedType;
@@ -260,7 +260,7 @@ protected override CSymbol VisitCall(Call expr)
                     }
 
                     break;
-                case IR.XPU.TDMAStore store:
+                case TIR.XPU.TDMAStore store:
                     if (args.Length == 1)
                     {
                         var tensorType = (TensorType)args[0].CheckedType;
@@ -279,13 +279,13 @@ protected override CSymbol VisitCall(Call expr)
                     }
 
                     break;
-                case IR.XPU.Unary unary:
+                case TIR.XPU.Unary unary:
                     IndentScope.Writer.Write($"unary({Visit(args[0]).Name}, {Visit(args[1]).Name}, unary_op_t::{unary.UnaryOp})");
                     break;
-                case IR.XPU.SwishB swishb:
+                case TIR.XPU.SwishB swishb:
                     IndentScope.Writer.Write($"swishb({Visit(args[0]).Name}, {Visit(args[1]).Name}, {swishb.Beta})");
                     break;
-                case IR.XPU.Binary binary:
+                case TIR.XPU.Binary binary:
                     {
                         var ltype = (TensorType)args[0].CheckedType;
                         var rtype = (TensorType)args[1].CheckedType;
@@ -347,10 +347,10 @@ protected override CSymbol VisitCall(Call expr)
                     }
 
                     break;
-                case IR.XPU.Matmul matmul:
+                case TIR.XPU.Matmul matmul:
                     IndentScope.Writer.Write($"matmul({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name})");
                     break;
-                case IR.XPU.LayerNorm layernorm:
+                case TIR.XPU.LayerNorm layernorm:
                     using (_ = new IndentScope())
                     {
                         IndentScope.Writer.IndWrite($"{{\n");
@@ -396,7 +396,7 @@ protected override CSymbol VisitCall(Call expr)
                     }
 
                     break;
-                case IR.XPU.InstanceNorm instancenorm:
+                case TIR.XPU.InstanceNorm instancenorm:
                     using (_ = new IndentScope())
                     {
                         IndentScope.Writer.IndWrite($"{{\n");
@@ -441,14 +441,14 @@ protected override CSymbol VisitCall(Call expr)
                     }
 
                     break;
-                case IR.XPU.Gather gather:
+                case TIR.XPU.Gather gather:
                     IndentScope.Writer.Write($"gather({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {gather.Axis})");
                     break;
-                case IR.XPU.Concat concat:
+                case TIR.XPU.Concat concat:
                     var positiveAxis = concat.Axis > 0 ? concat.Axis : concat.Axis + ((TensorType)args[0].CheckedType).Shape.Rank;
                     IndentScope.Writer.Write($"concat({{{string.Join(",", args.SkipLast(1).Select(Visit).Select(s => "&" + s.Name))}}}, {Visit(args[^1]).Name}, {positiveAxis})");
                     break;
-                case IR.XPU.Slice slice:
+                case TIR.XPU.Slice slice:
                     var begins = ((TensorConst)expr.Arguments[2]).Value.ToArray<int>();
                     var ends = ((TensorConst)expr.Arguments[3]).Value.ToArray<int>();
                     var axes = ((TensorConst)expr.Arguments[4]).Value.ToArray<int>().Select(a => a >= 0 ? a : a + ((TensorType)args[0].CheckedType).Shape.Rank).ToList();
@@ -478,7 +478,7 @@ protected override CSymbol VisitCall(Call expr)
 
                     IndentScope.Writer.Write($"__tensor_copy_sync(std::move({Visit(expr.Arguments[1]).Name}), {Visit(expr.Arguments[0]).Name}({{{string.Join(',', newbegins.Select(e => e.ToString()))}}},{{{string.Join(',', newends.Select(e => e.ToString()))}}}))");
                     break;
-                case IR.XPU.Softmax softmax:
+                case TIR.XPU.Softmax softmax:
                     {
                         positiveAxis = softmax.Axis > 0 ? softmax.Axis : softmax.Axis + ((TensorType)args[0].CheckedType).Shape.Rank;
                         var sbpOnAxis = softmax.DistType.NdSBP.Where(sbp => sbp is SBPSplit s && s.Axis == softmax.Axis).ToArray();
@@ -505,13 +505,13 @@ protected override CSymbol VisitCall(Call expr)
                     }
 
                     break;
-                case IR.XPU.Transpose transpose:
+                case TIR.XPU.Transpose transpose:
                     IndentScope.Writer.Write($"transpose({Visit(args[0]).Name}, {Visit(args[1]).Name}, {{{string.Join(",", transpose.Perm.Select(p => p.ToString()))}}})");
                     break;
-                case IR.XPU.ReShape reshape:
+                case TIR.XPU.ReShape reshape:
                     IndentScope.Writer.Write($"__tensor_copy_sync(std::move({Visit(args[1]).Name}),std::move(view({Visit(args[0]).Name},{{{args[1].CheckedShape.ToString()[1..^1]}}})))");
                     break;
-                case IR.XPU.GatherReduceScatter grs:
+                case TIR.XPU.GatherReduceScatter grs:
                     var ret_name = Visit(args[1]).Name;
                     bool reshard = args[0].CheckedType != args[1].CheckedType;
                     if (reshard)
@@ -557,7 +557,7 @@ protected override CSymbol VisitCall(Call expr)
                     }
 
                     break;
-                case IR.XPU.Conv2D conv:
+                case TIR.XPU.Conv2D conv:
                     var sbpOnInChannel = conv.DistType.NdSBP.Where(sbp => sbp is SBPPartialSum).ToArray();
                     string strategy = sbpOnInChannel.Length switch
                     {
@@ -570,10 +570,10 @@ protected override CSymbol VisitCall(Call expr)
 
                     IndentScope.Writer.Write($"conv2d(ctx, {Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {Visit(args[3]).Name}, {{{string.Join(",", conv.Stride.Select(p => p.ToString()))}}}, {{{string.Join(",", conv.Padding.Select(p => p.ToString()))}}}, {{{string.Join(",", conv.Dilation.Select(p => p.ToString()))}}}, {conv.Groups}, {strategy})");
                     break;
-                case IR.XPU.ReduceArg reduceArg:
+                case TIR.XPU.ReduceArg reduceArg:
                     IndentScope.Writer.Write($"reduce_arg({Visit(args[0]).Name}, {Visit(args[1]).Name}, {reduceArg.Axis}, {reduceArg.KeepDims.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, {reduceArg.SelectLastIndex.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, reduce_arg_op_t::{reduceArg.ReduceArgOp.ToC()})");
                     break;
-                case IR.XPU.Resize resize:
+                case TIR.XPU.Resize resize:
                     using (_ = new IndentScope())
                     {
                         IndentScope.Writer.IndWrite($"{{\n");
@@ -586,13 +586,13 @@ protected override CSymbol VisitCall(Call expr)
                     }
 
                     break;
-                case IR.XPU.Cast cast:
+                case TIR.XPU.Cast cast:
                     IndentScope.Writer.Write($"cast({Visit(args[0]).Name}, {Visit(args[1]).Name})");
                     break;
-                case IR.XPU.Expand expand:
+                case TIR.XPU.Expand expand:
                     IndentScope.Writer.Write($"expand({Visit(args[0]).Name}, {Visit(args[1]).Name})");
                     break;
-                case IR.XPU.Clamp clamp:
+                case TIR.XPU.Clamp clamp:
                     string min = clamp.Min is float.NegativeInfinity ? float.MinValue.ToString() : clamp.Min.ToString();
                     string max = clamp.Max is float.PositiveInfinity ? float.MaxValue.ToString() : clamp.Max.ToString();
                     IndentScope.Writer.Write($"clamp({Visit(args[0]).Name}, {Visit(args[1]).Name}, (float){min}, (float){max})");
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.XPU/CodeGen/CSourceExtensions.cs
similarity index 99%
rename from modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
rename to modules/Nncase.Modules.XPU/CodeGen/CSourceExtensions.cs
index b4b503aba2..627372e39c 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceExtensions.cs
+++ b/modules/Nncase.Modules.XPU/CodeGen/CSourceExtensions.cs
@@ -4,7 +4,7 @@
 using Nncase.IR;
 using Nncase.TIR;
 
-namespace Nncase.CodeGen.CPU;
+namespace Nncase.CodeGen.XPU;
 
 /// <summary>
 /// convert the type/op to c name.
diff --git a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs b/modules/Nncase.Modules.XPU/CodeGen/CSourceUtilities.cs
similarity index 97%
rename from modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
rename to modules/Nncase.Modules.XPU/CodeGen/CSourceUtilities.cs
index 359ba4c3e9..5ab831b64c 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/CSourceUtilities.cs
+++ b/modules/Nncase.Modules.XPU/CodeGen/CSourceUtilities.cs
@@ -5,7 +5,7 @@
 using Nncase.Diagnostics;
 using Nncase.IR.Math;
 
-namespace Nncase.CodeGen.CPU;
+namespace Nncase.CodeGen.XPU;
 
 internal static class CSourceUtilities
 {
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs b/modules/Nncase.Modules.XPU/CodeGen/FunctionBuilder.cs
similarity index 98%
rename from modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
rename to modules/Nncase.Modules.XPU/CodeGen/FunctionBuilder.cs
index e864a90077..4af770852a 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionBuilder.cs
+++ b/modules/Nncase.Modules.XPU/CodeGen/FunctionBuilder.cs
@@ -7,7 +7,7 @@
 using NetFabric.Hyperlinq;
 using Nncase.IR;
 
-namespace Nncase.CodeGen.CPU;
+namespace Nncase.CodeGen.XPU;
 
 /// <summary>
 /// StackVM function builder.
diff --git a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.XPU/CodeGen/FunctionCSource.cs
similarity index 95%
rename from modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
rename to modules/Nncase.Modules.XPU/CodeGen/FunctionCSource.cs
index bc49aec1e7..64fb966d7d 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/FunctionCSource.cs
+++ b/modules/Nncase.Modules.XPU/CodeGen/FunctionCSource.cs
@@ -1,6 +1,6 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
-#define MULTI_CORE_CPU
+#define MULTI_CORE_XPU
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -15,7 +15,7 @@
 
 namespace Nncase.CodeGen;
 
-#if MULTI_CORE_CPU
+#if MULTI_CORE_XPU
 internal sealed record FunctionCSource(string Main, string Shared, string Kernel)
 {
 }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.XPU/CodeGen/LinkableFunction.cs
similarity index 97%
rename from modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
rename to modules/Nncase.Modules.XPU/CodeGen/LinkableFunction.cs
index 5f51530941..acf5c9d418 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableFunction.cs
+++ b/modules/Nncase.Modules.XPU/CodeGen/LinkableFunction.cs
@@ -4,7 +4,7 @@
 using System.Runtime.InteropServices;
 using Nncase.IR;
 
-namespace Nncase.CodeGen.CPU;
+namespace Nncase.CodeGen.XPU;
 
 internal sealed class LinkableFunction : ILinkableFunction
 {
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.XPU/CodeGen/LinkableModule.cs
similarity index 96%
rename from modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
rename to modules/Nncase.Modules.XPU/CodeGen/LinkableModule.cs
index 3abd00897a..d674afcbc4 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkableModule.cs
+++ b/modules/Nncase.Modules.XPU/CodeGen/LinkableModule.cs
@@ -10,7 +10,7 @@
 using Nncase.Diagnostics;
 using Nncase.Runtime.StackVM;
 
-namespace Nncase.CodeGen.CPU;
+namespace Nncase.CodeGen.XPU;
 
 internal sealed class LinkableModule : ILinkableModule
 {
@@ -82,7 +82,7 @@ public ILinkedModule Link(ILinkContext linkContext)
                 }
             }
 
-            // using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.h"), FileMode.Create))
+            // using (var fs = File.Open(Path.Join(dumpPath, "xpuModule.h"), FileMode.Create))
             // {
             //     using (var writer = new StreamWriter(fs))
             //     {
@@ -90,7 +90,7 @@ public ILinkedModule Link(ILinkContext linkContext)
             //     }
             // }
 
-            // using (var fs = File.Open(Path.Join(dumpPath, "cpuModule.c"), FileMode.Create))
+            // using (var fs = File.Open(Path.Join(dumpPath, "xpuModule.c"), FileMode.Create))
             // {
             //     File.Open(csourcePath, FileMode.Open, FileAccess.Read).CopyTo(fs);
             // }
diff --git a/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs b/modules/Nncase.Modules.XPU/CodeGen/LinkedModule.cs
similarity index 91%
rename from modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
rename to modules/Nncase.Modules.XPU/CodeGen/LinkedModule.cs
index fb642bf446..45a5ba8ac6 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/LinkedModule.cs
+++ b/modules/Nncase.Modules.XPU/CodeGen/LinkedModule.cs
@@ -8,7 +8,7 @@
 using System.Threading.Tasks;
 using Nncase.Runtime.StackVM;
 
-namespace Nncase.CodeGen.CPU;
+namespace Nncase.CodeGen.XPU;
 
 internal sealed class LinkedModule : ILinkedModule
 {
@@ -22,7 +22,7 @@ public LinkedModule(IReadOnlyList<ILinkedFunction> functions, Stream text, Strea
         };
     }
 
-    public string ModuleKind => Targets.CPUTarget.Kind;
+    public string ModuleKind => Targets.XPUTarget.Kind;
 
     public uint Version => 0;
 
diff --git a/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs b/modules/Nncase.Modules.XPU/CodeGen/ModuleBuilder.cs
similarity index 92%
rename from modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
rename to modules/Nncase.Modules.XPU/CodeGen/ModuleBuilder.cs
index 46bda204cb..e17535a208 100644
--- a/modules/Nncase.Modules.CPU/CodeGen/ModuleBuilder.cs
+++ b/modules/Nncase.Modules.XPU/CodeGen/ModuleBuilder.cs
@@ -5,7 +5,7 @@
 using Nncase.Diagnostics;
 using Nncase.IR;
 
-namespace Nncase.CodeGen.CPU;
+namespace Nncase.CodeGen.XPU;
 
 /// <summary>
 /// K230CoreModule builder.
@@ -25,7 +25,7 @@ public ModuleBuilder(CompileOptions options)
     public CompileOptions CompileOptions { get; }
 
     /// <inheritdoc/>
-    public string ModuleKind => Targets.CPUTarget.Kind;
+    public string ModuleKind => Targets.XPUTarget.Kind;
 
     /// <inheritdoc/>
     public ILinkableModule Build(IReadOnlyList<BaseFunction> functions)
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs b/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/Boxing.cs
similarity index 99%
rename from modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
rename to modules/Nncase.Modules.XPU/Evaluator/IR/CPU/Boxing.cs
index c1e8aa5af6..812d3877ee 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/Boxing.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/Boxing.cs
@@ -9,7 +9,7 @@
 using Nncase.IR.CPU;
 using Nncase.Utilities;
 
-namespace Nncase.Evaluator.CPU;
+namespace Nncase.Evaluator.IR.CPU;
 
 public sealed class BoxingEvaluator : ITypeInferencer<Boxing>, ICostEvaluator<Boxing>, IEvaluator<Boxing>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUKernelOp.cs b/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUKernelOp.cs
similarity index 96%
rename from modules/Nncase.Modules.CPU/Evaluator/CPU/CPUKernelOp.cs
rename to modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUKernelOp.cs
index fa18c5439c..39e1f58601 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUKernelOp.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUKernelOp.cs
@@ -7,7 +7,7 @@
 using Nncase.IR;
 using Nncase.IR.CPU;
 
-namespace Nncase.Evaluator.CPU;
+namespace Nncase.Evaluator.IR.CPU;
 
 /// <summary>
 /// Evaluator for <see cref="CPUKernelOp"/>.
diff --git a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs b/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUModule.cs
similarity index 93%
rename from modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
rename to modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUModule.cs
index b86978fd5d..10c4ce0ad8 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/CPU/CPUModule.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUModule.cs
@@ -4,7 +4,7 @@
 using DryIoc;
 using Nncase.Hosting;
 
-namespace Nncase.Evaluator.CPU;
+namespace Nncase.Evaluator.IR.CPU;
 
 /// <summary>
 /// CPU module.
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Binary.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Binary.cs
similarity index 86%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Binary.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Binary.cs
index 36fa13389d..2e269b2c3a 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Binary.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Binary.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class BinaryEvaluator : ITypeInferencer<Binary>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Cast.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Cast.cs
similarity index 84%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Cast.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Cast.cs
index 3280ea0857..d1400e1bdb 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Cast.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Cast.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class CastEvaluator : ITypeInferencer<Cast>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Clamp.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Clamp.cs
similarity index 85%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Clamp.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Clamp.cs
index dcc443729d..c9b803b216 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Clamp.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Clamp.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class ClampEvaluator : ITypeInferencer<Clamp>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Concat.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Concat.cs
similarity index 86%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Concat.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Concat.cs
index 1e4f661a81..27400dee3d 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Concat.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Concat.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class ConcatEvaluator : ITypeInferencer<Concat>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Conv2D.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Conv2D.cs
similarity index 84%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Conv2D.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Conv2D.cs
index 7c4ee83412..049c34ba9b 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Conv2D.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Conv2D.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public class Conv2DEvaluator : ITypeInferencer<Conv2D>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Expand.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Expand.cs
similarity index 85%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Expand.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Expand.cs
index 79286ba8c1..d33ea69e2b 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Expand.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Expand.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class ExpandEvaluator : ITypeInferencer<Expand>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Gather.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Gather.cs
similarity index 85%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Gather.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Gather.cs
index 7d97d51ff6..1287e24e7e 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Gather.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Gather.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class GatherEvaluator : ITypeInferencer<Gather>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/GatherReduceScatter.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/GatherReduceScatter.cs
similarity index 90%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/GatherReduceScatter.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/GatherReduceScatter.cs
index 2ec6502918..f3e40a95e6 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/GatherReduceScatter.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/GatherReduceScatter.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public class GatherReduceScatterEvaluator : ITypeInferencer<GatherReduceScatter>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/InstanceNorm.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/InstanceNorm.cs
similarity index 85%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/InstanceNorm.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/InstanceNorm.cs
index f86323668e..b4751f51bb 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/InstanceNorm.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/InstanceNorm.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class InstanceNormEvaluator : ITypeInferencer<InstanceNorm>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/LayerNorm.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/LayerNorm.cs
similarity index 85%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/LayerNorm.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/LayerNorm.cs
index 825844bae8..e00af493a1 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/LayerNorm.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/LayerNorm.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class LayerNormEvaluator : ITypeInferencer<LayerNorm>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Matmul.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Matmul.cs
similarity index 85%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Matmul.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Matmul.cs
index 5da9e21761..fb7db656fe 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Matmul.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Matmul.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class MatmulEvaluator : ITypeInferencer<Matmul>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/ReShape.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReShape.cs
similarity index 85%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/ReShape.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReShape.cs
index 826d95257e..933184bee5 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/ReShape.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReShape.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class ReShapeEvaluator : ITypeInferencer<ReShape>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/ReduceArg.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReduceArg.cs
similarity index 86%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/ReduceArg.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReduceArg.cs
index 5bb1170054..25f7b665b0 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/ReduceArg.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReduceArg.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class ReduceArgEvaluator : ITypeInferencer<ReduceArg>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Resize.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Resize.cs
similarity index 85%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Resize.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Resize.cs
index 14ba21bdef..3ef07f9224 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Resize.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Resize.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class ResizeEvaluator : ITypeInferencer<Resize>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Slice.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Slice.cs
similarity index 85%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Slice.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Slice.cs
index 33e83d591c..7f46705790 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Slice.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Slice.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class SliceEvaluator : ITypeInferencer<Slice>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Softmax.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Softmax.cs
similarity index 85%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Softmax.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Softmax.cs
index 409788a1d5..c6aa508b4e 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Softmax.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Softmax.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class SoftmaxEvaluator : ITypeInferencer<Softmax>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/SwishB.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/SwishB.cs
similarity index 96%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/SwishB.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/SwishB.cs
index bb42e69481..9b3de37742 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/SwishB.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/SwishB.cs
@@ -3,7 +3,7 @@
 
 using Nncase.Evaluator;
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
 namespace Nncase;
 
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMALoad.cs
similarity index 89%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMALoad.cs
index d432fd678e..0a38a27837 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMALoad.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMALoad.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public class TDMALoadEvaluator : ITypeInferencer<TDMALoad>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMAStore.cs
similarity index 89%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMAStore.cs
index af78b1e0e0..f2c60f7f32 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/TDMAStore.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMAStore.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class TDMAStoreEvaluator : ITypeInferencer<TDMAStore>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Transpose.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Transpose.cs
similarity index 86%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Transpose.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Transpose.cs
index cf74d2698b..cfaeb31294 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Transpose.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Transpose.cs
@@ -2,9 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 public sealed class TransposeEvaluator : ITypeInferencer<Transpose>
 {
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/Unary.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Unary.cs
similarity index 96%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/Unary.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Unary.cs
index e19fd7a1eb..7bbac1a94f 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/Unary.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Unary.cs
@@ -3,7 +3,7 @@
 
 using Nncase.Evaluator;
 using Nncase.IR;
-using Nncase.IR.XPU;
+using Nncase.TIR.XPU;
 
 namespace Nncase;
 
diff --git a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/XPUModule.cs
similarity index 98%
rename from modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
rename to modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/XPUModule.cs
index f42826df09..c647696375 100644
--- a/modules/Nncase.Modules.CPU/Evaluator/XPU/XPUModule.cs
+++ b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/XPUModule.cs
@@ -7,7 +7,7 @@
 using Nncase.Evaluator.Tensors;
 using Nncase.Hosting;
 
-namespace Nncase.Evaluator.XPU;
+namespace Nncase.Evaluator.TIR.XPU;
 
 /// <summary>
 /// XPU module.
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/Boxing.cs b/modules/Nncase.Modules.XPU/IR/CPU/Boxing.cs
similarity index 100%
rename from modules/Nncase.Modules.CPU/IR/CPU/Boxing.cs
rename to modules/Nncase.Modules.XPU/IR/CPU/Boxing.cs
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs b/modules/Nncase.Modules.XPU/IR/CPU/CPUKernelOp.cs
similarity index 100%
rename from modules/Nncase.Modules.CPU/IR/CPU/CPUKernelOp.cs
rename to modules/Nncase.Modules.XPU/IR/CPU/CPUKernelOp.cs
diff --git a/modules/Nncase.Modules.CPU/IR/CPU/Functional.cs b/modules/Nncase.Modules.XPU/IR/CPU/Functional.cs
similarity index 100%
rename from modules/Nncase.Modules.CPU/IR/CPU/Functional.cs
rename to modules/Nncase.Modules.XPU/IR/CPU/Functional.cs
diff --git a/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj b/modules/Nncase.Modules.XPU/Nncase.Modules.XPU.csproj
similarity index 80%
rename from modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj
rename to modules/Nncase.Modules.XPU/Nncase.Modules.XPU.csproj
index edfe0f068e..4e9d1f7a7f 100644
--- a/modules/Nncase.Modules.CPU/Nncase.Modules.CPU.csproj
+++ b/modules/Nncase.Modules.XPU/Nncase.Modules.XPU.csproj
@@ -6,9 +6,8 @@
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-    <LangVersion>11.0</LangVersion>
   </PropertyGroup>
-
+  
   <ItemGroup>
     <ProjectReference Include="..\..\src\Nncase.Diagnostics\Nncase.Diagnostics.csproj" />
     <ProjectReference Include="..\..\src\Nncase.Passes\Nncase.Passes.csproj" />
@@ -20,4 +19,11 @@
     <ProjectReference Include="..\Nncase.Modules.StackVM\Nncase.Modules.StackVM.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Evaluator/" />
+    <Folder Include="Evaluator/IR/" />
+    <Folder Include="Evaluator/TIR/" />
+    <Folder Include="Evaluator/XPU/" />
+    <Folder Include="TIR/" />
+  </ItemGroup>
 </Project>
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/CombineMHA.cs b/modules/Nncase.Modules.XPU/Passes/Rules/CombineMHA.cs
similarity index 99%
rename from modules/Nncase.Modules.CPU/Passes/Rules/CombineMHA.cs
rename to modules/Nncase.Modules.XPU/Passes/Rules/CombineMHA.cs
index e8de33a9e5..3d5302ddac 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/CombineMHA.cs
+++ b/modules/Nncase.Modules.XPU/Passes/Rules/CombineMHA.cs
@@ -8,7 +8,6 @@
 using System.Text;
 using System.Threading.Tasks;
 using Nncase.IR;
-using Nncase.IR.CPU;
 using Nncase.IR.F;
 using Nncase.IR.Math;
 using Nncase.IR.NN;
@@ -16,6 +15,7 @@
 using Nncase.Passes.Rules.Neutral;
 using Nncase.PatternMatch;
 using Nncase.Targets;
+using Nncase.TIR.XPU;
 using static Nncase.IR.TypePatternUtility;
 using static Nncase.PatternMatch.F.Math;
 using static Nncase.PatternMatch.F.Tensors;
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/DumpConst.cs b/modules/Nncase.Modules.XPU/Passes/Rules/DumpConst.cs
similarity index 99%
rename from modules/Nncase.Modules.CPU/Passes/Rules/DumpConst.cs
rename to modules/Nncase.Modules.XPU/Passes/Rules/DumpConst.cs
index 50c0b3fc82..aa9becf447 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/DumpConst.cs
+++ b/modules/Nncase.Modules.XPU/Passes/Rules/DumpConst.cs
@@ -10,7 +10,6 @@
 using System.Threading.Tasks;
 using Nncase.Diagnostics;
 using Nncase.IR;
-using Nncase.IR.CPU;
 using Nncase.IR.F;
 using Nncase.IR.Math;
 using Nncase.IR.NN;
@@ -18,6 +17,7 @@
 using Nncase.Passes.Rules.Neutral;
 using Nncase.PatternMatch;
 using Nncase.Targets;
+using Nncase.TIR.XPU;
 using static Nncase.IR.TypePatternUtility;
 using static Nncase.PatternMatch.F.Math;
 using static Nncase.PatternMatch.F.NN;
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/FusionMerger.cs b/modules/Nncase.Modules.XPU/Passes/Rules/FusionMerger.cs
similarity index 99%
rename from modules/Nncase.Modules.CPU/Passes/Rules/FusionMerger.cs
rename to modules/Nncase.Modules.XPU/Passes/Rules/FusionMerger.cs
index f3791efba5..f8e9abb794 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/FusionMerger.cs
+++ b/modules/Nncase.Modules.XPU/Passes/Rules/FusionMerger.cs
@@ -11,7 +11,6 @@
 using DryIoc.ImTools;
 using Google.OrTools.LinearSolver;
 using Nncase.IR;
-using Nncase.IR.CPU;
 using Nncase.IR.Math;
 using Nncase.IR.NN;
 using Nncase.IR.Tensors;
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/LowerBinary.cs b/modules/Nncase.Modules.XPU/Passes/Rules/LowerBinary.cs
similarity index 100%
rename from modules/Nncase.Modules.CPU/Passes/Rules/LowerBinary.cs
rename to modules/Nncase.Modules.XPU/Passes/Rules/LowerBinary.cs
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs b/modules/Nncase.Modules.XPU/Passes/Rules/LowerMatMul.cs
similarity index 100%
rename from modules/Nncase.Modules.CPU/Passes/Rules/LowerMatMul.cs
rename to modules/Nncase.Modules.XPU/Passes/Rules/LowerMatMul.cs
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs b/modules/Nncase.Modules.XPU/Passes/Rules/LowerUnary.cs
similarity index 67%
rename from modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs
rename to modules/Nncase.Modules.XPU/Passes/Rules/LowerUnary.cs
index a6182d5c27..81aae570a1 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/LowerUnary.cs
+++ b/modules/Nncase.Modules.XPU/Passes/Rules/LowerUnary.cs
@@ -20,14 +20,14 @@ namespace Nncase.Passes.Rules;
 [RuleGenerator]
 public partial class LowerUnary : RewriteRule<Pattern>
 {
-    /// <inheritdoc/>
-    public override Pattern Pattern { get; } = IsUnary(
-      target_name: "unary",
-      _ => true,
-      IsWildcard("input") with { TypePattern = IsFloat() });
+  /// <inheritdoc/>
+  public override Pattern Pattern { get; } = IsUnary(
+    target_name: "unary",
+    _ => true,
+    IsWildcard("input") with { TypePattern = IsFloat() });
 
-    private Expr GetReplace(Unary unary, Expr input)
-    {
-        return CPUKernel(unary, input);
-    }
+  private Expr GetReplace(Unary unary, Expr input)
+  {
+    return CPUKernel(unary, input);
+  }
 }
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.XPU/Passes/Rules/MHAFusion.cs
similarity index 97%
rename from modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
rename to modules/Nncase.Modules.XPU/Passes/Rules/MHAFusion.cs
index 56c9035e05..8296b0278a 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MHAFusion.cs
+++ b/modules/Nncase.Modules.XPU/Passes/Rules/MHAFusion.cs
@@ -8,7 +8,6 @@
 using System.Text;
 using System.Threading.Tasks;
 using Nncase.IR;
-using Nncase.IR.CPU;
 using Nncase.IR.Math;
 using Nncase.IR.NN;
 using Nncase.IR.Tensors;
@@ -27,7 +26,7 @@ namespace Nncase.Passes.Rules;
 [RuleGenerator]
 public sealed partial class FuseMHA1 : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => CreatePattern();
 
@@ -100,7 +99,7 @@ private static Pattern CreatePattern()
 [RuleGenerator]
 public sealed partial class FuseMHA2 : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => CreatePattern();
 
@@ -217,7 +216,7 @@ private static Pattern CreatePattern()
 [RuleGenerator]
 public sealed partial class FuseMHA3 : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => CreatePattern();
 
@@ -277,7 +276,7 @@ private static Pattern CreatePattern()
 [RuleGenerator]
 public sealed partial class FuseSDTextEncoderHeader : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => CreatePattern();
 
@@ -314,7 +313,7 @@ private static Pattern CreatePattern()
 [RuleGenerator]
 public sealed partial class FuseSDTextEncoderTail : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => CreatePattern();
 
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs b/modules/Nncase.Modules.XPU/Passes/Rules/MakeFusion.cs
similarity index 92%
rename from modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
rename to modules/Nncase.Modules.XPU/Passes/Rules/MakeFusion.cs
index 617c829c51..59a6beff90 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/MakeFusion.cs
+++ b/modules/Nncase.Modules.XPU/Passes/Rules/MakeFusion.cs
@@ -18,9 +18,9 @@
 namespace Nncase.Passes.Rules;
 
 [RuleGenerator]
-internal sealed partial class CPUFusion : FusionMaker
+internal sealed partial class XPUFusion : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => IsCallWildcard("call", IsOp<CPUKernelOp>("op"));
 
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs b/modules/Nncase.Modules.XPU/Passes/Rules/UnetFusion.cs
similarity index 98%
rename from modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
rename to modules/Nncase.Modules.XPU/Passes/Rules/UnetFusion.cs
index ae30765b80..9dbcd7cb4c 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/UnetFusion.cs
+++ b/modules/Nncase.Modules.XPU/Passes/Rules/UnetFusion.cs
@@ -11,13 +11,13 @@
 using DryIoc.ImTools;
 using Google.OrTools.LinearSolver;
 using Nncase.IR;
-using Nncase.IR.CPU;
 using Nncase.IR.Math;
 using Nncase.IR.NN;
 using Nncase.IR.Tensors;
 using Nncase.Passes.Rules.Neutral;
 using Nncase.PatternMatch;
 using Nncase.Targets;
+using Nncase.TIR.XPU;
 using static Nncase.PatternMatch.F.Imaging;
 using static Nncase.PatternMatch.F.Math;
 using static Nncase.PatternMatch.F.NN;
@@ -33,7 +33,7 @@ namespace Nncase.Passes.Rules;
 [RuleGenerator]
 public sealed partial class FuseUnetSpatialTransformer : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => CreatePattern();
 
@@ -153,7 +153,7 @@ private static Pattern CreatePattern()
 [RuleGenerator]
 public sealed partial class FuseUnetResBlock : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => CreatePattern();
 
@@ -241,7 +241,7 @@ private static Pattern CreatePattern()
 [RuleGenerator]
 public sealed partial class FuseUnetTimeEmb : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => CreatePattern();
 
diff --git a/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs b/modules/Nncase.Modules.XPU/Passes/Rules/VAEFusion.cs
similarity index 97%
rename from modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
rename to modules/Nncase.Modules.XPU/Passes/Rules/VAEFusion.cs
index 59e22d2587..bc8426f802 100644
--- a/modules/Nncase.Modules.CPU/Passes/Rules/VAEFusion.cs
+++ b/modules/Nncase.Modules.XPU/Passes/Rules/VAEFusion.cs
@@ -8,13 +8,13 @@
 using System.Text;
 using System.Threading.Tasks;
 using Nncase.IR;
-using Nncase.IR.CPU;
 using Nncase.IR.Math;
 using Nncase.IR.NN;
 using Nncase.IR.Tensors;
 using Nncase.Passes.Rules.Neutral;
 using Nncase.PatternMatch;
 using Nncase.Targets;
+using Nncase.TIR.XPU;
 using static Nncase.PatternMatch.F.Imaging;
 using static Nncase.PatternMatch.F.Math;
 using static Nncase.PatternMatch.F.NN;
@@ -30,7 +30,7 @@ namespace Nncase.Passes.Rules;
 [RuleGenerator]
 public sealed partial class FuseVAEDecRes : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => CreatePattern();
 
@@ -89,7 +89,7 @@ private static Pattern CreatePattern()
 [RuleGenerator]
 public sealed partial class FuseVAEDecHead : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => CreatePattern();
 
@@ -132,7 +132,7 @@ private static Pattern CreatePattern()
 [RuleGenerator]
 public sealed partial class FuseVAEDecMHA : FusionMaker
 {
-    public override string ModuleKind { get; } = CPUTarget.Kind;
+    public override string ModuleKind { get; } = XPUTarget.Kind;
 
     public override Pattern Pattern => CreatePattern();
 
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs b/modules/Nncase.Modules.XPU/Passes/Tile/AutoDistributedConvertVisitor.cs
similarity index 100%
rename from modules/Nncase.Modules.CPU/Passes/Tile/AutoDistributedConvertVisitor.cs
rename to modules/Nncase.Modules.XPU/Passes/Tile/AutoDistributedConvertVisitor.cs
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/IFusionChecker.cs b/modules/Nncase.Modules.XPU/Passes/Tile/IFusionChecker.cs
similarity index 100%
rename from modules/Nncase.Modules.CPU/Passes/Tile/IFusionChecker.cs
rename to modules/Nncase.Modules.XPU/Passes/Tile/IFusionChecker.cs
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs b/modules/Nncase.Modules.XPU/Passes/Tile/MultiFusionChecker.cs
similarity index 100%
rename from modules/Nncase.Modules.CPU/Passes/Tile/MultiFusionChecker.cs
rename to modules/Nncase.Modules.XPU/Passes/Tile/MultiFusionChecker.cs
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs b/modules/Nncase.Modules.XPU/Passes/Tile/SingleXPUFusionConverter.cs
similarity index 91%
rename from modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
rename to modules/Nncase.Modules.XPU/Passes/Tile/SingleXPUFusionConverter.cs
index 6b082fab48..c90eb9d6ea 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/SingleCPUFusionConverter.cs
+++ b/modules/Nncase.Modules.XPU/Passes/Tile/SingleXPUFusionConverter.cs
@@ -11,9 +11,9 @@ namespace Nncase.Passes.Tile;
 /// <summary>
 /// convert the fusion to prim func.
 /// </summary>
-internal sealed class SingleCPUFusionConverter
+internal sealed class SingleXPUFusionConverter
 {
-    public SingleCPUFusionConverter(TileOptions tileOptions)
+    public SingleXPUFusionConverter(TileOptions tileOptions)
     {
         TileOptions = tileOptions;
     }
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.XPU/Passes/Tile/TIRConvertVisitor.cs
similarity index 87%
rename from modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
rename to modules/Nncase.Modules.XPU/Passes/Tile/TIRConvertVisitor.cs
index ac1ce1fbb5..819bcadcf2 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/TIRConvertVisitor.cs
+++ b/modules/Nncase.Modules.XPU/Passes/Tile/TIRConvertVisitor.cs
@@ -118,22 +118,22 @@ protected override Unit VisitLeafCall(Call expr)
 
     private void GenerateSwishB(Buffer input, Buffer ret, float beta)
     {
-        _mainBody.Add(IR.F.XPU.SwishB(input, ret, beta));
+        _mainBody.Add(TIR.F.XPU.SwishB(input, ret, beta));
     }
 
     private void GenerateReshape(Buffer input, Buffer ret)
     {
-        _mainBody.Add(IR.F.XPU.ReShape(input, ret));
+        _mainBody.Add(TIR.F.XPU.ReShape(input, ret));
     }
 
     private void GenerateConcat(Concat concat, Buffer[] inputs, Buffer ret)
     {
-        _mainBody.Add(IR.F.XPU.Concat(concat.Axis, inputs, ret));
+        _mainBody.Add(TIR.F.XPU.Concat(concat.Axis, inputs, ret));
     }
 
     private void GenerateSlice(Slice slice, Buffer input, Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType)
     {
-        _mainBody.Add(IR.F.XPU.Slice(input, output, begins, ends, axes, distributedType));
+        _mainBody.Add(TIR.F.XPU.Slice(input, output, begins, ends, axes, distributedType));
     }
 
     private void GenerateBoxing(IR.CPU.Boxing boxing, Buffer[] arguments, Buffer ret, Call expr)
@@ -142,13 +142,13 @@ private void GenerateBoxing(IR.CPU.Boxing boxing, Buffer[] arguments, Buffer ret
         {
             case (TensorType, DistributedType distTensorType):
                 {
-                    _mainBody.Add(IR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSBP, distTensorType.Placement));
+                    _mainBody.Add(TIR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSBP, distTensorType.Placement));
                 }
 
                 break;
             case (DistributedType distTensorType, TensorType):
                 {
-                    _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSBP, distTensorType.Placement));
+                    _mainBody.Add(TIR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSBP, distTensorType.Placement));
                 }
 
                 break;
@@ -162,12 +162,12 @@ private void GenerateBoxing(IR.CPU.Boxing boxing, Buffer[] arguments, Buffer ret
                             Hierarchy = new IRArray<int>(partialSumPos.Select(t => inType.Placement.Hierarchy[t.i])),
                             Name = new string(partialSumPos.Select(t => inType.Placement.Name[t.i]).ToArray()),
                         };
-                        _mainBody.Add(IR.F.XPU.GatherReduceScatter(arguments[0], ret, partialSumPos, placement));
+                        _mainBody.Add(TIR.F.XPU.GatherReduceScatter(arguments[0], ret, partialSumPos, placement));
                     }
                     else
                     {
-                        _mainBody.Add(IR.F.XPU.TDMAStore(arguments[0], None.Default, inType.NdSBP, inType.Placement));
-                        _mainBody.Add(IR.F.XPU.TDMALoad(ret, None.Default, outType.NdSBP, outType.Placement));
+                        _mainBody.Add(TIR.F.XPU.TDMAStore(arguments[0], None.Default, inType.NdSBP, inType.Placement));
+                        _mainBody.Add(TIR.F.XPU.TDMALoad(ret, None.Default, outType.NdSBP, outType.Placement));
                     }
                 }
 
@@ -180,7 +180,7 @@ private void GenerateBoxing(IR.CPU.Boxing boxing, Buffer[] arguments, Buffer ret
     private void GenerateUnary(string unaryOp, ReadOnlySpan<Buffer> arguments, Buffer ret)
     {
         var input = arguments[IR.Math.Unary.Input.Index];
-        _mainBody.Add(IR.F.XPU.Unary(unaryOp, input, ret));
+        _mainBody.Add(TIR.F.XPU.Unary(unaryOp, input, ret));
     }
 
     private void GenerateBinary(Binary binary, Buffer[] arguments, Buffer ret, Call expr)
@@ -188,67 +188,67 @@ private void GenerateBinary(Binary binary, Buffer[] arguments, Buffer ret, Call
         var lhs = (DistributedType)expr[Binary.Lhs].CheckedType;
         var rhs = (DistributedType)expr[Binary.Rhs].CheckedType;
         var outtype = (DistributedType)expr.CheckedType;
-        _mainBody.Add(IR.F.XPU.Binary(binary.BinaryOp, lhs, rhs, outtype, arguments[0], arguments[1], ret));
+        _mainBody.Add(TIR.F.XPU.Binary(binary.BinaryOp, lhs, rhs, outtype, arguments[0], arguments[1], ret));
     }
 
     private void GenerateMatmul(MatMul matmul, Buffer[] arguments, Buffer ret)
     {
-        _mainBody.Add(IR.F.XPU.Matmul(arguments[0], arguments[1], ret));
+        _mainBody.Add(TIR.F.XPU.Matmul(arguments[0], arguments[1], ret));
     }
 
     private void GenerateLayerNorm(LayerNorm layerNorm, Buffer[] arguments, Buffer ret, DistributedType distributedType)
     {
-        _mainBody.Add(IR.F.XPU.LayerNorm(layerNorm.Axis, layerNorm.Epsilon, layerNorm.UseMean, arguments[0], arguments[1], arguments[2], ret, distributedType));
+        _mainBody.Add(TIR.F.XPU.LayerNorm(layerNorm.Axis, layerNorm.Epsilon, layerNorm.UseMean, arguments[0], arguments[1], arguments[2], ret, distributedType));
     }
 
     private void GenerateInstanceNorm(InstanceNormalization instNorm, float eps, Buffer[] arguments, Buffer ret, DistributedType distributedType)
     {
-        _mainBody.Add(IR.F.XPU.InstanceNorm(eps, arguments[0], arguments[1], arguments[2], ret, distributedType));
+        _mainBody.Add(TIR.F.XPU.InstanceNorm(eps, arguments[0], arguments[1], arguments[2], ret, distributedType));
     }
 
     private void GenerateGather(Gather gahter, Buffer[] arguments, Buffer ret)
     {
-        _mainBody.Add(IR.F.XPU.Gather(gahter.Axis, arguments[0], arguments[1], ret));
+        _mainBody.Add(TIR.F.XPU.Gather(gahter.Axis, arguments[0], arguments[1], ret));
     }
 
     private void GenerateSoftmax(Softmax softmax, int axis, Buffer[] arguments, Buffer ret, DistributedType distributedType)
     {
-        _mainBody.Add(IR.F.XPU.Softmax(axis, arguments[0], ret, distributedType));
+        _mainBody.Add(TIR.F.XPU.Softmax(axis, arguments[0], ret, distributedType));
     }
 
     private void GenerateTranspose(Transpose transpose, int[] perm, Buffer[] arguments, Buffer ret)
     {
-        _mainBody.Add(IR.F.XPU.Transpose(perm, arguments[0], ret));
+        _mainBody.Add(TIR.F.XPU.Transpose(perm, arguments[0], ret));
     }
 
     private void GenerateConv2D(Conv2D conv, Buffer[] arguments, Buffer ret, int[] stride, int[] padding, int[] dilation, int groups, TensorConst fusedClamp, DistributedType distributedType)
     {
-        _mainBody.Add(IR.F.XPU.Conv2D(arguments[0], arguments[1], arguments[2], ret, stride, padding, dilation, groups, fusedClamp, distributedType));
+        _mainBody.Add(TIR.F.XPU.Conv2D(arguments[0], arguments[1], arguments[2], ret, stride, padding, dilation, groups, fusedClamp, distributedType));
     }
 
     private void GenerateReduceArg(ReduceArg reduceArg, Buffer[] arguments, Buffer ret, int axis, bool keepdims, bool selectLastIndex, ReduceArgOp op, DataType dataType)
     {
-        _mainBody.Add(IR.F.XPU.ReduceArg(arguments[0], ret, axis, keepdims, selectLastIndex, op, dataType));
+        _mainBody.Add(TIR.F.XPU.ReduceArg(arguments[0], ret, axis, keepdims, selectLastIndex, op, dataType));
     }
 
     private void GenerateResize(ResizeImage resize, Buffer[] arguments, Buffer ret, float[] roi, int[] newSize, float cubicCoeffA, int excludeOutside, float extrapolationValue, DistributedType distributedType)
     {
-        _mainBody.Add(IR.F.XPU.Resize(arguments[0], ret, roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, resize.ResizeMode, resize.TransformationMode, resize.NearestMode, resize.IsTFResize));
+        _mainBody.Add(TIR.F.XPU.Resize(arguments[0], ret, roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, resize.ResizeMode, resize.TransformationMode, resize.NearestMode, resize.IsTFResize));
     }
 
     private void GenerateCast(DataType dataType, CastMode castMode, ReadOnlySpan<Buffer> arguments, Buffer ret)
     {
-        _mainBody.Add(IR.F.XPU.Cast(arguments[0], ret, dataType, castMode));
+        _mainBody.Add(TIR.F.XPU.Cast(arguments[0], ret, dataType, castMode));
     }
 
     private void GenerateExpand(int[] shape, DistributedType distributedType, ReadOnlySpan<Buffer> arguments, Buffer ret)
     {
-        _mainBody.Add(IR.F.XPU.Expand(shape, distributedType, arguments[0], ret));
+        _mainBody.Add(TIR.F.XPU.Expand(shape, distributedType, arguments[0], ret));
     }
 
     private void GenerateClamp(ReadOnlySpan<Buffer> arguments, Buffer ret, float min, float max)
     {
-        _mainBody.Add(IR.F.XPU.Clamp(arguments[0], ret, min, max));
+        _mainBody.Add(TIR.F.XPU.Clamp(arguments[0], ret, min, max));
     }
 
 #if false
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs b/modules/Nncase.Modules.XPU/Passes/Tile/TileOptions.cs
similarity index 100%
rename from modules/Nncase.Modules.CPU/Passes/Tile/TileOptions.cs
rename to modules/Nncase.Modules.XPU/Passes/Tile/TileOptions.cs
diff --git a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs b/modules/Nncase.Modules.XPU/Passes/Tile/XPUSameInputFusionMergeRule.cs
similarity index 92%
rename from modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
rename to modules/Nncase.Modules.XPU/Passes/Tile/XPUSameInputFusionMergeRule.cs
index 9bbe5c0ff3..d4d99f95b7 100644
--- a/modules/Nncase.Modules.CPU/Passes/Tile/CPUFusionGroupMutator.cs
+++ b/modules/Nncase.Modules.XPU/Passes/Tile/XPUSameInputFusionMergeRule.cs
@@ -8,9 +8,9 @@
 
 namespace Nncase.Passes.Tile;
 
-internal sealed class CPUSameInputFusionMergeRule : Mutators.SameInputFusionMergeRule
+internal sealed class XPUSameInputFusionMergeRule : Mutators.SameInputFusionMergeRule
 {
-    public override string ModuleKind => CPUTarget.Kind;
+    public override string ModuleKind => XPUTarget.Kind;
 
     // todo enable multi input fusion merge pattern.
     public override Pattern CreatePattern(string target_module_kind)
@@ -34,12 +34,12 @@ public override Pattern CreatePattern(string target_module_kind)
     }
 }
 
-internal sealed class CPUFusionGroupMutator<T> : Mutators.FusionGroupMutator
+internal sealed class XPUFusionGroupMutator<T> : Mutators.FusionGroupMutator
   where T : IFusionChecker
 {
     private readonly TileOptions _tileOptions;
 
-    public CPUFusionGroupMutator(
+    public XPUFusionGroupMutator(
       Dictionary<Fusion, IFusionChecker> fusioncheckerCache,
       TileOptions tileOptions,
       Mutators.IMergeRewriteRule rule,
@@ -94,7 +94,7 @@ public CheckedConvertMutator(Dictionary<Fusion, BaseFunction> fusion_converted_c
     /// <inheritdoc/>
     protected override Expr RewriteLeafFusion(Fusion expr)
     {
-        if (expr is Fusion { ModuleKind: CPUTarget.Kind } fusion)
+        if (expr is Fusion { ModuleKind: XPUTarget.Kind } fusion)
         {
             if (!_fusionConertedCache.TryGetValue(fusion, out _))
             {
@@ -105,7 +105,7 @@ protected override Expr RewriteLeafFusion(Fusion expr)
                 }
                 else
                 {
-                    var converter = new SingleCPUFusionConverter(_tileOptions);
+                    var converter = new SingleXPUFusionConverter(_tileOptions);
                     prim_func = converter.Convert(fusion);
                 }
 
@@ -119,7 +119,7 @@ protected override Expr RewriteLeafFusion(Fusion expr)
 
     protected override Expr RewriteLeafCall(Call expr)
     {
-        if (expr.Target is Fusion { ModuleKind: CPUTarget.Kind } fusion)
+        if (expr.Target is Fusion { ModuleKind: XPUTarget.Kind } fusion)
         {
             var convert_func = _fusionConertedCache[fusion];
             PrimFunctionWrapper wrapper;
diff --git a/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs b/modules/Nncase.Modules.XPU/Passes/XPUFusionToTirPass.cs
similarity index 91%
rename from modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
rename to modules/Nncase.Modules.XPU/Passes/XPUFusionToTirPass.cs
index 293fd6a627..3cdbf9f40f 100644
--- a/modules/Nncase.Modules.CPU/Passes/CPUFusionToTirPass.cs
+++ b/modules/Nncase.Modules.XPU/Passes/XPUFusionToTirPass.cs
@@ -17,11 +17,11 @@
 
 namespace Nncase.Passes;
 
-internal sealed class CPUFusionToTirPass : ModulePass
+internal sealed class XPUFusionToTirPass : ModulePass
 {
     private readonly TileOptions _tileOptions;
 
-    public CPUFusionToTirPass(TileOptions tileOptions)
+    public XPUFusionToTirPass(TileOptions tileOptions)
     {
         _tileOptions = tileOptions;
     }
@@ -43,8 +43,8 @@ protected override Task<IRModule> RunCoreAsync(IRModule module, RunPassContext o
 
                 var post = (Function)rewriter.Rewrite(
                     func,
-                    new Mutators.IMergeRewriteRule[] { new CPUSameInputFusionMergeRule() },
-                    (rule, option) => new CPUFusionGroupMutator<MultiFusionChecker>(fusionCheckCache, _tileOptions, rule, option),
+                    new Mutators.IMergeRewriteRule[] { new XPUSameInputFusionMergeRule() },
+                    (rule, option) => new XPUFusionGroupMutator<MultiFusionChecker>(fusionCheckCache, _tileOptions, rule, option),
                     new() { AnalysisResults = analysis, MatchOptions = new Mutators.FusionGroupMutator.GroupedMatchOptions() });
 
                 var mutator = new CheckedConvertMutator(fusionConertedCache, fusionCheckCache, _tileOptions, options);
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Binary.cs
similarity index 94%
rename from modules/Nncase.Modules.CPU/IR/XPU/Binary.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Binary.cs
index d10bfb863f..1673988240 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Binary.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Binary.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Binary : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Cast.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Cast.cs
similarity index 93%
rename from modules/Nncase.Modules.CPU/IR/XPU/Cast.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Cast.cs
index ca9e3658c7..7f05949cc7 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Cast.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Cast.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Cast : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Clamp.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Clamp.cs
similarity index 91%
rename from modules/Nncase.Modules.CPU/IR/XPU/Clamp.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Clamp.cs
index 88a0cc2655..58058caa24 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Clamp.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Clamp.cs
@@ -1,9 +1,9 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
 using System.Dynamic;
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Clamp : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Concat.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Concat.cs
similarity index 84%
rename from modules/Nncase.Modules.CPU/IR/XPU/Concat.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Concat.cs
index 6270fb618d..5cf46941e8 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Concat.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Concat.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Concat : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Conv2D.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Conv2D.cs
similarity index 94%
rename from modules/Nncase.Modules.CPU/IR/XPU/Conv2D.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Conv2D.cs
index 301ea9f6e5..ee1df6afe0 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Conv2D.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Conv2D.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Conv2D : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Expand.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Expand.cs
similarity index 91%
rename from modules/Nncase.Modules.CPU/IR/XPU/Expand.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Expand.cs
index 3866fe78d1..0cf63b57e1 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Expand.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Expand.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Expand : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Functional.cs
similarity index 89%
rename from modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Functional.cs
index 150eab38d6..215a0103cd 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Functional.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Functional.cs
@@ -6,9 +6,11 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-using Nncase.IR.XPU;
+using Nncase.IR;
+using Nncase.TIR;
+using Nncase.TIR.XPU;
 
-namespace Nncase.IR.F;
+namespace Nncase.TIR.F;
 
 public partial class XPU
 {
@@ -49,7 +51,7 @@ public static Call InstanceNorm(float eps, Expr input, Expr scale, Expr bias, Ex
 
     public static Call Gather(int axis, Expr input, Expr indices, Expr output)
     {
-        return new Call(new IR.XPU.Gather(axis), input, indices, output);
+        return new Call(new TIR.XPU.Gather(axis), input, indices, output);
     }
 
     public static Call Concat(int axis, Expr[] inputs, Expr output)
@@ -64,22 +66,22 @@ public static Expr Slice(TIR.Buffer input, TIR.Buffer output, Expr begins, Expr
 
     public static Call Softmax(int axis, Expr input, Expr output, DistributedType distributedType)
     {
-        return new Call(new IR.XPU.Softmax(axis, distributedType), input, output);
+        return new Call(new TIR.XPU.Softmax(axis, distributedType), input, output);
     }
 
     public static Call Transpose(int[] perm, Expr input, Expr output)
     {
-        return new Call(new IR.XPU.Transpose(perm), input, output);
+        return new Call(new TIR.XPU.Transpose(perm), input, output);
     }
 
     public static Call ReShape(Expr input, Expr output)
     {
-        return new Call(new IR.XPU.ReShape(), input, output);
+        return new Call(new TIR.XPU.ReShape(), input, output);
     }
 
     public static Call SwishB(Expr input, Expr output, float beta)
     {
-        return new Call(new IR.XPU.SwishB(beta), input, output);
+        return new Call(new TIR.XPU.SwishB(beta), input, output);
     }
 
     public static Call GatherReduceScatter(Expr input, Expr output, (int, SBP)[] reducePosition, Placement placement)
@@ -114,6 +116,6 @@ public static Call Expand(int[] shape, DistributedType distributedType, Expr inp
 
     public static Call Clamp(Expr input, Expr output, float min, float max)
     {
-        return new Call(new IR.XPU.Clamp(min, max), input, output);
+        return new Call(new TIR.XPU.Clamp(min, max), input, output);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Gather.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Gather.cs
similarity index 92%
rename from modules/Nncase.Modules.CPU/IR/XPU/Gather.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Gather.cs
index 6b5902ca76..7232f0b0b1 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Gather.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Gather.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Gather : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/GatherReduceScatter.cs b/modules/Nncase.Modules.XPU/TIR/XPU/GatherReduceScatter.cs
similarity index 92%
rename from modules/Nncase.Modules.CPU/IR/XPU/GatherReduceScatter.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/GatherReduceScatter.cs
index 87588d26c4..2b69259d24 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/GatherReduceScatter.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/GatherReduceScatter.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class GatherReduceScatter : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/InstanceNorm.cs b/modules/Nncase.Modules.XPU/TIR/XPU/InstanceNorm.cs
similarity index 93%
rename from modules/Nncase.Modules.CPU/IR/XPU/InstanceNorm.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/InstanceNorm.cs
index a75142d8fa..3719792d44 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/InstanceNorm.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/InstanceNorm.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class InstanceNorm : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/LayerNorm.cs b/modules/Nncase.Modules.XPU/TIR/XPU/LayerNorm.cs
similarity index 94%
rename from modules/Nncase.Modules.CPU/IR/XPU/LayerNorm.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/LayerNorm.cs
index 2074880d48..ae20eb3feb 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/LayerNorm.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/LayerNorm.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class LayerNorm : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Matmul.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Matmul.cs
similarity index 91%
rename from modules/Nncase.Modules.CPU/IR/XPU/Matmul.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Matmul.cs
index 4053e2c5c4..01ddc3b9a4 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Matmul.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Matmul.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Matmul : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/ReShape.cs b/modules/Nncase.Modules.XPU/TIR/XPU/ReShape.cs
similarity index 89%
rename from modules/Nncase.Modules.CPU/IR/XPU/ReShape.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/ReShape.cs
index 92d6a585ad..89c7803a82 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/ReShape.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/ReShape.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class ReShape : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/ReduceArg.cs b/modules/Nncase.Modules.XPU/TIR/XPU/ReduceArg.cs
similarity index 96%
rename from modules/Nncase.Modules.CPU/IR/XPU/ReduceArg.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/ReduceArg.cs
index 89a6fc0ec6..55a629ea4f 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/ReduceArg.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/ReduceArg.cs
@@ -7,9 +7,10 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Nncase.IR;
 using Nncase.PatternMatch;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 /// <summary>
 /// ReduceArg expression.
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Resize.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Resize.cs
similarity index 96%
rename from modules/Nncase.Modules.CPU/IR/XPU/Resize.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Resize.cs
index 913136afeb..da15c8da77 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Resize.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Resize.cs
@@ -2,8 +2,9 @@
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System.Dynamic;
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Resize : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Slice.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Slice.cs
similarity index 93%
rename from modules/Nncase.Modules.CPU/IR/XPU/Slice.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Slice.cs
index b7fd780500..e797a5dea0 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Slice.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Slice.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Slice : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Softmax.cs
similarity index 91%
rename from modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Softmax.cs
index 40945ca4ed..d2816e56f9 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Softmax.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Softmax.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Softmax : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/SwishB.cs b/modules/Nncase.Modules.XPU/TIR/XPU/SwishB.cs
similarity index 90%
rename from modules/Nncase.Modules.CPU/IR/XPU/SwishB.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/SwishB.cs
index 21e4b3906f..cbf6f305fd 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/SwishB.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/SwishB.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class SwishB : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/TDMALoad.cs b/modules/Nncase.Modules.XPU/TIR/XPU/TDMALoad.cs
similarity index 91%
rename from modules/Nncase.Modules.CPU/IR/XPU/TDMALoad.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/TDMALoad.cs
index cb3be455d6..2bb7238ad5 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/TDMALoad.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/TDMALoad.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class TDMALoad : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/TDMAStore.cs b/modules/Nncase.Modules.XPU/TIR/XPU/TDMAStore.cs
similarity index 91%
rename from modules/Nncase.Modules.CPU/IR/XPU/TDMAStore.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/TDMAStore.cs
index 845878ede4..bbf12726c1 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/TDMAStore.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/TDMAStore.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class TDMAStore : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Transpose.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Transpose.cs
similarity index 90%
rename from modules/Nncase.Modules.CPU/IR/XPU/Transpose.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Transpose.cs
index 48e26d5f69..9579995aa4 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Transpose.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Transpose.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Transpose : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/Unary.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Unary.cs
similarity index 92%
rename from modules/Nncase.Modules.CPU/IR/XPU/Unary.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/Unary.cs
index ca431ca12e..4c2c76e277 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/Unary.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/Unary.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public sealed partial class Unary : XPUKernelOp
 {
diff --git a/modules/Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs b/modules/Nncase.Modules.XPU/TIR/XPU/XPUKernelOp.cs
similarity index 82%
rename from modules/Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs
rename to modules/Nncase.Modules.XPU/TIR/XPU/XPUKernelOp.cs
index 6c12cd006b..f52da3471e 100644
--- a/modules/Nncase.Modules.CPU/IR/XPU/XPUKernelOp.cs
+++ b/modules/Nncase.Modules.XPU/TIR/XPU/XPUKernelOp.cs
@@ -1,7 +1,8 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using Nncase.IR;
 
-namespace Nncase.IR.XPU;
+namespace Nncase.TIR.XPU;
 
 public abstract class XPUKernelOp : Op
 {
diff --git a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs b/modules/Nncase.Modules.XPU/Targets/XPUTarget.cs
similarity index 92%
rename from modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
rename to modules/Nncase.Modules.XPU/Targets/XPUTarget.cs
index a354c86557..3d0e0dfaf7 100644
--- a/modules/Nncase.Modules.CPU/Targets/CPUTarget.cs
+++ b/modules/Nncase.Modules.XPU/Targets/XPUTarget.cs
@@ -17,14 +17,14 @@
 namespace Nncase.Targets;
 
 /// <summary>
-/// Target for CPU.
+/// Target for XPU.
 /// </summary>
-public class CPUTarget : ITarget
+public class XPUTarget : ITarget
 {
     /// <summary>
     /// Gets kind.
     /// </summary>
-    public const string Kind = "cpu";
+    public const string Kind = "xpu";
 
     string ITarget.Kind => Kind;
 
@@ -79,10 +79,10 @@ public void RegisterTargetDependentAfterQuantPass(IPassManager passManager, Comp
     {
         passManager.AddWithName<DataflowPass>("MakeFusion").Configure(p =>
         {
-            p.Add<CPUFusion>();
+            p.Add<XPUFusion>();
         });
 
-        passManager.Add<CPUFusionToTirPass>(Passes.Tile.TileOptions.Default);
+        passManager.Add<XPUFusionToTirPass>(Passes.Tile.TileOptions.Default);
 
         passManager.Add<PrimFuncPass>().Configure(p =>
         {
@@ -112,9 +112,9 @@ public IModuleBuilder CreateModuleBuilder(string moduleKind, CompileOptions opti
         {
             return new StackVMModuleBuilder();
         }
-        else if (moduleKind == CPUTarget.Kind)
+        else if (moduleKind == XPUTarget.Kind)
         {
-            return new CodeGen.CPU.ModuleBuilder(options);
+            return new CodeGen.XPU.ModuleBuilder(options);
         }
 
         throw new NotSupportedException();
diff --git a/modules/Nncase.Modules.CPU/CPUApplicationPart.cs b/modules/Nncase.Modules.XPU/XPUApplicationPart.cs
similarity index 69%
rename from modules/Nncase.Modules.CPU/CPUApplicationPart.cs
rename to modules/Nncase.Modules.XPU/XPUApplicationPart.cs
index ad0c637cf5..ff56fca3ec 100644
--- a/modules/Nncase.Modules.CPU/CPUApplicationPart.cs
+++ b/modules/Nncase.Modules.XPU/XPUApplicationPart.cs
@@ -13,19 +13,19 @@
 namespace Nncase;
 
 /// <summary>
-/// CPU application part extensions.
+/// XPU application part extensions.
 /// </summary>
-public static class CPUApplicationPart
+public static class XPUApplicationPart
 {
     /// <summary>
-    /// Add CPU assembly.
+    /// Add XPU assembly.
     /// </summary>
     /// <param name="registrator">Service registrator.</param>
     /// <returns>Configured service registrator.</returns>
     public static IRegistrator AddCPU(this IRegistrator registrator)
     {
-        return registrator.RegisterModule<CPUModule>()
-            .RegisterModule<Evaluator.CPU.CPUModule>()
-            .RegisterModule<Evaluator.XPU.XPUModule>();
+        return registrator.RegisterModule<XPUModule>()
+            .RegisterModule<Evaluator.IR.CPU.CPUModule>()
+            .RegisterModule<Evaluator.TIR.XPU.XPUModule>();
     }
 }
diff --git a/modules/Nncase.Modules.CPU/CPUModule.cs b/modules/Nncase.Modules.XPU/XPUModule.cs
similarity index 73%
rename from modules/Nncase.Modules.CPU/CPUModule.cs
rename to modules/Nncase.Modules.XPU/XPUModule.cs
index 5e91015cef..63e550a4df 100644
--- a/modules/Nncase.Modules.CPU/CPUModule.cs
+++ b/modules/Nncase.Modules.XPU/XPUModule.cs
@@ -8,12 +8,12 @@
 namespace Nncase;
 
 /// <summary>
-/// CPU module.
+/// XPU module.
 /// </summary>
-internal class CPUModule : IApplicationPart
+internal class XPUModule : IApplicationPart
 {
     public void ConfigureServices(IRegistrator registrator)
     {
-        registrator.Register<ITarget, CPUTarget>(reuse: Reuse.Singleton);
+        registrator.Register<ITarget, XPUTarget>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.CPU/packages.lock.json b/modules/Nncase.Modules.XPU/packages.lock.json
similarity index 100%
rename from modules/Nncase.Modules.CPU/packages.lock.json
rename to modules/Nncase.Modules.XPU/packages.lock.json
diff --git a/modules/cpu/cmake/nncase_rt_modules_cpuConfig.cmake.in b/modules/cpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
deleted file mode 100644
index 497d8eb3b3..0000000000
--- a/modules/cpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
+++ /dev/null
@@ -1 +0,0 @@
-include(${CMAKE_CURRENT_LIST_DIR}/nncase_rt_modules_cpuTargets.cmake)
\ No newline at end of file
diff --git a/modules/cpu/examples/cpu_test/CMakeLists.txt b/modules/cpu/examples/cpu_test/CMakeLists.txt
deleted file mode 100644
index 92c0068dff..0000000000
--- a/modules/cpu/examples/cpu_test/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-set(SRC main.cpp)
-set(bin cpu_test.elf)
-
-add_executable(${bin} ${SRC})
-target_link_libraries(${bin} runtime_cpu)
\ No newline at end of file
diff --git a/modules/cpu/src/runtime/CMakeLists.txt b/modules/cpu/src/runtime/CMakeLists.txt
deleted file mode 100644
index 28c1c570b0..0000000000
--- a/modules/cpu/src/runtime/CMakeLists.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-cmake_minimum_required (VERSION 3.13)
-
-add_subdirectory(cmodel)
-
-set(SRCS runtime_module.cpp
-         runtime_function.cpp
-         thread_pool.cpp
-         elfload.cpp
-         elfloader.cpp
-         elfreloc_aarch64.cpp
-         elfreloc_amd64.cpp
-         elfreloc_i386.cpp
-         elfreloc_riscv64.cpp
-         hardware_context.cpp
-         shared_memory.cpp)
-
-if (BUILDING_RUNTIME)
-    if (ENABLE_CPU_RUNTIME)
-        add_library(runtime_cpu OBJECT ${SRCS})
-        target_link_libraries(runtime_cpu PUBLIC nncaseruntime pthread rt)
-        # set_target_properties(runtime_cpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
-        install(TARGETS runtime_cpu EXPORT nncaseruntimeTargets)
-    endif()
-else()
-    add_library(simulator_cpu OBJECT ${SRCS})
-    target_link_libraries(simulator_cpu PUBLIC nncasebase nncaseruntime pthread)
-    target_compile_definitions(simulator_cpu PUBLIC -DNNCASE_MODULES_CPU_DLL -DNNCASE_SIMULATOR)
-    set_target_properties(simulator_cpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
-endif()
diff --git a/modules/cpu/CMakeLists.txt b/modules/xpu/CMakeLists.txt
similarity index 62%
rename from modules/cpu/CMakeLists.txt
rename to modules/xpu/CMakeLists.txt
index 42d6983640..f175de6f14 100644
--- a/modules/cpu/CMakeLists.txt
+++ b/modules/xpu/CMakeLists.txt
@@ -5,12 +5,12 @@ include_directories(include)
 add_subdirectory(src/runtime)
 
 if (BUILDING_RUNTIME)
-    if (ENABLE_CPU_RUNTIME)
-        add_library(nncase_rt_modules_cpu STATIC ${SRCS})
-        target_include_directories(nncase_rt_modules_cpu PRIVATE include)
-        target_link_libraries(nncase_rt_modules_cpu PRIVATE runtime_cpu)
-        set_target_properties(nncase_rt_modules_cpu PROPERTIES
-                                                       OUTPUT_NAME "nncase.rt_modules.cpu")
+    if (ENABLE_XPU_RUNTIME)
+        add_library(nncase_rt_modules_xpu STATIC ${SRCS})
+        target_include_directories(nncase_rt_modules_xpu PRIVATE include)
+        target_link_libraries(nncase_rt_modules_xpu PRIVATE runtime_xpu)
+        set_target_properties(nncase_rt_modules_xpu PROPERTIES
+                                                       OUTPUT_NAME "nncase.rt_modules.xpu")
 
         install(DIRECTORY include/nncase/kernels
             DESTINATION include/nncase
@@ -36,25 +36,25 @@ if (BUILDING_RUNTIME)
             PATTERN "LICENSE.TXT"
             )
 
-        install(TARGETS nncase_rt_modules_cpu EXPORT nncaseruntimeTargets
+        install(TARGETS nncase_rt_modules_xpu EXPORT nncaseruntimeTargets
             ARCHIVE DESTINATION lib
             LIBRARY DESTINATION lib
             RUNTIME DESTINATION bin
             INCLUDES DESTINATION include
         )
 
-        configure_file(${CMAKE_CURRENT_LIST_DIR}/cmake/nncase_rt_modules_cpuConfig.cmake.in nncase_rt_modules_cpuConfig.cmake @ONLY)
-        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/nncase_rt_modules_cpuConfig.cmake DESTINATION lib/cmake/nncaseruntime)
+        configure_file(${CMAKE_CURRENT_LIST_DIR}/cmake/nncase_rt_modules_xpuConfig.cmake.in nncase_rt_modules_xpuConfig.cmake @ONLY)
+        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/nncase_rt_modules_xpuConfig.cmake DESTINATION lib/cmake/nncaseruntime)
 
         if (K230_LINUX_SDK_DIR)
             add_subdirectory(examples)
         endif()
     endif()
 else()
-    add_library(nncase_modules_cpu SHARED ${SRCS})
-    target_include_directories(nncase_modules_cpu PUBLIC include)
-    target_link_libraries(nncase_modules_cpu PRIVATE simulator_cpu nncasebase)
-    set_target_properties(nncase_modules_cpu PROPERTIES OUTPUT_NAME "nncase.simulator.cpu")
-    install(TARGETS nncase_modules_cpu
+    add_library(nncase_modules_xpu SHARED ${SRCS})
+    target_include_directories(nncase_modules_xpu PUBLIC include)
+    target_link_libraries(nncase_modules_xpu PRIVATE simulator_xpu nncasebase)
+    set_target_properties(nncase_modules_xpu PROPERTIES OUTPUT_NAME "nncase.simulator.xpu")
+    install(TARGETS nncase_modules_xpu
             COMPONENT nncase-runtime)
 endif()
diff --git a/modules/xpu/cmake/nncase_rt_modules_cpuConfig.cmake.in b/modules/xpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
new file mode 100644
index 0000000000..4fb80f7e2b
--- /dev/null
+++ b/modules/xpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
@@ -0,0 +1 @@
+include(${CMAKE_CURRENT_LIST_DIR}/nncase_rt_modules_xpuTargets.cmake)
\ No newline at end of file
diff --git a/modules/cpu/examples/CMakeLists.txt b/modules/xpu/examples/CMakeLists.txt
similarity index 70%
rename from modules/cpu/examples/CMakeLists.txt
rename to modules/xpu/examples/CMakeLists.txt
index ea209b0f0f..8f9decb2ea 100644
--- a/modules/cpu/examples/CMakeLists.txt
+++ b/modules/xpu/examples/CMakeLists.txt
@@ -1,4 +1,4 @@
 cmake_minimum_required(VERSION 3.13)
 project(examples C CXX)
 
-add_subdirectory(cpu_test)
\ No newline at end of file
+add_subdirectory(xpu_test)
\ No newline at end of file
diff --git a/modules/xpu/examples/cpu_test/CMakeLists.txt b/modules/xpu/examples/cpu_test/CMakeLists.txt
new file mode 100644
index 0000000000..7babfdcb63
--- /dev/null
+++ b/modules/xpu/examples/cpu_test/CMakeLists.txt
@@ -0,0 +1,5 @@
+set(SRC main.cpp)
+set(bin xpu_test.elf)
+
+add_executable(${bin} ${SRC})
+target_link_libraries(${bin} runtime_xpu)
\ No newline at end of file
diff --git a/modules/cpu/examples/cpu_test/main.cpp b/modules/xpu/examples/cpu_test/main.cpp
similarity index 100%
rename from modules/cpu/examples/cpu_test/main.cpp
rename to modules/xpu/examples/cpu_test/main.cpp
diff --git a/modules/cpu/include/nncase/runtime/cpu/compiler_defs.h b/modules/xpu/include/nncase/runtime/xpu/compiler_defs.h
similarity index 84%
rename from modules/cpu/include/nncase/runtime/cpu/compiler_defs.h
rename to modules/xpu/include/nncase/runtime/xpu/compiler_defs.h
index 1bebad4b9d..95e996a076 100644
--- a/modules/cpu/include/nncase/runtime/cpu/compiler_defs.h
+++ b/modules/xpu/include/nncase/runtime/xpu/compiler_defs.h
@@ -16,15 +16,15 @@
 #include <cstdint>
 
 #if defined(_MSC_VER)
-#ifdef NNCASE_MODULES_CPU_DLL
-#define NNCASE_MODULES_CPU_API __declspec(dllexport)
+#ifdef NNCASE_MODULES_XPU_DLL
+#define NNCASE_MODULES_XPU_API __declspec(dllexport)
 #elif NNCASE_SHARED_LIBS
-#define NNCASE_MODULES_CPU_API __declspec(dllimport)
+#define NNCASE_MODULES_XPU_API __declspec(dllimport)
 #else
-#define NNCASE_MODULES_CPU_API
+#define NNCASE_MODULES_XPU_API
 #endif
 #else
-#define NNCASE_MODULES_CPU_API __attribute__((visibility("default")))
+#define NNCASE_MODULES_XPU_API __attribute__((visibility("default")))
 #endif
 
 #define BEGIN_NS_NNCASE_RT_MODULE(MODULE)                                      \
diff --git a/modules/cpu/include/nncase/runtime/cpu/runtime_module.h b/modules/xpu/include/nncase/runtime/xpu/runtime_module.h
similarity index 72%
rename from modules/cpu/include/nncase/runtime/cpu/runtime_module.h
rename to modules/xpu/include/nncase/runtime/xpu/runtime_module.h
index 487908008d..4eda222854 100644
--- a/modules/cpu/include/nncase/runtime/cpu/runtime_module.h
+++ b/modules/xpu/include/nncase/runtime/xpu/runtime_module.h
@@ -16,13 +16,13 @@
 #include "compiler_defs.h"
 #include <nncase/runtime/runtime_module.h>
 
-BEGIN_NS_NNCASE_RT_MODULE(cpu)
+BEGIN_NS_NNCASE_RT_MODULE(xpu)
 
-NNCASE_INLINE_VAR constexpr module_kind_t cpu_module_type =
-    to_module_kind("cpu");
-NNCASE_INLINE_VAR constexpr uint32_t cpu_module_version = 0;
+NNCASE_INLINE_VAR constexpr module_kind_t xpu_module_type =
+    to_module_kind("xpu");
+NNCASE_INLINE_VAR constexpr uint32_t xpu_module_version = 0;
 
-NNCASE_MODULES_CPU_API result<std::unique_ptr<runtime_module>>
-create_cpu_runtime_module();
+NNCASE_MODULES_XPU_API result<std::unique_ptr<runtime_module>>
+create_xpu_runtime_module();
 
 END_NS_NNCASE_RT_MODULE
diff --git a/modules/xpu/src/runtime/CMakeLists.txt b/modules/xpu/src/runtime/CMakeLists.txt
new file mode 100644
index 0000000000..38ba9adc74
--- /dev/null
+++ b/modules/xpu/src/runtime/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required (VERSION 3.13)
+
+add_subdirectory(cmodel)
+
+set(SRCS runtime_module.cpp
+         runtime_function.cpp
+         thread_pool.cpp
+         elfload.cpp
+         elfloader.cpp
+         elfreloc_aarch64.cpp
+         elfreloc_amd64.cpp
+         elfreloc_i386.cpp
+         elfreloc_riscv64.cpp
+         hardware_context.cpp
+         shared_memory.cpp)
+
+if (BUILDING_RUNTIME)
+    if (ENABLE_XPU_RUNTIME)
+        add_library(runtime_xpu OBJECT ${SRCS})
+        target_link_libraries(runtime_xpu PUBLIC nncaseruntime pthread rt)
+        # set_target_properties(runtime_xpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
+        install(TARGETS runtime_xpu EXPORT nncaseruntimeTargets)
+    endif()
+else()
+    add_library(simulator_xpu OBJECT ${SRCS})
+    target_link_libraries(simulator_xpu PUBLIC nncasebase nncaseruntime pthread)
+    target_compile_definitions(simulator_xpu PUBLIC -DNNCASE_MODULES_XPU_DLL -DNNCASE_SIMULATOR)
+    set_target_properties(simulator_xpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
+endif()
diff --git a/modules/cpu/src/runtime/cmodel/CMakeLists.txt b/modules/xpu/src/runtime/cmodel/CMakeLists.txt
similarity index 66%
rename from modules/cpu/src/runtime/cmodel/CMakeLists.txt
rename to modules/xpu/src/runtime/cmodel/CMakeLists.txt
index 1340d2981c..7568605751 100644
--- a/modules/cpu/src/runtime/cmodel/CMakeLists.txt
+++ b/modules/xpu/src/runtime/cmodel/CMakeLists.txt
@@ -1,29 +1,29 @@
-project(cpu)
+project(xpu)
 cmake_minimum_required(VERSION 3.13)
 
-add_library(cpu_cmodel STATIC
+add_library(xpu_cmodel STATIC
   src/dummy.cpp
   ../hardware_context.cpp
 )
 
 set(CMAKE_CXX_STANDARD 20)
 
-target_include_directories(cpu_cmodel PUBLIC include)
-# target_include_directories(cpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../src/Native/include)
-target_include_directories(cpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../include)
-target_include_directories(cpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../runtime)
-# target_include_directories(cpu_cmodel PUBLIC /root/.conan/data/gsl-lite/0.37.0/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/)
-# target_link_libraries(cpu_cmodel PUBLIC gsl::gsl-lite)
+target_include_directories(xpu_cmodel PUBLIC include)
+# target_include_directories(xpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../src/Native/include)
+target_include_directories(xpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../include)
+target_include_directories(xpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../runtime)
+# target_include_directories(xpu_cmodel PUBLIC /root/.conan/data/gsl-lite/0.37.0/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/)
+# target_link_libraries(xpu_cmodel PUBLIC gsl::gsl-lite)
 # if(NOT APPLE AND NOT MSVC)
-#   target_link_libraries(cpu_cmodel PRIVATE rt)
+#   target_link_libraries(xpu_cmodel PRIVATE rt)
 # endif()
-set_target_properties(cpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
+set_target_properties(xpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
-# add_executable(cpu_cmodel_cli src/cpu_cmodel.cpp ../shared_memory.cpp)
-# target_link_libraries(cpu_cmodel_cli PUBLIC cpu_cmodel)
-# set_target_properties(cpu_cmodel_cli PROPERTIES POSITION_INDEPENDENT_CODE ON
-#   OUTPUT_NAME "nncase.simulator.cpu.c")
-# install(TARGETS cpu_cmodel_cli COMPONENT nncase-runtime)
+# add_executable(xpu_cmodel_cli src/xpu_cmodel.cpp ../shared_memory.cpp)
+# target_link_libraries(xpu_cmodel_cli PUBLIC xpu_cmodel)
+# set_target_properties(xpu_cmodel_cli PROPERTIES POSITION_INDEPENDENT_CODE ON
+#   OUTPUT_NAME "nncase.simulator.xpu.c")
+# install(TARGETS xpu_cmodel_cli COMPONENT nncase-runtime)
 
 # add_definitions(-D__riscv_vector)
 foreach(LIBRARY_PATH ${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES})
@@ -60,9 +60,9 @@ function(add_test name test_path)
   if (CMAKE_BUILD_TYPE STREQUAL "Release")
     add_compile_options(-O1)
   endif()
-  add_link_options(-no-pie -nostartfiles -fPIC -fno-stack-protector -static -Wl,-e,_Z6_startPN6nncase7runtime3cpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPh)
+  add_link_options(-no-pie -nostartfiles -fPIC -fno-stack-protector -static -Wl,-e,_Z6_startPN6nncase7runtime3xpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPh)
   add_executable(${name} "${test_path}/main.cpp")
-  target_link_libraries(${name} cpu_cmodel ${CRT1_LIB_PATH} ${CRTI_LIB_PATH})
+  target_link_libraries(${name} xpu_cmodel ${CRT1_LIB_PATH} ${CRTI_LIB_PATH})
 endfunction(add_test)
 
 # add_test(demo1 tests/demo1)
diff --git a/modules/cpu/src/runtime/cmodel/include/apply.h b/modules/xpu/src/runtime/cmodel/include/apply.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/apply.h
rename to modules/xpu/src/runtime/cmodel/include/apply.h
diff --git a/modules/cpu/src/runtime/cmodel/include/binary.h b/modules/xpu/src/runtime/cmodel/include/binary.h
similarity index 99%
rename from modules/cpu/src/runtime/cmodel/include/binary.h
rename to modules/xpu/src/runtime/cmodel/include/binary.h
index 5372d78493..2649ab1ab1 100644
--- a/modules/cpu/src/runtime/cmodel/include/binary.h
+++ b/modules/xpu/src/runtime/cmodel/include/binary.h
@@ -17,7 +17,7 @@
 #include <apply.h>
 #include <runtime_utils.h>
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 
 namespace kernels {
 
diff --git a/modules/cpu/src/runtime/cmodel/include/cast.h b/modules/xpu/src/runtime/cmodel/include/cast.h
similarity index 97%
rename from modules/cpu/src/runtime/cmodel/include/cast.h
rename to modules/xpu/src/runtime/cmodel/include/cast.h
index e2abd7a983..0d06a2058b 100644
--- a/modules/cpu/src/runtime/cmodel/include/cast.h
+++ b/modules/xpu/src/runtime/cmodel/include/cast.h
@@ -17,7 +17,7 @@
 #include <apply.h>
 #include <runtime_utils.h>
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 namespace kernels {
 namespace {
 template <class TInput, class TOutput>
diff --git a/modules/cpu/src/runtime/cmodel/include/clamp.h b/modules/xpu/src/runtime/cmodel/include/clamp.h
similarity index 97%
rename from modules/cpu/src/runtime/cmodel/include/clamp.h
rename to modules/xpu/src/runtime/cmodel/include/clamp.h
index de3a5a1ad9..ced09c9bd8 100644
--- a/modules/cpu/src/runtime/cmodel/include/clamp.h
+++ b/modules/xpu/src/runtime/cmodel/include/clamp.h
@@ -17,7 +17,7 @@
 #include <apply.h>
 #include <runtime_utils.h>
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 namespace kernels {
 namespace {
 template <class T>
diff --git a/modules/cpu/src/runtime/cmodel/include/concat.h b/modules/xpu/src/runtime/cmodel/include/concat.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/concat.h
rename to modules/xpu/src/runtime/cmodel/include/concat.h
diff --git a/modules/cpu/src/runtime/cmodel/include/expand.h b/modules/xpu/src/runtime/cmodel/include/expand.h
similarity index 97%
rename from modules/cpu/src/runtime/cmodel/include/expand.h
rename to modules/xpu/src/runtime/cmodel/include/expand.h
index 2e932be748..c761b1fea9 100644
--- a/modules/cpu/src/runtime/cmodel/include/expand.h
+++ b/modules/xpu/src/runtime/cmodel/include/expand.h
@@ -17,7 +17,7 @@
 #include <apply.h>
 #include <runtime_utils.h>
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 namespace kernels {
 namespace {
 template <class T>
diff --git a/modules/cpu/src/runtime/cmodel/include/gather.h b/modules/xpu/src/runtime/cmodel/include/gather.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/gather.h
rename to modules/xpu/src/runtime/cmodel/include/gather.h
diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_context.h b/modules/xpu/src/runtime/cmodel/include/hardware_context.h
similarity index 96%
rename from modules/cpu/src/runtime/cmodel/include/hardware_context.h
rename to modules/xpu/src/runtime/cmodel/include/hardware_context.h
index 413f84c9e1..c6120aac6b 100644
--- a/modules/cpu/src/runtime/cmodel/include/hardware_context.h
+++ b/modules/xpu/src/runtime/cmodel/include/hardware_context.h
@@ -3,7 +3,7 @@
 #include "../../method_table_def.h"
 #include <functional>
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 class hardware_context {
   public:
     // hardware_context(hardware_context_mt *impl) : impl_(impl){};
diff --git a/modules/cpu/src/runtime/cmodel/include/hardware_def.h b/modules/xpu/src/runtime/cmodel/include/hardware_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/hardware_def.h
rename to modules/xpu/src/runtime/cmodel/include/hardware_def.h
diff --git a/modules/cpu/src/runtime/cmodel/include/instance_norm.h b/modules/xpu/src/runtime/cmodel/include/instance_norm.h
similarity index 98%
rename from modules/cpu/src/runtime/cmodel/include/instance_norm.h
rename to modules/xpu/src/runtime/cmodel/include/instance_norm.h
index 9c00517226..c33363dd5c 100644
--- a/modules/cpu/src/runtime/cmodel/include/instance_norm.h
+++ b/modules/xpu/src/runtime/cmodel/include/instance_norm.h
@@ -5,7 +5,7 @@
 #include <riscv_vector.h>
 #endif
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 namespace kernels {
 
 namespace {
diff --git a/modules/cpu/src/runtime/cmodel/include/layernorm.h b/modules/xpu/src/runtime/cmodel/include/layernorm.h
similarity index 91%
rename from modules/cpu/src/runtime/cmodel/include/layernorm.h
rename to modules/xpu/src/runtime/cmodel/include/layernorm.h
index 2595057923..75854a62e1 100644
--- a/modules/cpu/src/runtime/cmodel/include/layernorm.h
+++ b/modules/xpu/src/runtime/cmodel/include/layernorm.h
@@ -5,7 +5,7 @@
 #include <riscv_vector.h>
 #endif
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 namespace kernels {
 
 namespace {
@@ -87,13 +87,15 @@ static int get_offset_from_index(gsl::span<const size_t> in_shape,
 }
 
 template <typename T>
-void layernorm_rvv_impl(
-    const T *input, const T *sum, const T *sum_sqr, T *output, const T *gamma,
-    const T *beta, gsl::span<const size_t> input_shape,
-    gsl::span<const size_t> input_stride, gsl::span<const size_t> output_stride,
-    [[maybe_unused]] gsl::span<const size_t> sum_strides,
-    [[maybe_unused]] gsl::span<const size_t> gamma_strides, T eps, int32_t axis,
-    int32_t norm_size, [[maybe_unused]] bool rms_norm = false) noexcept {
+void layernorm_rvv_impl(const T *input, const T *sum, const T *sum_sqr,
+                        T *output, const T *gamma, const T *beta,
+                        gsl::span<const size_t> input_shape,
+                        gsl::span<const size_t> input_stride,
+                        gsl::span<const size_t> output_stride,
+                        [[maybe_unused]] gsl::span<const size_t> sum_strides,
+                        [[maybe_unused]] gsl::span<const size_t> gamma_strides,
+                        T eps, int32_t axis, int32_t norm_size,
+                        [[maybe_unused]] bool rms_norm = false) noexcept {
 
     size_t outer_size = 1;
     for (auto i = 0; i < axis; i++) {
@@ -192,7 +194,7 @@ void layernorm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
     //     gsl::make_span(input_dims).template as_span<const size_t>(),
     //     gsl::make_span(input_strides).template as_span<const size_t>(), eps,
     //     axis, norm_size);
-        return layernorm_rvv_impl(
+    return layernorm_rvv_impl(
         input, sum, sum_sqr, output, gamma, beta,
         gsl::make_span(input_dims).template as_span<const size_t>(),
         gsl::make_span(input_strides).template as_span<const size_t>(),
diff --git a/modules/cpu/src/runtime/cmodel/include/matmul.h b/modules/xpu/src/runtime/cmodel/include/matmul.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/matmul.h
rename to modules/xpu/src/runtime/cmodel/include/matmul.h
diff --git a/modules/cpu/src/runtime/cmodel/include/reduce.h b/modules/xpu/src/runtime/cmodel/include/reduce.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/reduce.h
rename to modules/xpu/src/runtime/cmodel/include/reduce.h
diff --git a/modules/cpu/src/runtime/cmodel/include/reduce_arg.h b/modules/xpu/src/runtime/cmodel/include/reduce_arg.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/reduce_arg.h
rename to modules/xpu/src/runtime/cmodel/include/reduce_arg.h
diff --git a/modules/cpu/src/runtime/cmodel/include/resize.h b/modules/xpu/src/runtime/cmodel/include/resize.h
similarity index 99%
rename from modules/cpu/src/runtime/cmodel/include/resize.h
rename to modules/xpu/src/runtime/cmodel/include/resize.h
index 157ff23653..24c073b14f 100644
--- a/modules/cpu/src/runtime/cmodel/include/resize.h
+++ b/modules/xpu/src/runtime/cmodel/include/resize.h
@@ -6,7 +6,7 @@
 #include <riscv_vector.h>
 #endif
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 
 namespace kernels {
 namespace {
diff --git a/modules/cpu/src/runtime/cmodel/include/resize_util.h b/modules/xpu/src/runtime/cmodel/include/resize_util.h
similarity index 99%
rename from modules/cpu/src/runtime/cmodel/include/resize_util.h
rename to modules/xpu/src/runtime/cmodel/include/resize_util.h
index 69533414e1..0bf4bdc742 100644
--- a/modules/cpu/src/runtime/cmodel/include/resize_util.h
+++ b/modules/xpu/src/runtime/cmodel/include/resize_util.h
@@ -17,7 +17,7 @@
 #include "runtime_utils.h"
 #include <runtime_types.h>
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 
 using get_coordinate_func_t = float (*)(float, float, float, float, float,
                                         float);
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_types.h b/modules/xpu/src/runtime/cmodel/include/runtime_types.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/runtime_types.h
rename to modules/xpu/src/runtime/cmodel/include/runtime_types.h
diff --git a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h b/modules/xpu/src/runtime/cmodel/include/runtime_utils.h
similarity index 99%
rename from modules/cpu/src/runtime/cmodel/include/runtime_utils.h
rename to modules/xpu/src/runtime/cmodel/include/runtime_utils.h
index 13e161b793..11be007902 100644
--- a/modules/cpu/src/runtime/cmodel/include/runtime_utils.h
+++ b/modules/xpu/src/runtime/cmodel/include/runtime_utils.h
@@ -5,7 +5,7 @@
 #include <cstddef>
 #include <runtime_types.h>
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 
 static nncase_mt_t *nncase_mt;
 static runtime_util_mt *runtime_util;
diff --git a/modules/cpu/src/runtime/cmodel/include/slice.h b/modules/xpu/src/runtime/cmodel/include/slice.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/slice.h
rename to modules/xpu/src/runtime/cmodel/include/slice.h
diff --git a/modules/cpu/src/runtime/cmodel/include/small_vector.hpp b/modules/xpu/src/runtime/cmodel/include/small_vector.hpp
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/small_vector.hpp
rename to modules/xpu/src/runtime/cmodel/include/small_vector.hpp
diff --git a/modules/cpu/src/runtime/cmodel/include/softmax.h b/modules/xpu/src/runtime/cmodel/include/softmax.h
similarity index 99%
rename from modules/cpu/src/runtime/cmodel/include/softmax.h
rename to modules/xpu/src/runtime/cmodel/include/softmax.h
index c0245a52ea..f61fded2d5 100644
--- a/modules/cpu/src/runtime/cmodel/include/softmax.h
+++ b/modules/xpu/src/runtime/cmodel/include/softmax.h
@@ -16,7 +16,7 @@
 #include <runtime_utils.h>
 #include <type_traits>
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 
 namespace kernels {
 
diff --git a/modules/cpu/src/runtime/cmodel/include/tdma.h b/modules/xpu/src/runtime/cmodel/include/tdma.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/tdma.h
rename to modules/xpu/src/runtime/cmodel/include/tdma.h
diff --git a/modules/cpu/src/runtime/cmodel/include/tensor.h b/modules/xpu/src/runtime/cmodel/include/tensor.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/tensor.h
rename to modules/xpu/src/runtime/cmodel/include/tensor.h
diff --git a/modules/cpu/src/runtime/cmodel/include/thread_context.h b/modules/xpu/src/runtime/cmodel/include/thread_context.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/thread_context.h
rename to modules/xpu/src/runtime/cmodel/include/thread_context.h
diff --git a/modules/cpu/src/runtime/cmodel/include/transpose.h b/modules/xpu/src/runtime/cmodel/include/transpose.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/include/transpose.h
rename to modules/xpu/src/runtime/cmodel/include/transpose.h
diff --git a/modules/cpu/src/runtime/cmodel/include/unary.h b/modules/xpu/src/runtime/cmodel/include/unary.h
similarity index 95%
rename from modules/cpu/src/runtime/cmodel/include/unary.h
rename to modules/xpu/src/runtime/cmodel/include/unary.h
index ad1e506d63..98c3c74eba 100644
--- a/modules/cpu/src/runtime/cmodel/include/unary.h
+++ b/modules/xpu/src/runtime/cmodel/include/unary.h
@@ -17,7 +17,7 @@
 #include <apply.h>
 #include <runtime_utils.h>
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 namespace kernels {
 
 namespace {
@@ -92,9 +92,9 @@ void unary(unary_op_t op, const T *input, T *output,
 }
 
 void swishb(const float *input, float *output, float beta,
-                gsl::span<const size_t> input_strides,
-                gsl::span<const size_t> out_shape,
-                gsl::span<const size_t> out_strides) noexcept {
+            gsl::span<const size_t> input_strides,
+            gsl::span<const size_t> out_shape,
+            gsl::span<const size_t> out_strides) noexcept {
     unary_impl(
         [&beta](float x) {
             return x * (1 / (1 + nncase_mt->float_unary_exp(-(x * beta))));
diff --git a/modules/cpu/src/runtime/cmodel/src/cpu_cmodel.cpp b/modules/xpu/src/runtime/cmodel/src/cpu_cmodel.cpp
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/src/cpu_cmodel.cpp
rename to modules/xpu/src/runtime/cmodel/src/cpu_cmodel.cpp
diff --git a/modules/cpu/src/runtime/cmodel/src/dummy.cpp b/modules/xpu/src/runtime/cmodel/src/dummy.cpp
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/src/dummy.cpp
rename to modules/xpu/src/runtime/cmodel/src/dummy.cpp
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/decoder_layer/cluster_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/decoder_layer/cluster_def.h
rename to modules/xpu/src/runtime/cmodel/tests/decoder_layer/cluster_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/golden.py b/modules/xpu/src/runtime/cmodel/tests/decoder_layer/golden.py
similarity index 99%
rename from modules/cpu/src/runtime/cmodel/tests/decoder_layer/golden.py
rename to modules/xpu/src/runtime/cmodel/tests/decoder_layer/golden.py
index 2f50bb66cf..1b4295769c 100644
--- a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/golden.py
+++ b/modules/xpu/src/runtime/cmodel/tests/decoder_layer/golden.py
@@ -19,7 +19,7 @@ def swish(x:np.ndarray):
 def gather(data:np.ndarray, axis:int, indices:np.ndarray):
     return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
 
-const_dir = "/compiler/huochenghai/GNNE/rebuild-ir/nncase/modules/cpu/src/runtime/cmodel/tests/demo3/golden"
+const_dir = "/compiler/huochenghai/GNNE/rebuild-ir/nncase/modules/xpu/src/runtime/cmodel/tests/demo3/golden"
 
 hidden_in = np.reshape(np.fromfile(os.path.join(const_dir,"input_0_0.bin"), dtype=np.float32), (1, 384, 8192))
 attn_mask = np.reshape(np.fromfile(os.path.join(const_dir,"input_1_0.bin"), dtype=np.float32), (1, 1, 384, 384))
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h b/modules/xpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
rename to modules/xpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp b/modules/xpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
rename to modules/xpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
diff --git a/modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
rename to modules/xpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/demo1/cluster_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo1/cluster_def.h
rename to modules/xpu/src/runtime/cmodel/tests/demo1/cluster_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/golden.py b/modules/xpu/src/runtime/cmodel/tests/demo1/golden.py
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo1/golden.py
rename to modules/xpu/src/runtime/cmodel/tests/demo1/golden.py
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/xpu/src/runtime/cmodel/tests/demo1/kernel.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo1/kernel.h
rename to modules/xpu/src/runtime/cmodel/tests/demo1/kernel.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp b/modules/xpu/src/runtime/cmodel/tests/demo1/main.cpp
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo1/main.cpp
rename to modules/xpu/src/runtime/cmodel/tests/demo1/main.cpp
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/demo1/shared_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo1/shared_def.h
rename to modules/xpu/src/runtime/cmodel/tests/demo1/shared_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/demo2/cluster_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo2/cluster_def.h
rename to modules/xpu/src/runtime/cmodel/tests/demo2/cluster_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/golden.py b/modules/xpu/src/runtime/cmodel/tests/demo2/golden.py
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo2/golden.py
rename to modules/xpu/src/runtime/cmodel/tests/demo2/golden.py
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h b/modules/xpu/src/runtime/cmodel/tests/demo2/kernel.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo2/kernel.h
rename to modules/xpu/src/runtime/cmodel/tests/demo2/kernel.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp b/modules/xpu/src/runtime/cmodel/tests/demo2/main.cpp
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo2/main.cpp
rename to modules/xpu/src/runtime/cmodel/tests/demo2/main.cpp
diff --git a/modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/demo2/shared_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/demo2/shared_def.h
rename to modules/xpu/src/runtime/cmodel/tests/demo2/shared_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/embed/cluster_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/embed/cluster_def.h
rename to modules/xpu/src/runtime/cmodel/tests/embed/cluster_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/golden.py b/modules/xpu/src/runtime/cmodel/tests/embed/golden.py
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/embed/golden.py
rename to modules/xpu/src/runtime/cmodel/tests/embed/golden.py
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/kernel.h b/modules/xpu/src/runtime/cmodel/tests/embed/kernel.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/embed/kernel.h
rename to modules/xpu/src/runtime/cmodel/tests/embed/kernel.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/main.cpp b/modules/xpu/src/runtime/cmodel/tests/embed/main.cpp
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/embed/main.cpp
rename to modules/xpu/src/runtime/cmodel/tests/embed/main.cpp
diff --git a/modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/embed/shared_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/embed/shared_def.h
rename to modules/xpu/src/runtime/cmodel/tests/embed/shared_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/head/cluster_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/head/cluster_def.h
rename to modules/xpu/src/runtime/cmodel/tests/head/cluster_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/golden.py b/modules/xpu/src/runtime/cmodel/tests/head/golden.py
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/head/golden.py
rename to modules/xpu/src/runtime/cmodel/tests/head/golden.py
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/kernel.h b/modules/xpu/src/runtime/cmodel/tests/head/kernel.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/head/kernel.h
rename to modules/xpu/src/runtime/cmodel/tests/head/kernel.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/main.cpp b/modules/xpu/src/runtime/cmodel/tests/head/main.cpp
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/head/main.cpp
rename to modules/xpu/src/runtime/cmodel/tests/head/main.cpp
diff --git a/modules/cpu/src/runtime/cmodel/tests/head/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/head/shared_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/head/shared_def.h
rename to modules/xpu/src/runtime/cmodel/tests/head/shared_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/norm/cluster_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/norm/cluster_def.h
rename to modules/xpu/src/runtime/cmodel/tests/norm/cluster_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/golden.py b/modules/xpu/src/runtime/cmodel/tests/norm/golden.py
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/norm/golden.py
rename to modules/xpu/src/runtime/cmodel/tests/norm/golden.py
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/kernel.h b/modules/xpu/src/runtime/cmodel/tests/norm/kernel.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/norm/kernel.h
rename to modules/xpu/src/runtime/cmodel/tests/norm/kernel.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/main.cpp b/modules/xpu/src/runtime/cmodel/tests/norm/main.cpp
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/norm/main.cpp
rename to modules/xpu/src/runtime/cmodel/tests/norm/main.cpp
diff --git a/modules/cpu/src/runtime/cmodel/tests/norm/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/norm/shared_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/norm/shared_def.h
rename to modules/xpu/src/runtime/cmodel/tests/norm/shared_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/unary/cluster_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/unary/cluster_def.h
rename to modules/xpu/src/runtime/cmodel/tests/unary/cluster_def.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/golden.py b/modules/xpu/src/runtime/cmodel/tests/unary/golden.py
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/unary/golden.py
rename to modules/xpu/src/runtime/cmodel/tests/unary/golden.py
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/kernel.h b/modules/xpu/src/runtime/cmodel/tests/unary/kernel.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/unary/kernel.h
rename to modules/xpu/src/runtime/cmodel/tests/unary/kernel.h
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/main.cpp b/modules/xpu/src/runtime/cmodel/tests/unary/main.cpp
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/unary/main.cpp
rename to modules/xpu/src/runtime/cmodel/tests/unary/main.cpp
diff --git a/modules/cpu/src/runtime/cmodel/tests/unary/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/unary/shared_def.h
similarity index 100%
rename from modules/cpu/src/runtime/cmodel/tests/unary/shared_def.h
rename to modules/xpu/src/runtime/cmodel/tests/unary/shared_def.h
diff --git a/modules/cpu/src/runtime/elf.h b/modules/xpu/src/runtime/elf.h
similarity index 100%
rename from modules/cpu/src/runtime/elf.h
rename to modules/xpu/src/runtime/elf.h
diff --git a/modules/cpu/src/runtime/elfarch.h b/modules/xpu/src/runtime/elfarch.h
similarity index 100%
rename from modules/cpu/src/runtime/elfarch.h
rename to modules/xpu/src/runtime/elfarch.h
diff --git a/modules/cpu/src/runtime/elfload.cpp b/modules/xpu/src/runtime/elfload.cpp
similarity index 100%
rename from modules/cpu/src/runtime/elfload.cpp
rename to modules/xpu/src/runtime/elfload.cpp
diff --git a/modules/cpu/src/runtime/elfload.h b/modules/xpu/src/runtime/elfload.h
similarity index 100%
rename from modules/cpu/src/runtime/elfload.h
rename to modules/xpu/src/runtime/elfload.h
diff --git a/modules/cpu/src/runtime/elfloader.cpp b/modules/xpu/src/runtime/elfloader.cpp
similarity index 59%
rename from modules/cpu/src/runtime/elfloader.cpp
rename to modules/xpu/src/runtime/elfloader.cpp
index fbd5b7fdfa..5675838370 100644
--- a/modules/cpu/src/runtime/elfloader.cpp
+++ b/modules/xpu/src/runtime/elfloader.cpp
@@ -3,7 +3,7 @@
 
 using namespace nncase;
 using namespace nncase::runtime;
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 
 int elfloader::invoke_elf(hardware_context_mt *hw_ctx_impl,
                           runtime_util_mt *rt_util_mt,
@@ -37,47 +37,52 @@ int elfloader::invoke_elf(hardware_context_mt *hw_ctx_impl,
 
 #if defined(__riscv)
     Elf_Shdr sym_shdr;
-    for (size_t i = 0; i < ctx_.ehdr.e_shnum; i++)
-    {
-        memcpy(&sym_shdr, (void*)((uintptr_t)ctx_.elf + ctx_.ehdr.e_shoff + ctx_.ehdr.e_shentsize*i), ctx_.ehdr.e_shentsize);
+    for (size_t i = 0; i < ctx_.ehdr.e_shnum; i++) {
+        memcpy(&sym_shdr,
+               (void *)((uintptr_t)ctx_.elf + ctx_.ehdr.e_shoff +
+                        ctx_.ehdr.e_shentsize * i),
+               ctx_.ehdr.e_shentsize);
         if (sym_shdr.sh_type == SHT_SYMTAB) {
             break;
         }
     }
-    
+
     Elf_Shdr str_shdr;
-    memcpy(&str_shdr, (void*)((uintptr_t)ctx_.elf + ctx_.ehdr.e_shoff + ctx_.ehdr.e_shentsize*sym_shdr.sh_link), ctx_.ehdr.e_shentsize);
-    
+    memcpy(&str_shdr,
+           (void *)((uintptr_t)ctx_.elf + ctx_.ehdr.e_shoff +
+                    ctx_.ehdr.e_shentsize * sym_shdr.sh_link),
+           ctx_.ehdr.e_shentsize);
+
     size_t sym_num = sym_shdr.sh_size / sym_shdr.sh_entsize;
     Elf_Sym symbol;
-    for (size_t i = 0; i < sym_num; i++)
-    {
-        memcpy(&symbol, (void*)((uintptr_t)ctx_.elf + sym_shdr.sh_offset + sym_shdr.sh_entsize*i), sym_shdr.sh_entsize);
-        if (!strncmp((char*)((uintptr_t)ctx_.elf + str_shdr.sh_offset + symbol.st_name), "__global_pointer$", 19)) {
+    for (size_t i = 0; i < sym_num; i++) {
+        memcpy(&symbol,
+               (void *)((uintptr_t)ctx_.elf + sym_shdr.sh_offset +
+                        sym_shdr.sh_entsize * i),
+               sym_shdr.sh_entsize);
+        if (!strncmp((char *)((uintptr_t)ctx_.elf + str_shdr.sh_offset +
+                              symbol.st_name),
+                     "__global_pointer$", 19)) {
             break;
         }
     }
-    asm volatile (
-        "addi sp, sp, -8;\
+    asm volatile("addi sp, sp, -8;\
         sd gp, 0(sp);\
         mv gp, %0\
         "
-        :
-        :"r"(symbol.st_value + (uintptr_t)buf_)
-        :
-    );
+                 :
+                 : "r"(symbol.st_value + (uintptr_t)buf_)
+                 :);
 #endif
     ep(hw_ctx_impl, rt_util_mt, nncase_mt_impl, inputs, rdata);
 #if defined(__riscv)
 
-    asm volatile (
-        "ld gp, 0(sp);\
+    asm volatile("ld gp, 0(sp);\
         addi sp, sp, 8;\
         "
-        :
-        :
-        :
-    );
+                 :
+                 :
+                 :);
 #endif
     free(ptr_);
 
diff --git a/modules/cpu/src/runtime/elfloader.h b/modules/xpu/src/runtime/elfloader.h
similarity index 95%
rename from modules/cpu/src/runtime/elfloader.h
rename to modules/xpu/src/runtime/elfloader.h
index 959201c53a..fca10e73b9 100644
--- a/modules/cpu/src/runtime/elfloader.h
+++ b/modules/xpu/src/runtime/elfloader.h
@@ -4,7 +4,7 @@
 #include "method_table_impl.h"
 #include <inttypes.h>
 #include <math.h>
-#include <nncase/runtime/cpu/compiler_defs.h>
+#include <nncase/runtime/xpu/compiler_defs.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -12,7 +12,7 @@
 #include <sys/mman.h>
 #endif
 
-BEGIN_NS_NNCASE_RT_MODULE(cpu)
+BEGIN_NS_NNCASE_RT_MODULE(xpu)
 
 typedef void (*entrypoint_t)(hardware_context_mt *hw_ctx_impl,
                              runtime_util_mt *rt_util_mt,
diff --git a/modules/cpu/src/runtime/elfreloc_aarch64.cpp b/modules/xpu/src/runtime/elfreloc_aarch64.cpp
similarity index 100%
rename from modules/cpu/src/runtime/elfreloc_aarch64.cpp
rename to modules/xpu/src/runtime/elfreloc_aarch64.cpp
diff --git a/modules/cpu/src/runtime/elfreloc_amd64.cpp b/modules/xpu/src/runtime/elfreloc_amd64.cpp
similarity index 100%
rename from modules/cpu/src/runtime/elfreloc_amd64.cpp
rename to modules/xpu/src/runtime/elfreloc_amd64.cpp
diff --git a/modules/cpu/src/runtime/elfreloc_i386.cpp b/modules/xpu/src/runtime/elfreloc_i386.cpp
similarity index 100%
rename from modules/cpu/src/runtime/elfreloc_i386.cpp
rename to modules/xpu/src/runtime/elfreloc_i386.cpp
diff --git a/modules/cpu/src/runtime/elfreloc_riscv64.cpp b/modules/xpu/src/runtime/elfreloc_riscv64.cpp
similarity index 100%
rename from modules/cpu/src/runtime/elfreloc_riscv64.cpp
rename to modules/xpu/src/runtime/elfreloc_riscv64.cpp
diff --git a/modules/cpu/src/runtime/gsl-lite.hpp b/modules/xpu/src/runtime/gsl-lite.hpp
similarity index 100%
rename from modules/cpu/src/runtime/gsl-lite.hpp
rename to modules/xpu/src/runtime/gsl-lite.hpp
diff --git a/modules/cpu/src/runtime/hardware_context.cpp b/modules/xpu/src/runtime/hardware_context.cpp
similarity index 99%
rename from modules/cpu/src/runtime/hardware_context.cpp
rename to modules/xpu/src/runtime/hardware_context.cpp
index 3fb14685e4..4fdb86a613 100644
--- a/modules/cpu/src/runtime/hardware_context.cpp
+++ b/modules/xpu/src/runtime/hardware_context.cpp
@@ -2,7 +2,7 @@
 #include "hardware_def.h"
 #include <pthread.h>
 
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 std::unique_ptr<hardware_context_impl> hardware_context::impl_;
 
 class condition_variable {
diff --git a/modules/cpu/src/runtime/hardware_context.h b/modules/xpu/src/runtime/hardware_context.h
similarity index 88%
rename from modules/cpu/src/runtime/hardware_context.h
rename to modules/xpu/src/runtime/hardware_context.h
index 1882d74080..6cb45a2224 100644
--- a/modules/cpu/src/runtime/hardware_context.h
+++ b/modules/xpu/src/runtime/hardware_context.h
@@ -2,11 +2,11 @@
 
 #include <functional>
 #include <memory>
-#include <nncase/runtime/cpu/compiler_defs.h>
+#include <nncase/runtime/xpu/compiler_defs.h>
 
 struct hardware_context_impl;
 
-BEGIN_NS_NNCASE_RT_MODULE(cpu)
+BEGIN_NS_NNCASE_RT_MODULE(xpu)
 namespace hardware_context {
 void init();
 
diff --git a/modules/cpu/src/runtime/hardware_def.h b/modules/xpu/src/runtime/hardware_def.h
similarity index 100%
rename from modules/cpu/src/runtime/hardware_def.h
rename to modules/xpu/src/runtime/hardware_def.h
diff --git a/modules/cpu/src/runtime/io_utils.h b/modules/xpu/src/runtime/io_utils.h
similarity index 100%
rename from modules/cpu/src/runtime/io_utils.h
rename to modules/xpu/src/runtime/io_utils.h
diff --git a/modules/cpu/src/runtime/method_table_def.h b/modules/xpu/src/runtime/method_table_def.h
similarity index 97%
rename from modules/cpu/src/runtime/method_table_def.h
rename to modules/xpu/src/runtime/method_table_def.h
index f7c823ed40..a388011dd4 100644
--- a/modules/cpu/src/runtime/method_table_def.h
+++ b/modules/xpu/src/runtime/method_table_def.h
@@ -1,9 +1,9 @@
 #pragma once
 
 #include <functional>
-#include <nncase/runtime/cpu/compiler_defs.h>
+#include <nncase/runtime/xpu/compiler_defs.h>
 
-BEGIN_NS_NNCASE_RT_MODULE(cpu)
+BEGIN_NS_NNCASE_RT_MODULE(xpu)
 
 typedef struct nncase_method_table {
     // float unary
diff --git a/modules/cpu/src/runtime/method_table_impl.h b/modules/xpu/src/runtime/method_table_impl.h
similarity index 98%
rename from modules/cpu/src/runtime/method_table_impl.h
rename to modules/xpu/src/runtime/method_table_impl.h
index 98d6ccc14a..fd4668ac4d 100644
--- a/modules/cpu/src/runtime/method_table_impl.h
+++ b/modules/xpu/src/runtime/method_table_impl.h
@@ -5,12 +5,12 @@
 #include "thread_pool.h"
 #include <functional>
 #include <math.h>
-#include <nncase/runtime/cpu/compiler_defs.h>
+#include <nncase/runtime/xpu/compiler_defs.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
-BEGIN_NS_NNCASE_RT_MODULE(cpu)
+BEGIN_NS_NNCASE_RT_MODULE(xpu)
 
 inline float float_unary_logical_not(float x) { return !x; }
 inline float float_unary_neg(float x) { return std::negate<float>()(x); }
diff --git a/modules/cpu/src/runtime/runtime_function.cpp b/modules/xpu/src/runtime/runtime_function.cpp
similarity index 93%
rename from modules/cpu/src/runtime/runtime_function.cpp
rename to modules/xpu/src/runtime/runtime_function.cpp
index 5f1da9edb6..c35cf2b3aa 100644
--- a/modules/cpu/src/runtime/runtime_function.cpp
+++ b/modules/xpu/src/runtime/runtime_function.cpp
@@ -21,7 +21,7 @@
 
 using namespace nncase;
 using namespace nncase::runtime;
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 
 namespace {
 typedef struct memory_range {
@@ -41,11 +41,11 @@ typedef struct desc_header {
 
 } // namespace
 
-cpu_runtime_module &cpu_runtime_function::module() const noexcept {
-    return static_cast<cpu_runtime_module &>(runtime_function::module());
+xpu_runtime_module &xpu_runtime_function::module() const noexcept {
+    return static_cast<xpu_runtime_module &>(runtime_function::module());
 }
 
-result<void> cpu_runtime_function::initialize_core(
+result<void> xpu_runtime_function::initialize_core(
     NNCASE_UNUSED runtime_function_init_context &context) noexcept {
     text_ = module().text_physical().subspan(context.header().entrypoint,
                                              context.header().text_size);
@@ -111,7 +111,7 @@ result<void> cpu_runtime_function::initialize_core(
 }
 
 result<value_t>
-cpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
+xpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
                                   NNCASE_UNUSED value_t return_value) noexcept {
     // try_var(id, module().find_id_by_function(this));
 
diff --git a/modules/cpu/src/runtime/runtime_function.h b/modules/xpu/src/runtime/runtime_function.h
similarity index 91%
rename from modules/cpu/src/runtime/runtime_function.h
rename to modules/xpu/src/runtime/runtime_function.h
index ffaab9c605..b92b0ed295 100644
--- a/modules/cpu/src/runtime/runtime_function.h
+++ b/modules/xpu/src/runtime/runtime_function.h
@@ -17,13 +17,13 @@
 #include <nncase/kernels/kernel_context.h>
 #include <nncase/runtime/runtime_function.h>
 
-BEGIN_NS_NNCASE_RT_MODULE(cpu)
+BEGIN_NS_NNCASE_RT_MODULE(xpu)
 
-class cpu_runtime_function : public runtime_function {
+class xpu_runtime_function : public runtime_function {
   public:
     using runtime_function::runtime_function;
 
-    cpu_runtime_module &module() const noexcept;
+    xpu_runtime_module &module() const noexcept;
 
   protected:
     result<void>
diff --git a/modules/cpu/src/runtime/runtime_module.cpp b/modules/xpu/src/runtime/runtime_module.cpp
similarity index 79%
rename from modules/cpu/src/runtime/runtime_module.cpp
rename to modules/xpu/src/runtime/runtime_module.cpp
index 989ad42b8e..0d9a44c653 100644
--- a/modules/cpu/src/runtime/runtime_module.cpp
+++ b/modules/xpu/src/runtime/runtime_module.cpp
@@ -20,9 +20,9 @@
 
 using namespace nncase;
 using namespace nncase::runtime;
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 
-result<void> cpu_runtime_module::initialize_before_functions(
+result<void> xpu_runtime_module::initialize_before_functions(
     runtime_module_init_context &context) noexcept {
     // if (!context.is_section_pinned())
     //     return nncase::err(std::errc::bad_address);
@@ -36,30 +36,30 @@ result<void> cpu_runtime_module::initialize_before_functions(
 }
 
 result<std::unique_ptr<runtime_function>>
-cpu_runtime_module::create_function() noexcept {
+xpu_runtime_module::create_function() noexcept {
     std::unique_ptr<runtime_function> mod(new (std::nothrow)
-                                              cpu_runtime_function(*this));
+                                              xpu_runtime_function(*this));
     if (mod)
         return ok(std::move(mod));
     return err(std::errc::not_enough_memory);
 }
 
-result<std::unique_ptr<runtime_module>> cpu::create_cpu_runtime_module() {
+result<std::unique_ptr<runtime_module>> xpu::create_xpu_runtime_module() {
     std::unique_ptr<runtime_module> mod(new (std::nothrow)
-                                            cpu_runtime_module());
+                                            xpu_runtime_module());
     if (mod)
         return ok(std::move(mod));
     return err(std::errc::not_enough_memory);
 }
 
 extern "C" {
-NNCASE_MODULES_CPU_API void
+NNCASE_MODULES_XPU_API void
 RUNTIME_MODULE_ACTIVATOR_NAME(result<std::unique_ptr<runtime_module>> &result) {
-    result = create_cpu_runtime_module();
+    result = create_xpu_runtime_module();
 }
 }
 
 #ifndef NNCASE_SIMULATOR
 runtime_registration nncase::runtime::builtin_runtimes[] = {
-    {cpu_module_type, RUNTIME_MODULE_ACTIVATOR_NAME}, {}};
+    {xpu_module_type, RUNTIME_MODULE_ACTIVATOR_NAME}, {}};
 #endif
diff --git a/modules/cpu/src/runtime/runtime_module.h b/modules/xpu/src/runtime/runtime_module.h
similarity index 90%
rename from modules/cpu/src/runtime/runtime_module.h
rename to modules/xpu/src/runtime/runtime_module.h
index f672aeeab2..2c40734520 100644
--- a/modules/cpu/src/runtime/runtime_module.h
+++ b/modules/xpu/src/runtime/runtime_module.h
@@ -13,11 +13,11 @@
  * limitations under the License.
  */
 #pragma once
-#include <nncase/runtime/cpu/runtime_module.h>
+#include <nncase/runtime/xpu/runtime_module.h>
 
-BEGIN_NS_NNCASE_RT_MODULE(cpu)
+BEGIN_NS_NNCASE_RT_MODULE(xpu)
 
-class cpu_runtime_module : public runtime_module {
+class xpu_runtime_module : public runtime_module {
   public:
     gsl::span<const gsl::byte> rdata_physical() noexcept { return rdata_; }
     gsl::span<gsl::byte> data_physical() noexcept { return data_; }
diff --git a/modules/cpu/src/runtime/runtime_utils.h b/modules/xpu/src/runtime/runtime_utils.h
similarity index 91%
rename from modules/cpu/src/runtime/runtime_utils.h
rename to modules/xpu/src/runtime/runtime_utils.h
index a242dcc2f9..4aaf10edb4 100644
--- a/modules/cpu/src/runtime/runtime_utils.h
+++ b/modules/xpu/src/runtime/runtime_utils.h
@@ -11,11 +11,11 @@
 #elif defined(__APPLE__)
 #include <pthread.h>
 #endif
-#include <nncase/runtime/cpu/compiler_defs.h>
+#include <nncase/runtime/xpu/compiler_defs.h>
 #include <numeric>
 #include <vector>
 
-BEGIN_NS_NNCASE_RT_MODULE(cpu)
+BEGIN_NS_NNCASE_RT_MODULE(xpu)
 inline void create_thread(pthread_t &pt, void *param_, void *(*call)(void *)) {
     void *(*new_call)(void *) = call; // + (intptr_t)buf;
     int ret = pthread_create(&pt, NULL, new_call, param_);
diff --git a/modules/cpu/src/runtime/shared_memory.cpp b/modules/xpu/src/runtime/shared_memory.cpp
similarity index 99%
rename from modules/cpu/src/runtime/shared_memory.cpp
rename to modules/xpu/src/runtime/shared_memory.cpp
index bd402dcf09..437e4c8e2d 100644
--- a/modules/cpu/src/runtime/shared_memory.cpp
+++ b/modules/xpu/src/runtime/shared_memory.cpp
@@ -28,7 +28,7 @@
 
 using namespace nncase;
 using namespace nncase::runtime;
-using namespace nncase::runtime::cpu;
+using namespace nncase::runtime::xpu;
 
 shared_memory::shared_memory(const std::filesystem::path &path, size_t size,
                              shared_memory_openmode mode)
diff --git a/modules/cpu/src/runtime/shared_memory.h b/modules/xpu/src/runtime/shared_memory.h
similarity index 93%
rename from modules/cpu/src/runtime/shared_memory.h
rename to modules/xpu/src/runtime/shared_memory.h
index 3d20b85426..029d7bb4ba 100644
--- a/modules/cpu/src/runtime/shared_memory.h
+++ b/modules/xpu/src/runtime/shared_memory.h
@@ -15,13 +15,13 @@
 #pragma once
 #include "gsl-lite.hpp"
 #include <filesystem>
-#include <nncase/runtime/cpu/compiler_defs.h>
+#include <nncase/runtime/xpu/compiler_defs.h>
 
 #ifdef WIN32
 #include <Windows.h>
 #endif
 
-BEGIN_NS_NNCASE_RT_MODULE(cpu)
+BEGIN_NS_NNCASE_RT_MODULE(xpu)
 
 enum class shared_memory_openmode { create, open };
 
diff --git a/modules/cpu/src/runtime/thread_pool.cpp b/modules/xpu/src/runtime/thread_pool.cpp
similarity index 86%
rename from modules/cpu/src/runtime/thread_pool.cpp
rename to modules/xpu/src/runtime/thread_pool.cpp
index c73a47b6ed..6efaa5f2fb 100644
--- a/modules/cpu/src/runtime/thread_pool.cpp
+++ b/modules/xpu/src/runtime/thread_pool.cpp
@@ -1,16 +1,16 @@
 #include "thread_pool.h"
 #include <stdexcept>
 
-using namespace nncase::runtime::cpu::thread_pool;
+using namespace nncase::runtime::xpu::thread_pool;
 
 int threads_size =
     atoi(getenv("NNCASE_MAX_THREADS") ? getenv("NNCASE_MAX_THREADS") : "0");
 int threads_count;
 std::vector<pthread_t> threads;
 std::vector<void *> users;
-uintptr_t nncase::runtime::cpu::thread_pool::paddr_offset;
+uintptr_t nncase::runtime::xpu::thread_pool::paddr_offset;
 
-void *nncase::runtime::cpu::thread_pool::thread_start(thread_func callable,
+void *nncase::runtime::xpu::thread_pool::thread_start(thread_func callable,
                                                       void *user,
                                                       size_t user_size) {
     auto user_ = malloc(user_size);
@@ -41,7 +41,7 @@ void *nncase::runtime::cpu::thread_pool::thread_start(thread_func callable,
     return nullptr;
 }
 
-void *nncase::runtime::cpu::thread_pool::thread_end() {
+void *nncase::runtime::xpu::thread_pool::thread_end() {
     if (threads_size) {
         for (int i = 0; i < std::min(threads_size, threads_count); i++) {
             // if (threads[i].joinable()) {
diff --git a/modules/cpu/src/runtime/thread_pool.h b/modules/xpu/src/runtime/thread_pool.h
similarity index 88%
rename from modules/cpu/src/runtime/thread_pool.h
rename to modules/xpu/src/runtime/thread_pool.h
index f5baed41f7..45d427dadf 100644
--- a/modules/cpu/src/runtime/thread_pool.h
+++ b/modules/xpu/src/runtime/thread_pool.h
@@ -3,12 +3,12 @@
 #include <cstddef>
 #include <cstdlib>
 #include <cstring>
-#include <nncase/runtime/cpu/compiler_defs.h>
+#include <nncase/runtime/xpu/compiler_defs.h>
 #include <pthread.h>
 #include <utility>
 #include <vector>
 
-BEGIN_NS_NNCASE_RT_MODULE(cpu)
+BEGIN_NS_NNCASE_RT_MODULE(xpu)
 namespace thread_pool {
 
 using thread_func = void *(*)(void *);
diff --git a/nncase.sln b/nncase.sln
index 4c4b9496e2..4a984a4408 100644
--- a/nncase.sln
+++ b/nncase.sln
@@ -77,7 +77,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nncase.Tests.TestFixture",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nncase.Passes", "src\Nncase.Passes\Nncase.Passes.csproj", "{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nncase.Modules.CPU", "modules\Nncase.Modules.CPU\Nncase.Modules.CPU.csproj", "{97DA8EED-F382-4A2E-AE0E-F297A00DA19D}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nncase.Modules.XPU", "modules\Nncase.Modules.XPU\Nncase.Modules.XPU.csproj", "{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -173,10 +173,10 @@ Global
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}.Release|Any CPU.Build.0 = Release|Any CPU
-		{97DA8EED-F382-4A2E-AE0E-F297A00DA19D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{97DA8EED-F382-4A2E-AE0E-F297A00DA19D}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{97DA8EED-F382-4A2E-AE0E-F297A00DA19D}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{97DA8EED-F382-4A2E-AE0E-F297A00DA19D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -207,7 +207,7 @@ Global
 		{E365B1B1-4D13-4839-9763-A7A7C5F32FD4} = {BCA74168-F015-4B5B-B4CD-C83AE06B9822}
 		{98A03405-CA53-4EC4-9B18-94D1C8DF9453} = {E5A4516C-4080-4346-991D-57A7AA76ADA6}
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42} = {BCA74168-F015-4B5B-B4CD-C83AE06B9822}
-		{97DA8EED-F382-4A2E-AE0E-F297A00DA19D} = {9859F5E8-5504-4AFE-B955-9497A0A0CD66}
+		{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45} = {9859F5E8-5504-4AFE-B955-9497A0A0CD66}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {9492E141-292E-4D60-9C6E-3738AB234DB2}
diff --git a/python/nncase/__init__.py b/python/nncase/__init__.py
index a2376a8717..55668c348b 100644
--- a/python/nncase/__init__.py
+++ b/python/nncase/__init__.py
@@ -282,7 +282,7 @@ def _import_module(self, model_content: bytes | io.RawIOBase) -> None:
 
 def check_target(target: str):
     def test_target(target: str):
-        return target in ["cpu", "k510", "k230"]
+        return target in ["cpu", "k510", "k230", "xpu"]
 
     def target_exists(target: str):
         return _nncase.Target.exists(target)
diff --git a/src/Nncase.Cli/packages.lock.json b/src/Nncase.Cli/packages.lock.json
index 712cc915f1..7b53b77dd2 100644
--- a/src/Nncase.Cli/packages.lock.json
+++ b/src/Nncase.Cli/packages.lock.json
@@ -680,8 +680,8 @@
           "Nncase.Evaluator": "[1.0.0, )",
           "Nncase.Graph": "[1.0.0, )",
           "Nncase.Importer": "[1.0.0, )",
-          "Nncase.Modules.CPU": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
+          "Nncase.Modules.XPU": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )",
           "Nncase.Quantization": "[1.0.0, )",
           "Nncase.Simulator": "[1.0.0, )"
@@ -743,19 +743,19 @@
       "nncase.io": {
         "type": "Project"
       },
-      "nncase.modules.cpu": {
+      "nncase.modules.stackvm": {
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
-          "Nncase.Diagnostics": "[1.0.0, )",
-          "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }
       },
-      "nncase.modules.stackvm": {
+      "nncase.modules.xpu": {
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Diagnostics": "[1.0.0, )",
+          "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }
       },
diff --git a/src/Nncase.Compiler/Nncase.Compiler.csproj b/src/Nncase.Compiler/Nncase.Compiler.csproj
index ab93c75220..3be85fb5fa 100644
--- a/src/Nncase.Compiler/Nncase.Compiler.csproj
+++ b/src/Nncase.Compiler/Nncase.Compiler.csproj
@@ -14,7 +14,7 @@
     </ItemGroup>
 
     <ItemGroup>
-        <ProjectReference Include="..\..\modules\Nncase.Modules.CPU\Nncase.Modules.CPU.csproj" />
+        <ProjectReference Include="..\..\modules\Nncase.Modules.XPU\Nncase.Modules.XPU.csproj" />
         <ProjectReference Include="..\Nncase.CodeGen\Nncase.CodeGen.csproj" />
         <ProjectReference Include="..\Nncase.Core\Nncase.Core.csproj" />
         <ProjectReference Include="..\Nncase.Diagnostics\Nncase.Diagnostics.csproj" />
diff --git a/src/Nncase.Compiler/packages.lock.json b/src/Nncase.Compiler/packages.lock.json
index 8cede23417..c294c26198 100644
--- a/src/Nncase.Compiler/packages.lock.json
+++ b/src/Nncase.Compiler/packages.lock.json
@@ -720,19 +720,19 @@
       "nncase.io": {
         "type": "Project"
       },
-      "nncase.modules.cpu": {
+      "nncase.modules.stackvm": {
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
-          "Nncase.Diagnostics": "[1.0.0, )",
-          "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }
       },
-      "nncase.modules.stackvm": {
+      "nncase.modules.xpu": {
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Diagnostics": "[1.0.0, )",
+          "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }
       },
diff --git a/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj b/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
index d3b0b7e32b..6867a47837 100644
--- a/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
+++ b/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
@@ -22,7 +22,7 @@
     </ItemGroup>
     
     <ItemGroup>
-        <ProjectReference Include="..\..\modules\Nncase.Modules.CPU\Nncase.Modules.CPU.csproj" />
+        <ProjectReference Include="..\..\modules\Nncase.Modules.XPU\Nncase.Modules.XPU.csproj" />
         <ProjectReference Include="..\..\modules\Nncase.Modules.StackVM\Nncase.Modules.StackVM.csproj" />
         <ProjectReference Include="..\Nncase.Core\Nncase.Core.csproj" />
         <ProjectReference Include="..\Nncase.CodeGen\Nncase.CodeGen.csproj" />
diff --git a/src/Nncase.Tests.TestFixture/TestClassBase.cs b/src/Nncase.Tests.TestFixture/TestClassBase.cs
index a457a53a11..fe2e36a864 100644
--- a/src/Nncase.Tests.TestFixture/TestClassBase.cs
+++ b/src/Nncase.Tests.TestFixture/TestClassBase.cs
@@ -38,7 +38,7 @@ public TestClassBase()
     /// <summary>
     /// Gets or sets default target name.
     /// </summary>
-    public virtual string DefaultTargetName { get; set; } = CPUTarget.Kind;
+    public virtual string DefaultTargetName { get; set; } = XPUTarget.Kind;
 
     /// <summary>
     /// Gets test output root.
diff --git a/src/Nncase.Tests.TestFixture/packages.lock.json b/src/Nncase.Tests.TestFixture/packages.lock.json
index 8d3a8be05e..d2a726fe30 100644
--- a/src/Nncase.Tests.TestFixture/packages.lock.json
+++ b/src/Nncase.Tests.TestFixture/packages.lock.json
@@ -1132,19 +1132,19 @@
       "nncase.io": {
         "type": "Project"
       },
-      "nncase.modules.cpu": {
+      "nncase.modules.stackvm": {
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
-          "Nncase.Diagnostics": "[1.0.0, )",
-          "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }
       },
-      "nncase.modules.stackvm": {
+      "nncase.modules.xpu": {
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Diagnostics": "[1.0.0, )",
+          "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }
       },
diff --git a/src/Nncase.Tests/Distributed/UnitTestKernels.cs b/src/Nncase.Tests/Distributed/UnitTestKernels.cs
index ca301bd61a..e339334d2e 100644
--- a/src/Nncase.Tests/Distributed/UnitTestKernels.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestKernels.cs
@@ -114,7 +114,7 @@ public BinaryCase1()
         {
             var l0 = IR.F.CPU.Boxing(lhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.B }, place));
             var r0 = IR.F.CPU.Boxing(rhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.S(2) }, place));
-            Fusion = new Fusion(Name + "_fusion", CPUTarget.Kind, IR.F.CPU.Boxing(l0 + r0, type), new[] { lhs, rhs });
+            Fusion = new Fusion(Name + "_fusion", XPUTarget.Kind, IR.F.CPU.Boxing(l0 + r0, type), new[] { lhs, rhs });
         }
 
         Vars = new[] { lhs, rhs };
diff --git a/src/Nncase.Tests/Simulator/UnitTestInterop.cs b/src/Nncase.Tests/Simulator/UnitTestInterop.cs
index cd9ed60a28..f262ec7812 100644
--- a/src/Nncase.Tests/Simulator/UnitTestInterop.cs
+++ b/src/Nncase.Tests/Simulator/UnitTestInterop.cs
@@ -25,7 +25,7 @@ public UnitTestInterop()
         var y = x + 1.0f;
         var main = new Function("main", y, new[] { x });
         var module = new IRModule(main);
-        var target = CompilerServices.GetTarget(CPUTarget.Kind);
+        var target = CompilerServices.GetTarget(XPUTarget.Kind);
         var modelBuilder = new ModelBuilder(target, CompileOptions);
         var linkedModel = modelBuilder.Build(module);
         using var output = new MemoryStream();
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTarget.cs b/src/Nncase.Tests/Targets/UnitTestXPUTarget.cs
similarity index 97%
rename from src/Nncase.Tests/Targets/UnitTestCPUTarget.cs
rename to src/Nncase.Tests/Targets/UnitTestXPUTarget.cs
index 71f4c72bc6..52b4748fc2 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTarget.cs
+++ b/src/Nncase.Tests/Targets/UnitTestXPUTarget.cs
@@ -24,11 +24,11 @@
 namespace Nncase.Tests.Targets;
 
 [AutoSetupTestMethod(InitSession = true)]
-public class UnitTestCPUTarget : TestClassBase
+public class UnitTestXPUTarget : TestClassBase
 {
-    public UnitTestCPUTarget()
+    public UnitTestXPUTarget()
     {
-        DefaultTargetName = CPUTarget.Kind;
+        DefaultTargetName = XPUTarget.Kind;
     }
 
     public static IEnumerable<object[]> TestGetItemData =>
@@ -47,16 +47,16 @@ public UnitTestCPUTarget()
 
     [Fact]
     [AutoSetupTestMethod(InitSession = false)]
-    public void TestCPUTargetKind()
+    public void TestXPUTargetKind()
     {
-        Assert.Equal("cpu", CPUTarget.Kind);
+        Assert.Equal("XPU", XPUTarget.Kind);
     }
 
     [Fact]
     [AutoSetupTestMethod(InitSession = false)]
-    public void TestCreateCPUTarget()
+    public void TestCreateXPUTarget()
     {
-        var target = CompilerServices.GetTarget(CPUTarget.Kind);
+        var target = CompilerServices.GetTarget(XPUTarget.Kind);
         Assert.NotNull(target);
     }
 
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestXPUTargetTiling.cs
similarity index 96%
rename from src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
rename to src/Nncase.Tests/Targets/UnitTestXPUTargetTiling.cs
index 850efef9f5..8c07d981d7 100644
--- a/src/Nncase.Tests/Targets/UnitTestCPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestXPUTargetTiling.cs
@@ -28,11 +28,11 @@
 namespace Nncase.Tests.Targets;
 
 [AutoSetupTestMethod(InitSession = true)]
-public class UnitTestCPUTargetTiling : TestClassBase
+public class UnitTestXPUTargetTiling : TestClassBase
 {
-    public UnitTestCPUTargetTiling()
+    public UnitTestXPUTargetTiling()
     {
-        DefaultTargetName = CPUTarget.Kind;
+        DefaultTargetName = XPUTarget.Kind;
 #if DEBUG
         CompileOptions.DumpFlags = Diagnostics.DumpFlags.PassIR | Diagnostics.DumpFlags.Rewrite | Diagnostics.DumpFlags.CodeGen | Diagnostics.DumpFlags.EGraphCost | Diagnostics.DumpFlags.Tiling;
 #endif
@@ -66,7 +66,7 @@ public UnitTestCPUTargetTiling()
     // [ClassData(typeof(TilingCaseExpand))]
     // [ClassData(typeof(TilingCaseSDMHA))]
     [ClassData(typeof(TilingCaseClamp))]
-    public async Task TestCpuFunction(Function main, Tensor[] inputs)
+    public async Task TestXpuFunction(Function main, Tensor[] inputs)
     {
         var module = new IR.IRModule(main);
         var parameterLength = main.Parameters.Length;
@@ -129,7 +129,7 @@ public TilingCaseSlice()
         {
             fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, shape));
             var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Slice()), fin_a, new[] { 64 }, new[] { 128 }, new[] { 3 }, new[] { 1 });
-            fusion = new Fusion("cpu", v1, fin_a);
+            fusion = new Fusion("xpu", v1, fin_a);
         }
 
         var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
@@ -159,7 +159,7 @@ public TilingCaseConcat()
             fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, in_a_shape));
             fin_b = new Var("fin_b", new TensorType(DataTypes.Float32, in_b_shape));
             var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Concat(3)), new IR.Tuple(fin_a, fin_b));
-            fusion = new Fusion("cpu", v1, fin_a, fin_b);
+            fusion = new Fusion("xpu", v1, fin_a, fin_b);
         }
 
         var input_a_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, in_a_shape).Evaluate().AsTensor();
@@ -195,7 +195,7 @@ public TilingCaseMatmulLayerNorm()
             var v2 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), v1, weights);
             var v3 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Unary(UnaryOp.Exp)), v2);
 
-            fusion = new Fusion("cpu", v3, fin);
+            fusion = new Fusion("xpu", v3, fin);
         }
 
         var main = new Function("matmul_layernorm", new Call(fusion, hid_in), new[] { hid_in });
@@ -234,7 +234,7 @@ public TilingCaseMHA()
             var v10 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Binary(BinaryOp.Mul)), v6, v8);
             var v11 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Binary(BinaryOp.Add)), v9, v10);
 
-            fusion = new Fusion("cpu", v11, fin, fin2);
+            fusion = new Fusion("xpu", v11, fin, fin2);
         }
 
         var main = new Function("mha_qk", new Call(fusion, hid_in, pos_ids), new[] { hid_in, pos_ids });
@@ -336,7 +336,7 @@ public TilingCaseMatmul()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, lhsShape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), fin, rhs);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("matmul", new Call(fusion, lhs), new[] { lhs });
@@ -371,7 +371,7 @@ public TilingCaseMatmulUnary()
             fin = new Var("input", new TensorType(DataTypes.Float32, lhsShape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), fin, rhs);
             var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Unary(UnaryOp.Neg)), v0);
-            fusion = new Fusion("cpu", v1, fin);
+            fusion = new Fusion("xpu", v1, fin);
         }
 
         var main = new Function("matmul_unary", new Call(fusion, lhs), new[] { lhs });
@@ -407,7 +407,7 @@ public TilingCaseLayerNorm()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, shape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.LayerNorm(axis, 1e-5f, false)), fin, scale, bias);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("layernorm", new Call(fusion, input), new[] { input });
@@ -440,7 +440,7 @@ public TilingCaseLayerNormBinary()
             var v0 = new Call(new IR.NN.LayerNorm(axis, 1e-5f, true), fin, scale, bias);
             var v1 = IR.F.NN.Swish(v0, 1.602f);
             var v2 = IR.F.Math.Binary(BinaryOp.Add, fin, v1);
-            fusion = new Fusion("cpu", v2, fin);
+            fusion = new Fusion("xpu", v2, fin);
         }
 
         var main = new Function("layernorm_binary", new Call(fusion, input), new[] { input });
@@ -470,7 +470,7 @@ public TilingCaseInstanceNorm()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, shape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.InstanceNormalization()), fin, scale, bias, 1e-5);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("instance_norm", new Call(fusion, input), new[] { input });
@@ -506,7 +506,7 @@ public TilingCaseGather()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Gather(axis)), fin, indices);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("gather", new Call(fusion, input), new[] { input });
@@ -538,7 +538,7 @@ public TilingCaseGatherBinary()
             fin = new Var("indices", new TensorType(DataTypes.Int32, indicesShape));
             var v0 = new Call(new IR.Tensors.Gather(axis), input, fin);
             var v1 = new Call(new IR.Math.Binary(BinaryOp.Add), v0, IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 77, 768 }).Evaluate().AsTensor());
-            fusion = new Fusion("cpu", v1, fin);
+            fusion = new Fusion("xpu", v1, fin);
         }
 
         var main = new Function("gather_binary", new Call(fusion, indices), new[] { indices });
@@ -567,7 +567,7 @@ public TilingCaseSoftmax()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.Softmax()), fin, axis);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("softmax", new Call(fusion, input), new[] { input });
@@ -596,7 +596,7 @@ public TilingCaseTranspose()
         {
             fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, shape));
             var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Transpose()), fin_a, perm);
-            fusion = new Fusion("cpu", v1, fin_a);
+            fusion = new Fusion("xpu", v1, fin_a);
         }
 
         var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
@@ -622,7 +622,7 @@ public TilingCaseReshape1()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Reshape()), fin, newShape);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("reshape1", new Call(fusion, input), new[] { input });
@@ -651,7 +651,7 @@ public TilingCaseReshape2()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Reshape()), fin, newShape);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("reshape2", new Call(fusion, input), new[] { input });
@@ -679,7 +679,7 @@ public TilingCaseReduceArg()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64)), fin, 1, false, false);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("argmax", new Call(fusion, input), new[] { input });
@@ -707,7 +707,7 @@ public TilingCaseReduceArg2()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64)), fin, 2, true, false);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("argmax2", new Call(fusion, input), new[] { input });
@@ -769,7 +769,7 @@ public TilingCaseConv2D()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.Conv2D(PadMode.Constant)), fin, weights, bias, stride, padding, dilation, groups, fusedClamp);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("conv2d", new Call(fusion, input), new[] { input });
@@ -797,7 +797,7 @@ public TilingCaseResize()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, shape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Imaging.ResizeImage(ImageResizeMode.NearestNeighbor, ImageResizeTransformationMode.Asymmetric, ImageResizeNearestMode.Floor, false)), fin, None.Default, new[] { 1, 512, 128, 128 }, None.Default, None.Default, None.Default);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("nearest_resize", new Call(fusion, input), new[] { input });
@@ -830,7 +830,7 @@ public TilingCaseCast()
         {
             fin = new Var("input", new TensorType(DataTypes.Int64, shape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Cast(DataTypes.Float32, CastMode.KDefault)), fin);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("cast", new Call(fusion, input), new[] { input });
@@ -884,7 +884,7 @@ public TilingCaseSDMHA()
             var v22 = IR.F.Math.MatMul(v21, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 3072, 768 }).Evaluate().AsTensor()); // f32[1,77,768]
             var v23 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), v22); // f32[1,77,768]
             var v24 = IR.F.Math.Binary(BinaryOp.Add, v17, v23); // f32[1,77,768]
-            fusion = new Fusion("cpu", new IR.Tuple(v17, v23, v24), new[] { fin });
+            fusion = new Fusion("xpu", new IR.Tuple(v17, v23, v24), new[] { fin });
         }
 
         var input = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 77, 768 }));
@@ -914,7 +914,7 @@ public TilingCaseExpand()
         {
             fin = new Var("input", new TensorType(DataTypes.Int64, shape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Expand()), fin, newShape);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("expand", new Call(fusion, input), new[] { input });
@@ -943,7 +943,7 @@ public TilingCaseClamp()
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, shape));
             var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Clamp()), fin, float.NegativeInfinity, float.PositiveInfinity);
-            fusion = new Fusion("cpu", v0, fin);
+            fusion = new Fusion("xpu", v0, fin);
         }
 
         var main = new Function("clamp", new Call(fusion, input), new[] { input });
diff --git a/src/Nncase.Tests/packages.lock.json b/src/Nncase.Tests/packages.lock.json
index 23220aaadc..07b123dd74 100644
--- a/src/Nncase.Tests/packages.lock.json
+++ b/src/Nncase.Tests/packages.lock.json
@@ -1476,8 +1476,8 @@
           "Nncase.Evaluator": "[1.0.0, )",
           "Nncase.Graph": "[1.0.0, )",
           "Nncase.Importer": "[1.0.0, )",
-          "Nncase.Modules.CPU": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
+          "Nncase.Modules.XPU": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )",
           "Nncase.Quantization": "[1.0.0, )",
           "Nncase.Simulator": "[1.0.0, )"
@@ -1539,19 +1539,19 @@
       "nncase.io": {
         "type": "Project"
       },
-      "nncase.modules.cpu": {
+      "nncase.modules.stackvm": {
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
-          "Nncase.Diagnostics": "[1.0.0, )",
-          "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }
       },
-      "nncase.modules.stackvm": {
+      "nncase.modules.xpu": {
         "type": "Project",
         "dependencies": {
           "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Diagnostics": "[1.0.0, )",
+          "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )"
         }
       },
@@ -1586,8 +1586,8 @@
           "MethodBoundaryAspect.Fody": "[2.0.148, )",
           "Nncase.CodeGen": "[1.0.0, )",
           "Nncase.Core": "[1.0.0, )",
-          "Nncase.Modules.CPU": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
+          "Nncase.Modules.XPU": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )",
           "Nncase.Simulator": "[1.0.0, )",
           "System.Linq.Async": "[6.0.1, )",

From edade3916256e5f3ddecd4d00a086bac787e61a3 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 25 Oct 2023 20:15:00 +0800
Subject: [PATCH 280/308] add rvv clamp

---
 .../cpu/src/runtime/cmodel/include/clamp.h    | 54 +++++++++++++++++--
 1 file changed, 49 insertions(+), 5 deletions(-)

diff --git a/modules/cpu/src/runtime/cmodel/include/clamp.h b/modules/cpu/src/runtime/cmodel/include/clamp.h
index de3a5a1ad9..bebf734c06 100644
--- a/modules/cpu/src/runtime/cmodel/include/clamp.h
+++ b/modules/cpu/src/runtime/cmodel/include/clamp.h
@@ -16,15 +16,53 @@
 #include "../../gsl-lite.hpp"
 #include <apply.h>
 #include <runtime_utils.h>
+#ifdef __riscv_vector
+#include <riscv_vector.h>
+#endif
 
 using namespace nncase::runtime::cpu;
 namespace kernels {
 namespace {
+#ifdef __riscv_vector
 template <class T>
-void clamp_impl(const T *input, T min, T max, T *output,
-                gsl::span<const size_t> in_shape,
-                gsl::span<const size_t> in_strides,
-                gsl::span<const size_t> out_strides) {
+void clamp_rvv_impl(const T *input, T min, T max, T *output,
+                    gsl::span<const size_t> in_shape,
+                    gsl::span<const size_t> in_strides,
+                    gsl::span<const size_t> out_strides) {
+    auto [new_in_shape, new_in_stride] = to_nd(in_shape, in_strides, 5);
+    auto [new_out_shape, new_out_stride] = to_nd(in_shape, out_strides, 5);
+    for (size_t n = 0; n < new_in_shape[0]; ++n) {
+        for (size_t c = 0; c < new_in_shape[1]; ++c) {
+            for (size_t h = 0; h < new_in_shape[2]; ++h) {
+                for (size_t w = 0; w < new_in_shape[3]; ++w) {
+                    const T *in_ptr = input + n * new_in_stride[0] +
+                                      c * new_in_stride[1] + h * new_in_stride[2] +
+                                      w * new_in_stride[3];
+                    T *out_ptr = output + n * new_out_stride[0] +
+                                       c * new_out_stride[1] + h * new_out_stride[2] +
+                                       w * new_out_stride[3];
+                    size_t vl;
+                    for (size_t i = new_in_shape[4]; i > 0; i -= vl) {
+                        vl = vsetvl_e32m8(i);
+                        vfloat32m8_t vx = vle32_v_f32m8(in_ptr, vl);
+                        vx = vfmax_vf_f32m8(vx, min, vl);
+                        vx = vfmin_vf_f32m8(vx, max, vl);
+                        vse32_v_f32m8(out_ptr, vx, vl);
+                        in_ptr += vl;
+                        out_ptr += vl;
+                    }
+                }
+            }
+        }
+    }
+    return;
+}
+#else
+template <class T>
+void clamp_native_impl(const T *input, T min, T max, T *output,
+                       gsl::span<const size_t> in_shape,
+                       gsl::span<const size_t> in_strides,
+                       gsl::span<const size_t> out_strides) {
     return apply(in_shape, [&](gsl::span<const size_t> index) -> void {
         const auto v = input[offset(index, in_strides)];
         output[offset(index, out_strides)] = static_cast<T>(
@@ -33,12 +71,18 @@ void clamp_impl(const T *input, T min, T max, T *output,
         return;
     });
 }
+#endif
 } // namespace
 
 template <class T>
 void clamp(const T *input, T *output, T min, T max,
            gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
            gsl::span<const size_t> out_strides) {
-    clamp_impl(input, min, max, output, in_shape, in_strides, out_strides);
+#ifdef __riscv_vector
+    clamp_rvv_impl(input, min, max, output, in_shape, in_strides, out_strides);
+#else
+    clamp_native_impl(input, min, max, output, in_shape, in_strides,
+                      out_strides);
+#endif
 }
 } // namespace kernels
\ No newline at end of file

From 7789d1fbee67d33a82d93ebef3469909b8c9562e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Thu, 26 Oct 2023 04:20:10 +0000
Subject: [PATCH 281/308] Clean modules dir

---
 CMakeLists.txt                                |    4 +-
 .../CodeGen/CSourceBuiltn.cs                  |  494 --
 .../CodeGen/CSourceCompiler.cs                |  153 -
 .../CodeGen/CSourceConvertVisitor.cs          | 1049 -----
 .../CodeGen/CSourceExtensions.cs              |  119 -
 .../CodeGen/CSourceUtilities.cs               |   42 -
 .../CodeGen/FunctionBuilder.cs                |   94 -
 .../CodeGen/FunctionCSource.cs                |   36 -
 .../CodeGen/LinkableFunction.cs               |   34 -
 .../CodeGen/LinkableModule.cs                 |  138 -
 .../CodeGen/LinkedModule.cs                   |   32 -
 .../CodeGen/ModuleBuilder.cs                  |   38 -
 .../Evaluator/IR/CPU/Boxing.cs                |  145 -
 .../Evaluator/IR/CPU/CPUKernelOp.cs           |   34 -
 .../Evaluator/IR/CPU/CPUModule.cs             |   19 -
 .../Evaluator/TIR/XPU/Binary.cs               |   15 -
 .../Evaluator/TIR/XPU/Cast.cs                 |   12 -
 .../Evaluator/TIR/XPU/Clamp.cs                |   12 -
 .../Evaluator/TIR/XPU/Concat.cs               |   15 -
 .../Evaluator/TIR/XPU/Conv2D.cs               |   12 -
 .../Evaluator/TIR/XPU/Expand.cs               |   12 -
 .../Evaluator/TIR/XPU/Gather.cs               |   12 -
 .../Evaluator/TIR/XPU/GatherReduceScatter.cs  |   17 -
 .../Evaluator/TIR/XPU/InstanceNorm.cs         |   12 -
 .../Evaluator/TIR/XPU/LayerNorm.cs            |   12 -
 .../Evaluator/TIR/XPU/Matmul.cs               |   12 -
 .../Evaluator/TIR/XPU/ReShape.cs              |   12 -
 .../Evaluator/TIR/XPU/ReduceArg.cs            |   15 -
 .../Evaluator/TIR/XPU/Resize.cs               |   12 -
 .../Evaluator/TIR/XPU/Slice.cs                |   15 -
 .../Evaluator/TIR/XPU/Softmax.cs              |   12 -
 .../Evaluator/TIR/XPU/SwishB.cs               |   18 -
 .../Evaluator/TIR/XPU/TDMALoad.cs             |   17 -
 .../Evaluator/TIR/XPU/TDMAStore.cs            |   17 -
 .../Evaluator/TIR/XPU/Transpose.cs            |   15 -
 .../Evaluator/TIR/XPU/Unary.cs                |   18 -
 .../Evaluator/TIR/XPU/XPUModule.cs            |   41 -
 modules/Nncase.Modules.XPU/IR/CPU/Boxing.cs   |   29 -
 .../Nncase.Modules.XPU/IR/CPU/CPUKernelOp.cs  |   33 -
 .../Nncase.Modules.XPU/IR/CPU/Functional.cs   |   30 -
 .../Nncase.Modules.XPU.csproj                 |   29 -
 .../Passes/Rules/CombineMHA.cs                |  121 -
 .../Passes/Rules/DumpConst.cs                 |  120 -
 .../Passes/Rules/FusionMerger.cs              |   79 -
 .../Passes/Rules/LowerBinary.cs               |   39 -
 .../Passes/Rules/LowerMatMul.cs               |   39 -
 .../Passes/Rules/LowerUnary.cs                |   33 -
 .../Passes/Rules/MHAFusion.cs                 |  353 --
 .../Passes/Rules/MakeFusion.cs                |   46 -
 .../Passes/Rules/UnetFusion.cs                |  290 --
 .../Passes/Rules/VAEFusion.cs                 |  186 -
 .../Tile/AutoDistributedConvertVisitor.cs     |  284 --
 .../Passes/Tile/IFusionChecker.cs             |   29 -
 .../Passes/Tile/MultiFusionChecker.cs         |   20 -
 .../Passes/Tile/SingleXPUFusionConverter.cs   |   40 -
 .../Passes/Tile/TIRConvertVisitor.cs          |  418 --
 .../Passes/Tile/TileOptions.cs                |   21 -
 .../Tile/XPUSameInputFusionMergeRule.cs       |  162 -
 .../Passes/XPUFusionToTirPass.cs              |   71 -
 modules/Nncase.Modules.XPU/TIR/XPU/Binary.cs  |   28 -
 modules/Nncase.Modules.XPU/TIR/XPU/Cast.cs    |   19 -
 modules/Nncase.Modules.XPU/TIR/XPU/Clamp.cs   |   17 -
 modules/Nncase.Modules.XPU/TIR/XPU/Concat.cs  |   10 -
 modules/Nncase.Modules.XPU/TIR/XPU/Conv2D.cs  |   26 -
 modules/Nncase.Modules.XPU/TIR/XPU/Expand.cs  |   16 -
 .../Nncase.Modules.XPU/TIR/XPU/Functional.cs  |  121 -
 modules/Nncase.Modules.XPU/TIR/XPU/Gather.cs  |   16 -
 .../TIR/XPU/GatherReduceScatter.cs            |   16 -
 .../TIR/XPU/InstanceNorm.cs                   |   20 -
 .../Nncase.Modules.XPU/TIR/XPU/LayerNorm.cs   |   24 -
 modules/Nncase.Modules.XPU/TIR/XPU/Matmul.cs  |   14 -
 modules/Nncase.Modules.XPU/TIR/XPU/ReShape.cs |   12 -
 .../Nncase.Modules.XPU/TIR/XPU/ReduceArg.cs   |   45 -
 modules/Nncase.Modules.XPU/TIR/XPU/Resize.cs  |   35 -
 modules/Nncase.Modules.XPU/TIR/XPU/Slice.cs   |   18 -
 modules/Nncase.Modules.XPU/TIR/XPU/Softmax.cs |   16 -
 modules/Nncase.Modules.XPU/TIR/XPU/SwishB.cs  |   14 -
 .../Nncase.Modules.XPU/TIR/XPU/TDMALoad.cs    |   16 -
 .../Nncase.Modules.XPU/TIR/XPU/TDMAStore.cs   |   16 -
 .../Nncase.Modules.XPU/TIR/XPU/Transpose.cs   |   14 -
 modules/Nncase.Modules.XPU/TIR/XPU/Unary.cs   |   20 -
 .../Nncase.Modules.XPU/TIR/XPU/XPUKernelOp.cs |    9 -
 .../Nncase.Modules.XPU/Targets/XPUTarget.cs   |  122 -
 .../Nncase.Modules.XPU/XPUApplicationPart.cs  |   31 -
 modules/Nncase.Modules.XPU/XPUModule.cs       |   19 -
 modules/Nncase.Modules.XPU/packages.lock.json |  295 --
 modules/xpu/CMakeLists.txt                    |   60 -
 .../nncase_rt_modules_cpuConfig.cmake.in      |    1 -
 modules/xpu/examples/CMakeLists.txt           |    4 -
 modules/xpu/examples/cpu_test/CMakeLists.txt  |    5 -
 modules/xpu/examples/cpu_test/main.cpp        |  201 -
 .../nncase/runtime/xpu/compiler_defs.h        |   38 -
 .../nncase/runtime/xpu/runtime_module.h       |   28 -
 modules/xpu/src/runtime/CMakeLists.txt        |   29 -
 modules/xpu/src/runtime/cmodel/CMakeLists.txt |   76 -
 .../xpu/src/runtime/cmodel/include/apply.h    |  102 -
 .../xpu/src/runtime/cmodel/include/binary.h   |  143 -
 modules/xpu/src/runtime/cmodel/include/cast.h |   49 -
 .../xpu/src/runtime/cmodel/include/clamp.h    |   88 -
 .../xpu/src/runtime/cmodel/include/concat.h   |   55 -
 .../xpu/src/runtime/cmodel/include/expand.h   |   46 -
 .../xpu/src/runtime/cmodel/include/gather.h   |   74 -
 .../runtime/cmodel/include/hardware_context.h |   39 -
 .../src/runtime/cmodel/include/hardware_def.h |    5 -
 .../runtime/cmodel/include/instance_norm.h    |  131 -
 .../src/runtime/cmodel/include/layernorm.h    |  216 -
 .../xpu/src/runtime/cmodel/include/matmul.h   |  196 -
 .../xpu/src/runtime/cmodel/include/reduce.h   |  184 -
 .../src/runtime/cmodel/include/reduce_arg.h   |   81 -
 .../xpu/src/runtime/cmodel/include/resize.h   |  141 -
 .../src/runtime/cmodel/include/resize_util.h  |  127 -
 .../runtime/cmodel/include/runtime_types.h    |   73 -
 .../runtime/cmodel/include/runtime_utils.h    |  218 -
 .../xpu/src/runtime/cmodel/include/slice.h    |   67 -
 .../runtime/cmodel/include/small_vector.hpp   | 1003 ----
 .../xpu/src/runtime/cmodel/include/softmax.h  |  115 -
 modules/xpu/src/runtime/cmodel/include/tdma.h |  864 ----
 .../xpu/src/runtime/cmodel/include/tensor.h   |   96 -
 .../runtime/cmodel/include/thread_context.h   |   16 -
 .../src/runtime/cmodel/include/transpose.h    |   46 -
 .../xpu/src/runtime/cmodel/include/unary.h    |  104 -
 .../xpu/src/runtime/cmodel/src/cpu_cmodel.cpp |   58 -
 modules/xpu/src/runtime/cmodel/src/dummy.cpp  |    0
 .../cmodel/tests/decoder_layer/cluster_def.h  |  171 -
 .../cmodel/tests/decoder_layer/golden.py      |  106 -
 .../cmodel/tests/decoder_layer/kernel.h       |  406 --
 .../cmodel/tests/decoder_layer/main.cpp       |  352 --
 .../cmodel/tests/decoder_layer/shared_def.h   |   32 -
 .../runtime/cmodel/tests/demo1/cluster_def.h  |  171 -
 .../src/runtime/cmodel/tests/demo1/golden.py  |   33 -
 .../src/runtime/cmodel/tests/demo1/kernel.h   |  152 -
 .../src/runtime/cmodel/tests/demo1/main.cpp   |  160 -
 .../runtime/cmodel/tests/demo1/shared_def.h   |    9 -
 .../runtime/cmodel/tests/demo2/cluster_def.h  |  171 -
 .../src/runtime/cmodel/tests/demo2/golden.py  |   39 -
 .../src/runtime/cmodel/tests/demo2/kernel.h   |  129 -
 .../src/runtime/cmodel/tests/demo2/main.cpp   |  164 -
 .../runtime/cmodel/tests/demo2/shared_def.h   |    9 -
 .../runtime/cmodel/tests/embed/cluster_def.h  |  171 -
 .../src/runtime/cmodel/tests/embed/golden.py  |   31 -
 .../src/runtime/cmodel/tests/embed/kernel.h   |   29 -
 .../src/runtime/cmodel/tests/embed/main.cpp   |  126 -
 .../runtime/cmodel/tests/embed/shared_def.h   |    3 -
 .../runtime/cmodel/tests/head/cluster_def.h   |  171 -
 .../src/runtime/cmodel/tests/head/golden.py   |   34 -
 .../src/runtime/cmodel/tests/head/kernel.h    |   26 -
 .../src/runtime/cmodel/tests/head/main.cpp    |  133 -
 .../runtime/cmodel/tests/head/shared_def.h    |    5 -
 .../runtime/cmodel/tests/norm/cluster_def.h   |  171 -
 .../src/runtime/cmodel/tests/norm/golden.py   |   31 -
 .../src/runtime/cmodel/tests/norm/kernel.h    |   24 -
 .../src/runtime/cmodel/tests/norm/main.cpp    |  115 -
 .../runtime/cmodel/tests/norm/shared_def.h    |    3 -
 .../runtime/cmodel/tests/unary/cluster_def.h  |  171 -
 .../src/runtime/cmodel/tests/unary/golden.py  |   12 -
 .../src/runtime/cmodel/tests/unary/kernel.h   |   19 -
 .../src/runtime/cmodel/tests/unary/main.cpp   |  114 -
 .../runtime/cmodel/tests/unary/shared_def.h   |    3 -
 modules/xpu/src/runtime/elf.h                 |  578 ---
 modules/xpu/src/runtime/elfarch.h             |   35 -
 modules/xpu/src/runtime/elfload.cpp           |  262 --
 modules/xpu/src/runtime/elfload.h             |   96 -
 modules/xpu/src/runtime/elfloader.cpp         |   90 -
 modules/xpu/src/runtime/elfloader.h           |   65 -
 modules/xpu/src/runtime/elfreloc_aarch64.cpp  |   62 -
 modules/xpu/src/runtime/elfreloc_amd64.cpp    |   27 -
 modules/xpu/src/runtime/elfreloc_i386.cpp     |   28 -
 modules/xpu/src/runtime/elfreloc_riscv64.cpp  |   32 -
 modules/xpu/src/runtime/gsl-lite.hpp          | 4076 -----------------
 modules/xpu/src/runtime/hardware_context.cpp  |  138 -
 modules/xpu/src/runtime/hardware_context.h    |   26 -
 modules/xpu/src/runtime/hardware_def.h        |    5 -
 modules/xpu/src/runtime/io_utils.h            |   28 -
 modules/xpu/src/runtime/method_table_def.h    |  105 -
 modules/xpu/src/runtime/method_table_impl.h   |  137 -
 modules/xpu/src/runtime/runtime_function.cpp  |  133 -
 modules/xpu/src/runtime/runtime_function.h    |   45 -
 modules/xpu/src/runtime/runtime_module.cpp    |   65 -
 modules/xpu/src/runtime/runtime_module.h      |   41 -
 modules/xpu/src/runtime/runtime_utils.h       |   35 -
 modules/xpu/src/runtime/shared_memory.cpp     |  128 -
 modules/xpu/src/runtime/shared_memory.h       |   48 -
 modules/xpu/src/runtime/thread_pool.cpp       |   57 -
 modules/xpu/src/runtime/thread_pool.h         |   27 -
 nncase.sln                                    |    7 -
 src/Nncase.Cli/packages.lock.json             |   10 -
 src/Nncase.Compiler/Compiler.cs               |   21 -
 .../Hosting/CompilerHostBuilderExtensions.cs  |    3 +-
 src/Nncase.Compiler/Nncase.Compiler.csproj    |    1 -
 src/Nncase.Core/DistributedType.cs            |   18 +-
 src/Nncase.Tests/Core/UnitTestExpression.cs   |    6 +-
 .../Distributed/UnitTestConstruct.cs          |   14 +-
 src/Nncase.Tests/Distributed/UnitTestCost.cs  |    4 +-
 .../Distributed/UnitTestKernels.cs            |   14 +-
 .../Distributed/UnitTestTypeInfer.cs          |   34 +-
 .../Distributed/UnitTestUtilities.cs          |   10 +-
 .../Targets/UnitTestXPUTargetTiling.cs        |   70 +-
 src/Nncase.Tests/packages.lock.json           |    1 -
 198 files changed, 87 insertions(+), 21017 deletions(-)
 delete mode 100644 modules/Nncase.Modules.XPU/CodeGen/CSourceBuiltn.cs
 delete mode 100644 modules/Nncase.Modules.XPU/CodeGen/CSourceCompiler.cs
 delete mode 100644 modules/Nncase.Modules.XPU/CodeGen/CSourceConvertVisitor.cs
 delete mode 100644 modules/Nncase.Modules.XPU/CodeGen/CSourceExtensions.cs
 delete mode 100644 modules/Nncase.Modules.XPU/CodeGen/CSourceUtilities.cs
 delete mode 100644 modules/Nncase.Modules.XPU/CodeGen/FunctionBuilder.cs
 delete mode 100644 modules/Nncase.Modules.XPU/CodeGen/FunctionCSource.cs
 delete mode 100644 modules/Nncase.Modules.XPU/CodeGen/LinkableFunction.cs
 delete mode 100644 modules/Nncase.Modules.XPU/CodeGen/LinkableModule.cs
 delete mode 100644 modules/Nncase.Modules.XPU/CodeGen/LinkedModule.cs
 delete mode 100644 modules/Nncase.Modules.XPU/CodeGen/ModuleBuilder.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/IR/CPU/Boxing.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUKernelOp.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUModule.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Binary.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Cast.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Clamp.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Concat.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Conv2D.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Expand.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Gather.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/GatherReduceScatter.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/InstanceNorm.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/LayerNorm.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Matmul.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReShape.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReduceArg.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Resize.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Slice.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Softmax.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/SwishB.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMALoad.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMAStore.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Transpose.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Unary.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/XPUModule.cs
 delete mode 100644 modules/Nncase.Modules.XPU/IR/CPU/Boxing.cs
 delete mode 100644 modules/Nncase.Modules.XPU/IR/CPU/CPUKernelOp.cs
 delete mode 100644 modules/Nncase.Modules.XPU/IR/CPU/Functional.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Nncase.Modules.XPU.csproj
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Rules/CombineMHA.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Rules/DumpConst.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Rules/FusionMerger.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Rules/LowerBinary.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Rules/LowerMatMul.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Rules/LowerUnary.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Rules/MHAFusion.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Rules/MakeFusion.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Rules/UnetFusion.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Rules/VAEFusion.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Tile/AutoDistributedConvertVisitor.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Tile/IFusionChecker.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Tile/MultiFusionChecker.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Tile/SingleXPUFusionConverter.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Tile/TIRConvertVisitor.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Tile/TileOptions.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/Tile/XPUSameInputFusionMergeRule.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Passes/XPUFusionToTirPass.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Binary.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Cast.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Clamp.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Concat.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Conv2D.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Expand.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Functional.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Gather.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/GatherReduceScatter.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/InstanceNorm.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/LayerNorm.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Matmul.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/ReShape.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/ReduceArg.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Resize.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Slice.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Softmax.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/SwishB.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/TDMALoad.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/TDMAStore.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Transpose.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/Unary.cs
 delete mode 100644 modules/Nncase.Modules.XPU/TIR/XPU/XPUKernelOp.cs
 delete mode 100644 modules/Nncase.Modules.XPU/Targets/XPUTarget.cs
 delete mode 100644 modules/Nncase.Modules.XPU/XPUApplicationPart.cs
 delete mode 100644 modules/Nncase.Modules.XPU/XPUModule.cs
 delete mode 100644 modules/Nncase.Modules.XPU/packages.lock.json
 delete mode 100644 modules/xpu/CMakeLists.txt
 delete mode 100644 modules/xpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
 delete mode 100644 modules/xpu/examples/CMakeLists.txt
 delete mode 100644 modules/xpu/examples/cpu_test/CMakeLists.txt
 delete mode 100644 modules/xpu/examples/cpu_test/main.cpp
 delete mode 100644 modules/xpu/include/nncase/runtime/xpu/compiler_defs.h
 delete mode 100644 modules/xpu/include/nncase/runtime/xpu/runtime_module.h
 delete mode 100644 modules/xpu/src/runtime/CMakeLists.txt
 delete mode 100644 modules/xpu/src/runtime/cmodel/CMakeLists.txt
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/apply.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/binary.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/cast.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/clamp.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/concat.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/expand.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/gather.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/hardware_context.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/hardware_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/instance_norm.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/layernorm.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/matmul.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/reduce.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/reduce_arg.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/resize.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/resize_util.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/runtime_types.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/runtime_utils.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/slice.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/small_vector.hpp
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/softmax.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/tdma.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/tensor.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/thread_context.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/transpose.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/include/unary.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/src/cpu_cmodel.cpp
 delete mode 100644 modules/xpu/src/runtime/cmodel/src/dummy.cpp
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/decoder_layer/cluster_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/decoder_layer/golden.py
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/demo1/cluster_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/demo1/golden.py
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/demo1/kernel.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/demo1/main.cpp
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/demo1/shared_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/demo2/cluster_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/demo2/golden.py
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/demo2/kernel.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/demo2/main.cpp
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/demo2/shared_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/embed/cluster_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/embed/golden.py
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/embed/kernel.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/embed/main.cpp
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/embed/shared_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/head/cluster_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/head/golden.py
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/head/kernel.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/head/main.cpp
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/head/shared_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/norm/cluster_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/norm/golden.py
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/norm/kernel.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/norm/main.cpp
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/norm/shared_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/unary/cluster_def.h
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/unary/golden.py
 delete mode 100755 modules/xpu/src/runtime/cmodel/tests/unary/kernel.h
 delete mode 100755 modules/xpu/src/runtime/cmodel/tests/unary/main.cpp
 delete mode 100644 modules/xpu/src/runtime/cmodel/tests/unary/shared_def.h
 delete mode 100644 modules/xpu/src/runtime/elf.h
 delete mode 100644 modules/xpu/src/runtime/elfarch.h
 delete mode 100644 modules/xpu/src/runtime/elfload.cpp
 delete mode 100644 modules/xpu/src/runtime/elfload.h
 delete mode 100644 modules/xpu/src/runtime/elfloader.cpp
 delete mode 100644 modules/xpu/src/runtime/elfloader.h
 delete mode 100644 modules/xpu/src/runtime/elfreloc_aarch64.cpp
 delete mode 100644 modules/xpu/src/runtime/elfreloc_amd64.cpp
 delete mode 100644 modules/xpu/src/runtime/elfreloc_i386.cpp
 delete mode 100644 modules/xpu/src/runtime/elfreloc_riscv64.cpp
 delete mode 100644 modules/xpu/src/runtime/gsl-lite.hpp
 delete mode 100644 modules/xpu/src/runtime/hardware_context.cpp
 delete mode 100644 modules/xpu/src/runtime/hardware_context.h
 delete mode 100644 modules/xpu/src/runtime/hardware_def.h
 delete mode 100644 modules/xpu/src/runtime/io_utils.h
 delete mode 100644 modules/xpu/src/runtime/method_table_def.h
 delete mode 100644 modules/xpu/src/runtime/method_table_impl.h
 delete mode 100644 modules/xpu/src/runtime/runtime_function.cpp
 delete mode 100644 modules/xpu/src/runtime/runtime_function.h
 delete mode 100644 modules/xpu/src/runtime/runtime_module.cpp
 delete mode 100644 modules/xpu/src/runtime/runtime_module.h
 delete mode 100644 modules/xpu/src/runtime/runtime_utils.h
 delete mode 100644 modules/xpu/src/runtime/shared_memory.cpp
 delete mode 100644 modules/xpu/src/runtime/shared_memory.h
 delete mode 100644 modules/xpu/src/runtime/thread_pool.cpp
 delete mode 100644 modules/xpu/src/runtime/thread_pool.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 94b279d2ac..e716e0742d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -263,7 +263,5 @@ if(BUILD_TESTING)
 endif()
 
 # Modules
-if (NOT MSVC)
-add_subdirectory(modules/xpu)
-endif()
+
 #add_subdirectory(modules/vulkan)
diff --git a/modules/Nncase.Modules.XPU/CodeGen/CSourceBuiltn.cs b/modules/Nncase.Modules.XPU/CodeGen/CSourceBuiltn.cs
deleted file mode 100644
index 6752f505af..0000000000
--- a/modules/Nncase.Modules.XPU/CodeGen/CSourceBuiltn.cs
+++ /dev/null
@@ -1,494 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-#define MULTI_CORE_XPU
-using System.Runtime.CompilerServices;
-using NetFabric.Hyperlinq;
-
-namespace Nncase.CodeGen.XPU;
-
-public static class CSourceBuiltn
-{
-#if MULTI_CORE_XPU
-    public const string KernelHeader = @"#include ""thread_context.h""
-using namespace shared;
-";
-
-    public static string ClusterDef()
-    {
-        return @"#pragma once
-#include <hardware_context.h>
-#include <tdma.h>
-
-namespace block0 {
-#include ""shared.h""
-constexpr size_t bid = 0;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include ""kernel.h""
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include ""kernel.h""
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include ""kernel.h""
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include ""kernel.h""
-} // namespace thread3
-} // namespace block0
-
-namespace block1 {
-#include ""shared.h""
-constexpr size_t bid = 1;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include ""kernel.h""
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include ""kernel.h""
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include ""kernel.h""
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include ""kernel.h""
-} // namespace thread3
-} // namespace block1
-
-namespace block2 {
-#include ""shared.h""
-constexpr size_t bid = 2;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include ""kernel.h""
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include ""kernel.h""
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include ""kernel.h""
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include ""kernel.h""
-} // namespace thread3
-} // namespace block2
-
-namespace block3 {
-#include ""shared.h""
-constexpr size_t bid = 3;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include ""kernel.h""
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include ""kernel.h""
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include ""kernel.h""
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include ""kernel.h""
-} // namespace thread3
-} // namespace block3
-
-namespace block4 {
-#include ""shared.h""
-constexpr size_t bid = 4;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include ""kernel.h""
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include ""kernel.h""
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include ""kernel.h""
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include ""kernel.h""
-} // namespace thread3
-} // namespace block4
-
-namespace block5 {
-#include ""shared.h""
-constexpr size_t bid = 5;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include ""kernel.h""
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include ""kernel.h""
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include ""kernel.h""
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include ""kernel.h""
-} // namespace thread3
-} // namespace block5
-
-namespace block6 {
-#include ""shared.h""
-constexpr size_t bid = 6;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include ""kernel.h""
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include ""kernel.h""
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include ""kernel.h""
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include ""kernel.h""
-} // namespace thread3
-} // namespace block6
-
-namespace block7 {
-#include ""shared.h""
-constexpr size_t bid = 7;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include ""kernel.h""
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include ""kernel.h""
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include ""kernel.h""
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include ""kernel.h""
-} // namespace thread3
-} // namespace block7
-";
-    }
-
-    public static string CMakeDef(string name, [CallerFilePath] string? callerFilePath = null)
-    {
-        var solutionPath = Path.GetFullPath(Path.Join(callerFilePath!, "../../../.."));
-        return $@"project(xpu)
-cmake_minimum_required(VERSION 3.13)
-
-add_library(
-  xpu_cmodel STATIC
-  {solutionPath}/modules/xpu/src/runtime/cmodel/src/dummy.cpp)
-
-set(CMAKE_CXX_STANDARD 20)
-
-target_include_directories(
-  xpu_cmodel
-  PUBLIC
-    {solutionPath}/modules/xpu/src/runtime/cmodel/include
-)
-target_include_directories(
-  xpu_cmodel
-  PUBLIC {solutionPath}/modules/xpu/include)
-target_include_directories(
-  xpu_cmodel
-  PUBLIC {solutionPath}/modules/xpu/src/runtime/)
-set_target_properties(xpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-# add_definitions(-D__riscv_vector)
-foreach(LIBRARY_PATH ${{CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}})
-    # Construct the full path to the library file
-    set(CRTI_LIB_PATH ""${{LIBRARY_PATH}}/crti.o"")
-
-    # Check if the library file exists
-    if(EXISTS ${{CRTI_LIB_PATH}})
-        message(""crti.o Library found at: ${{CRTI_LIB_PATH}}"")
-        break()  # Stop searching if found
-    endif()
-endforeach()
-
-if(NOT CRTI_LIB_PATH)
-    message(""crti.o Library not found"")
-endif()
-
-foreach(LIBRARY_PATH ${{CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES}})
-    # Construct the full path to the library file
-    set(CRT1_LIB_PATH ""${{LIBRARY_PATH}}/crt1.o"")
-
-    # Check if the library file exists
-    if(EXISTS ${{CRT1_LIB_PATH}})
-        message(""crt1.o Library found at: ${{CRT1_LIB_PATH}}"")
-        break()  # Stop searching if found
-    endif()
-endforeach()
-
-if(NOT CRT1_LIB_PATH)
-    message(""crt1.o Library not found"")
-endif()
-
-if(CMAKE_BUILD_TYPE STREQUAL ""Release"")
-  add_compile_options(-O1)
-endif()
-add_compile_options(-fPIE)
-add_link_options(
-  -no-pie
-  -nostartfiles
-  -fPIC
-  -fno-stack-protector
-  -static
-  -Wl,-e,_Z6_startPN6nncase7runtime3xpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPhS8_
-)
-add_executable({name} ""main.cpp"")
-target_link_libraries({name} xpu_cmodel ${{CRT1_LIB_PATH}} ${{CRTI_LIB_PATH}})
-";
-    }
-
-    public static string MakeKernel(string ctype, string kernelImpl)
-    {
-        return KernelHeader + ctype + kernelImpl;
-    }
-
-    public static string MakeMain(TIR.PrimFunction primFunction, IEnumerable<TIR.Buffer> rdataBuffers)
-    {
-        string device_tensors = string.Join('\n', primFunction.Parameters.ToArray().Concat(rdataBuffers).Select(b => $"static tensor<{b.ElemType.ToC()},{b.MemSpan.Location.ToC()}> *{b.Name};").ToArray());
-
-        string init_tensors = string.Join("\n", primFunction.Parameters.ToArray().Select((b, i) =>
-        {
-            var size = TensorUtilities.GetSize(b.CheckedShape.ToValueArray(), TensorUtilities.GetStrides(b.CheckedShape.ToValueArray()), 1);
-            return $@"    auto {b.Name}_ = tensor<{b.ElemType.ToC()}, {b.MemSpan.Location.ToC()}>(gsl::make_span(({b.ElemType.ToC()}*)inputs[{i}], {size}), {{{string.Join(',', b.CheckedShape)}}});
-    {b.Name} = &{b.Name}_;";
-        }).Concat(rdataBuffers.Select(b =>
-        {
-            var size = TensorUtilities.GetSize(b.CheckedShape.ToValueArray(), TensorUtilities.GetStrides(b.CheckedShape.ToValueArray()), 1);
-            return $@"    auto {b.Name}_ = tensor<{b.ElemType.ToC()}, {b.MemSpan.Location.ToC()}>(gsl::make_span(({b.ElemType.ToC()}*)(rdata + {((IR.TensorConst)b.MemSpan.Start).Value.ToScalar<ulong>()}), {size}), {{{string.Join(',', b.CheckedShape)}}});
-    {b.Name} = &{b.Name}_;";
-        })));
-
-        return @$"#include ""cluster_def.h""
-#include <runtime_utils.h>
-
-#define DEFINE_TFUNC(b, t)                                                     \
-    void *f_##b##_##t(void *arg) {{                                             \
-        block##b::thread##t::{primFunction.Name}({string.Join(',', primFunction.Parameters.AsValueEnumerable().Select(b => '*' + b.Name).ToArray().Concat(rdataBuffers.Select(b => '*' + b.Name)).ToArray())});               \
-        return arg;                                                            \
-    }}
-
-#define DEFINE_BFUNC(b)                                                        \
-    DEFINE_TFUNC(b, 0)                                                         \
-    DEFINE_TFUNC(b, 1)                                                         \
-    DEFINE_TFUNC(b, 2)                                                         \
-    DEFINE_TFUNC(b, 3)
-
-{device_tensors}
-
-DEFINE_BFUNC(0)
-DEFINE_BFUNC(1)
-DEFINE_BFUNC(2)
-DEFINE_BFUNC(3)
-DEFINE_BFUNC(4)
-DEFINE_BFUNC(5)
-DEFINE_BFUNC(6)
-DEFINE_BFUNC(7)
-
-int main() {{}}
-extern ""C"" {{void __libc_csu_fini(){{}} void __libc_csu_init(){{}}}}
-
-void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs, uint8_t *rdata) {{
-    runtime_util = rt_util_mt;
-    nncase_mt = nncase_mt_impl;
-    global_hardware_init(hw_ctx_impl);
-
-{init_tensors}
-
-    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
-
-    runtime_util->create_thread(t_0_0, NULL, f_0_0);
-    runtime_util->create_thread(t_0_1, NULL, f_0_1);
-    runtime_util->create_thread(t_0_2, NULL, f_0_2);
-    runtime_util->create_thread(t_0_3, NULL, f_0_3);
-    runtime_util->create_thread(t_1_0, NULL, f_1_0);
-    runtime_util->create_thread(t_1_1, NULL, f_1_1);
-    runtime_util->create_thread(t_1_2, NULL, f_1_2);
-    runtime_util->create_thread(t_1_3, NULL, f_1_3);
-    runtime_util->create_thread(t_2_0, NULL, f_2_0);
-    runtime_util->create_thread(t_2_1, NULL, f_2_1);
-    runtime_util->create_thread(t_2_2, NULL, f_2_2);
-    runtime_util->create_thread(t_2_3, NULL, f_2_3);
-    runtime_util->create_thread(t_3_0, NULL, f_3_0);
-    runtime_util->create_thread(t_3_1, NULL, f_3_1);
-    runtime_util->create_thread(t_3_2, NULL, f_3_2);
-    runtime_util->create_thread(t_3_3, NULL, f_3_3);
-    runtime_util->create_thread(t_4_0, NULL, f_4_0);
-    runtime_util->create_thread(t_4_1, NULL, f_4_1);
-    runtime_util->create_thread(t_4_2, NULL, f_4_2);
-    runtime_util->create_thread(t_4_3, NULL, f_4_3);
-    runtime_util->create_thread(t_5_0, NULL, f_5_0);
-    runtime_util->create_thread(t_5_1, NULL, f_5_1);
-    runtime_util->create_thread(t_5_2, NULL, f_5_2);
-    runtime_util->create_thread(t_5_3, NULL, f_5_3);
-    runtime_util->create_thread(t_6_0, NULL, f_6_0);
-    runtime_util->create_thread(t_6_1, NULL, f_6_1);
-    runtime_util->create_thread(t_6_2, NULL, f_6_2);
-    runtime_util->create_thread(t_6_3, NULL, f_6_3);
-    runtime_util->create_thread(t_7_0, NULL, f_7_0);
-    runtime_util->create_thread(t_7_1, NULL, f_7_1);
-    runtime_util->create_thread(t_7_2, NULL, f_7_2);
-    runtime_util->create_thread(t_7_3, NULL, f_7_3);
-
-    runtime_util->join_thread(t_0_0);
-    runtime_util->join_thread(t_0_1);
-    runtime_util->join_thread(t_0_2);
-    runtime_util->join_thread(t_0_3);
-    runtime_util->join_thread(t_1_0);
-    runtime_util->join_thread(t_1_1);
-    runtime_util->join_thread(t_1_2);
-    runtime_util->join_thread(t_1_3);
-    runtime_util->join_thread(t_2_0);
-    runtime_util->join_thread(t_2_1);
-    runtime_util->join_thread(t_2_2);
-    runtime_util->join_thread(t_2_3);
-    runtime_util->join_thread(t_3_0);
-    runtime_util->join_thread(t_3_1);
-    runtime_util->join_thread(t_3_2);
-    runtime_util->join_thread(t_3_3);
-    runtime_util->join_thread(t_4_0);
-    runtime_util->join_thread(t_4_1);
-    runtime_util->join_thread(t_4_2);
-    runtime_util->join_thread(t_4_3);
-    runtime_util->join_thread(t_5_0);
-    runtime_util->join_thread(t_5_1);
-    runtime_util->join_thread(t_5_2);
-    runtime_util->join_thread(t_5_3);
-    runtime_util->join_thread(t_6_0);
-    runtime_util->join_thread(t_6_1);
-    runtime_util->join_thread(t_6_2);
-    runtime_util->join_thread(t_6_3);
-    runtime_util->join_thread(t_7_0);
-    runtime_util->join_thread(t_7_1);
-    runtime_util->join_thread(t_7_2);
-    runtime_util->join_thread(t_7_3);
-}}";
-    }
-
-    public static string MakeShared(string shareds)
-    {
-        return @$"#include <tdma.h>
-
-namespace shared {{
-{shareds}
-}} // namespace shared";
-    }
-
-#else
-    public const string BufferType = "buffer_t";
-
-    public const string BufferStruct = @"typedef struct buffer {
-    void *vaddr;
-    size_t paddr;
-    uint32_t *shape;
-    uint32_t *stride;
-    uint32_t rank;
-} buffer_t;";
-
-    public const string MethodTable = @"typedef struct nncase_method_table {
-    // float unary
-    float (*float_unary_abs)(float);
-    float (*float_unary_acos)(float);
-    float (*float_unary_acosh)(float);
-    float (*float_unary_asin)(float);
-    float (*float_unary_asinh)(float);
-    float (*float_unary_ceil)(float);
-    float (*float_unary_cos)(float);
-    float (*float_unary_cosh)(float);
-    float (*float_unary_exp)(float);
-    float (*float_unary_floor)(float);
-    float (*float_unary_log)(float);
-    float (*float_unary_logical_not)(float);
-    float (*float_unary_neg)(float);
-    float (*float_unary_round)(float);
-    float (*float_unary_rsqrt)(float);
-    float (*float_unary_sign)(float);
-    float (*float_unary_sin)(float);
-    float (*float_unary_sinh)(float);
-    float (*float_unary_sqrt)(float);
-    float (*float_unary_square)(float);
-    float (*float_unary_tanh)(float);
-    // float bianry
-    float (*float_binary_add)(float, float);
-    float (*float_binary_sub)(float, float);
-    float (*float_binary_mul)(float, float);
-    float (*float_binary_div)(float, float);
-    float (*float_binary_min)(float, float);
-    float (*float_binary_max)(float, float);
-    float (*float_binary_pow)(float, float);
-    float (*float_binary_logical_and)(float, float);
-    float (*float_binary_mod)(float, float);
-    // int32 bianry
-    int32_t (*int32_binary_add)(int32_t, int32_t);
-    int32_t (*int32_binary_sub)(int32_t, int32_t);
-    int32_t (*int32_binary_mul)(int32_t, int32_t);
-    int32_t (*int32_binary_div)(int32_t, int32_t);
-    int32_t (*int32_binary_min)(int32_t, int32_t);
-    int32_t (*int32_binary_max)(int32_t, int32_t);
-    int32_t (*int32_binary_pow)(int32_t, int32_t);
-    int32_t (*int32_binary_logical_and)(int32_t, int32_t);
-    int32_t (*int32_binary_mod)(int32_t, int32_t);
-    // int64 bianry
-    int64_t (*int64_binary_add)(int64_t, int64_t);
-    int64_t (*int64_binary_sub)(int64_t, int64_t);
-    int64_t (*int64_binary_mul)(int64_t, int64_t);
-    int64_t (*int64_binary_div)(int64_t, int64_t);
-    int64_t (*int64_binary_min)(int64_t, int64_t);
-    int64_t (*int64_binary_max)(int64_t, int64_t);
-    int64_t (*int64_binary_pow)(int64_t, int64_t);
-    int64_t (*int64_binary_logical_and)(int64_t, int64_t);
-    int64_t (*int64_binary_mod)(int64_t, int64_t);
-    // bool binary
-    bool (*bool_binary_and)(bool, bool);
-    bool (*bool_binary_or)(bool, bool);
-    bool (*bool_binary_xor)(bool, bool);
-    // multi-thread
-    void *(*thread_start)(void *(*callable)(void *), void *user, size_t user_size);
-    void *(*thread_end)();
-} nncase_mt_t;";
-
-    public const string Include = @"#include <stdbool.h>\n#include <stdint.h>\n#include <stddef.h>";
-
-    public const string FixedParameters = "nncase_mt_t* nncase_mt, uint8_t* data, const uint8_t* rdata";
-
-    public const string MainPrologue = $@"void _start(size_t func_id, uint8_t** buffers, {FixedParameters}) {{";
-
-    public const string MainEpilogue = @"}";
-
-    public static string Header => $@"
-{Include}
-
-{MethodTable}
-
-{BufferStruct}
-";
-#endif
-}
diff --git a/modules/Nncase.Modules.XPU/CodeGen/CSourceCompiler.cs b/modules/Nncase.Modules.XPU/CodeGen/CSourceCompiler.cs
deleted file mode 100644
index 44037ce105..0000000000
--- a/modules/Nncase.Modules.XPU/CodeGen/CSourceCompiler.cs
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Text;
-using Nncase.IR;
-using Nncase.Schedule;
-using Nncase.TIR;
-
-namespace Nncase.CodeGen;
-
-/// <summary>
-/// the csource code compiler.
-/// </summary>
-public class CSourceCompiler
-{
-    /// <summary>
-    /// compiler exe name.
-    /// </summary>
-    private string _exe = string.Empty;
-
-    /// <summary>
-    /// compiler exe name.
-    /// </summary>
-    private string _arch = string.Empty;
-
-    /// <summary>
-    /// compiler exe name.
-    /// </summary>
-    private string _ext = string.Empty;
-
-    public CSourceCompiler()
-    {
-        PlatformSpecific();
-        ArchSpecific();
-    }
-
-    protected string Exe
-    {
-        get => _exe;
-    }
-
-    protected string Arch
-    {
-        get => _arch;
-    }
-
-    protected string Ext
-    {
-        get => _ext;
-    }
-
-    /// <summary>
-    /// compile the source txt, write to the out_path.
-    /// </summary>
-    /// <param name="sourcePath"> c source code.</param>
-    /// <param name="outPath"> out .so path. </param>
-    /// <returns> outPath. </returns>
-    public string Compile(string sourcePath, string outPath)
-    {
-        var errMsg = new StringBuilder();
-        using (var errWriter = new StringWriter(errMsg))
-        {
-            using (var proc = new Process())
-            {
-                proc.StartInfo.FileName = Exe;
-                proc.StartInfo.Arguments = ArgumentsSpecific(sourcePath, outPath);
-                proc.StartInfo.RedirectStandardError = true;
-                proc.ErrorDataReceived += (sender, e) => errWriter.WriteLine(e.Data);
-                proc.Start();
-                proc.BeginErrorReadLine();
-                proc.WaitForExit();
-                if (proc.ExitCode != 0)
-                {
-                    throw new InvalidOperationException(errMsg.ToString());
-                }
-            }
-        }
-
-        return outPath;
-    }
-
-    /// <summary>
-    /// create the temp dll file and compile source
-    /// <see cref="Compile(string, string)"/>.
-    /// </summary>
-    public string Compile(string sourcePath) => Compile(sourcePath, Path.Join(sourcePath, "build", Path.GetFileName(sourcePath)));
-
-    /// <summary>
-    /// select current pattern's exe.
-    /// </summary>
-    /// <exception cref="NotSupportedException">NotSupportedException.</exception>
-    private void PlatformSpecific()
-    {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-        {
-            _exe = "/bin/bash";
-            _ext = "so";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-        {
-            _exe = "clang";
-            _ext = "dylib";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-        {
-            _exe = "cmd";
-            _ext = "dll";
-        }
-
-        if (System.Environment.GetEnvironmentVariable("NNCASE_XPU_COMPILER") is string exe)
-        {
-            _exe = exe;
-        }
-    }
-
-    private void ArchSpecific()
-    {
-        _arch = RuntimeInformation.OSArchitecture switch
-        {
-            Architecture.X64 => RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "x86-64" : "x86_64",
-            Architecture.Arm64 => "arm64",
-            _ => throw new NotSupportedException(RuntimeInformation.OSArchitecture.ToString()),
-        };
-    }
-
-    private string ArgumentsSpecific(string sourcePath, string outPath)
-    {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-        {
-            // return $"-c \"export PATH=/data/huochenghai/toolchain/riscv64-unknown-linux_gnu_12.0.1/bin:$PATH && cd {sourcePath} && mkdir -p build && cd build && rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=riscv64-unknown-linux-gnu-gcc -DCMAKE_CXX_COMPILER=riscv64-unknown-linux-gnu-g++ -DCMAKE_SYSTEM_PROCESSOR=riscv64 && cmake --build .\"";
-            return $"-c \"cd {sourcePath} && /bin/mkdir -p build && cd build && /bin/rm -rf * && cmake .. -DCMAKE_BUILD_TYPE=Release && cmake --build .\"";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-        {
-            return $"{sourcePath} -nostartfiles -pie -fPIC -o {outPath} -static -e__start";
-        }
-        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-        {
-            var vsdir = Environment.GetEnvironmentVariable("VSAPPIDDIR") ?? throw new InvalidOperationException("Cannot find vs");
-            var vcvardir = Path.Combine(vsdir, "..\\..\\VC\\Auxiliary\\Build\\vcvarsall.bat");
-            return $"/C (\"{vcvardir}\" x64) && (cl /D_USRDLL /D_WINDLL \"{sourcePath}\" /MT /link /DLL /OUT:\"{outPath}\")";
-        }
-
-        throw new System.NotSupportedException("Only Support Linux/Osx/Windows");
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/CodeGen/CSourceConvertVisitor.cs b/modules/Nncase.Modules.XPU/CodeGen/CSourceConvertVisitor.cs
deleted file mode 100644
index dfaa008696..0000000000
--- a/modules/Nncase.Modules.XPU/CodeGen/CSourceConvertVisitor.cs
+++ /dev/null
@@ -1,1049 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-#define MULTI_CORE_XPU
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reactive;
-using System.Runtime.InteropServices;
-using System.Text;
-using NetFabric.Hyperlinq;
-using Nncase.IR;
-using Nncase.Runtime;
-using Nncase.TIR;
-
-namespace Nncase.CodeGen.XPU;
-
-internal struct IndentScope : IDisposable
-{
-    private static readonly AsyncLocal<IndentWriter?> _writer = new AsyncLocal<IndentWriter?>();
-
-    private readonly bool _initialized;
-
-    private readonly IndentWriter? _originalWriter;
-
-    public IndentScope(StringBuilder sb)
-    {
-        _initialized = true;
-        _originalWriter = _writer.Value;
-        _writer.Value = new IndentWriter(sb);
-    }
-
-    public IndentScope()
-    {
-        _initialized = true;
-        if (_writer.Value is null)
-        {
-            return;
-        }
-
-        _originalWriter = _writer.Value;
-        _writer.Value = new(_originalWriter.GetStringBuilder(), _originalWriter.Indent + 2);
-    }
-
-    public static IndentWriter Writer => _writer.Value!;
-
-    public void Dispose()
-    {
-        if (_initialized)
-        {
-            _writer.Value = _originalWriter;
-        }
-    }
-}
-
-/// <summary>
-/// the c symbol define.
-/// </summary>
-internal sealed class CSymbol
-{
-    public CSymbol(string type, string name)
-    {
-        Type = type;
-        Name = name;
-    }
-
-    public static IReadOnlyList<CSymbol> Builtns => new CSymbol[] {
-        new CSymbol("nncase_mt_t*", "nncase_mt"),
-        new CSymbol("uint8_t*", "data"),
-        new CSymbol("const uint8_t*", "rdata"),
-    };
-
-    public string Type { get; }
-
-    public string Name { get; }
-
-    public override string ToString() => $"{Type} {Name}";
-}
-
-internal sealed class IndentWriter : StringWriter
-{
-    public IndentWriter(StringBuilder sb, int indent = 0)
-        : base(sb)
-    {
-        Indent = indent;
-    }
-
-    public int Indent { get; set; }
-
-    public void IndWrite(string? value)
-    {
-        for (int i = 0; i < Indent; i++)
-        {
-            Write(' ');
-        }
-
-        Write(value);
-    }
-}
-
-#if MULTI_CORE_XPU
-/// <summary>
-/// convert single prim function to c source.
-/// </summary>
-internal sealed class CSourceConvertVisitor : ExprFunctor<CSymbol, Unit>
-{
-    private readonly Dictionary<Expr, CSymbol> _exprMemo;
-    private readonly StringBuilder _kernelBuilder;
-
-    private readonly StringBuilder _sharedBuilder;
-    private readonly StringWriter _sharedWriter;
-
-    public CSourceConvertVisitor()
-    {
-        _kernelBuilder = new StringBuilder();
-        _sharedBuilder = new StringBuilder();
-        _sharedWriter = new StringWriter(_sharedBuilder);
-        _exprMemo = new(ReferenceEqualityComparer.Instance);
-    }
-
-    public PrimFunction VisitEntry => (TIR.PrimFunction)VisitRoot!;
-
-    public FunctionCSource GetFunctionCSource()
-    {
-        _exprMemo.Keys.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location == MemoryLocation.L2Data).ToList().ForEach(b =>
-        {
-            _sharedWriter.Write(_exprMemo[b]);
-            _sharedWriter.WriteLine(";");
-        });
-
-        var ctype = $"void {VisitEntry.Name}({string.Join(", ", VisitEntry.Parameters.AsValueEnumerable().Select(Visit).Select(s => $"{s.Type} &{s.Name}").ToArray().Concat(_exprMemo.Keys.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location == MemoryLocation.Rdata).Select(Visit).Select(s => $" {s.Type} &{s.Name}").ToArray()))})";
-        return new(
-            CSourceBuiltn.MakeMain(VisitEntry, _exprMemo.Keys.OfType<TIR.Buffer>().Where(b => b.MemSpan.Location == MemoryLocation.Rdata)),
-            CSourceBuiltn.MakeShared(_sharedBuilder.ToString()),
-            CSourceBuiltn.MakeKernel(ctype, _kernelBuilder.ToString()));
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitPrimFunction(PrimFunction expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        if (expr.CheckedType is not CallableType { ReturnType: TupleType r } || r != TupleType.Void)
-        {
-            throw new NotSupportedException("The PrimFunction must return void!");
-        }
-
-        var ctype = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(Visit).Select(s => $"{s.Type} &{s.Name}").ToArray())})";
-
-        using (var scope = new IndentScope(_kernelBuilder))
-        {
-            // 1. Function signature
-            IndentScope.Writer.IndWrite($"{{\n");
-
-            // 2. Function body
-            using (_ = new IndentScope())
-            {
-                IndentScope.Writer.IndWrite($"thread_context ctx(bid, tid);\n");
-                Visit(expr.Body);
-            }
-
-            // 3. Function closing
-            IndentScope.Writer.IndWrite("}\n");
-        }
-
-        symbol = new(ctype, expr.Name);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitMemSpan(MemSpan expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        var start = Visit(expr.Start);
-        _ = Visit(expr.Size);
-        string name = start.Name;
-        if (expr.Start is TensorConst or Call)
-        {
-            var loc = expr.Location switch
-            {
-                MemoryLocation.Rdata => "rdata",
-                MemoryLocation.Data => "data",
-                _ => throw new NotSupportedException(),
-            };
-            name = $"({loc} + {start.Name})";
-        }
-
-        symbol = new(start.Type, name);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    protected override CSymbol VisitBuffer(TIR.Buffer expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        var type = $"tensor<{expr.ElemType.ToC()}, {expr.MemSpan.Location.ToC()}> ";
-
-        symbol = new(type, expr.Name);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitCall(Call expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        string type = expr.CheckedType switch
-        {
-            TupleType x when x == TupleType.Void => string.Empty,
-            TensorType { IsScalar: true } x => x.DType.ToC(),
-            _ => throw new NotSupportedException(),
-        };
-
-        string str = string.Empty;
-        if (expr.Target is TIR.XPU.XPUKernelOp xpuOp)
-        {
-            foreach (var item in expr.Arguments.ToArray().OfType<TIR.Buffer>())
-            {
-                DeclBuffer(item);
-            }
-
-            var args = expr.Arguments.ToArray().OfType<TIR.Buffer>().ToArray();
-            switch (xpuOp)
-            {
-                case TIR.XPU.TDMALoad load:
-                    if (args.Length == 1)
-                    {
-                        var tensorType = (TensorType)args[0].CheckedType;
-                        var splitAxisAndScale = load.NdSbp.Select((sbp, i) => sbp is SBPSplit s ? (s.Axis, load.Placement.Hierarchy[i]) : (0, 1)).ToArray();
-                        var fullShape = tensorType.Shape.ToValueArray();
-                        foreach (var s in splitAxisAndScale)
-                        {
-                            fullShape[s.Item1] *= s.Item2;
-                        }
-
-                        IndentScope.Writer.Write($"tdma_boxing_load_sync({Visit(args[0]).Name}, {{{string.Join(',', fullShape)}}}, {tensorType.Shape.ToSlicing(load.NdSbp, load.Placement)[1..^1]}, ctx)");
-                    }
-                    else
-                    {
-                        IndentScope.Writer.Write($"tdma_load_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{args[0].CheckedShape.ToSlicing(load.NdSbp, load.Placement)})");
-                    }
-
-                    break;
-                case TIR.XPU.TDMAStore store:
-                    if (args.Length == 1)
-                    {
-                        var tensorType = (TensorType)args[0].CheckedType;
-                        var splitAxisAndScale = store.NdSbp.Select((sbp, i) => sbp is SBPSplit s ? (s.Axis, store.Placement.Hierarchy[i]) : (0, 1)).ToArray();
-                        var fullShape = tensorType.Shape.ToValueArray();
-                        foreach (var s in splitAxisAndScale)
-                        {
-                            fullShape[s.Item1] *= s.Item2;
-                        }
-
-                        IndentScope.Writer.Write($"tdma_boxing_store_sync({Visit(args[0]).Name}, {{{string.Join(',', fullShape)}}}, {tensorType.Shape.ToSlicing(store.NdSbp, store.Placement)[1..^1]}, ctx)");
-                    }
-                    else
-                    {
-                        IndentScope.Writer.Write($"tdma_store_async({Visit(args[0]).Name}, {Visit(args[1]).Name}{args[0].CheckedShape.ToSlicing(store.NdSbp, store.Placement)})");
-                    }
-
-                    break;
-                case TIR.XPU.Unary unary:
-                    IndentScope.Writer.Write($"unary({Visit(args[0]).Name}, {Visit(args[1]).Name}, unary_op_t::{unary.UnaryOp})");
-                    break;
-                case TIR.XPU.SwishB swishb:
-                    IndentScope.Writer.Write($"swishb({Visit(args[0]).Name}, {Visit(args[1]).Name}, {swishb.Beta})");
-                    break;
-                case TIR.XPU.Binary binary:
-                    {
-                        var ltype = (TensorType)args[0].CheckedType;
-                        var rtype = (TensorType)args[1].CheckedType;
-                        var outtype = (TensorType)args[2].CheckedType;
-                        var lshape = ltype.Shape;
-                        var rshape = rtype.Shape;
-                        var outshape = outtype.Shape;
-                        var lpad = outtype.Shape.Rank - lshape.Rank;
-                        var rpad = outtype.Shape.Rank - rshape.Rank;
-                        var lsbp = Enumerable.Repeat<SBP>(SBP.B, binary.LhsType.Placement.Rank).ToArray();
-                        var rsbp = Enumerable.Repeat<SBP>(SBP.B, binary.RhsType.Placement.Rank).ToArray();
-
-                        var lnewShape = ltype.Shape.ToValueArray();
-                        var rnewShape = rtype.Shape.ToValueArray();
-                        for (int i = 0; i < binary.RhsType.Placement.Rank; i++)
-                        {
-                            switch (binary.LhsType.NdSBP[i], binary.RhsType.NdSBP[i])
-                            {
-                                case (SBPSplit s, SBPBroadCast):
-                                    var baxis = s.Axis - lshape.Rank + rshape.Rank;
-                                    if (outshape[s.Axis + lpad] == lshape[s.Axis] && baxis < rshape.Rank && baxis >= 0 && lshape[s.Axis] != rshape[baxis] && rshape[baxis] != 1)
-                                    {
-                                        rsbp[i] = SBP.S(baxis);
-                                        rnewShape[baxis] /= binary.RhsType.Placement.Hierarchy[i];
-                                    }
-
-                                    break;
-                                case (SBPBroadCast, SBPSplit s):
-                                    var aaxis = s.Axis - rshape.Rank + lshape.Rank;
-                                    if (outshape[s.Axis + rpad] == rshape[s.Axis] && aaxis < lshape.Rank && aaxis >= 0 && rshape[s.Axis] != lshape[aaxis] && lshape[aaxis] != 1)
-                                    {
-                                        lsbp[i] = SBP.S(aaxis);
-                                        lnewShape[aaxis] /= binary.RhsType.Placement.Hierarchy[i];
-                                    }
-
-                                    break;
-                                default:
-                                    break;
-                            }
-                        }
-
-                        string lhsStr = Visit(args[0]).Name;
-                        string rhsStr = Visit(args[1]).Name;
-                        if (lsbp.Any(s => s is SBPSplit))
-                        {
-                            var slice = new Shape(lnewShape).ToSlicing(lsbp, binary.LhsType.Placement);
-                            IndentScope.Writer.Write($"auto {lhsStr}_ = {lhsStr}{slice};\n");
-                            lhsStr += "_";
-                        }
-
-                        if (rsbp.Any(s => s is SBPSplit))
-                        {
-                            var slice = new Shape(rnewShape).ToSlicing(rsbp, binary.RhsType.Placement);
-                            IndentScope.Writer.Write($"auto {rhsStr}_ = {rhsStr}{slice};\n");
-                            rhsStr += "_";
-                        }
-
-                        IndentScope.Writer.Write($"binary({lhsStr}, {rhsStr}, {Visit(args[2]).Name}, binary_op_t::{binary.BinaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)})");
-                    }
-
-                    break;
-                case TIR.XPU.Matmul matmul:
-                    IndentScope.Writer.Write($"matmul({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name})");
-                    break;
-                case TIR.XPU.LayerNorm layernorm:
-                    using (_ = new IndentScope())
-                    {
-                        IndentScope.Writer.IndWrite($"{{\n");
-
-                        var dividedType = Utilities.DistributedUtility.GetDividedTensorType(layernorm.DistType);
-                        var sbpOnAxis = layernorm.DistType.NdSBP.Where(sbp => sbp is SBPSplit s && s.Axis >= layernorm.Axis).ToArray();
-                        switch (sbpOnAxis.Length)
-                        {
-                            case 0:
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
-                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
-                                IndentScope.Writer.IndWrite($"layernorm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({layernorm.Epsilon}), {layernorm.Axis}, {layernorm.DistType.TensorType.Shape[layernorm.Axis]}, {(!layernorm.UseMean).ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)});\n");
-                                break;
-                            case 1:
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
-                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
-                                if (sbpOnAxis[0] == layernorm.DistType.NdSBP[1])
-                                {
-                                    IndentScope.Writer.IndWrite($"tdma_reduce_async(sum, sum, reduce_op_t::sum, ctx);\n");
-                                    IndentScope.Writer.IndWrite($"tdma_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, ctx);\n");
-                                }
-                                else
-                                {
-                                    IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum, sum, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
-                                    IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
-                                }
-
-                                IndentScope.Writer.IndWrite($"layernorm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({layernorm.Epsilon}), {layernorm.Axis}, {layernorm.DistType.TensorType.Shape[layernorm.Axis]}, {(!layernorm.UseMean).ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)});\n");
-                                break;
-                            case 2:
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(layernorm.Axis))}}});\n");
-                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
-                                IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum, sum, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
-                                IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
-                                IndentScope.Writer.IndWrite($"layernorm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({layernorm.Epsilon}), {layernorm.Axis}, {layernorm.DistType.TensorType.Shape[layernorm.Axis]}, {(!layernorm.UseMean).ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)});\n");
-                                break;
-                        }
-
-                        IndentScope.Writer.IndWrite("}\n");
-                    }
-
-                    break;
-                case TIR.XPU.InstanceNorm instancenorm:
-                    using (_ = new IndentScope())
-                    {
-                        IndentScope.Writer.IndWrite($"{{\n");
-
-                        var dividedType = Utilities.DistributedUtility.GetDividedTensorType(instancenorm.DistType);
-                        var sbpOnAxis = instancenorm.DistType.NdSBP.Where(sbp => sbp is SBPSplit s && s.Axis > 1).ToArray();
-                        switch (sbpOnAxis.Length)
-                        {
-                            case 0:
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
-                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
-                                IndentScope.Writer.IndWrite($"instance_norm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({instancenorm.Epsilon}), {instancenorm.DistType.TensorType.Shape[2]});\n");
-                                break;
-                            case 1:
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
-                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
-                                if (sbpOnAxis[0] == instancenorm.DistType.NdSBP[1])
-                                {
-                                    IndentScope.Writer.IndWrite($"tdma_reduce_async(sum, sum, reduce_op_t::sum, ctx);\n");
-                                    IndentScope.Writer.IndWrite($"tdma_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, ctx);\n");
-                                }
-                                else
-                                {
-                                    IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum, sum, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
-                                    IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
-                                }
-
-                                IndentScope.Writer.IndWrite($"instance_norm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({instancenorm.Epsilon}), {instancenorm.DistType.TensorType.Shape[2]});\n"); break;
-                            case 2:
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
-                                IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> sum_sqr({{{string.Join(",", dividedType.Shape.ToArray().Take(2))}}});\n");
-                                IndentScope.Writer.IndWrite($"reduce_sum_sqr({Visit(args[0]).Name}, sum, sum_sqr);\n");
-                                IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum, sum, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
-                                IndentScope.Writer.IndWrite($"tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
-                                IndentScope.Writer.IndWrite($"instance_norm({Visit(args[0]).Name}, sum, sum_sqr,{Visit(args[3]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, static_cast<{args[0].CheckedDataType.ToC()}>({instancenorm.Epsilon}), {instancenorm.DistType.TensorType.Shape[2]});\n");
-                                break;
-                        }
-
-                        IndentScope.Writer.IndWrite("}\n");
-                    }
-
-                    break;
-                case TIR.XPU.Gather gather:
-                    IndentScope.Writer.Write($"gather({Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {gather.Axis})");
-                    break;
-                case TIR.XPU.Concat concat:
-                    var positiveAxis = concat.Axis > 0 ? concat.Axis : concat.Axis + ((TensorType)args[0].CheckedType).Shape.Rank;
-                    IndentScope.Writer.Write($"concat({{{string.Join(",", args.SkipLast(1).Select(Visit).Select(s => "&" + s.Name))}}}, {Visit(args[^1]).Name}, {positiveAxis})");
-                    break;
-                case TIR.XPU.Slice slice:
-                    var begins = ((TensorConst)expr.Arguments[2]).Value.ToArray<int>();
-                    var ends = ((TensorConst)expr.Arguments[3]).Value.ToArray<int>();
-                    var axes = ((TensorConst)expr.Arguments[4]).Value.ToArray<int>().ToList();
-                    var retType = (TensorType)expr.Arguments[1].CheckedType;
-
-                    var newbegins = Enumerable.Repeat(0, retType.Shape.Rank).ToArray();
-                    var newends = retType.Shape.ToArray();
-                    for (int i = 0; i < slice.DistributedType.Placement.Rank; i++)
-                    {
-                        var sbp = slice.DistributedType.NdSBP[i];
-                        if (sbp is SBPSplit { Axis: int axis })
-                        {
-                            if (axes.IndexOf(axis) is int j && j != -1)
-                            {
-                                begins[j] /= slice.DistributedType.Placement.Hierarchy[i];
-                            }
-                        }
-                    }
-
-                    for (int i = 0; i < newbegins.Length; i++)
-                    {
-                        if (axes.IndexOf(i) is int j && j != -1)
-                        {
-                            newbegins[i] += begins[j];
-                        }
-                    }
-
-                    IndentScope.Writer.Write($"__tensor_copy_sync(std::move({Visit(expr.Arguments[1]).Name}), {Visit(expr.Arguments[0]).Name}({{{string.Join(',', newbegins.Select(e => e.ToString()))}}},{{{string.Join(',', newends.Select(e => e.ToString()))}}}))");
-                    break;
-                case TIR.XPU.Softmax softmax:
-                    {
-                        positiveAxis = softmax.Axis > 0 ? softmax.Axis : softmax.Axis + ((TensorType)args[0].CheckedType).Shape.Rank;
-                        var sbpOnAxis = softmax.DistType.NdSBP.Where(sbp => sbp is SBPSplit s && s.Axis == softmax.Axis).ToArray();
-                        switch (sbpOnAxis.Length)
-                        {
-                            case 0:
-                                IndentScope.Writer.IndWrite($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {positiveAxis}, ctx, reduce_strategy_t::none)");
-                                break;
-                            case 1:
-                                if (sbpOnAxis[0] == softmax.DistType.NdSBP[1])
-                                {
-                                    IndentScope.Writer.IndWrite($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {positiveAxis}, ctx, reduce_strategy_t::by_thread)");
-                                }
-                                else
-                                {
-                                    IndentScope.Writer.IndWrite($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {positiveAxis}, ctx, reduce_strategy_t::by_block)");
-                                }
-
-                                break;
-                            case 2:
-                                IndentScope.Writer.IndWrite($"softmax({Visit(args[0]).Name}, {Visit(args[1]).Name}, {positiveAxis}, ctx, reduce_strategy_t::all)");
-                                break;
-                        }
-                    }
-
-                    break;
-                case TIR.XPU.Transpose transpose:
-                    IndentScope.Writer.Write($"transpose({Visit(args[0]).Name}, {Visit(args[1]).Name}, {{{string.Join(",", transpose.Perm.Select(p => p.ToString()))}}})");
-                    break;
-                case TIR.XPU.ReShape reshape:
-                    IndentScope.Writer.Write($"__tensor_copy_sync(std::move({Visit(args[1]).Name}),std::move(view({Visit(args[0]).Name},{{{args[1].CheckedShape.ToString()[1..^1]}}})))");
-                    break;
-                case TIR.XPU.GatherReduceScatter grs:
-                    var ret_name = Visit(args[1]).Name;
-                    bool reshard = args[0].CheckedType != args[1].CheckedType;
-                    if (reshard)
-                    {
-                        IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> {ret_name}_tmp({{{string.Join(",", args[0].CheckedShape)}}});\n");
-                    }
-                    else
-                    {
-                        IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local>& {ret_name}_tmp = {ret_name};\n");
-                    }
-
-                    if (grs.ReducePosition.Count == 2)
-                    {
-                        IndentScope.Writer.IndWrite($"tdma_all_reduce_async({Visit(args[0]).Name}, {ret_name}_tmp, reduce_op_t::sum, reduce_strategy_t::all, ctx);\n");
-                    }
-                    else if (grs.ReducePosition[0].Hierarchy == 0)
-                    {
-                        IndentScope.Writer.IndWrite($"tdma_all_reduce_async({Visit(args[0]).Name}, {ret_name}_tmp, reduce_op_t::sum, reduce_strategy_t::by_block, ctx);\n");
-                    }
-                    else
-                    {
-                        IndentScope.Writer.IndWrite($"tdma_reduce_async({Visit(args[0]).Name}, {ret_name}_tmp, reduce_op_t::sum, ctx);\n");
-                    }
-
-                    if (reshard)
-                    {
-                        var splitAxis = Enumerable.Range(0, grs.ReducePosition.Count).Select(i => grs.ReducePosition[i].SBP is SBPSplit { Axis: int axis } ? (axis, grs.Placement.Hierarchy[i]) : (0, 1)).ToArray();
-                        var inputShape = args[1].CheckedShape.ToValueArray();
-                        foreach (var sa in splitAxis)
-                        {
-                            inputShape[sa.Item1] *= sa.Item2;
-                        }
-
-                        if (Enumerable.SequenceEqual(inputShape, args[0].CheckedShape.ToValueArray()))
-                        {
-                            IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}), {ret_name}_tmp{args[1].CheckedShape.ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)});\n");
-                        }
-                        else
-                        {
-                            IndentScope.Writer.IndWrite($"tensor<{args[0].CheckedDataType.ToC()}, loc_t::local> {ret_name}_tmp_view = view({ret_name}_tmp, {{{string.Join(",", inputShape)}}});\n");
-                            IndentScope.Writer.IndWrite($"__tensor_copy_sync(std::move({ret_name}),std::move({ret_name}_tmp_view{args[1].CheckedShape.ToSlicing(new IRArray<SBP>(grs.ReducePosition.Select(t => t.SBP)), grs.Placement)}));\n");
-                        }
-                    }
-
-                    break;
-                case TIR.XPU.Conv2D conv:
-                    var sbpOnInChannel = conv.DistType.NdSBP.Where(sbp => sbp is SBPPartialSum).ToArray();
-                    string strategy = sbpOnInChannel.Length switch
-                    {
-                        0 => "reduce_strategy_t::none",
-                        1 when sbpOnInChannel[0] == conv.DistType.NdSBP[1] => "reduce_strategy_t::by_thread",
-                        1 => "reduce_strategy_t::by_block",
-                        2 => "reduce_strategy_t::all",
-                        _ => throw new InvalidOperationException("Invalid length"),
-                    };
-
-                    IndentScope.Writer.Write($"conv2d(ctx, {Visit(args[0]).Name}, {Visit(args[1]).Name}, {Visit(args[2]).Name}, {Visit(args[3]).Name}, {{{string.Join(",", conv.Stride.Select(p => p.ToString()))}}}, {{{string.Join(",", conv.Padding.Select(p => p.ToString()))}}}, {{{string.Join(",", conv.Dilation.Select(p => p.ToString()))}}}, {conv.Groups}, {strategy})");
-                    break;
-                case TIR.XPU.ReduceArg reduceArg:
-                    IndentScope.Writer.Write($"reduce_arg({Visit(args[0]).Name}, {Visit(args[1]).Name}, {reduceArg.Axis}, {reduceArg.KeepDims.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, {reduceArg.SelectLastIndex.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)}, reduce_arg_op_t::{reduceArg.ReduceArgOp.ToC()})");
-                    break;
-                case TIR.XPU.Resize resize:
-                    using (_ = new IndentScope())
-                    {
-                        IndentScope.Writer.IndWrite($"{{\n");
-
-                        IndentScope.Writer.IndWrite($"float roi[{resize.Roi.Count}] = {{{string.Join(",", resize.Roi.Select(p => p.ToString()))}}};\n");
-                        IndentScope.Writer.IndWrite($"int32_t new_size[{resize.NewSize.Count}] = {{{string.Join(",", resize.NewSize.Select(p => p.ToString()))}}};\n");
-                        IndentScope.Writer.IndWrite($"resize({Visit(args[0]).Name}, {Visit(args[1]).Name}, roi, new_size, {resize.CubicCoeffA.ToString()}, {resize.ExcludeOutsideValue.ToString()}, {resize.ExtrapolationValue.ToString()}, image_resize_mode_t::{resize.ResizeMode.ToC()}, image_resize_transformation_mode_t::{resize.TransformationMode.ToC()}, image_resize_nearest_mode_t::{resize.NearestMode.ToC()}, {resize.IsTFResize.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture)});\n");
-
-                        IndentScope.Writer.IndWrite("}\n");
-                    }
-
-                    break;
-                case TIR.XPU.Cast cast:
-                    IndentScope.Writer.Write($"cast({Visit(args[0]).Name}, {Visit(args[1]).Name})");
-                    break;
-                case TIR.XPU.Expand expand:
-                    IndentScope.Writer.Write($"expand({Visit(args[0]).Name}, {Visit(args[1]).Name})");
-                    break;
-                case TIR.XPU.Clamp clamp:
-                    string min = clamp.Min is float.NegativeInfinity ? float.MinValue.ToString() : clamp.Min.ToString();
-                    string max = clamp.Max is float.PositiveInfinity ? float.MaxValue.ToString() : clamp.Max.ToString();
-                    IndentScope.Writer.Write($"clamp({Visit(args[0]).Name}, {Visit(args[1]).Name}, (float){min}, (float){max})");
-                    break;
-                default:
-                    throw new NotSupportedException(xpuOp.ToString());
-            }
-        }
-        else
-        {
-            var arguments = expr.Arguments.AsValueEnumerable().Select(Visit).ToArray();
-            switch (expr.Target)
-            {
-                case IR.Math.Binary op:
-                    str = CSourceUtilities.ContertBinary(op, arguments);
-                    break;
-                case IR.Math.Unary op:
-                    str = CSourceUtilities.ContertUnary(op, arguments);
-                    break;
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        symbol = new(type, str);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitConst(Const expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        string type;
-        string str;
-        if (expr is TensorConst { Value: Tensor { ElementType: PrimType ptype, Shape: { IsScalar: true } } scalar })
-        {
-            str = scalar[0].ToString() switch
-            {
-                "True" => "1",
-                "False" => "0",
-                null => string.Empty,
-                var x => x,
-            };
-
-            type = ptype.ToC();
-        }
-        else if (expr is TensorConst { Value: Tensor { ElementType: PointerType { ElemType: PrimType }, Shape: { IsScalar: true } } pointer })
-        {
-            str = pointer.ToScalar<ulong>().ToString();
-            type = "uint8_t *";
-        }
-        else
-        {
-            throw new NotSupportedException();
-        }
-
-        symbol = new(type, str);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitSequential(Sequential expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        foreach (var field in expr.Fields)
-        {
-            if (field is Call call)
-            {
-                IndentScope.Writer.IndWrite(Visit(call).Name);
-                IndentScope.Writer.Write(";\n");
-            }
-            else
-            {
-                Visit(field);
-            }
-        }
-
-        symbol = new(string.Empty, string.Empty);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    private void DeclBuffer(TIR.Buffer buffer)
-    {
-        if (_exprMemo.ContainsKey(buffer))
-        {
-            return;
-        }
-
-        var symbol = Visit(buffer);
-
-        if (buffer.MemSpan.Location == MemoryLocation.Rdata)
-        {
-            return;
-        }
-
-        IndentScope.Writer.IndWrite($"{symbol.Type} {symbol.Name}({{{string.Join(',', buffer.Dimensions.AsValueEnumerable().Select(Visit).Select(s => s.Name).ToArray())}}});\n");
-    }
-}
-#else
-/// <summary>
-/// convert single prim function to c source.
-/// </summary>
-internal sealed class CSourceConvertVisitor : ExprFunctor<CSymbol, Unit>
-{
-    private readonly Dictionary<Expr, CSymbol> _exprMemo;
-    private readonly StringBuilder _implBuilder;
-    private readonly StringBuilder _declBuilder;
-    private readonly StringWriter _declWriter;
-
-    public CSourceConvertVisitor()
-    {
-        _implBuilder = new StringBuilder();
-        _declBuilder = new StringBuilder();
-        _declWriter = new StringWriter(_declBuilder);
-        _exprMemo = new(ReferenceEqualityComparer.Instance);
-    }
-
-    public PrimFunction VisitEntry => (TIR.PrimFunction)VisitRoot!;
-
-    public FunctionCSource GetFunctionCSource()
-    {
-        return new(_declBuilder.ToString(), _implBuilder.ToString());
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitPrimFunction(PrimFunction expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        if (expr.CheckedType is not CallableType { ReturnType: TupleType r } || r != TupleType.Void)
-        {
-            throw new NotSupportedException("The PrimFunction must return void!");
-        }
-
-        var type = $"void {expr.Name}({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(b => Visit(b.MemSpan.Start).ToString()).ToArray())}, {CSourceBuiltn.FixedParameters})";
-
-        _declWriter.WriteLine(type + ";");
-        _declWriter.WriteLine();
-
-        using (var scope = new IndentScope(_implBuilder))
-        {
-            // 1. Function signature
-            IndentScope.Writer.IndWrite($"{type} {{\n");
-
-            // 2. Function body
-            using (_ = new IndentScope())
-            {
-                Visit(expr.Body);
-            }
-
-            // 3. Function closing
-            IndentScope.Writer.IndWrite("}\n");
-        }
-
-        var ctype = $"void (*{expr.Name})({string.Join(", ", expr.Parameters.AsValueEnumerable().Select(b => Visit(b.MemSpan.Start).ToString()).ToArray())}, {CSourceBuiltn.FixedParameters})";
-        symbol = new(ctype, expr.Name);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitMemSpan(MemSpan expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        var start = Visit(expr.Start);
-        _ = Visit(expr.Size);
-        string name = start.Name;
-        if (expr.Start is TensorConst or Call)
-        {
-            var loc = expr.Location switch
-            {
-                MemoryLocation.Rdata => "rdata",
-                MemoryLocation.Data => "data",
-                _ => throw new NotSupportedException(),
-            };
-            name = $"({loc} + {start.Name})";
-        }
-
-        symbol = new(start.Type, name);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitCall(Call expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        var arguments = expr.Arguments.AsValueEnumerable().Select(Visit).ToArray();
-        string type = expr.CheckedType switch
-        {
-            TupleType x when x == TupleType.Void => string.Empty,
-            TensorType { IsScalar: true } x => x.DType.ToC(),
-            _ => throw new NotSupportedException(),
-        };
-
-        string str;
-        switch (expr.Target)
-        {
-            case IR.Math.Binary op:
-                str = CSourceUtilities.ContertBinary(op, arguments);
-                break;
-            case IR.Math.Unary op:
-                str = CSourceUtilities.ContertUnary(op, arguments);
-                break;
-            case Store:
-                str = $"((({arguments[2].Type} *){arguments[0].Name})[{arguments[1].Name}] = {arguments[2].Name})";
-                break;
-            case Load:
-                str = $"((({type} *){arguments[0].Name})[{arguments[1].Name}])";
-                break;
-            case IR.Buffers.MatchBuffer op:
-                var n = arguments[0].Name;
-                var pb = (TIR.Buffer)expr[IR.Buffers.MatchBuffer.Input];
-                var ind = new string(Enumerable.Repeat<char>(' ', IndentScope.Writer.Indent).ToArray());
-                str = $@"uint32_t _{n}_shape[] = {{ {string.Join(", ", pb.Dimensions.AsValueEnumerable().Select(e => Visit(e).Name).ToArray())} }};
-{ind}uint32_t _{n}_stride[] = {{ {string.Join(", ", pb.Strides.AsValueEnumerable().Select(e => Visit(e).Name).ToArray())} }};
-{ind}buffer_t _{n} = {{
-{ind}{ind}.vaddr = ((uint8_t*) rdata + {Visit(pb.MemSpan.Start).Name}),
-{ind}{ind}.paddr = 0,
-{ind}{ind}.shape = _{n}_shape,
-{ind}{ind}.stride = _{n}_stride,
-{ind}{ind}.rank = {pb.Dimensions.Length} }};
-{ind}buffer_t *{n} = &_{n}";
-                break;
-            default:
-                throw new NotSupportedException();
-        }
-
-        symbol = new(type, str);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitConst(Const expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        string type;
-        string str;
-        if (expr is TensorConst { Value: Tensor { ElementType: PrimType ptype, Shape: { IsScalar: true } } scalar })
-        {
-            str = scalar[0].ToString() switch
-            {
-                "True" => "1",
-                "False" => "0",
-                null => string.Empty,
-                var x => x,
-            };
-
-            type = ptype.ToC();
-        }
-        else if (expr is TensorConst { Value: Tensor { ElementType: PointerType { ElemType: PrimType }, Shape: { IsScalar: true } } pointer })
-        {
-            str = pointer.ToScalar<ulong>().ToString();
-            type = "uint8_t *";
-        }
-        else
-        {
-            throw new NotSupportedException();
-        }
-
-        symbol = new(type, str);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitVar(Var expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        if (expr.CheckedType is not TensorType { Shape: { IsScalar: true } } ttype)
-        {
-            throw new NotSupportedException();
-        }
-
-        symbol = new(ttype.DType.ToC(), new($"{expr.Name}_{expr.GlobalVarIndex}"));
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitFor(For expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        // 1. For Loop signature
-        var loopVar = Visit(expr.LoopVar);
-        IndentScope.Writer.IndWrite($"for ({loopVar.Type} {loopVar.Name} = {Visit(expr.Domain.Start).Name}; {loopVar.Name} < {Visit(expr.Domain.Stop).Name}; {loopVar.Name}+={Visit(expr.Domain.Step).Name}) {{\n");
-
-        if (expr.Mode == LoopMode.Parallel)
-        {
-            // find the vars will be used and make new struct type.
-            var msg_fields = _exprMemo.Where(p => p.Key is MemSpan or TIR.Buffer or Var).Select(p => p.Value).Concat(CSymbol.Builtns).ToArray();
-            var msg_type = DeclThreadMessageStruct(msg_fields);
-
-            using (new IndentScope(_declBuilder))
-            {
-                IndentScope.Writer.IndWrite($"void *{VisitEntry.Name}_inner(void *args) {{\n");
-                using (new IndentScope())
-                {
-                    IndentScope.Writer.IndWrite($"{msg_type}* _message = ({msg_type}*)args;\n");
-                    foreach (var sym in msg_fields)
-                    {
-                        IndentScope.Writer.IndWrite($"{sym.Type} {sym.Name} = _message->{sym.Name};\n");
-                    }
-
-                    Visit(expr.Body);
-                }
-
-                IndentScope.Writer.IndWrite(" return 0;\n");
-                IndentScope.Writer.IndWrite("}\n");
-            }
-
-            using (new IndentScope())
-            {
-                IndentScope.Writer.IndWrite($"{msg_type} _message = {{\n");
-                foreach (var sym in msg_fields)
-                {
-                    IndentScope.Writer.IndWrite($".{sym.Name} = {sym.Name},\n");
-                }
-
-                IndentScope.Writer.IndWrite("};\n");
-
-                IndentScope.Writer.IndWrite($"nncase_mt->thread_start({VisitEntry.Name}_inner, (void *)&_message, sizeof ({msg_type}));\n");
-            }
-        }
-        else
-        {
-            using (_ = new IndentScope())
-            {
-                // 2. For Body
-                Visit(expr.Body);
-            }
-        }
-
-        // 3. For closing
-        IndentScope.Writer.IndWrite("}\n");
-
-        if (expr.Mode == LoopMode.Parallel)
-        {
-            IndentScope.Writer.IndWrite("nncase_mt->thread_end();\n");
-        }
-
-        symbol = new(string.Empty, string.Empty);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitSequential(Sequential expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        foreach (var field in expr.Fields)
-        {
-            if (field is Call call)
-            {
-                IndentScope.Writer.IndWrite(Visit(call).Name);
-                IndentScope.Writer.Write(";\n");
-            }
-            else
-            {
-                Visit(field);
-            }
-        }
-
-        symbol = new(string.Empty, string.Empty);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    /// <inheritdoc/>
-    protected override CSymbol VisitIfThenElse(IfThenElse expr)
-    {
-        if (_exprMemo.TryGetValue(expr, out var symbol))
-        {
-            return symbol;
-        }
-
-        IndentScope.Writer.IndWrite($"if({Visit(expr.Condition).Name}) {{\n");
-        using (_ = new IndentScope())
-        {
-            Visit(expr.Then);
-        }
-
-        IndentScope.Writer.IndWrite("} else {\n");
-        using (_ = new IndentScope())
-        {
-            Visit(expr.Else);
-        }
-
-        IndentScope.Writer.IndWrite("}\n");
-
-        symbol = new(string.Empty, string.Empty);
-        _exprMemo.Add(expr, symbol);
-        return symbol;
-    }
-
-    private string DeclThreadMessageStruct(IEnumerable<CSymbol> keyValues)
-    {
-        var type = $"{VisitEntry.Name}_thread_message_t";
-        _declWriter.WriteLine("typedef struct {");
-        foreach (var sym in keyValues)
-        {
-            if (sym.Name == string.Empty)
-            {
-                throw new InvalidOperationException("empty name");
-            }
-
-            _declWriter.WriteLine("  " + sym.Type + " " + sym.Name + ";");
-        }
-
-        _declWriter.WriteLine($"}} {type};");
-        _declWriter.WriteLine();
-        return type;
-    }
-}
-#endif
diff --git a/modules/Nncase.Modules.XPU/CodeGen/CSourceExtensions.cs b/modules/Nncase.Modules.XPU/CodeGen/CSourceExtensions.cs
deleted file mode 100644
index 627372e39c..0000000000
--- a/modules/Nncase.Modules.XPU/CodeGen/CSourceExtensions.cs
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR;
-
-namespace Nncase.CodeGen.XPU;
-
-/// <summary>
-/// convert the type/op to c name.
-/// </summary>
-internal static class CSourceExtensions
-{
-    private static readonly Dictionary<PrimType, string> _primTypeToC = new()
-    {
-        { DataTypes.Boolean, "uint8_t" },
-        { DataTypes.Int8, "int8_t" },
-        { DataTypes.Int16, "int16_t" },
-        { DataTypes.Int32, "int32_t" },
-        { DataTypes.Int64, "int64_t" },
-        { DataTypes.UInt8, "uint8_t" },
-        { DataTypes.UInt16, "uint16_t" },
-        { DataTypes.UInt32, "uint32_t" },
-        { DataTypes.UInt64, "uint64_t" },
-        { DataTypes.Float32, "float" },
-        { DataTypes.Float64, "double" },
-    };
-
-    public static string ToC(this PrimType primType) =>
-        _primTypeToC[primType];
-
-    public static string ToC(this ReduceArgOp op) => op switch
-    {
-        ReduceArgOp.ArgMin => "arg_min",
-        ReduceArgOp.ArgMax => "arg_max",
-        _ => throw new NotImplementedException(),
-    };
-
-    public static string ToC(this DataType dataType) => dataType switch
-    {
-        PrimType ptype => ptype.ToC(),
-        PointerType => "uint8_t *",
-        _ => throw new NotSupportedException(dataType.ToString()),
-    };
-
-    public static string ToC(this MemoryLocation location) => location switch
-    {
-        MemoryLocation.Output or MemoryLocation.Input or MemoryLocation.Rdata => "loc_t::device",
-        MemoryLocation.L2Data => "loc_t::shared",
-        MemoryLocation.L1Data => "loc_t::local",
-        _ => throw new NotSupportedException(location.ToString()),
-    };
-
-    public static string ToC(this ImageResizeMode mode) => mode switch
-    {
-        ImageResizeMode.Bilinear => "bilinear",
-        ImageResizeMode.NearestNeighbor => "nearest_neighbor",
-        _ => throw new NotImplementedException(),
-    };
-
-    public static string ToC(this ImageResizeTransformationMode mode) => mode switch
-    {
-        ImageResizeTransformationMode.HalfPixel => "half_pixel",
-        ImageResizeTransformationMode.PytorchHalfPixel => "pytorch_half_pixel",
-        ImageResizeTransformationMode.AlignCorners => "align_corners",
-        ImageResizeTransformationMode.Asymmetric => "asymmetric",
-        ImageResizeTransformationMode.TFCropAndResize => "tfcrop_and_resize",
-        _ => throw new NotImplementedException(),
-    };
-
-    public static string ToC(this ImageResizeNearestMode mode) => mode switch
-    {
-        ImageResizeNearestMode.RoundPreferFloor => "round_prefer_floor",
-        ImageResizeNearestMode.RoundPreferCeil => "round_prefer_ceil",
-        ImageResizeNearestMode.Floor => "floor",
-        ImageResizeNearestMode.Ceil => "ceil",
-        _ => throw new NotImplementedException(),
-    };
-
-    public static string ToSlicing(this Shape shape, string[] begins, IRArray<SBP> ndsbp, Placement placement)
-    {
-        var hstrides = TensorUtilities.GetStrides(placement.Hierarchy.ToArray());
-        var splits = Enumerable.Range(0, begins.Length).Select(_ => new List<(int H, SBPSplit S)>()).ToArray();
-        foreach (var (sbp, i) in ndsbp.Select((s, i) => (s, i)))
-        {
-            if (sbp is SBPSplit { Axis: int axis } split)
-            {
-                splits[axis].Add((i, split));
-            }
-        }
-
-        foreach (var splist in splits)
-        {
-            splist.Sort((a, b) => -a.H.CompareTo(b.H));
-        }
-
-        for (int i = 0; i < begins.Length; i++)
-        {
-            var sp = splits[i];
-            if (sp.Count > 0)
-            {
-                begins[i] += " + " + sp.Skip(1).Aggregate($"{placement.Name[sp[0].H]}id", (acc, p) => $"({acc} + {TensorUtilities.GetProduct(placement.Hierarchy[(p.H + 1)..])} * {placement.Name[p.H]}id)") + $" * {shape[i]}";
-            }
-        }
-
-        return $"({{{string.Join(',', begins)}}}, {{{string.Join(",", shape)}}})";
-    }
-
-    public static string ToSlicing(this Shape shape, IRArray<SBP> ndsbp, Placement placement) => ToSlicing(shape, Enumerable.Repeat("0", shape.Rank).ToArray(), ndsbp, placement);
-
-    public static string ToC(this BinaryOp binaryOp) => binaryOp switch
-    {
-        BinaryOp.Add => "+",
-        BinaryOp.Sub => "-",
-        BinaryOp.Mul => "*",
-        BinaryOp.Div => "/",
-        _ => throw new NotSupportedException(binaryOp.ToString()),
-    };
-}
diff --git a/modules/Nncase.Modules.XPU/CodeGen/CSourceUtilities.cs b/modules/Nncase.Modules.XPU/CodeGen/CSourceUtilities.cs
deleted file mode 100644
index 5ab831b64c..0000000000
--- a/modules/Nncase.Modules.XPU/CodeGen/CSourceUtilities.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.Globalization;
-using Nncase.Diagnostics;
-using Nncase.IR.Math;
-
-namespace Nncase.CodeGen.XPU;
-
-internal static class CSourceUtilities
-{
-    public static string ContertBinary(Binary binary, CSymbol[] arguments)
-    {
-        var lhs = arguments[Binary.Lhs.Index].Name;
-        var rhs = arguments[Binary.Rhs.Index].Name;
-        string str;
-        switch (binary.BinaryOp)
-        {
-            case BinaryOp.Add or BinaryOp.Sub or BinaryOp.Mul or BinaryOp.Div:
-                str = $"({lhs} {binary.BinaryOp.ToC()} {rhs})";
-                break;
-            default:
-                throw new NotSupportedException();
-        }
-
-        return str;
-    }
-
-    internal static string ContertUnary(Unary op, CSymbol[] arguments)
-    {
-        var input = arguments[Unary.Input.Index].Name;
-        string str;
-        switch (op.UnaryOp)
-        {
-            default:
-                str = $"nncase_mt->{arguments[0].Type}_{nameof(Unary).ToLower(CultureInfo.CurrentCulture)}_{op.UnaryOp.ToString().ToLower(CultureInfo.CurrentCulture)}{input}";
-                break;
-        }
-
-        return str;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/CodeGen/FunctionBuilder.cs b/modules/Nncase.Modules.XPU/CodeGen/FunctionBuilder.cs
deleted file mode 100644
index 4af770852a..0000000000
--- a/modules/Nncase.Modules.XPU/CodeGen/FunctionBuilder.cs
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-#pragma warning disable
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading.Tasks;
-using NetFabric.Hyperlinq;
-using Nncase.IR;
-
-namespace Nncase.CodeGen.XPU;
-
-/// <summary>
-/// StackVM function builder.
-/// </summary>
-internal class FunctionBuilder : IDisposable
-{
-    private readonly uint _id;
-    private readonly SectionManager _sectionManager;
-    private readonly BinaryWriter _textWriter;
-    private readonly BinaryWriter _rdataWriter;
-
-    /// <summary>
-    /// NOTE sync with the k230 runtime function.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    private struct MemoryRange
-    {
-        public uint Start;
-        public uint Size;
-    }
-
-    /// <summary>
-    /// NOTE sync with the k230 runtime function.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    private unsafe struct DescHeader
-    {
-        /// <summary>
-        /// input pool size.
-        /// </summary>
-        public uint InputPoolSize;
-
-        /// <summary>
-        /// output pool size.
-        /// </summary>
-        public uint OutputPoolSize;
-
-        /// <summary>
-        /// input numbers.
-        /// </summary>
-        public uint Inputs;
-
-        /// <summary>
-        /// output numbers.
-        /// </summary>
-        public uint Outputs;
-    }
-
-    public FunctionBuilder(uint id, BinaryWriter rdataWriter)
-    {
-        _id = id;
-        _sectionManager = new();
-        _textWriter = _sectionManager.GetWriter(WellknownSectionNames.Text);
-        _rdataWriter = rdataWriter;
-    }
-
-    public unsafe LinkableFunction Build(TIR.PrimFunction function)
-    {
-        // 1. convert func to csource
-        var visitor = new CSourceConvertVisitor();
-        visitor.Visit(function);
-        var functionCSource = visitor.GetFunctionCSource();
-
-        // 3. write the rdata
-        foreach (var (@const, range) in function.SchedResult.Rdatas)
-        {
-            var bytes = ((TensorConst)@const).Value.BytesBuffer;
-            var size = range.Max - range.Min;
-            if ((uint)bytes.Length != size)
-            {
-                throw new InvalidDataException("The Buffer Szie Not Equal!");
-            }
-
-            _rdataWriter.Position(range.Min);
-            _rdataWriter.Write(bytes);
-        }
-
-        return new LinkableFunction(_id, function, functionCSource, _sectionManager.GetContent(WellknownSectionNames.Text));
-    }
-
-    public void Dispose()
-    {
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/CodeGen/FunctionCSource.cs b/modules/Nncase.Modules.XPU/CodeGen/FunctionCSource.cs
deleted file mode 100644
index 64fb966d7d..0000000000
--- a/modules/Nncase.Modules.XPU/CodeGen/FunctionCSource.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-#define MULTI_CORE_XPU
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Text;
-using Nncase.IR;
-using Nncase.Schedule;
-using Nncase.TIR;
-
-namespace Nncase.CodeGen;
-
-#if MULTI_CORE_XPU
-internal sealed record FunctionCSource(string Main, string Shared, string Kernel)
-{
-}
-
-#else
-internal sealed class FunctionCSource
-{
-    public FunctionCSource(string declaration, string implementation)
-    {
-        Declaration = declaration;
-        Implementation = implementation;
-    }
-
-    public string Declaration { get; }
-
-    public string Implementation { get; }
-}
-#endif
diff --git a/modules/Nncase.Modules.XPU/CodeGen/LinkableFunction.cs b/modules/Nncase.Modules.XPU/CodeGen/LinkableFunction.cs
deleted file mode 100644
index acf5c9d418..0000000000
--- a/modules/Nncase.Modules.XPU/CodeGen/LinkableFunction.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.Runtime.InteropServices;
-using Nncase.IR;
-
-namespace Nncase.CodeGen.XPU;
-
-internal sealed class LinkableFunction : ILinkableFunction
-{
-    public LinkableFunction(uint id, TIR.PrimFunction sourceFunction, FunctionCSource funcCSource, Stream text)
-    {
-        Id = id;
-        SourceFunction = sourceFunction;
-        PrimFunction = sourceFunction;
-        FunctionCSource = funcCSource;
-        Text = text;
-        Sections = Array.Empty<ILinkedSection>();
-    }
-
-    public uint Id { get; }
-
-    public BaseFunction SourceFunction { get; }
-
-    public TIR.PrimFunction PrimFunction { get; }
-
-    public FunctionCSource FunctionCSource { get; }
-
-    public Stream Text { get; }
-
-    public IEnumerable<FunctionRef> FunctionRefs => Enumerable.Empty<FunctionRef>();
-
-    public IReadOnlyList<ILinkedSection> Sections { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/CodeGen/LinkableModule.cs b/modules/Nncase.Modules.XPU/CodeGen/LinkableModule.cs
deleted file mode 100644
index d674afcbc4..0000000000
--- a/modules/Nncase.Modules.XPU/CodeGen/LinkableModule.cs
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.Diagnostics;
-using Nncase.Runtime.StackVM;
-
-namespace Nncase.CodeGen.XPU;
-
-internal sealed class LinkableModule : ILinkableModule
-{
-    private const int _textAlignment = 8;
-
-    private readonly Stream _rdata;
-
-    private readonly IReadOnlyList<LinkableFunction> _functions;
-    private readonly CompileOptions _options;
-
-    public LinkableModule(Stream rdata, IReadOnlyList<LinkableFunction> functions, CompileOptions options)
-    {
-        _rdata = rdata;
-        _functions = functions;
-        _options = options;
-    }
-
-    public ILinkedModule Link(ILinkContext linkContext)
-    {
-        // var csourcePath = LinkCSources();
-        if (_options.DumpFlags.HasFlag(DumpFlags.CodeGen))
-        {
-            foreach (var func in _functions)
-            {
-                var dumpPath = Path.Join(_options.DumpDir, func.PrimFunction.Name);
-                if (!Directory.Exists(dumpPath))
-                {
-                    Directory.CreateDirectory(dumpPath);
-                }
-
-                using (var fs = File.Open(Path.Join(dumpPath, "cluster_def.h"), FileMode.Create))
-                {
-                    using (var writer = new StreamWriter(fs))
-                    {
-                        writer.Write(CSourceBuiltn.ClusterDef());
-                    }
-                }
-
-                using (var fs = File.Open(Path.Join(dumpPath, "main.cpp"), FileMode.Create))
-                {
-                    using (var writer = new StreamWriter(fs))
-                    {
-                        writer.Write(func.FunctionCSource.Main);
-                    }
-                }
-
-                using (var fs = File.Open(Path.Join(dumpPath, "shared.h"), FileMode.Create))
-                {
-                    using (var writer = new StreamWriter(fs))
-                    {
-                        writer.Write(func.FunctionCSource.Shared);
-                    }
-                }
-
-                using (var fs = File.Open(Path.Join(dumpPath, "kernel.h"), FileMode.Create))
-                {
-                    using (var writer = new StreamWriter(fs))
-                    {
-                        writer.Write(func.FunctionCSource.Kernel);
-                    }
-                }
-
-                using (var fs = File.Open(Path.Join(dumpPath, "CMakeLists.txt"), FileMode.Create))
-                {
-                    using (var writer = new StreamWriter(fs))
-                    {
-                        writer.Write(CSourceBuiltn.CMakeDef(func.PrimFunction.Name));
-                    }
-                }
-            }
-
-            // using (var fs = File.Open(Path.Join(dumpPath, "xpuModule.h"), FileMode.Create))
-            // {
-            //     using (var writer = new StreamWriter(fs))
-            //     {
-            //         writer.Write(CSourceBuiltn.Header);
-            //     }
-            // }
-
-            // using (var fs = File.Open(Path.Join(dumpPath, "xpuModule.c"), FileMode.Create))
-            // {
-            //     File.Open(csourcePath, FileMode.Open, FileAccess.Read).CopyTo(fs);
-            // }
-        }
-
-        var manager = new SectionManager();
-        var textWriter = manager.GetWriter(WellknownSectionNames.Text);
-        var linkedFunctions = new List<LinkedFunction>();
-        int offset = 0;
-        foreach (var func in _functions)
-        {
-            var dumpPath = Path.Join(_options.DumpDir, func.PrimFunction.Name);
-            var elfPath = CompileCSource(dumpPath);
-
-            var func_text = File.ReadAllBytes(elfPath);
-            textWriter.Write(func_text);
-            linkedFunctions.Add(new LinkedFunction(func.Id, func.SourceFunction, (uint)offset, (uint)func_text.Length, func.Sections));
-            offset += func_text.Length;
-        }
-
-        return new LinkedModule(linkedFunctions, manager.GetContent(WellknownSectionNames.Text)!, _rdata);
-    }
-
-    // private string LinkCSources()
-    // {
-    // writer.WriteLine(CSourceBuiltn.MakeHeader(_functions));
-    // foreach (var func in _functions)
-    // {
-    //     var path = Path.GetTempFileName() + ".cpp";
-    //     using (var fs = File.OpenWrite(path))
-    //     {
-    //         using (var writer = new StreamWriter(fs))
-    //         {
-    //             writer.WriteLine(CSourceBuiltn.MakeHeader(_functions));
-    //         }
-    //     }
-    // }
-    // return path;
-    // }
-    private string CompileCSource(string sourcePath)
-    {
-        var compiler = new CSourceCompiler();
-        return compiler.Compile(sourcePath, Path.Join(sourcePath, "build", Path.GetFileName(sourcePath)));
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/CodeGen/LinkedModule.cs b/modules/Nncase.Modules.XPU/CodeGen/LinkedModule.cs
deleted file mode 100644
index 45a5ba8ac6..0000000000
--- a/modules/Nncase.Modules.XPU/CodeGen/LinkedModule.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.Runtime.StackVM;
-
-namespace Nncase.CodeGen.XPU;
-
-internal sealed class LinkedModule : ILinkedModule
-{
-    public LinkedModule(IReadOnlyList<ILinkedFunction> functions, Stream text, Stream rdata)
-    {
-        Functions = functions;
-        Sections = new[]
-        {
-            new LinkedSection(text, WellknownSectionNames.Text, 0, 8, (ulong)text.Length),
-            new LinkedSection(rdata, WellknownSectionNames.Rdata, 0, 8, (ulong)rdata.Length),
-        };
-    }
-
-    public string ModuleKind => Targets.XPUTarget.Kind;
-
-    public uint Version => 0;
-
-    public IReadOnlyList<ILinkedFunction> Functions { get; }
-
-    public IReadOnlyList<ILinkedSection> Sections { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/CodeGen/ModuleBuilder.cs b/modules/Nncase.Modules.XPU/CodeGen/ModuleBuilder.cs
deleted file mode 100644
index e17535a208..0000000000
--- a/modules/Nncase.Modules.XPU/CodeGen/ModuleBuilder.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.Text;
-using Nncase.Diagnostics;
-using Nncase.IR;
-
-namespace Nncase.CodeGen.XPU;
-
-/// <summary>
-/// K230CoreModule builder.
-/// </summary>
-public sealed class ModuleBuilder : IModuleBuilder
-{
-    private readonly SectionManager _sectionManager;
-    private readonly BinaryWriter _rdataWriter;
-
-    public ModuleBuilder(CompileOptions options)
-    {
-        _sectionManager = new();
-        _rdataWriter = _sectionManager.GetWriter(WellknownSectionNames.Rdata);
-        CompileOptions = options;
-    }
-
-    public CompileOptions CompileOptions { get; }
-
-    /// <inheritdoc/>
-    public string ModuleKind => Targets.XPUTarget.Kind;
-
-    /// <inheritdoc/>
-    public ILinkableModule Build(IReadOnlyList<BaseFunction> functions)
-    {
-        var linkableFunctions = functions.OfType<TIR.PrimFunction>().Select((f, i) => new FunctionBuilder((uint)i, _rdataWriter).Build(f)).ToArray();
-        _rdataWriter.Flush();
-
-        return new LinkableModule(_sectionManager.GetContent(WellknownSectionNames.Rdata)!, linkableFunctions, CompileOptions);
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/Boxing.cs b/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/Boxing.cs
deleted file mode 100644
index bc8229f6ae..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/Boxing.cs
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-#pragma warning disable SA1010, SA1008
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Nncase.CostModel;
-using Nncase.IR;
-using Nncase.IR.CPU;
-using Nncase.Utilities;
-
-namespace Nncase.Evaluator.IR.CPU;
-
-public sealed class BoxingEvaluator : ITypeInferencer<Boxing>, ICostEvaluator<Boxing>, IEvaluator<Boxing>
-{
-    private const int _burstLength = 256;
-
-    public IRType Visit(ITypeInferenceContext context, Boxing target)
-    {
-        return target.NewType;
-    }
-
-    public Cost Visit(ICostEvaluateContext context, Boxing target)
-    {
-        var inType = context.GetArgumentType<IRType>(target, Boxing.Input);
-        var returnType = context.GetReturnType<IRType>();
-        var cost = new Cost() { [CostFactorNames.MemoryLoad] = 0, [CostFactorNames.MemoryStore] = 0 };
-        switch (inType, returnType)
-        {
-            case (TensorType tensorType, DistributedType distTensorType):
-                cost = new Cost()
-                {
-                    [CostFactorNames.MemoryLoad] = CostUtility.GetMemoryAccess(tensorType),
-                    [CostFactorNames.MemoryStore] = (UInt128)((float)CostUtility.GetMemoryAccess(distTensorType) / DistributedUtility.GetDividedTensorEfficiency(distTensorType, _burstLength)),
-                };
-                break;
-            case (DistributedType distTensorType, TensorType tensorType):
-                cost = new Cost()
-                {
-                    [CostFactorNames.MemoryLoad] = (UInt128)((float)CostUtility.GetMemoryAccess(distTensorType) / DistributedUtility.GetDividedTensorEfficiency(distTensorType, _burstLength)),
-                    [CostFactorNames.MemoryStore] = CostUtility.GetMemoryAccess(tensorType),
-                };
-                break;
-
-            case (DistributedType a, DistributedType b) when a.Placement == b.Placement && a.NdSBP != b.NdSBP:
-                {
-                    var fullLoadStore = new Cost()
-                    {
-                        [CostFactorNames.MemoryStore] = (UInt128)((float)CostUtility.GetMemoryAccess(a) / DistributedUtility.GetDividedTensorEfficiency(a, _burstLength)),
-                        [CostFactorNames.MemoryLoad] = (UInt128)((float)CostUtility.GetMemoryAccess(b) / DistributedUtility.GetDividedTensorEfficiency(b, _burstLength)),
-                    };
-
-                    float scatterPart = 1;
-                    float gatherPart = 1;
-                    for (int i = 0; i < a.Placement.Rank; i++)
-                    {
-                        switch (a.NdSBP[i], b.NdSBP[i])
-                        {
-                            case (SBPSplit { Axis: int ax }, SBP sbpout):
-                                switch (sbpout)
-                                {
-                                    case SBPSplit { Axis: int bx }:
-                                        if (ax != bx)
-                                        {
-                                            // when split different axis, need global load store.
-                                            return fullLoadStore;
-                                        }
-
-                                        break;
-                                    case SBPBroadCast:
-                                        scatterPart *= a.Placement.Hierarchy[i];
-                                        gatherPart *= a.Placement.Hierarchy[i];
-                                        break;
-                                    default:
-                                        throw new NotSupportedException("split to partial");
-                                }
-
-                                break;
-                            case (SBPBroadCast, SBPBroadCast or SBPSplit):
-                                // no cost.
-                                cost += new Cost()
-                                {
-                                    [CostFactorNames.CPUCycles] = 1,
-                                };
-                                break;
-                            case (SBPPartialSum, SBP sbpout):
-                                switch (sbpout)
-                                {
-                                    case SBPPartialSum:
-                                        break;
-                                    case SBPBroadCast or SBPSplit:
-                                        gatherPart *= a.Placement.Hierarchy[i];
-                                        if (i == 0)
-                                        {
-                                            scatterPart *= a.Placement.Hierarchy[i];
-                                        }
-
-                                        break;
-                                }
-
-                                break;
-                            default:
-                                throw new NotSupportedException($"{a} to {b}");
-                        }
-                    }
-
-                    if (gatherPart > 1f)
-                    {
-                        cost += new Cost()
-                        {
-                            [CostFactorNames.MemoryStore] = (UInt128)((gatherPart - 1) * (float)CostUtility.GetMemoryAccess(DistributedUtility.GetDividedTensorType(a)) / gatherPart),
-                        };
-                    }
-
-                    if (scatterPart > 1f)
-                    {
-                        cost += new Cost()
-                        {
-                            [CostFactorNames.MemoryLoad] = (UInt128)((scatterPart - 1) * (float)CostUtility.GetMemoryAccess(DistributedUtility.GetDividedTensorType(b)) / scatterPart),
-                        };
-                    }
-                }
-
-                break;
-            case (DistributedType a, DistributedType b) when a.TensorType != b.TensorType && a.Placement == b.Placement:
-                cost = new Cost()
-                {
-                    [CostFactorNames.MemoryStore] = (UInt128)((float)CostUtility.GetMemoryAccess(a) / DistributedUtility.GetDividedTensorEfficiency(a, _burstLength)),
-                    [CostFactorNames.MemoryLoad] = (UInt128)((float)CostUtility.GetMemoryAccess(b) / DistributedUtility.GetDividedTensorEfficiency(b, _burstLength)),
-                };
-                break;
-            case (DistributedType a, DistributedType b) when a == b:
-                throw new InvalidOperationException($"the boxing inType == outType");
-            default:
-                throw new NotSupportedException($"{inType} {returnType}");
-        }
-
-        return cost;
-    }
-
-    public IValue Visit(IEvaluateContext context, Boxing target)
-    {
-        return context.GetArgumentValue(target, Boxing.Input);
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUKernelOp.cs b/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUKernelOp.cs
deleted file mode 100644
index 39e1f58601..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUKernelOp.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Linq;
-using Nncase.CostModel;
-using Nncase.IR;
-using Nncase.IR.CPU;
-
-namespace Nncase.Evaluator.IR.CPU;
-
-/// <summary>
-/// Evaluator for <see cref="CPUKernelOp"/>.
-/// </summary>
-public class CPUKernelOpEvaluator : IEvaluator<CPUKernelOp>, ITypeInferencer<CPUKernelOp>, ICostEvaluator<CPUKernelOp>
-{
-    /// <inheritdoc/>
-    public IValue Visit(IEvaluateContext context, CPUKernelOp target)
-    {
-        return CompilerServices.EvaluateOp(target.Target, context);
-    }
-
-    /// <inheritdoc/>
-    public IRType Visit(ITypeInferenceContext context, CPUKernelOp target)
-    {
-        return CompilerServices.InferenceOp(target.Target, context, new());
-    }
-
-    /// <inheritdoc/>
-    public Cost Visit(ICostEvaluateContext context, CPUKernelOp target)
-    {
-        return CompilerServices.EvaluateOpCost(target.Target, context);
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUModule.cs b/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUModule.cs
deleted file mode 100644
index 10c4ce0ad8..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/IR/CPU/CPUModule.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using DryIoc;
-using Nncase.Hosting;
-
-namespace Nncase.Evaluator.IR.CPU;
-
-/// <summary>
-/// CPU module.
-/// </summary>
-internal class CPUModule : IApplicationPart
-{
-    public void ConfigureServices(IRegistrator registrator)
-    {
-        registrator.RegisterManyInterface<CPUKernelOpEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<BoxingEvaluator>(reuse: Reuse.Singleton);
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Binary.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Binary.cs
deleted file mode 100644
index 2e269b2c3a..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Binary.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class BinaryEvaluator : ITypeInferencer<Binary>
-{
-    public IRType Visit(ITypeInferenceContext context, Binary target)
-    {
-        return TupleType.Void;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Cast.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Cast.cs
deleted file mode 100644
index d1400e1bdb..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Cast.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class CastEvaluator : ITypeInferencer<Cast>
-{
-    public IRType Visit(ITypeInferenceContext context, Cast target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Clamp.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Clamp.cs
deleted file mode 100644
index c9b803b216..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Clamp.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class ClampEvaluator : ITypeInferencer<Clamp>
-{
-    public IRType Visit(ITypeInferenceContext context, Clamp target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Concat.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Concat.cs
deleted file mode 100644
index 27400dee3d..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Concat.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class ConcatEvaluator : ITypeInferencer<Concat>
-{
-    public IRType Visit(ITypeInferenceContext context, Concat target)
-    {
-        return TupleType.Void;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Conv2D.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Conv2D.cs
deleted file mode 100644
index 049c34ba9b..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Conv2D.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public class Conv2DEvaluator : ITypeInferencer<Conv2D>
-{
-    public IRType Visit(ITypeInferenceContext context, Conv2D target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Expand.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Expand.cs
deleted file mode 100644
index d33ea69e2b..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Expand.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class ExpandEvaluator : ITypeInferencer<Expand>
-{
-    public IRType Visit(ITypeInferenceContext context, Expand target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Gather.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Gather.cs
deleted file mode 100644
index 1287e24e7e..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Gather.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class GatherEvaluator : ITypeInferencer<Gather>
-{
-    public IRType Visit(ITypeInferenceContext context, Gather target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/GatherReduceScatter.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/GatherReduceScatter.cs
deleted file mode 100644
index f3e40a95e6..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/GatherReduceScatter.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public class GatherReduceScatterEvaluator : ITypeInferencer<GatherReduceScatter>
-{
-    public IRType Visit(ITypeInferenceContext context, GatherReduceScatter target)
-    {
-        _ = context.CheckArgumentType<IRType>(target, GatherReduceScatter.Input);
-        _ = context.CheckArgumentType<IRType>(target, GatherReduceScatter.Output);
-        return TupleType.Void;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/InstanceNorm.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/InstanceNorm.cs
deleted file mode 100644
index b4751f51bb..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/InstanceNorm.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class InstanceNormEvaluator : ITypeInferencer<InstanceNorm>
-{
-    public IRType Visit(ITypeInferenceContext context, InstanceNorm target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/LayerNorm.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/LayerNorm.cs
deleted file mode 100644
index e00af493a1..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/LayerNorm.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class LayerNormEvaluator : ITypeInferencer<LayerNorm>
-{
-    public IRType Visit(ITypeInferenceContext context, LayerNorm target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Matmul.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Matmul.cs
deleted file mode 100644
index fb7db656fe..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Matmul.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class MatmulEvaluator : ITypeInferencer<Matmul>
-{
-    public IRType Visit(ITypeInferenceContext context, Matmul target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReShape.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReShape.cs
deleted file mode 100644
index 933184bee5..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReShape.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class ReShapeEvaluator : ITypeInferencer<ReShape>
-{
-    public IRType Visit(ITypeInferenceContext context, ReShape target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReduceArg.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReduceArg.cs
deleted file mode 100644
index 25f7b665b0..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/ReduceArg.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class ReduceArgEvaluator : ITypeInferencer<ReduceArg>
-{
-    public IRType Visit(ITypeInferenceContext context, ReduceArg target)
-    {
-        return TupleType.Void;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Resize.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Resize.cs
deleted file mode 100644
index 3ef07f9224..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Resize.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class ResizeEvaluator : ITypeInferencer<Resize>
-{
-    public IRType Visit(ITypeInferenceContext context, Resize target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Slice.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Slice.cs
deleted file mode 100644
index 7f46705790..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Slice.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class SliceEvaluator : ITypeInferencer<Slice>
-{
-    public IRType Visit(ITypeInferenceContext context, Slice target)
-    {
-        return TupleType.Void;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Softmax.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Softmax.cs
deleted file mode 100644
index c6aa508b4e..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Softmax.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class SoftmaxEvaluator : ITypeInferencer<Softmax>
-{
-    public IRType Visit(ITypeInferenceContext context, Softmax target) => TupleType.Void;
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/SwishB.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/SwishB.cs
deleted file mode 100644
index 9b3de37742..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/SwishB.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.Evaluator;
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase;
-
-public sealed class SwishBEvaluator : ITypeInferencer<SwishB>
-{
-    public IRType Visit(ITypeInferenceContext context, SwishB target)
-    {
-        context.CheckArgumentType<TensorType>(target, SwishB.Input);
-        context.CheckArgumentType<TensorType>(target, SwishB.Output);
-        return TupleType.Void;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMALoad.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMALoad.cs
deleted file mode 100644
index 0a38a27837..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMALoad.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public class TDMALoadEvaluator : ITypeInferencer<TDMALoad>
-{
-    public IRType Visit(ITypeInferenceContext context, TDMALoad target)
-    {
-        _ = context.CheckArgumentType<TensorType>(target, TDMALoad.Dest);
-        _ = context.CheckArgumentType<IRType>(target, TDMALoad.Src);
-        return TupleType.Void;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMAStore.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMAStore.cs
deleted file mode 100644
index f2c60f7f32..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/TDMAStore.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class TDMAStoreEvaluator : ITypeInferencer<TDMAStore>
-{
-    public IRType Visit(ITypeInferenceContext context, TDMAStore target)
-    {
-        _ = context.CheckArgumentType<TensorType>(target, TDMAStore.Src);
-        _ = context.CheckArgumentType<IRType>(target, TDMAStore.Dest);
-        return TupleType.Void;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Transpose.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Transpose.cs
deleted file mode 100644
index cfaeb31294..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Transpose.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-public sealed class TransposeEvaluator : ITypeInferencer<Transpose>
-{
-    public IRType Visit(ITypeInferenceContext context, Transpose target)
-    {
-        return TupleType.Void;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Unary.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Unary.cs
deleted file mode 100644
index 7bbac1a94f..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/Unary.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using Nncase.Evaluator;
-using Nncase.IR;
-using Nncase.TIR.XPU;
-
-namespace Nncase;
-
-public sealed class UnaryEvaluator : ITypeInferencer<Unary>
-{
-    public IRType Visit(ITypeInferenceContext context, Unary target)
-    {
-        context.CheckArgumentType<TensorType>(target, Unary.Input);
-        context.CheckArgumentType<TensorType>(target, Unary.Output);
-        return TupleType.Void;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/XPUModule.cs b/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/XPUModule.cs
deleted file mode 100644
index c647696375..0000000000
--- a/modules/Nncase.Modules.XPU/Evaluator/TIR/XPU/XPUModule.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using DryIoc;
-using Nncase.Evaluator.Imaging;
-using Nncase.Evaluator.NN;
-using Nncase.Evaluator.Tensors;
-using Nncase.Hosting;
-
-namespace Nncase.Evaluator.TIR.XPU;
-
-/// <summary>
-/// XPU module.
-/// </summary>
-internal class XPUModule : IApplicationPart
-{
-    public void ConfigureServices(IRegistrator registrator)
-    {
-        registrator.RegisterManyInterface<TDMALoadEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<TDMAStoreEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<UnaryEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<SwishBEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<BinaryEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<MatmulEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<LayerNormEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<InstanceNormEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<GatherEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<ConcatEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<SliceEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<SoftmaxEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<TransposeEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<ReShapeEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<GatherReduceScatterEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<Conv2DEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<ReduceArgEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<ResizeEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<CastEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<ExpandEvaluator>(reuse: Reuse.Singleton);
-        registrator.RegisterManyInterface<ClampEvaluator>(reuse: Reuse.Singleton);
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/IR/CPU/Boxing.cs b/modules/Nncase.Modules.XPU/IR/CPU/Boxing.cs
deleted file mode 100644
index d86c10bdaf..0000000000
--- a/modules/Nncase.Modules.XPU/IR/CPU/Boxing.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.PatternMatch;
-
-namespace Nncase.IR.CPU;
-
-/// <summary>
-/// Boxing expression.
-/// </summary>
-[PatternFunctionalGenerator]
-public sealed partial class Boxing : Op
-{
-    /// <summary>
-    /// Gets input.
-    /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(Boxing), 0, "input");
-
-    public IRType NewType { get; }
-
-    /// <inheritdoc/>
-    public override string DisplayProperty() => $"{NewType}";
-}
diff --git a/modules/Nncase.Modules.XPU/IR/CPU/CPUKernelOp.cs b/modules/Nncase.Modules.XPU/IR/CPU/CPUKernelOp.cs
deleted file mode 100644
index 22a75beb56..0000000000
--- a/modules/Nncase.Modules.XPU/IR/CPU/CPUKernelOp.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR.Math;
-using Nncase.PatternMatch;
-
-namespace Nncase.IR.CPU;
-
-public sealed class CPUKernelOp : Op
-{
-    private readonly ExprPinner _exprPinner;
-
-    public CPUKernelOp(Op target)
-    {
-        _exprPinner = new(target);
-        Target = target;
-    }
-
-    /// <summary>
-    /// Gets the target.
-    /// </summary>
-    public Op Target { get; }
-
-    /// <inheritdoc/>
-    public override IEnumerable<ParameterInfo> Parameters => Target.Parameters;
-
-    public override string DisplayProperty() => Target.GetType().Name;
-}
diff --git a/modules/Nncase.Modules.XPU/IR/CPU/Functional.cs b/modules/Nncase.Modules.XPU/IR/CPU/Functional.cs
deleted file mode 100644
index c985e554e9..0000000000
--- a/modules/Nncase.Modules.XPU/IR/CPU/Functional.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR.CPU;
-
-namespace Nncase.IR.F;
-
-public partial class CPU
-{
-    /// <summary>
-    /// Call cpu kernel.
-    /// </summary>
-    /// <param name="target">Unary operator.</param>
-    /// <param name="inputs">Source inputs.</param>
-    /// <returns>Result expression.</returns>
-    public static Call CPUKernel(Op target, params Expr[] inputs)
-    {
-        return new Call(new CPUKernelOp(target), inputs);
-    }
-
-    public static Call Boxing(Expr input, IRType type)
-    {
-        return new Call(new Boxing(type), input);
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Nncase.Modules.XPU.csproj b/modules/Nncase.Modules.XPU/Nncase.Modules.XPU.csproj
deleted file mode 100644
index 4e9d1f7a7f..0000000000
--- a/modules/Nncase.Modules.XPU/Nncase.Modules.XPU.csproj
+++ /dev/null
@@ -1,29 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <RootNamespace>Nncase</RootNamespace>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
-    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-  </PropertyGroup>
-  
-  <ItemGroup>
-    <ProjectReference Include="..\..\src\Nncase.Diagnostics\Nncase.Diagnostics.csproj" />
-    <ProjectReference Include="..\..\src\Nncase.Passes\Nncase.Passes.csproj" />
-    <ProjectReference Include="..\..\src\Nncase.CodeGen\Nncase.CodeGen.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="../../tools/Nncase.SourceGenerator/Nncase.SourceGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
-    <ProjectReference Include="..\Nncase.Modules.StackVM\Nncase.Modules.StackVM.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Folder Include="Evaluator/" />
-    <Folder Include="Evaluator/IR/" />
-    <Folder Include="Evaluator/TIR/" />
-    <Folder Include="Evaluator/XPU/" />
-    <Folder Include="TIR/" />
-  </ItemGroup>
-</Project>
diff --git a/modules/Nncase.Modules.XPU/Passes/Rules/CombineMHA.cs b/modules/Nncase.Modules.XPU/Passes/Rules/CombineMHA.cs
deleted file mode 100644
index 3d5302ddac..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Rules/CombineMHA.cs
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reactive;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-using Nncase.IR.F;
-using Nncase.IR.Math;
-using Nncase.IR.NN;
-using Nncase.IR.Tensors;
-using Nncase.Passes.Rules.Neutral;
-using Nncase.PatternMatch;
-using Nncase.Targets;
-using Nncase.TIR.XPU;
-using static Nncase.IR.TypePatternUtility;
-using static Nncase.PatternMatch.F.Math;
-using static Nncase.PatternMatch.F.Tensors;
-using static Nncase.PatternMatch.Utility;
-using static Nncase.Utilities.ReplaceUtility;
-
-namespace Nncase.Passes.Rules;
-
-/// <summary>
-/// Convert QKV computation to MHA style.
-/// %9 = MatMul(%2, const(f32[768,768]))
-/// %10 = Add(BinaryOp.Add, const(f32[768]), %9)
-/// %11 = Reshape(%10, const(i32[4] : {1,77,12,64}))
-/// %12 = Transpose(%11, const(i64[4] : {0L,2L,1L,3L}))
-/// %13 = Reshape(%12, const(i32[3] : {12,77,64})).
-/// </summary>
-[RuleGenerator]
-public sealed partial class CombineMHA : IRewriteRule
-{
-    public CombineMHA()
-    {
-        Pattern v0 = IsMatMul("mm", "mmCall", IsWildcard("x"), IsTensorConst("w"));
-
-        var bias = IsAlt(
-            IsBinary("add", "addCall", op => op.BinaryOp == BinaryOp.Add, IsTensorConst("bias"), v0),
-            IsBinary("add", "addCall", op => op.BinaryOp == BinaryOp.Add, v0, IsTensorConst("bias")),
-            v0);
-        var scale = IsAlt(
-            IsBinary("mul", "mulCall", op => op.BinaryOp == BinaryOp.Mul, bias, IsTensorConst("scale")),
-            IsBinary("mul", "mulCall", op => op.BinaryOp == BinaryOp.Mul, IsTensorConst("scale"), bias),
-            bias);
-
-        var v1 = IsReshape("rshape", "rshapeCall", scale, IsTensorConst("newShape"));
-        var v2 = IsTranspose("tp", "tpCall", v1, IsTensorConst("perm")) with { TypePattern = HasFixedShape() };
-        Pattern = v2;
-    }
-
-    public IPattern Pattern { get; }
-
-    private Expr? GetReplace(Expr x, Call mmCall, TensorConst w, TensorConst newShape, int[] perm, IMatchResult matchResult)
-    {
-        var mmOutShape = mmCall.CheckedShape.ToValueArray();
-        var wReshape = newShape.Value.ToArray<int>().TakeLast(2).ToArray();
-
-        // TODO: add more patterns, only llama65b for now
-        if (perm.Length == 4 && perm.SequenceEqual(new[] { 0, 2, 1, 3 })
-             && wReshape.Aggregate(1, (x, y) => x * y) == mmOutShape[^1]
-             && (mmOutShape.Length == 2 || (mmOutShape.Length == 3 && mmOutShape[0] == 1)))
-        {
-            var newW = Tensors.Transpose(Tensors.Reshape(w, new[] { -1, wReshape[0], wReshape[1] }), new[] { 1, 0, 2 });
-            var newMm = Tensors.MatMul(Tensors.Unsqueeze(x, new[] { 1 }), newW);
-            if (matchResult["bias"] is TensorConst bias)
-            {
-                return null;
-            }
-
-            if (matchResult["scale"] is TensorConst scale)
-            {
-                return null;
-            }
-
-            return newMm;
-        }
-        else if (perm.Length == 3 && perm.SequenceEqual(new[] { 1, 0, 2 })
-            && wReshape.Aggregate(1, (x, y) => x * y) == mmOutShape[^1]
-            && (mmOutShape.Length == 2 || (mmOutShape.Length == 3 && mmOutShape[0] == 1)))
-        {
-            var newW = Tensors.Transpose(Tensors.Reshape(w, new[] { -1, wReshape[0], wReshape[1] }), new[] { 1, 0, 2 });
-            var newMm = Tensors.MatMul(x, newW);
-            if (matchResult["bias"] is TensorConst bias)
-            {
-                newMm = IR.F.Math.Add(newMm, bias.Value.Shape.IsScalar ? bias : Tensors.Reshape(bias, new[] { -1, 1, wReshape[1] }));
-            }
-
-            if (matchResult["scale"] is TensorConst scale)
-            {
-                newMm = IR.F.Math.Mul(newMm, scale.Value.Shape.IsScalar ? scale : Tensors.Reshape(scale, new[] { -1, 1, wReshape[1] }));
-            }
-
-            return newMm;
-        }
-        else if (perm.Length == 3 && perm.SequenceEqual(new[] { 1, 2, 0 })
-            && wReshape.Aggregate(1, (x, y) => x * y) == mmOutShape[^1]
-            && (mmOutShape.Length == 2 || (mmOutShape.Length == 3 && mmOutShape[0] == 1)))
-        {
-            var newW = Tensors.Transpose(Tensors.Reshape(w, new[] { -1, wReshape[0], wReshape[1] }), new[] { 1, 0, 2 });
-            var newMm = Tensors.MatMul(x, newW);
-            if (matchResult["bias"] is TensorConst bias)
-            {
-                newMm = IR.F.Math.Add(newMm, bias.Value.Shape.IsScalar ? bias : Tensors.Reshape(bias, new[] { -1, 1, wReshape[1] }));
-            }
-
-            if (matchResult["scale"] is TensorConst scale)
-            {
-                newMm = IR.F.Math.Mul(newMm, scale.Value.Shape.IsScalar ? scale : Tensors.Reshape(scale, new[] { -1, 1, wReshape[1] }));
-            }
-
-            return Tensors.Transpose(newMm, new[] { 0, 2, 1 });
-        }
-
-        return null;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Rules/DumpConst.cs b/modules/Nncase.Modules.XPU/Passes/Rules/DumpConst.cs
deleted file mode 100644
index aa9becf447..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Rules/DumpConst.cs
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.SymbolStore;
-using System.Linq;
-using System.Reactive;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.IR.F;
-using Nncase.IR.Math;
-using Nncase.IR.NN;
-using Nncase.IR.Tensors;
-using Nncase.Passes.Rules.Neutral;
-using Nncase.PatternMatch;
-using Nncase.Targets;
-using Nncase.TIR.XPU;
-using static Nncase.IR.TypePatternUtility;
-using static Nncase.PatternMatch.F.Math;
-using static Nncase.PatternMatch.F.NN;
-using static Nncase.PatternMatch.F.Tensors;
-using static Nncase.PatternMatch.Utility;
-using static Nncase.Utilities.ReplaceUtility;
-
-namespace Nncase.Passes.Rules;
-
-/// <summary>
-/// Dump Weights of MM.
-/// </summary>
-[RuleGenerator]
-public sealed partial class DumpMM : IRewriteRule
-{
-    public IPattern Pattern { get; } =
-            IsMatMul(
-                "mm",
-                "mmCall",
-                _ => true,
-                IsWildcard("x"),
-                IsTensorConst("w"));
-
-    private Expr? GetReplace(Expr x, Call mmCall, TensorConst w)
-    {
-        var name = mmCall.Metadata.OutputNames?[0].Replace('/', '_') + "_weights.bin";
-        var dir = DumpScope.Current.Directory;
-        Directory.CreateDirectory(dir);
-        using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name), FileMode.Create)))
-        {
-            bw.Write(w.Value.BytesBuffer);
-        }
-
-        return null;
-    }
-}
-
-/// <summary>
-/// Dump Consts of layernorm.
-/// </summary>
-[RuleGenerator]
-public sealed partial class DumpLayerNorm : IRewriteRule
-{
-    public IPattern Pattern { get; } =
-            IsLayerNorm(
-                "ln",
-                "lnCall",
-                _ => true,
-                IsWildcard("x"),
-                IsTensorConst("scale"),
-                IsTensorConst("bias"));
-
-    private Expr? GetReplace(Call lnCall, TensorConst scale, TensorConst bias)
-    {
-        var name = lnCall.Metadata.OutputNames?[0].Replace('/', '_');
-        var dir = DumpScope.Current.Directory;
-        Directory.CreateDirectory(dir);
-
-        using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name + "_scale.bin"), FileMode.Create)))
-        {
-            bw.Write(scale.Value.BytesBuffer);
-        }
-
-        using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name + "_bias.bin"), FileMode.Create)))
-        {
-            bw.Write(bias.Value.BytesBuffer);
-        }
-
-        return null;
-    }
-}
-
-/// <summary>
-/// Dump Consts of Gather.
-/// </summary>
-[RuleGenerator]
-public sealed partial class DumpGather : IRewriteRule
-{
-    public IPattern Pattern { get; } =
-            IsGather(
-                "gather",
-                "gatherCall",
-                _ => true,
-                IsTensorConst("data"),
-                IsWildcard("index"));
-
-    private Expr? GetReplace(Call gatherCall, TensorConst data)
-    {
-        var name = gatherCall.Metadata.OutputNames?[0].Replace('/', '_') + "_data.bin";
-        var dir = DumpScope.Current.Directory;
-        Directory.CreateDirectory(dir);
-
-        using (var bw = new BinaryWriter(File.Open(Path.Join(dir, name), FileMode.Create)))
-        {
-            bw.Write(data.Value.BytesBuffer);
-        }
-
-        return null;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Rules/FusionMerger.cs b/modules/Nncase.Modules.XPU/Passes/Rules/FusionMerger.cs
deleted file mode 100644
index f8e9abb794..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Rules/FusionMerger.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net.Http.Headers;
-using System.Reactive;
-using System.Text;
-using System.Threading.Tasks;
-using DryIoc.ImTools;
-using Google.OrTools.LinearSolver;
-using Nncase.IR;
-using Nncase.IR.Math;
-using Nncase.IR.NN;
-using Nncase.IR.Tensors;
-using Nncase.Passes.Rules.Neutral;
-using Nncase.PatternMatch;
-using Nncase.Targets;
-using static Nncase.PatternMatch.F.Math;
-using static Nncase.PatternMatch.Utility;
-using static Nncase.Utilities.ReplaceUtility;
-
-namespace Nncase.Passes.Rules;
-
-/// <summary>
-/// Unet Merger for all.
-/// </summary>
-public sealed class FusionMerger : ExprCloner<Unit>
-{
-    private readonly IReadOnlyDictionary<Expr, Var> _multiVarMap;
-
-    public FusionMerger(IReadOnlyDictionary<Expr, Var> multiVarMap)
-    {
-        _multiVarMap = multiVarMap;
-    }
-
-    protected override Expr VisitCall(Call expr, Unit context)
-    {
-        if (_multiVarMap.TryGetValue(expr, out var newVar))
-        {
-            return newVar;
-        }
-
-        return base.VisitCall(expr, context);
-    }
-
-    protected override Expr VisitLeafCall(Call expr, Unit context)
-    {
-        var target = Clone(expr.Target, context);
-        var arguments = CloneArray(expr.Arguments, context);
-        if (target is Binary)
-        {
-            arguments = arguments.Select(e => e switch { TensorConst { Value: Tensor { Shape.IsScalar: true } } tc => Const.FromTensor(Tensor.FromBytes(tc.ValueType.DType, tc.Value.BytesBuffer.ToArray(), new[] { 1 })), _ => e }).ToArray();
-        }
-
-        if (target is Conv2D conv)
-        {
-            var bias = (TensorConst)arguments[2];
-            var fusedClamp = ((TensorConst)arguments[7]).Value.ToArray<float>();
-            var newConv = IR.F.NN.Conv2D(arguments[0], arguments[1], Tensor.Zeros<float>(bias.CheckedShape), arguments[3], arguments[4], arguments[5], conv.PadMode, arguments[6], new[] { float.NegativeInfinity, float.PositiveInfinity });
-            var newBias = IR.F.Math.Add(newConv, Tensor.FromBytes(bias.CheckedDataType, bias.Value.BytesBuffer.ToArray(), new[] { bias.CheckedShape[0].FixedValue, 1, 1 }));
-            var newClamp = IR.F.Math.Clamp(newBias, fusedClamp[0], fusedClamp[1]);
-            return newClamp;
-        }
-
-        return expr.With(target: target, arguments: arguments);
-    }
-
-    protected override Expr VisitLeafVar(Var expr, Unit context)
-    {
-        if (_multiVarMap.TryGetValue(expr, out var newVar))
-        {
-            return newVar;
-        }
-
-        throw new InvalidOperationException();
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Rules/LowerBinary.cs b/modules/Nncase.Modules.XPU/Passes/Rules/LowerBinary.cs
deleted file mode 100644
index ffef820490..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Rules/LowerBinary.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-using Nncase.IR.Math;
-using Nncase.PatternMatch;
-
-using static Nncase.IR.F.CPU;
-using static Nncase.IR.TypePatternUtility;
-using static Nncase.PatternMatch.F.Math;
-using static Nncase.PatternMatch.Utility;
-
-namespace Nncase.Passes.Rules;
-
-[RuleGenerator]
-public partial class LowerBinary : RewriteRule<Pattern>
-{
-    /// <inheritdoc/>
-    public override Pattern Pattern { get; } = IsBinary(
-      target_name: "binary",
-      _ => true,
-      IsWildcard("lhs") with { TypePattern = IsFloat() },
-      IsWildcard("rhs") with { TypePattern = IsFloat() });
-
-    private Expr? GetReplace(Binary binary, Expr lhs, Expr rhs)
-    {
-        if (lhs.CheckedShape.Rank != rhs.CheckedShape.Rank)
-        {
-            return null;
-        }
-
-        return CPUKernel(binary, lhs, rhs);
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Rules/LowerMatMul.cs b/modules/Nncase.Modules.XPU/Passes/Rules/LowerMatMul.cs
deleted file mode 100644
index a087945bbf..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Rules/LowerMatMul.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-using Nncase.IR.Math;
-using Nncase.PatternMatch;
-
-using static Nncase.IR.F.CPU;
-using static Nncase.IR.TypePatternUtility;
-using static Nncase.PatternMatch.F.Math;
-using static Nncase.PatternMatch.Utility;
-
-namespace Nncase.Passes.Rules;
-
-[RuleGenerator]
-public partial class LowerMatMul : RewriteRule<Pattern>
-{
-    /// <inheritdoc/>
-    public override Pattern Pattern { get; } = IsMatMul(
-      target_name: "matmul",
-      _ => true,
-      IsWildcard("inputA") with { TypePattern = IsFloat() },
-      IsWildcard("inputB") with { TypePattern = IsFloat() });
-
-    private Expr? GetReplace(MatMul matmul, Expr inputA, Expr inputB)
-    {
-        if (inputA.CheckedShape.Rank == inputB.CheckedShape.Rank && inputA.CheckedShape.Zip(inputB.CheckedShape).SkipLast(2).All(d => d.First == d.Second))
-        {
-            return CPUKernel(matmul, inputA, inputB);
-        }
-
-        return null;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Rules/LowerUnary.cs b/modules/Nncase.Modules.XPU/Passes/Rules/LowerUnary.cs
deleted file mode 100644
index 81aae570a1..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Rules/LowerUnary.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-using Nncase.IR.Math;
-using Nncase.PatternMatch;
-
-using static Nncase.IR.F.CPU;
-using static Nncase.IR.TypePatternUtility;
-using static Nncase.PatternMatch.F.Math;
-using static Nncase.PatternMatch.Utility;
-
-namespace Nncase.Passes.Rules;
-
-[RuleGenerator]
-public partial class LowerUnary : RewriteRule<Pattern>
-{
-  /// <inheritdoc/>
-  public override Pattern Pattern { get; } = IsUnary(
-    target_name: "unary",
-    _ => true,
-    IsWildcard("input") with { TypePattern = IsFloat() });
-
-  private Expr GetReplace(Unary unary, Expr input)
-  {
-    return CPUKernel(unary, input);
-  }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Rules/MHAFusion.cs b/modules/Nncase.Modules.XPU/Passes/Rules/MHAFusion.cs
deleted file mode 100644
index 8296b0278a..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Rules/MHAFusion.cs
+++ /dev/null
@@ -1,353 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reactive;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-using Nncase.IR.Math;
-using Nncase.IR.NN;
-using Nncase.IR.Tensors;
-using Nncase.Passes.Rules.Neutral;
-using Nncase.PatternMatch;
-using Nncase.Targets;
-using static Nncase.PatternMatch.F.Math;
-using static Nncase.PatternMatch.F.NN;
-using static Nncase.PatternMatch.F.Tensors;
-using static Nncase.PatternMatch.Utility;
-using static Nncase.Utilities.ReplaceUtility;
-
-namespace Nncase.Passes.Rules;
-
-// pattern from BERT base
-[RuleGenerator]
-public sealed partial class FuseMHA1 : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => CreatePattern();
-
-    private static Pattern CreatePattern()
-    {
-        var v0 = IsTensorConst("v0");
-        var v1 = IsTensorConst("v1");
-        var v2 = IsWildcard("x");
-
-        var v3 = IsTensorConst("v3");
-        var v4 = IsCall("v4", IsOp<MatMul>(), IsVArgs(v2, v3));
-        var v5 = IsCall("v5", IsOp<Binary>(), IsVArgs(v1, v4));
-        var v6 = IsTensorConst("v6");
-        var v7 = IsCall("v7", IsOp<Reshape>(), IsVArgs(v5, v6));
-        var v8 = IsTensorConst("v8");
-        var v9 = IsCall("v9", IsOp<Transpose>(), IsVArgs(v7, v8));
-        var v10 = IsTensorConst("v10");
-        var v11 = IsTensorConst("v11");
-        var v12 = IsCall("v12", IsOp<MatMul>(), IsVArgs(v2, v11));
-        var v13 = IsCall("v13", IsOp<Binary>(), IsVArgs(v10, v12));
-        var v14 = IsCall("v14", IsOp<Reshape>(), IsVArgs(v13, v6));
-        var v15 = IsTensorConst("v15");
-        var v16 = IsCall("v16", IsOp<Transpose>(), IsVArgs(v14, v15));
-        var v17 = IsCall("v17", IsOp<MatMul>(), IsVArgs(v9, v16));
-        var v18 = IsTensorConst("v18");
-        var v19 = IsCall("v19", IsOp<Binary>(), IsVArgs(v17, v18));
-        var v20 = IsWildcard("mask");
-
-        var v21 = IsCall("v21", IsOp<Binary>(), IsVArgs(v19, v20));
-        var v22 = IsTensorConst("v22");
-        var v23 = IsCall("v23", IsOp<Reshape>(), IsVArgs(v21, v22));
-        var v24 = IsTensorConst("v24");
-        var v25 = IsCall("v25", IsOp<Softmax>(), IsVArgs(v23, v24));
-        var v26 = IsTensorConst("v26");
-        var v27 = IsCall("v27", IsOp<Reshape>(), IsVArgs(v25, v26));
-        var v28 = IsTensorConst("v28");
-        var v29 = IsTensorConst("v29");
-        var v30 = IsCall("v30", IsOp<MatMul>(), IsVArgs(v2, v29));
-        var v31 = IsCall("v31", IsOp<Binary>(), IsVArgs(v28, v30));
-        var v32 = IsCall("v32", IsOp<Reshape>(), IsVArgs(v31, v6));
-        var v33 = IsCall("v33", IsOp<Transpose>(), IsVArgs(v32, v8));
-        var v34 = IsCall("v34", IsOp<MatMul>(), IsVArgs(v27, v33));
-        var v35 = IsCall("v35", IsOp<Transpose>(), IsVArgs(v34, v8));
-        var v36 = IsTensorConst("v36");
-        var v37 = IsCall("v37", IsOp<Reshape>(), IsVArgs(v35, v36));
-        var v38 = IsTensorConst("v38");
-        var v39 = IsCall("v39", IsOp<MatMul>(), IsVArgs(v37, v38));
-        var v40 = IsCall("v40", IsOp<Binary>(), IsVArgs(v0, v39));
-        var v41 = IsCall("v41", IsOp<Binary>(), IsVArgs(v40, v2));
-        var v42 = IsTensorConst("v42");
-        var v43 = IsTensorConst("v43");
-        var v44 = IsCall("root", IsOp<LayerNorm>(), IsVArgs(v41, v42, v43));
-        return v44;
-    }
-
-    private Call? GetReplace(Call root, Expr x, Expr mask)
-    {
-        var newInputs = new List<Expr>
-        {
-            new Var(x.CheckedType!),
-            new Var(mask.CheckedType!),
-        };
-
-        var callFusion = new Call(new Fusion("MHABertBase", $"{nameof(FuseMHA1)}_{Count++}", ModuleKind, root, newInputs.OfType<Var>().ToArray()), x, mask);
-        return callFusion;
-    }
-}
-
-// pattern for LLaMA-65B
-[RuleGenerator]
-public sealed partial class FuseMHA2 : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => CreatePattern();
-
-    private static Pattern CreatePattern()
-    {
-        var v1 = IsWildcard("hidden_in");
-
-        var v2 = IsTensorConst("v2");
-        var v3 = IsTensorConst("v3");
-        var v4 = IsCall("v4", IsOp<LayerNorm>(), IsVArgs(v1, v2, v3));
-        var v5 = IsTensorConst("v5");
-        var v6 = IsCall("v6", IsOp<Unsqueeze>(), IsVArgs(v4, v5));
-        var v7 = IsTensorConst("v7");
-        var v8 = IsCall("v8", IsOp<MatMul>(), IsVArgs(v6, v7));
-        var v9 = IsTensorConst("v9");
-        var v10 = IsWildcard("position_ids");
-
-        var v11 = IsCall("v11", IsOp<Gather>(), IsVArgs(v9, v10));
-        var v12 = IsTensorConst("v12");
-        var v13 = IsCall("v13", IsOp<Reshape>(), IsVArgs(v11, v12));
-        var v14 = IsCall("v14", IsOp<Binary>(), IsVArgs(v8, v13));
-        var v15 = IsTensorConst("v15");
-        var v16 = IsTensorConst("v16");
-        var v17 = IsTensorConst("v17");
-        var v18 = IsTensorConst("v18");
-        var v19 = IsCall("v19", IsOp<Slice>(), IsVArgs(v8, v15, v16, v17, v18));
-        var v20 = IsCall("v20", IsOp<Unary>(), IsVArgs(v19));
-        var v21 = IsTensorConst("v21");
-        var v22 = IsCall("v22", IsOp<Slice>(), IsVArgs(v8, v21, v15, v17, v18));
-        var v23 = IsTuple("v23", IsVArgs(v20, v22));
-
-        var v24 = IsCall("v24", IsOp<Concat>(), IsVArgs(v23));
-        var v25 = IsTensorConst("v25");
-        var v26 = IsCall("v26", IsOp<Gather>(), IsVArgs(v25, v10));
-        var v27 = IsCall("v27", IsOp<Reshape>(), IsVArgs(v26, v12));
-        var v28 = IsCall("v28", IsOp<Binary>(), IsVArgs(v24, v27));
-        var v29 = IsCall("v29", IsOp<Binary>(), IsVArgs(v14, v28));
-        var v30 = IsTensorConst("v30");
-        var v31 = IsCall("v31", IsOp<Unsqueeze>(), IsVArgs(v4, v30));
-        var v32 = IsTensorConst("v32");
-        var v33 = IsCall("v33", IsOp<MatMul>(), IsVArgs(v31, v32));
-        var v34 = IsCall("v34", IsOp<Binary>(), IsVArgs(v33, v13));
-        var v35 = IsCall("v35", IsOp<Slice>(), IsVArgs(v33, v15, v16, v17, v18));
-        var v36 = IsCall("v36", IsOp<Unary>(), IsVArgs(v35));
-        var v37 = IsCall("v37", IsOp<Slice>(), IsVArgs(v33, v21, v15, v17, v18));
-        var v38 = IsTuple("v38", IsVArgs(v36, v37));
-
-        var v39 = IsCall("v39", IsOp<Concat>(), IsVArgs(v38));
-        var v40 = IsCall("v40", IsOp<Binary>(), IsVArgs(v39, v27));
-        var v41 = IsCall("v41", IsOp<Binary>(), IsVArgs(v34, v40));
-        var v42 = IsTensorConst("v42");
-        var v43 = IsCall("v43", IsOp<Transpose>(), IsVArgs(v41, v42));
-        var v44 = IsCall("v44", IsOp<MatMul>(), IsVArgs(v29, v43));
-        var v45 = IsTensorConst("v45");
-        var v46 = IsCall("v46", IsOp<Binary>(), IsVArgs(v44, v45));
-        var v47 = IsWildcard("attn_mask");
-
-        var v48 = IsCall("v48", IsOp<Binary>(), IsVArgs(v46, v47));
-        var v49 = IsTensorConst("v49");
-        var v50 = IsCall("v50", IsOp<Softmax>(), IsVArgs(v48, v49));
-        var v51 = IsTensorConst("v51");
-        var v52 = IsCall("v52", IsOp<Unsqueeze>(), IsVArgs(v4, v51));
-        var v53 = IsTensorConst("v53");
-        var v54 = IsCall("v54", IsOp<MatMul>(), IsVArgs(v52, v53));
-        var v55 = IsCall("v55", IsOp<MatMul>(), IsVArgs(v50, v54));
-        var v56 = IsTensorConst("v56");
-        var v57 = IsCall("v57", IsOp<Transpose>(), IsVArgs(v55, v56));
-        var v58 = IsTensorConst("v58");
-        var v59 = IsCall("v59", IsOp<Reshape>(), IsVArgs(v57, v58));
-        var v60 = IsTensorConst("v60");
-        var v61 = IsCall("v61", IsOp<MatMul>(), IsVArgs(v59, v60));
-        var v62 = IsCall("v62", IsOp<Binary>(), IsVArgs(v1, v61));
-        var v63 = IsCall("v63", IsOp<LayerNorm>(), IsVArgs(v62, v2, v3));
-        var v64 = IsTensorConst("v64");
-        var v65 = IsCall("v65", IsOp<MatMul>(), IsVArgs(v63, v64));
-        var v66 = IsTensorConst("v66");
-        var v67 = IsCall("v67", IsOp<Swish>(), IsVArgs(v65, v66));
-        var v68 = IsTensorConst("v68");
-        var v69 = IsCall("v69", IsOp<MatMul>(), IsVArgs(v63, v68));
-        var v70 = IsCall("v70", IsOp<Binary>(), IsVArgs(v67, v69));
-        var v71 = IsTensorConst("v71");
-        var v72 = IsCall("v72", IsOp<MatMul>(), IsVArgs(v70, v71));
-        var v73 = IsCall("root", IsOp<Binary>(), IsVArgs(v62, v72));
-
-        return v73;
-    }
-
-    private Call? GetReplace(Call root, Expr hidden_in, Expr position_ids, Expr attn_mask)
-    {
-        var newInputs = new List<Expr>
-        {
-            new Var(hidden_in.CheckedType!),
-            new Var(position_ids.CheckedType!),
-            new Var(attn_mask.CheckedType!),
-        };
-
-        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
-        {
-            { hidden_in, (Var)newInputs[0] },
-            { position_ids, (Var)newInputs[1] },
-            { attn_mask, (Var)newInputs[2] },
-        };
-        var merger = new FusionMerger(multiVarMap);
-        var clonedRoot = merger.Clone(root, default);
-
-        var callFusion = new Call(new Fusion("MHALLaMA65B", $"{nameof(FuseMHA2)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), hidden_in, position_ids, attn_mask);
-        return callFusion;
-    }
-}
-
-/// <summary>
-/// stable-disffusion text encoder.
-/// </summary>
-[RuleGenerator]
-public sealed partial class FuseMHA3 : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => CreatePattern();
-
-    private static Pattern CreatePattern()
-    {
-        var v26 = IsWildcard("input");
-        var v27 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v26, IsTensorConst(), IsTensorConst()); // f32[1,77,768]
-        var v28 = IsMatMul(v27, IsTensorConst()); // f32[12,77,64]
-        var v29 = IsBinary(BinaryOp.Add, v28, IsTensorConst()); // f32[12,77,64]
-        var v30 = IsBinary(BinaryOp.Mul, v29, IsTensorConst()); // f32[12,77,64]
-        var v31 = IsMatMul(v27, IsTensorConst()); // f32[12,77,64]
-        var v32 = IsBinary(BinaryOp.Add, v31, IsTensorConst()); // f32[12,77,64]
-        var v33 = IsTranspose(v32, IsTensorConst()); // f32[12,64,77]
-        var v34 = IsMatMul(v30, v33); // f32[12,77,77]
-        var v35 = IsBinary(BinaryOp.Add, v34, IsTensorConst()); // f32[12,77,77]
-        var v36 = IsSoftmax(v35, IsTensorConst()); // f32[12,77,77]
-        var v37 = IsMatMul(v27, IsTensorConst()); // f32[12,77,64]
-        var v38 = IsBinary(BinaryOp.Add, v37, IsTensorConst()); // f32[12,77,64]
-        var v39 = IsMatMul(v36, v38); // f32[12,77,64]
-        var v40 = IsTranspose(v39, IsTensorConst()); // f32[77,12,64]
-        var v41 = IsReshape(v40, IsTensorConst()); // f32[1,77,768]
-        var v42 = IsMatMul(v41, IsTensorConst()); // f32[1,77,768]
-        var v43 = IsBinary(BinaryOp.Add, IsTensorConst(), v42); // f32[1,77,768]
-        var v44 = IsBinary(BinaryOp.Add, v26, v43); // f32[1,77,768]
-        var v45 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v44, IsTensorConst(), IsTensorConst()); // f32[1,77,768]
-        var v46 = IsMatMul(v45, IsTensorConst()); // f32[1,77,3072]
-        var v47 = IsBinary(BinaryOp.Add, IsTensorConst(), v46); // f32[1,77,3072]
-        var v48 = IsSwish(v47, IsTensorConst()); // f32[1,77,3072]
-        var v49 = IsMatMul(v48, IsTensorConst()); // f32[1,77,768]
-        var v50 = IsBinary(BinaryOp.Add, IsTensorConst(), v49); // f32[1,77,768]
-        var v51 = IsBinary(null, "root", BinaryOp.Add, v44, v50); // f32[1,77,768]
-        return v51;
-    }
-
-    private Call? GetReplace(Call root, Expr input)
-    {
-        var newInputs = new List<Expr>
-        {
-            new Var(input.CheckedType!),
-        };
-
-        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
-        {
-            { input, (Var)newInputs[0] },
-        };
-        var merger = new FusionMerger(multiVarMap);
-        var clonedRoot = merger.Clone(root, default);
-
-        var callFusion = new Call(new Fusion("SDTextEncoderMHA", $"{nameof(FuseMHA3)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
-        return callFusion;
-    }
-}
-
-/// <summary>
-/// stable-disffusion text encoder header.
-/// </summary>
-[RuleGenerator]
-public sealed partial class FuseSDTextEncoderHeader : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => CreatePattern();
-
-    private static Pattern CreatePattern()
-    {
-        var v0 = IsWildcard("input");
-        var v1 = IsGather(0, IsTensorConst(), v0); // f32[12,77,64]
-        var v2 = IsBinary(null, "root", BinaryOp.Add, v1, IsTensorConst()); // f32[12,77,64]
-        return v2;
-    }
-
-    private Call? GetReplace(Call root, Expr input)
-    {
-        var newInputs = new List<Var>
-        {
-            new Var(input.CheckedType!),
-        };
-
-        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
-        {
-            { input, newInputs[0] },
-        };
-        var merger = new FusionMerger(multiVarMap);
-        var clonedRoot = merger.Clone(root, default);
-
-        var callFusion = new Call(new Fusion("SDTextEncoderHeader", $"{nameof(FuseSDTextEncoderHeader)}_{Count++}", ModuleKind, clonedRoot, newInputs.ToArray()), input);
-        return callFusion;
-    }
-}
-
-/// <summary>
-/// stable-disffusion text encoder header.
-/// </summary>
-[RuleGenerator]
-public sealed partial class FuseSDTextEncoderTail : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => CreatePattern();
-
-    private static Pattern CreatePattern()
-    {
-        var vinput_ids = IsWildcard("input_ids");
-        var v13 = IsWildcard("input");
-        var v14 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v13, IsTensorConst(), IsTensorConst()); // f32[1,77,768]
-        var v15 = IsReshape(v14, IsTensorConst()); // f32[77,768]
-        var v16 = IsReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64, vinput_ids, IsTensorConst(), IsTensorConst(), IsTensorConst()); // i64[1]
-        var v17 = IsBinary(BinaryOp.Add, v16, IsTensorConst()); // i64[1]
-        var v18 = IsGather(Axis: 0, v15, v17); // f32[1,768]
-        var v19 = IsTuple("root", IsVArgs(v14, v18));
-        return v19;
-    }
-
-    private Call? GetReplace(IR.Tuple root, Expr input_ids, Expr input)
-    {
-        var newInputs = new Var[]
-        {
-            new Var(input_ids.CheckedType!),
-            new Var(input.CheckedType!),
-        };
-
-        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
-        {
-            { input_ids, newInputs[0] },
-            { input, newInputs[1] },
-        };
-
-        var merger = new FusionMerger(multiVarMap);
-        var clonedRoot = merger.Clone(root, default);
-
-        var callFusion = new Call(new Fusion("SDTextEncoderTail", $"{nameof(FuseSDTextEncoderTail)}_{Count++}", ModuleKind, clonedRoot, newInputs), input_ids, input);
-        return callFusion;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Rules/MakeFusion.cs b/modules/Nncase.Modules.XPU/Passes/Rules/MakeFusion.cs
deleted file mode 100644
index 59a6beff90..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Rules/MakeFusion.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-using Nncase.IR.CPU;
-using Nncase.Passes.Rules.Neutral;
-using Nncase.PatternMatch;
-using Nncase.Targets;
-using static Nncase.PatternMatch.F.Tensors;
-using static Nncase.PatternMatch.Utility;
-using static Nncase.Utilities.ReplaceUtility;
-
-namespace Nncase.Passes.Rules;
-
-[RuleGenerator]
-internal sealed partial class XPUFusion : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => IsCallWildcard("call", IsOp<CPUKernelOp>("op"));
-
-    private Call? GetReplace(Call call, CPUKernelOp op, IReadOnlyList<Expr> callParams)
-    {
-        var newInputs = new List<Expr>();
-        for (int i = 0; i < callParams.Count; i++)
-        {
-            if (callParams[i] is Call or Var)
-            {
-                newInputs.Add(new Var(callParams[i].CheckedType!));
-            }
-            else
-            {
-                newInputs.Add(callParams[i]);
-            }
-        }
-
-        var newCall = new Call(op, newInputs.ToArray());
-        var callFusion = new Call(new Fusion($"{op.Target.GetType().Name}_{Count++}", ModuleKind, newCall, newInputs.OfType<Var>().ToArray()), newInputs.Select((e, i) => (e, i)).Where(p => p.e is Var).Select(p => callParams[p.i]).ToArray());
-        return callFusion;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Rules/UnetFusion.cs b/modules/Nncase.Modules.XPU/Passes/Rules/UnetFusion.cs
deleted file mode 100644
index 9dbcd7cb4c..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Rules/UnetFusion.cs
+++ /dev/null
@@ -1,290 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Net.Http.Headers;
-using System.Reactive;
-using System.Text;
-using System.Threading.Tasks;
-using DryIoc.ImTools;
-using Google.OrTools.LinearSolver;
-using Nncase.IR;
-using Nncase.IR.Math;
-using Nncase.IR.NN;
-using Nncase.IR.Tensors;
-using Nncase.Passes.Rules.Neutral;
-using Nncase.PatternMatch;
-using Nncase.Targets;
-using Nncase.TIR.XPU;
-using static Nncase.PatternMatch.F.Imaging;
-using static Nncase.PatternMatch.F.Math;
-using static Nncase.PatternMatch.F.NN;
-using static Nncase.PatternMatch.F.Tensors;
-using static Nncase.PatternMatch.Utility;
-using static Nncase.Utilities.ReplaceUtility;
-
-namespace Nncase.Passes.Rules;
-
-/// <summary>
-/// stable-disffusion Unet spatial transformer.
-/// </summary>
-[RuleGenerator]
-public sealed partial class FuseUnetSpatialTransformer : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => CreatePattern();
-
-    private static Pattern CreatePattern()
-    {
-        // resIn
-        var v37 = IsWildcard("input");
-        var v38 = IsReshape(v37, IsTensorConst());
-        var v39 = IsInstanceNormalization(v38, IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v40 = IsReshape(v39, IsTensorConst());
-        var v41 = IsBinary(BinaryOp.Mul, v40, IsTensorConst());
-        var v42 = IsBinary(BinaryOp.Add, v41, IsTensorConst());
-        var v43 = IsConv2D(PadMode.Constant, v42, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-
-        // self attention
-        var v44 = IsTranspose(v43, IsTensorConst());
-        var v45 = IsReshape(v44, IsTensorConst());
-        var v46 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v45, IsTensorConst(), IsTensorConst());
-        var v47 = IsMatMul(v46, IsTensorConst());
-        var v48 = IsReshape(v47, IsTensorConst());
-        var v49 = IsTranspose(v48, IsTensorConst());
-        var v50 = IsReshape(v49, IsTensorConst());
-        var v51 = IsMatMul(v46, IsTensorConst());
-        var v52 = IsReshape(v51, IsTensorConst());
-        var v53 = IsTranspose(v52, IsTensorConst());
-        var v54 = IsReshape(v53, IsTensorConst());
-        var v55 = IsTranspose(v54, IsTensorConst());
-        var v56 = IsMatMul(v50, v55);
-        var v57 = IsBinary(BinaryOp.Mul, v56, IsTensorConst());
-        var v58 = IsBinary(BinaryOp.Add, v57, IsTensorConst());
-        var v59 = IsSoftmax(v58, IsTensorConst());
-        var v60 = IsMatMul(v46, IsTensorConst());
-        var v61 = IsReshape(v60, IsTensorConst());
-        var v62 = IsTranspose(v61, IsTensorConst());
-        var v63 = IsReshape(v62, IsTensorConst());
-        var v64 = IsMatMul(v59, v63);
-        var v65 = IsReshape(v64, IsTensorConst());
-        var v66 = IsTranspose(v65, IsTensorConst());
-        var v67 = IsReshape(v66, IsTensorConst());
-        var v68 = IsMatMul(v67, IsTensorConst());
-        var v69 = IsBinary(BinaryOp.Add, IsTensorConst(), v68);
-        var v70 = IsBinary(BinaryOp.Add, v69, v45);
-
-        // cross attention
-        var v71 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v70, IsTensorConst(), IsTensorConst());
-        var v72 = IsMatMul(v71, IsTensorConst());
-        var v73 = IsReshape(v72, IsTensorConst());
-        var v74 = IsTranspose(v73, IsTensorConst());
-        var v75 = IsReshape(v74, IsTensorConst());
-        var vencoderHiddenStates = IsWildcard("encoderHiddenStates");
-        var v76 = IsMatMul(vencoderHiddenStates, IsTensorConst());
-        var v77 = IsReshape(v76, IsTensorConst());
-        var v78 = IsTranspose(v77, IsTensorConst());
-        var v79 = IsReshape(v78, IsTensorConst());
-        var v80 = IsTranspose(v79, IsTensorConst());
-        var v81 = IsMatMul(v75, v80);
-        var v82 = IsBinary(BinaryOp.Mul, v81, IsTensorConst());
-        var v83 = IsBinary(BinaryOp.Add, v82, IsTensorConst());
-        var v84 = IsSoftmax(v83, IsTensorConst());
-        var v85 = IsMatMul(vencoderHiddenStates, IsTensorConst());
-        var v86 = IsReshape(v85, IsTensorConst());
-        var v87 = IsTranspose(v86, IsTensorConst());
-        var v88 = IsReshape(v87, IsTensorConst());
-        var v89 = IsMatMul(v84, v88);
-
-        // FF
-        var v90 = IsReshape(v89, IsTensorConst());
-        var v91 = IsTranspose(v90, IsTensorConst());
-        var v92 = IsReshape(v91, IsTensorConst());
-        var v93 = IsMatMul(v92, IsTensorConst());
-        var v94 = IsBinary(BinaryOp.Add, IsTensorConst(), v93);
-        var v95 = IsBinary(BinaryOp.Add, v94, v70);
-        var v96 = IsLayerNorm(Axis: 2, Epsilon: 1E-05f, UseMean: true, v95, IsTensorConst(), IsTensorConst());
-        var v97 = IsMatMul(v96, IsTensorConst());
-        var v98 = IsBinary(BinaryOp.Add, IsTensorConst(), v97);
-        var v99 = IsSlice(v98, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v100 = IsSlice(v98, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v101 = IsGelu(v100, IsTensorConst());
-        var v102 = IsBinary(BinaryOp.Mul, v99, v101);
-        var v103 = IsMatMul(v102, IsTensorConst());
-        var v104 = IsBinary(BinaryOp.Add, IsTensorConst(), v103);
-        var v105 = IsBinary(BinaryOp.Add, v104, v95);
-        var v106 = IsReshape(v105, IsTensorConst());
-        var v107 = IsTranspose(v106, IsTensorConst());
-
-        // res with result of ResBlock
-        var v108 = IsConv2D(PadMode.Constant, v107, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var root = IsBinary(null, "root", BinaryOp.Add, v108, v37);
-
-        return root!;
-    }
-
-    private Call? GetReplace(Call root, Expr input, Expr encoderHiddenStates)
-    {
-        var newInputs = new List<Expr>
-        {
-            new Var(input.CheckedType!),
-            new Var(encoderHiddenStates.CheckedType!),
-        };
-
-        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
-        {
-            { input, (Var)newInputs[0] },
-            { encoderHiddenStates, (Var)newInputs[1] },
-        };
-        var merger = new FusionMerger(multiVarMap);
-        var clonedRoot = merger.Clone(root, default);
-
-        var callFusion = new Call(new Fusion("UnetSpatialTransformer", $"{nameof(FuseUnetSpatialTransformer)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input, encoderHiddenStates);
-        return callFusion;
-    }
-}
-
-/// <summary>
-/// stable-disffusion Unet res block.
-/// </summary>
-[RuleGenerator]
-public sealed partial class FuseUnetResBlock : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => CreatePattern();
-
-    private static Pattern CreatePattern()
-    {
-        // 1st part with conv
-        var vIn = IsWildcard("input");
-        var vIn2 = IsWildcard("input2");
-        var resizeIn = IsResizeImage(ImageResizeMode.NearestNeighbor, ImageResizeTransformationMode.Asymmetric, ImageResizeNearestMode.Floor, false, vIn, IsWildcard(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var convIn = IsConv2D(PadMode.Constant, IsAlt(resizeIn, vIn2), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var vtuple1 = IsTuple(IsVArgs(vIn, IsAlt(convIn, vIn2)));
-        var vtuple2 = IsTuple(IsVArgs(convIn, vIn2));
-        var vConcat = IsConcat(Axis: 1, IsAlt(vtuple2, vtuple1));
-        var conv0 = IsConv2D(PadMode.Constant, vConcat, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var conv1 = IsConv2D(PadMode.Constant, vIn, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var conv2 = IsConv2D(PadMode.Constant, conv1, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v1 = IsReshape(IsAlt(vConcat, conv1, vIn), IsTensorConst());
-        var v2 = IsInstanceNormalization(v1, IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v3 = IsReshape(v2, IsTensorConst());
-        var v4 = IsBinary(BinaryOp.Mul, v3, IsTensorConst());
-        var v5 = IsBinary(BinaryOp.Add, v4, IsTensorConst());
-        var v6 = IsSwish(v5, IsTensorConst());
-        var v7 = IsConv2D(PadMode.Constant, v6, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-
-        // 2nd part with emb
-        var v25 = IsWildcard("emb");
-        var v26 = IsMatMul(v25, IsTensorConst());
-        var v27 = IsBinary(BinaryOp.Add, v26, IsTensorConst());
-        var v28 = IsReshape(v27, IsTensorConst());
-
-        // 1st + 2nd
-        var v29 = IsBinary(BinaryOp.Add, v7, v28);
-
-        // res
-        var v30 = IsReshape(v29, IsTensorConst());
-        var v31 = IsInstanceNormalization(v30, IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v32 = IsReshape(v31, IsTensorConst());
-        var v33 = IsBinary(BinaryOp.Mul, v32, IsTensorConst());
-        var v34 = IsBinary(BinaryOp.Add, v33, IsTensorConst());
-        var v35 = IsSwish(v34, IsTensorConst());
-        var v36 = IsConv2D(PadMode.Constant, v35, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v37 = IsBinary(null, "root", BinaryOp.Add, conv0, v36);
-        var v38 = IsBinary(null, "root", BinaryOp.Add, conv2, v36);
-        var v39 = IsBinary(null, "root", BinaryOp.Add, conv1, v36);
-        var v40 = IsBinary(null, "root", BinaryOp.Add, vIn, v36);
-        var root = IsAlt(v37, v38, v39, v40);
-
-        return root!;
-    }
-
-    private Call? GetReplace(Call root, IMatchResult result)
-    {
-        var oldInputs = new List<Expr> {
-            (Expr)result["input"],
-            (Expr)result["emb"],
-        };
-        if (result["input2"] is Expr expr)
-        {
-            oldInputs.Add(expr);
-        }
-
-        var newInputs = new List<Expr>();
-        foreach (var i in oldInputs)
-        {
-            newInputs.Add(new Var(i.CheckedType!));
-        }
-
-        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance);
-        for (var i = 0; i < newInputs.Count; i++)
-        {
-            multiVarMap.Add(oldInputs[i], (Var)newInputs[i]);
-        }
-
-        var merger = new FusionMerger(multiVarMap);
-        var clonedRoot = merger.Clone(root, default);
-
-        var callFusion = new Call(new Fusion("UnetResBlock", $"{nameof(FuseUnetResBlock)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), oldInputs.ToArray());
-        return callFusion;
-    }
-}
-
-/// <summary>
-/// stable-disffusion Unet TimeStep Embedding.
-/// </summary>
-[RuleGenerator]
-public sealed partial class FuseUnetTimeEmb : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => CreatePattern();
-
-    private static Pattern CreatePattern()
-    {
-        var vtimestep = IsWildcard("input");
-        var v8 = IsExpand(vtimestep, IsTensorConst());
-        var v9 = IsReshape(v8, IsTensorConst());
-        var v10 = IsCast(DataTypes.Float32, CastMode.KDefault, v9);
-        var v11 = IsBinary(BinaryOp.Mul, v10, IsTensorConst());
-        var v12 = IsUnary(UnaryOp.Sin, v11);
-        var v13 = IsUnary(UnaryOp.Cos, v11);
-        var v14 = IsTuple(IsVArgs(v12, v13));
-        var v15 = IsConcat(Axis: 1, v14);
-        var v16 = IsSlice(v15, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v17 = IsSlice(v15, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v18 = IsTuple(IsVArgs(v16, v17));
-        var v19 = IsConcat(Axis: 1, v18);
-        var v20 = IsMatMul(v19, IsTensorConst());
-        var v21 = IsBinary(BinaryOp.Add, v20, IsTensorConst());
-        var v22 = IsSwish(v21, IsTensorConst());
-        var v23 = IsMatMul(v22, IsTensorConst());
-        var v24 = IsBinary(BinaryOp.Add, v23, IsTensorConst());
-        var root = IsSwish(null, "root", v24, IsTensorConst());
-
-        return root!;
-    }
-
-    private Call? GetReplace(Call root, Expr input)
-    {
-        var newInputs = new List<Expr>
-        {
-            new Var(input.CheckedType!),
-        };
-
-        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
-        {
-            { input, (Var)newInputs[0] },
-        };
-        var merger = new FusionMerger(multiVarMap);
-        var clonedRoot = merger.Clone(root, default);
-
-        var callFusion = new Call(new Fusion("UnetTimeEmb", $"{nameof(FuseUnetTimeEmb)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
-        return callFusion;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Rules/VAEFusion.cs b/modules/Nncase.Modules.XPU/Passes/Rules/VAEFusion.cs
deleted file mode 100644
index bc8426f802..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Rules/VAEFusion.cs
+++ /dev/null
@@ -1,186 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reactive;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-using Nncase.IR.Math;
-using Nncase.IR.NN;
-using Nncase.IR.Tensors;
-using Nncase.Passes.Rules.Neutral;
-using Nncase.PatternMatch;
-using Nncase.Targets;
-using Nncase.TIR.XPU;
-using static Nncase.PatternMatch.F.Imaging;
-using static Nncase.PatternMatch.F.Math;
-using static Nncase.PatternMatch.F.NN;
-using static Nncase.PatternMatch.F.Tensors;
-using static Nncase.PatternMatch.Utility;
-using static Nncase.Utilities.ReplaceUtility;
-
-namespace Nncase.Passes.Rules;
-
-/// <summary>
-/// stable-disffusion VAE Decoder res-block.
-/// </summary>
-[RuleGenerator]
-public sealed partial class FuseVAEDecRes : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => CreatePattern();
-
-    private static Pattern CreatePattern()
-    {
-        var vIn = IsWildcard("input");
-        var vConv0 = IsConv2D(PadMode.Constant, vIn, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var vResize = IsResizeImage(ImageResizeMode.NearestNeighbor, ImageResizeTransformationMode.Asymmetric, ImageResizeNearestMode.Floor, false, vIn, IsWildcard(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var vConv1 = IsConv2D(PadMode.Constant, vConv0, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var vConv2 = IsConv2D(PadMode.Constant, vResize, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v1 = IsAlt(vConv2, vConv1, vIn);
-        var v2 = IsReshape(v1, IsTensorConst());
-        var v3 = IsInstanceNormalization(v2, IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v4 = IsReshape(v3, IsTensorConst());
-        var v5 = IsBinary(BinaryOp.Mul, v4, IsTensorConst());
-        var v6 = IsBinary(BinaryOp.Add, v5, IsTensorConst());
-        var v7 = IsSwish(v6, IsTensorConst());
-        var v8 = IsConv2D(PadMode.Constant, v7, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v9 = IsReshape(v8, IsTensorConst());
-        var v10 = IsInstanceNormalization(v9, IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v11 = IsReshape(v10, IsTensorConst());
-        var v12 = IsBinary(BinaryOp.Mul, v11, IsTensorConst());
-        var v13 = IsBinary(BinaryOp.Add, v12, IsTensorConst());
-        var v14 = IsSwish(v13, IsTensorConst());
-        var v15 = IsConv2D(PadMode.Constant, v14, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v16 = IsConv2D(PadMode.Constant, v1, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v17 = IsSwappableBinary(null!, "root", b => b.BinaryOp == BinaryOp.Add, v16, v15);
-        var v18 = IsSwappableBinary(null!, "root", b => b.BinaryOp == BinaryOp.Add, v1, v15);
-        var root = IsAlt(v17, v18);
-
-        return root;
-    }
-
-    private Call? GetReplace(Call root, Expr input)
-    {
-        var newInputs = new List<Expr>
-        {
-            new Var(input.CheckedType!),
-        };
-
-        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
-        {
-            { input, (Var)newInputs[0] },
-        };
-        var merger = new FusionMerger(multiVarMap);
-        var clonedRoot = merger.Clone(root, default);
-
-        var callFusion = new Call(new Fusion("VAEDecRes", $"{nameof(FuseVAEDecRes)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
-        return callFusion;
-    }
-}
-
-/// <summary>
-/// stable-disffusion VAE Decoder Head.
-/// </summary>
-[RuleGenerator]
-public sealed partial class FuseVAEDecHead : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => CreatePattern();
-
-    private static Pattern CreatePattern()
-    {
-        var v72 = IsWildcard("input");
-        var v73 = IsReshape(v72, IsTensorConst());
-        var v74 = IsInstanceNormalization(v73, IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v75 = IsReshape(v74, IsTensorConst());
-        var v76 = IsBinary(BinaryOp.Mul, v75, IsTensorConst());
-        var v77 = IsBinary(BinaryOp.Add, v76, IsTensorConst());
-        var v78 = IsSwish(v77, IsTensorConst());
-        var v79 = IsConv2D(null, "root", PadMode.Constant, v78, IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst(), IsTensorConst());
-
-        return v79!;
-    }
-
-    private Call? GetReplace(Call root, Expr input)
-    {
-        var newInputs = new List<Expr>
-        {
-            new Var(input.CheckedType!),
-        };
-
-        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
-        {
-            { input, (Var)newInputs[0] },
-        };
-        var merger = new FusionMerger(multiVarMap);
-        var clonedRoot = merger.Clone(root, default);
-
-        var callFusion = new Call(new Fusion("VAEDecHead", $"{nameof(FuseVAEDecHead)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
-        return callFusion;
-    }
-}
-
-/// <summary>
-/// stable-disffusion VAE Decoder MHA.
-/// </summary>
-[RuleGenerator]
-public sealed partial class FuseVAEDecMHA : FusionMaker
-{
-    public override string ModuleKind { get; } = XPUTarget.Kind;
-
-    public override Pattern Pattern => CreatePattern();
-
-    private static Pattern CreatePattern()
-    {
-        var v0 = IsWildcard("input");
-        var v1 = IsReshape(v0, IsTensorConst());
-        var v2 = IsInstanceNormalization(v1, IsTensorConst(), IsTensorConst(), IsTensorConst());
-        var v3 = IsReshape(v2, IsTensorConst());
-        var v4 = IsBinary(BinaryOp.Mul, v3, IsTensorConst());
-        var v5 = IsBinary(BinaryOp.Add, v4, IsTensorConst());
-        var v6 = IsReshape(v5, IsTensorConst());
-        var v7 = IsTranspose(v6, IsTensorConst());
-        var v8 = IsMatMul(v7, IsTensorConst());
-        var v9 = IsBinary(BinaryOp.Add, IsTensorConst(), v8);
-        var v10 = IsMatMul(v7, IsTensorConst());
-        var v11 = IsBinary(BinaryOp.Add, IsTensorConst(), v10);
-        var v12 = IsTranspose(v11, IsTensorConst());
-        var v13 = IsMatMul(v9, v12);
-        var v14 = IsBinary(BinaryOp.Mul, v13, IsTensorConst());
-        var v15 = IsBinary(BinaryOp.Add, v14, IsTensorConst());
-        var v16 = IsSoftmax(v15, IsTensorConst());
-        var v17 = IsMatMul(v7, IsTensorConst());
-        var v18 = IsBinary(BinaryOp.Add, IsTensorConst(), v17);
-        var v19 = IsMatMul(v16, v18);
-        var v20 = IsMatMul(v19, IsTensorConst());
-        var v21 = IsTranspose(v20, IsTensorConst());
-        var v22 = IsBinary(BinaryOp.Add, IsTensorConst(), v21);
-        var v23 = IsReshape(v22, IsTensorConst());
-        var v24 = IsBinary(null!, "root", BinaryOp.Add, v23, v0);
-        return v24!;
-    }
-
-    private Call? GetReplace(Call root, Expr input)
-    {
-        var newInputs = new List<Expr>
-        {
-            new Var(input.CheckedType!),
-        };
-
-        var multiVarMap = new Dictionary<Expr, Var>(ReferenceEqualityComparer.Instance)
-        {
-            { input, (Var)newInputs[0] },
-        };
-        var merger = new FusionMerger(multiVarMap);
-        var clonedRoot = merger.Clone(root, default);
-
-        var callFusion = new Call(new Fusion("VAEDecMHA", $"{nameof(FuseVAEDecMHA)}_{Count++}", ModuleKind, clonedRoot, newInputs.OfType<Var>().ToArray()), input);
-        return callFusion;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Tile/AutoDistributedConvertVisitor.cs b/modules/Nncase.Modules.XPU/Passes/Tile/AutoDistributedConvertVisitor.cs
deleted file mode 100644
index 80901c11b5..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Tile/AutoDistributedConvertVisitor.cs
+++ /dev/null
@@ -1,284 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.Reactive;
-using System.Runtime.CompilerServices;
-using NetFabric.Hyperlinq;
-using Nncase.IR;
-using Nncase.IR.CPU;
-using Nncase.IR.Tensors;
-
-[assembly: InternalsVisibleTo("Nncase.Tests")]
-
-namespace Nncase.Passes.Tile;
-
-internal sealed class AutoDistributedConvertVisitor : ExprVisitor<Dictionary<IRType, List<Expr>>, Unit>
-{
-    public AutoDistributedConvertVisitor(TileOptions tileOptions)
-    {
-        TileOptions = tileOptions;
-        Placement = new Placement(Placement.DeviceKind.CPU, tileOptions.Hierarchy, "bt");
-    }
-
-    public TileOptions TileOptions { get; }
-
-    public Placement Placement { get; }
-
-    public static IReadOnlyList<Expr> GetLeafCandidateBoxings(Expr expr, Placement placement)
-    {
-        return Utilities.DistributedUtility.GetLeafCandidateNDSBPs((TensorType)expr.CheckedType, placement).
-            Select(ndsbp => IR.F.CPU.Boxing(expr, new DistributedType((TensorType)expr.CheckedType, ndsbp, placement))).
-            ToArray();
-    }
-
-    public Expr Convert(Expr body)
-    {
-        var equivalents = Visit(body).Select(g => g.Value[0] switch
-        {
-            IR.Tuple tp => new IR.Tuple(tp.Fields.ToArray().Select((f, i) => IR.F.CPU.Boxing(f, ((IR.Tuple)body).Fields[i].CheckedType)).ToArray()),
-            Expr e => (Expr)IR.F.CPU.Boxing(e, body.CheckedType),
-        }).ToArray();
-        using (new ExprPinner(equivalents))
-        {
-            BranchCut();
-        }
-
-        var graph = new EGraph();
-        foreach (var (exprKey, buckets) in ExprMemo.Where(kv => kv.Key is not Op))
-        {
-            foreach (var (typeKey, bucket) in buckets.Where(kv => kv.Value.Any()))
-            {
-                Unions(graph, bucket);
-            }
-        }
-
-        var root = Unions(graph, equivalents);
-        return graph.Extract(root, null, out _);
-    }
-
-    protected override Dictionary<IRType, List<Expr>> DefaultVisitLeaf(Expr expr)
-    {
-        return new();
-    }
-
-    protected override Dictionary<IRType, List<Expr>> VisitLeafTuple(IR.Tuple expr)
-    {
-        return expr.Fields.ToArray().
-                Select(Visit).
-                CartesianProduct().
-                Select(e => new IR.Tuple(e.Select(e => e.Value[0]).ToArray())).
-                GroupBy(tp => tp.CheckedType).
-                ToDictionary(g => g.Key, g => g.ToList<Expr>());
-    }
-
-    protected override Dictionary<IRType, List<Expr>> VisitLeafCall(Call expr)
-    {
-        if (expr.Target is not Op op)
-        {
-            throw new NotSupportedException("not support auto distributed call function");
-        }
-
-        foreach (var param in op.Parameters)
-        {
-            VisitLeafArgument(param.ParameterKind, expr.Arguments[param.Index]);
-        }
-
-        return expr.Arguments.ToArray().
-                    Select(Visit).
-                    CartesianProduct().
-                    Select(args => args.ToArray()).
-                    Select(args => BuildEquivalCalls(op, args.Select(kv => kv.Value[0]).ToArray()).ToArray()).
-                    SelectMany(i => i).
-                    GroupBy(c => c.CheckedType).
-                    ToDictionary(g => g.Key, g => new List<Expr>(g.ToList<Expr>()));
-    }
-
-    private Dictionary<IRType, List<Expr>> VisitLeafArgument(ParameterKind parameterKind, Expr expr)
-    {
-        var updateBuckets = (Dictionary<IRType, List<Expr>> buckets, IEnumerable<Expr> equivalents) =>
-        {
-            foreach (var eq in equivalents)
-            {
-                if (!buckets.TryGetValue(eq.CheckedType, out var bucket))
-                {
-                    bucket = new();
-                    buckets.Add(eq.CheckedType, bucket);
-                }
-
-                bucket.Add(eq);
-            }
-        };
-
-        var buckets = ExprMemo[expr];
-        if (!buckets.Any())
-        {
-            switch (parameterKind, expr)
-            {
-                case (ParameterKind.Input, Expr e) when e is Const or Var:
-                    updateBuckets(buckets, GetLeafCandidateBoxings(e, Placement));
-                    break;
-                case (ParameterKind.Input, Expr e) when e is IR.Tuple tp:
-                    foreach (var f in tp.Fields)
-                    {
-                        VisitLeafArgument(parameterKind, f);
-                    }
-
-                    foreach (var (k, v) in VisitLeafTuple(tp))
-                    {
-                        buckets.Add(k, v);
-                    }
-
-                    break;
-                case (ParameterKind.Attribute, Var e):
-                    updateBuckets(buckets, new[] { e });
-                    break;
-                case (ParameterKind.Attribute, TensorConst e):
-                    updateBuckets(buckets, new[] { e.With() }); // remove all old users.
-                    break;
-                case (ParameterKind.Attribute, None e):
-                    updateBuckets(buckets, new[] { e.With() });
-                    break;
-                default:
-                    throw new InvalidOperationException();
-            }
-        }
-
-        return buckets;
-    }
-
-    private IEnumerable<Call> BuildEquivalCalls(Op target, Expr[] args)
-    {
-        if (!target.Parameters.Where(p => p.ParameterKind == ParameterKind.Input).All(p => IsDistributed(args[p.Index].CheckedType)))
-        {
-            throw new InvalidDataException();
-        }
-
-        var calls = new List<Call>();
-        var call = new Call(target, args);
-        var valid = call.InferenceType();
-        if (!valid)
-        {
-            // 1. dispose current call
-            using var pinner = new ExprPinner(args);
-            call.Dispose();
-
-            if (target is CPUKernelOp { Target: Reshape } || target is Reshape)
-            {
-                // the reshape need force boxing.
-                var newShape = ((TensorConst)args[1]).Value.ToArray<int>();
-                var inType = (DistributedType)args[0].CheckedType;
-                var tensorType = inType.TensorType with { Shape = newShape };
-                foreach (var boxing in Utilities.DistributedUtility.GetLeafCandidateNDSBPs(tensorType, inType.Placement).
-                    Select(ndsbp => IR.F.CPU.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))))
-                {
-                    if (boxing.CheckedType is InvalidType)
-                    {
-                        boxing.Dispose();
-                    }
-                    else
-                    {
-                        calls.Add(boxing);
-                    }
-                }
-            }
-            else
-            {
-                // todo expand search space.
-                // calls.AddRange(Utilities.DistributedUtility.GetLeafCandidateNDSBPs(tensorType, inType.Placement).
-                // Select(ndsbp => IR.F.CPU.Boxing(args[0], new DistributedType(tensorType, ndsbp, inType.Placement))));
-            }
-        }
-        else
-        {
-            calls.Add(call);
-            if (call.CheckedType is DistributedType distributedType)
-            {
-                calls.AddRange(Utilities.DistributedUtility.GetPartialCandidateNDSBPs(distributedType).
-                    Select(ndsbp => IR.F.CPU.Boxing(call, distributedType with { NdSBP = ndsbp })));
-            }
-        }
-
-        return calls;
-    }
-
-    private IReadOnlyList<Expr> GetReBoxings(Expr expr)
-    {
-        if (expr is IR.Tuple tuple)
-        {
-            var candidates = tuple.Fields.ToArray().
-                Select(GetReBoxings).
-                CartesianProduct();
-            return candidates.Any() ? candidates.
-                Select(fs => new IR.Tuple(fs.ToArray())).
-                ToArray() : Array.Empty<Expr>();
-        }
-
-        var type = (DistributedType)expr.CheckedType;
-        var tensorType = type.TensorType;
-        var candidateNdsbps = new List<SBP>[type.Placement.Rank];
-        for (int i = 0; i < type.Placement.Rank; i++)
-        {
-            candidateNdsbps[i] = new List<SBP> { SBP.B };
-            for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
-            {
-                if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && Utilities.DistributedUtility.IsDivisible(s, type.Placement.Hierarchy[i]))
-                {
-                    candidateNdsbps[i].Add(SBP.S(axis));
-                }
-            }
-        }
-
-        return candidateNdsbps.CartesianProduct().
-            Select(ndsbp => new IRArray<SBP>(ndsbp)).
-            Where(ndsbp => ndsbp != type.NdSBP).
-            Select(ndsbp => new DistributedType(tensorType, new IRArray<SBP>(ndsbp), type.Placement)).
-            Select(disttype => IR.F.CPU.Boxing(expr, disttype)).ToArray();
-    }
-
-    private bool IsDistributed(IRType type) => type switch
-    {
-        DistributedType => true,
-        TupleType t => t.All(IsDistributed),
-        _ => false,
-    };
-
-    private EClass Unions(EGraph graph, IEnumerable<Expr> equivalents)
-    {
-        var eids = equivalents.Select(graph.Add).ToArray();
-        foreach (var cls in eids.Skip(1))
-        {
-            graph.Union(eids[0], cls);
-        }
-
-        graph.Rebuild();
-        return eids[0];
-    }
-
-    private void BranchCut()
-    {
-        bool changed = true;
-        while (changed)
-        {
-            changed = false;
-            foreach (var (_, bukets) in ExprMemo)
-            {
-                foreach (var (_, buket) in bukets.Where(kv => kv.Value.Any()))
-                {
-                    if (!buket[0].Users.Any())
-                    {
-                        foreach (var item in buket)
-                        {
-                            using (new ExprPinner(item.Operands.ToArray()))
-                            {
-                                item.Dispose();
-                            }
-                        }
-
-                        buket.Clear();
-                        changed = true;
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Tile/IFusionChecker.cs b/modules/Nncase.Modules.XPU/Passes/Tile/IFusionChecker.cs
deleted file mode 100644
index 9c7bd70876..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Tile/IFusionChecker.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-
-namespace Nncase.Passes.Tile;
-
-internal interface IFusionChecker
-{
-    /// <summary>
-    /// 检查fusion是否可以正常执行.
-    /// </summary>
-    /// <param name="fusion">fusion.</param>
-    /// <param name="passOptions">passOptions.</param>
-    /// <returns>.</returns>
-    public bool Check(Fusion fusion, RunPassContext passOptions);
-
-    /// <summary>
-    /// 通常当check过一个fusion之后, 可以cache部分的内容, 此时通过convert复用.
-    /// </summary>
-    /// <param name="passOptions">passOptions.</param>
-    /// <returns>.</returns>
-    public TIR.PrimFunction Convert(RunPassContext passOptions);
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Tile/MultiFusionChecker.cs b/modules/Nncase.Modules.XPU/Passes/Tile/MultiFusionChecker.cs
deleted file mode 100644
index 0a5d5a31e3..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Tile/MultiFusionChecker.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.Collections.Immutable;
-using System.Runtime.CompilerServices;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.TIR;
-
-namespace Nncase.Passes.Tile;
-
-/// <summary>
-/// the multi Fusion checker.
-/// </summary>
-internal sealed class MultiFusionChecker : IFusionChecker
-{
-    public bool Check(Fusion fusion, RunPassContext passOptions) => false;
-
-    public PrimFunction Convert(RunPassContext passOptions) => throw new NotImplementedException();
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Tile/SingleXPUFusionConverter.cs b/modules/Nncase.Modules.XPU/Passes/Tile/SingleXPUFusionConverter.cs
deleted file mode 100644
index c90eb9d6ea..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Tile/SingleXPUFusionConverter.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using NetFabric.Hyperlinq;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.TIR;
-
-namespace Nncase.Passes.Tile;
-
-/// <summary>
-/// convert the fusion to prim func.
-/// </summary>
-internal sealed class SingleXPUFusionConverter
-{
-    public SingleXPUFusionConverter(TileOptions tileOptions)
-    {
-        TileOptions = tileOptions;
-    }
-
-    public TileOptions TileOptions { get; }
-
-    public TIR.PrimFunction Convert(Fusion fusion)
-    {
-        // 1. convert to distribute graph
-        var distConverter = new AutoDistributedConvertVisitor(TileOptions);
-        var body = distConverter.Convert(fusion.Body);
-        var newFusion = fusion.With(body: body);
-        if (DumpScope.Current.IsEnabled(DumpFlags.Tiling))
-        {
-            DumpScope.Current.DumpDotIR(newFusion, newFusion.Name, "Distribute");
-        }
-
-        // 2. convert new fusion to prim func
-        var primBody = new List<Expr>();
-        var visitor = new TIRConvertVisitor(primBody);
-        visitor.Visit(newFusion);
-        return T.PrimFunc(newFusion.Name, newFusion.ModuleKind, visitor.InputBuffers.Concat(visitor.OutputBuffers).ToArray()).Body(primBody.ToArray()).Build();
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Tile/TIRConvertVisitor.cs b/modules/Nncase.Modules.XPU/Passes/Tile/TIRConvertVisitor.cs
deleted file mode 100644
index 819bcadcf2..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Tile/TIRConvertVisitor.cs
+++ /dev/null
@@ -1,418 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.Reactive;
-using NetFabric.Hyperlinq;
-using Nncase.IR;
-using Nncase.IR.Imaging;
-using Nncase.IR.Math;
-using Nncase.IR.NN;
-using Nncase.IR.Tensors;
-using Nncase.TIR;
-using Nncase.Utilities;
-using Buffer = Nncase.TIR.Buffer;
-
-namespace Nncase.Passes.Tile;
-
-public sealed class TIRConvertVisitor : ExprVisitor<Unit, Unit>
-{
-    private readonly Dictionary<Expr, TIR.Buffer> _buffersMap = new(ReferenceEqualityComparer.Instance);
-    private readonly List<Expr> _mainBody;
-    private readonly List<(int, TIR.Buffer)> _outputbuffers;
-
-    public TIRConvertVisitor(List<Expr> mainBody)
-    {
-        _mainBody = mainBody;
-        _outputbuffers = new();
-    }
-
-    public Fusion VisitRootFusion => (Fusion)VisitRoot!;
-
-    public IEnumerable<TIR.Buffer> OutputBuffers => _outputbuffers.OrderBy(p => p.Item1).Select(p => p.Item2);
-
-    public IEnumerable<TIR.Buffer> InputBuffers => VisitRootFusion.Parameters.ToArray().Select(p => _buffersMap[p]).OfType<TIR.Buffer>().Where(b => b.MemSpan.Location.HasFlag(MemoryLocation.Input));
-
-    protected override Unit DefaultVisitLeaf(Expr expr)
-    {
-        return default;
-    }
-
-    protected override Unit VisitLeafCall(Call expr)
-    {
-        var arguments = expr.Arguments.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray();
-        var ret = AllocOrGetBuffer(expr);
-        var op = expr.Target is IR.CPU.CPUKernelOp kop ? kop.Target : expr.Target;
-        switch (op)
-        {
-            case Unary unary:
-                GenerateUnary(unary.UnaryOp.ToString().ToLower(System.Globalization.CultureInfo.CurrentCulture), arguments, ret);
-                break;
-            case Binary binary:
-                GenerateBinary(binary, arguments, ret, expr);
-                break;
-            case MatMul matmul:
-                GenerateMatmul(matmul, arguments, ret);
-                break;
-            case LayerNorm layernorm:
-                GenerateLayerNorm(layernorm, arguments, ret, (DistributedType)expr.Arguments[0].CheckedType);
-                break;
-            case InstanceNormalization instnorm:
-                GenerateInstanceNorm(instnorm, ((TensorConst)expr.Arguments[3]).Value.ToScalar<float>(), arguments, ret, (DistributedType)expr.Arguments[0].CheckedType);
-                break;
-            case Gather gather:
-                GenerateGather(gather, arguments, ret);
-                break;
-            case Concat concat:
-                GenerateConcat(concat, ((IR.Tuple)expr.Arguments[0]).Fields.AsValueEnumerable().Select(AllocOrGetBuffer).ToArray(), ret);
-                break;
-            case Slice slice:
-                GenerateSlice(slice, arguments[0], ret, expr.Arguments[1], expr.Arguments[2], expr.Arguments[3], (DistributedType)expr.CheckedType);
-                break;
-            case Softmax softmax:
-                GenerateSoftmax(softmax, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), arguments, ret, (DistributedType)expr.CheckedType);
-                break;
-            case Transpose transpose:
-                GenerateTranspose(transpose, ((TensorConst)expr.Arguments[1]).Value.ToArray<int>(), arguments, ret);
-                break;
-            case Reshape or Unsqueeze:
-                GenerateReshape(arguments[0], ret);
-                break;
-            case Swish:
-                GenerateSwishB(arguments[0], ret, ((TensorConst)expr.Arguments[1]).Value.ToScalar<float>());
-                break;
-            case Gelu:
-                GenerateUnary("gelu", arguments, ret);
-                break;
-            case IR.CPU.Boxing boxing:
-                GenerateBoxing(boxing, arguments, ret, expr);
-                break;
-            case Conv2D conv:
-                GenerateConv2D(conv, arguments, ret, ((TensorConst)expr.Arguments[3]).Value.ToArray<int>(), ((TensorConst)expr.Arguments[4]).Value.ToArray<int>(), ((TensorConst)expr.Arguments[5]).Value.ToArray<int>(), ((TensorConst)expr.Arguments[6]).Value.ToScalar<int>(), (TensorConst)expr.Arguments[7], (DistributedType)expr.CheckedType);
-                break;
-            case ReduceArg reduceArg:
-                GenerateReduceArg(reduceArg, arguments, ret, ((TensorConst)expr.Arguments[1]).Value.ToScalar<int>(), ((TensorConst)expr.Arguments[2]).Value.ToScalar<bool>(), ((TensorConst)expr.Arguments[3]).Value.ToScalar<bool>(), reduceArg.ReduceArgOp, reduceArg.DestType);
-                break;
-            case ResizeImage resize:
-                float[] roi = expr.Arguments[1] is TensorConst tc ? tc.Value.ToArray<float>() : new[] { 0f, 0f, 1f, 1f };
-                int[] newSize = ((TensorConst)expr.Arguments[2]).Value.ToArray<int>();
-                float cubicCoeffA = expr.Arguments[3] is TensorConst tc1 ? tc1.Value.ToScalar<float>() : -0.75f;
-                int excludeOutside = expr.Arguments[4] is TensorConst tc2 ? tc2.Value.ToScalar<int>() : 0;
-                float extrapolationValue = expr.Arguments[5] is TensorConst tc3 ? tc3.Value.ToScalar<float>() : 0f;
-                GenerateResize(resize, arguments, ret, roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, (DistributedType)expr.CheckedType);
-                break;
-            case Cast cast:
-                GenerateCast(cast.NewType, cast.CastMode, arguments, ret);
-                break;
-            case Expand expand:
-                GenerateExpand(((TensorConst)expr.Arguments[1]).Value.ToArray<int>(), (DistributedType)expr.CheckedType, arguments, ret);
-                break;
-            case Clamp clamp:
-                GenerateClamp(arguments, ret, ((TensorConst)expr.Arguments[1]).Value.ToArray<float>()[0], ((TensorConst)expr.Arguments[2]).Value.ToArray<float>()[0]);
-                break;
-            default:
-                throw new NotSupportedException();
-        }
-
-        return default;
-    }
-
-    private void GenerateSwishB(Buffer input, Buffer ret, float beta)
-    {
-        _mainBody.Add(TIR.F.XPU.SwishB(input, ret, beta));
-    }
-
-    private void GenerateReshape(Buffer input, Buffer ret)
-    {
-        _mainBody.Add(TIR.F.XPU.ReShape(input, ret));
-    }
-
-    private void GenerateConcat(Concat concat, Buffer[] inputs, Buffer ret)
-    {
-        _mainBody.Add(TIR.F.XPU.Concat(concat.Axis, inputs, ret));
-    }
-
-    private void GenerateSlice(Slice slice, Buffer input, Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType)
-    {
-        _mainBody.Add(TIR.F.XPU.Slice(input, output, begins, ends, axes, distributedType));
-    }
-
-    private void GenerateBoxing(IR.CPU.Boxing boxing, Buffer[] arguments, Buffer ret, Call expr)
-    {
-        switch (expr.Arguments[0].CheckedType, boxing.NewType)
-        {
-            case (TensorType, DistributedType distTensorType):
-                {
-                    _mainBody.Add(TIR.F.XPU.TDMALoad(ret, arguments[0], distTensorType.NdSBP, distTensorType.Placement));
-                }
-
-                break;
-            case (DistributedType distTensorType, TensorType):
-                {
-                    _mainBody.Add(TIR.F.XPU.TDMAStore(arguments[0], ret, distTensorType.NdSBP, distTensorType.Placement));
-                }
-
-                break;
-            case (DistributedType inType, DistributedType outType):
-                {
-                    var partialSumPos = Enumerable.Range(0, inType.NdSBP.Count).Where(i => inType.NdSBP[i] is SBPPartialSum).Select(i => (i, outType.NdSBP[i])).ToArray();
-                    if (partialSumPos.Length > 0)
-                    {
-                        var placement = inType.Placement with
-                        {
-                            Hierarchy = new IRArray<int>(partialSumPos.Select(t => inType.Placement.Hierarchy[t.i])),
-                            Name = new string(partialSumPos.Select(t => inType.Placement.Name[t.i]).ToArray()),
-                        };
-                        _mainBody.Add(TIR.F.XPU.GatherReduceScatter(arguments[0], ret, partialSumPos, placement));
-                    }
-                    else
-                    {
-                        _mainBody.Add(TIR.F.XPU.TDMAStore(arguments[0], None.Default, inType.NdSBP, inType.Placement));
-                        _mainBody.Add(TIR.F.XPU.TDMALoad(ret, None.Default, outType.NdSBP, outType.Placement));
-                    }
-                }
-
-                break;
-            default:
-                throw new NotSupportedException();
-        }
-    }
-
-    private void GenerateUnary(string unaryOp, ReadOnlySpan<Buffer> arguments, Buffer ret)
-    {
-        var input = arguments[IR.Math.Unary.Input.Index];
-        _mainBody.Add(TIR.F.XPU.Unary(unaryOp, input, ret));
-    }
-
-    private void GenerateBinary(Binary binary, Buffer[] arguments, Buffer ret, Call expr)
-    {
-        var lhs = (DistributedType)expr[Binary.Lhs].CheckedType;
-        var rhs = (DistributedType)expr[Binary.Rhs].CheckedType;
-        var outtype = (DistributedType)expr.CheckedType;
-        _mainBody.Add(TIR.F.XPU.Binary(binary.BinaryOp, lhs, rhs, outtype, arguments[0], arguments[1], ret));
-    }
-
-    private void GenerateMatmul(MatMul matmul, Buffer[] arguments, Buffer ret)
-    {
-        _mainBody.Add(TIR.F.XPU.Matmul(arguments[0], arguments[1], ret));
-    }
-
-    private void GenerateLayerNorm(LayerNorm layerNorm, Buffer[] arguments, Buffer ret, DistributedType distributedType)
-    {
-        _mainBody.Add(TIR.F.XPU.LayerNorm(layerNorm.Axis, layerNorm.Epsilon, layerNorm.UseMean, arguments[0], arguments[1], arguments[2], ret, distributedType));
-    }
-
-    private void GenerateInstanceNorm(InstanceNormalization instNorm, float eps, Buffer[] arguments, Buffer ret, DistributedType distributedType)
-    {
-        _mainBody.Add(TIR.F.XPU.InstanceNorm(eps, arguments[0], arguments[1], arguments[2], ret, distributedType));
-    }
-
-    private void GenerateGather(Gather gahter, Buffer[] arguments, Buffer ret)
-    {
-        _mainBody.Add(TIR.F.XPU.Gather(gahter.Axis, arguments[0], arguments[1], ret));
-    }
-
-    private void GenerateSoftmax(Softmax softmax, int axis, Buffer[] arguments, Buffer ret, DistributedType distributedType)
-    {
-        _mainBody.Add(TIR.F.XPU.Softmax(axis, arguments[0], ret, distributedType));
-    }
-
-    private void GenerateTranspose(Transpose transpose, int[] perm, Buffer[] arguments, Buffer ret)
-    {
-        _mainBody.Add(TIR.F.XPU.Transpose(perm, arguments[0], ret));
-    }
-
-    private void GenerateConv2D(Conv2D conv, Buffer[] arguments, Buffer ret, int[] stride, int[] padding, int[] dilation, int groups, TensorConst fusedClamp, DistributedType distributedType)
-    {
-        _mainBody.Add(TIR.F.XPU.Conv2D(arguments[0], arguments[1], arguments[2], ret, stride, padding, dilation, groups, fusedClamp, distributedType));
-    }
-
-    private void GenerateReduceArg(ReduceArg reduceArg, Buffer[] arguments, Buffer ret, int axis, bool keepdims, bool selectLastIndex, ReduceArgOp op, DataType dataType)
-    {
-        _mainBody.Add(TIR.F.XPU.ReduceArg(arguments[0], ret, axis, keepdims, selectLastIndex, op, dataType));
-    }
-
-    private void GenerateResize(ResizeImage resize, Buffer[] arguments, Buffer ret, float[] roi, int[] newSize, float cubicCoeffA, int excludeOutside, float extrapolationValue, DistributedType distributedType)
-    {
-        _mainBody.Add(TIR.F.XPU.Resize(arguments[0], ret, roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, resize.ResizeMode, resize.TransformationMode, resize.NearestMode, resize.IsTFResize));
-    }
-
-    private void GenerateCast(DataType dataType, CastMode castMode, ReadOnlySpan<Buffer> arguments, Buffer ret)
-    {
-        _mainBody.Add(TIR.F.XPU.Cast(arguments[0], ret, dataType, castMode));
-    }
-
-    private void GenerateExpand(int[] shape, DistributedType distributedType, ReadOnlySpan<Buffer> arguments, Buffer ret)
-    {
-        _mainBody.Add(TIR.F.XPU.Expand(shape, distributedType, arguments[0], ret));
-    }
-
-    private void GenerateClamp(ReadOnlySpan<Buffer> arguments, Buffer ret, float min, float max)
-    {
-        _mainBody.Add(TIR.F.XPU.Clamp(arguments[0], ret, min, max));
-    }
-
-#if false
-        private void GenerateUnary(IR.Math.Unary unary, ReadOnlySpan<Buffer> arguments, Buffer ret)
-        {
-            var loops = Enumerable.Range(0, input.Rank).Select(i => (T.ForLoop(out var loopVar, (0, input.Dimensions[i]), i == 0 ? LoopMode.Parallel : LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
-            var loopVars = loops.Select(f => f.loopVar).ToArray();
-            Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Unary(unary.UnaryOp, T.BufferLoad(input, loopVars)));
-            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-            _mainBody.Add(T.Block(nameof(Unary)).Body(
-                T.MatchBuffer(arguments[0]),
-                T.MatchBuffer(ret),
-                final).Build());
-        }
-
-        private void GenerateMatMul(ReadOnlySpan<Buffer> arguments, Buffer ret, Call expr)
-        {
-            var lhs = arguments[0];
-            var rhs = arguments[1];
-            var loops = Enumerable.Range(0, lhs.Rank - 2).Select(i => (T.ForLoop(out var loopVar, (0, lhs.Dimensions[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
-            var loopVars = loops.Select(f => f.loopVar).ToArray();
-            var stmt = T.ForLoop(out var m, (0, lhs.Dimensions[^2]), LoopMode.Parallel).Body(
-                T.Serial(out var n, (0, rhs.Dimensions[^1])).Body(
-                    T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), 0f),
-                    T.Serial(out var k, (0, lhs.Dimensions[^1])).Body(
-                        T.BufferStore(ret, loopVars.Concat(new[] { m, n }).ToArray(), T.BufferLoad(ret, loopVars.Concat(new[] { m, n }).ToArray()) + (T.BufferLoad(lhs, loopVars.Concat(new[] { m, k }).ToArray()) * T.BufferLoad(rhs, loopVars.Concat(new[] { k, n }).ToArray())))))).
-                Build();
-            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-            // [m,k] @ [k, n]
-            var body = T.Block(nameof(MatMul)).Body(
-                T.MatchBuffer(arguments[0]),
-                T.MatchBuffer(arguments[1]),
-                T.MatchBuffer(ret),
-                final);
-            _mainBody.Add(body.Build());
-        }
-
-        private void GenerateBinary(Binary binary, ReadOnlySpan<Buffer> arguments, Buffer ret, Call call)
-        {
-            var lhs = call.Arguments[Binary.Lhs.Index];
-            var rhs = call.Arguments[Binary.Rhs.Index];
-            var lhsBuffer = arguments[Binary.Lhs.Index];
-            var rhsBuffer = arguments[Binary.Rhs.Index];
-
-            var outShape = call.CheckedShape.ToValueArray();
-            var lhsShape = Enumerable.Repeat(1, outShape.Length).ToArray();
-            Array.Copy(lhs.CheckedShape.ToValueArray(), 0, lhsShape, lhsShape.Length - lhs.CheckedShape.Rank, lhs.CheckedShape.Rank);
-            var rhsShape = Enumerable.Repeat(1, outShape.Length).ToArray();
-            Array.Copy(rhs.CheckedShape.ToValueArray(), 0, rhsShape, rhsShape.Length - rhs.CheckedShape.Rank, rhs.CheckedShape.Rank);
-
-            var lhsScale = outShape.Zip(lhsShape).Select(s => s.First / s.Second).ToArray();
-            var rhsScale = outShape.Zip(rhsShape).Select(s => s.First / s.Second).ToArray();
-
-            var loops = Enumerable.Range(0, outShape.Length).Select(i => (T.ForLoop(out var loopVar, (0, outShape[i]), LoopMode.Serial, $"loop_{i}"), loopVar)).ToArray();
-            var loopVars = loops.Select(f => f.loopVar).ToArray();
-            var lhsLoopVars = loopVars.Zip(lhsScale).Select(v => v.First / v.Second).ToArray();
-            var rhsLoopVars = loopVars.Zip(rhsScale).Select(v => v.First / v.Second).ToArray();
-            Expr stmt = T.BufferStore(ret, loopVars, IR.F.Math.Binary(binary.BinaryOp, T.BufferLoad(lhsBuffer, lhsLoopVars), T.BufferLoad(rhsBuffer, rhsLoopVars)));
-            var final = loops.Reverse().Aggregate(stmt, (acc, p) => p.Item1.Body(acc).Build());
-            var body = T.Block(nameof(Binary)).Body(
-                T.MatchBuffer(arguments[0]),
-                T.MatchBuffer(arguments[1]),
-                T.MatchBuffer(ret),
-                final);
-            _mainBody.Add(body.Build());
-        }
-#endif
-
-    private TIR.Buffer AllocOrGetBuffer(Expr expr)
-    {
-        var name = $"buffer_{_buffersMap.Keys.Count}";
-        if (!_buffersMap.TryGetValue(expr, out var buffer))
-        {
-            switch (expr)
-            {
-                case Call c:
-                    var (type, loc) = GetTypeAndLocation(c.CheckedType);
-                    var index = CheckRootCall(c, ref loc);
-                    buffer = T.AttachBuffer(type, loc, out _, out _, name);
-                    if (index != -1)
-                    {
-                        _outputbuffers.Add((index, buffer));
-                    }
-
-                    break;
-                case Var v:
-                    buffer = T.AttachBuffer((TensorType)v.CheckedType, MemoryLocation.Input, out _, out _, name);
-                    break;
-                case TensorConst c:
-                    buffer = T.AttachBuffer(c, out _, name);
-                    break;
-                case IR.Tuple:
-                    return null!;
-                case IR.None:
-                    return null!;
-                default:
-                    throw new NotSupportedException();
-            }
-
-            _buffersMap.Add(expr, buffer);
-        }
-
-        return buffer;
-    }
-
-    private int CheckRootCall(Call c, ref MemoryLocation loc)
-    {
-        var index = -1;
-        if (VisitRootFusion.Body is Call rootCall && ReferenceEquals(c, rootCall))
-        {
-            index = 0;
-            loc = MemoryLocation.Output;
-        }
-        else if (VisitRootFusion.Body is IR.Tuple tp)
-        {
-            for (int i = 0; i < tp.Fields.Length; i++)
-            {
-                if (ReferenceEquals(tp.Fields[i], c))
-                {
-                    index = i;
-                    loc = MemoryLocation.Output;
-                }
-            }
-        }
-
-        return index;
-    }
-
-    private Tuple<TensorType, MemoryLocation> GetTypeAndLocation(IRType type)
-    {
-        MemoryLocation location = MemoryLocation.Data;
-        if (type is DistributedType distTensorType)
-        {
-            if (distTensorType.Placement.Rank == 2)
-            {
-                location = MemoryLocation.L1Data;
-            }
-            else if (distTensorType.Placement.Rank == 1)
-            {
-                location = MemoryLocation.L2Data;
-            }
-        }
-
-        TensorType tensorType;
-        if (type is DistributedType distTensor)
-        {
-            if (!DistributedUtility.IsDistributable(distTensor.TensorType, distTensor.NdSBP.ToArray(), distTensor.Placement, out var tType))
-            {
-                throw new NotSupportedException();
-            }
-            else
-            {
-                tensorType = tType;
-            }
-        }
-        else if (type is TensorType ttype)
-        {
-            tensorType = ttype;
-        }
-        else
-        {
-            throw new NotSupportedException();
-        }
-
-        return new Tuple<TensorType, MemoryLocation>(tensorType, location);
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Tile/TileOptions.cs b/modules/Nncase.Modules.XPU/Passes/Tile/TileOptions.cs
deleted file mode 100644
index ab5091d606..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Tile/TileOptions.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Nncase.Passes.Tile;
-
-/// <summary>
-/// TileOptions.
-/// </summary>
-/// <param name="TargetTileSize">TargetTileSize.</param>
-/// <param name="Hierarchy">the hierarchy shapes.</param>
-/// <param name="HierarchySizes">each hierarchy ram size.</param>
-public sealed record TileOptions(int[] TargetTileSize, int[] Hierarchy, int[] HierarchySizes)
-{
-    public static TileOptions Default { get; } = new(Array.Empty<int>(), new[] { 8, 4 }, new[] { 30 * (int)MathF.Pow(2, 30), 10 * (int)MathF.Pow(2, 30) });
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/Tile/XPUSameInputFusionMergeRule.cs b/modules/Nncase.Modules.XPU/Passes/Tile/XPUSameInputFusionMergeRule.cs
deleted file mode 100644
index d4d99f95b7..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/Tile/XPUSameInputFusionMergeRule.cs
+++ /dev/null
@@ -1,162 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using System.Runtime.CompilerServices;
-using Nncase.IR;
-using Nncase.PatternMatch;
-using Nncase.Targets;
-using static Nncase.PatternMatch.Utility;
-
-namespace Nncase.Passes.Tile;
-
-internal sealed class XPUSameInputFusionMergeRule : Mutators.SameInputFusionMergeRule
-{
-    public override string ModuleKind => XPUTarget.Kind;
-
-    // todo enable multi input fusion merge pattern.
-    public override Pattern CreatePattern(string target_module_kind)
-    {
-        var inputPat = IsWildcard("input");
-
-        var callerPattern = IsCall(
-            "caller",
-            IsFusion(
-                "caller_fusion",
-                target_module_kind,
-                IsWildcard(),
-                IsVArgs(IsWildcard())),
-            IsVArgs("caller_inputs", new[] {
-              IsCall(
-                  $"callee_{0}",
-                  IsFusion($"callee_fusion_{0}", target_module_kind, IsWildcard(), IsVArgs(IsWildcard())),
-                  inputPat),
-            }));
-        return callerPattern;
-    }
-}
-
-internal sealed class XPUFusionGroupMutator<T> : Mutators.FusionGroupMutator
-  where T : IFusionChecker
-{
-    private readonly TileOptions _tileOptions;
-
-    public XPUFusionGroupMutator(
-      Dictionary<Fusion, IFusionChecker> fusioncheckerCache,
-      TileOptions tileOptions,
-      Mutators.IMergeRewriteRule rule,
-      RunPassContext passOptions)
-        : base(rule, passOptions)
-    {
-        _tileOptions = tileOptions;
-        FusioncheckerCache = fusioncheckerCache;
-    }
-
-    public Dictionary<Fusion, IFusionChecker> FusioncheckerCache { get; }
-
-    /// <inheritdoc/>
-    public override bool MergedFusionCheckCallBack(Fusion mergedFusion, HashSet<Fusion> candidateFusions)
-    {
-        // var checker = (IFusionChecker)Activator.CreateInstance(typeof(T), new object[] { _tileOptions })!;
-        // var ret = checker.Check(mergedFusion, PassOptions);
-        // if (ret)
-        // {
-        //     FusioncheckerCache.Add(mergedFusion, checker);
-        //     foreach (var cand in candidateFusions)
-        //     { // release the merged fusion.
-        //         FusioncheckerCache.Remove(cand);
-        //     }
-        // }
-
-        // return ret;
-        return false;
-    }
-
-    public override Expr MergedFusionRewriteCallBack(Expr mergedFusionBody)
-    {
-        return mergedFusionBody;
-    }
-}
-
-internal sealed class CheckedConvertMutator : ExprRewriter
-{
-    private readonly Dictionary<Fusion, BaseFunction> _fusionConertedCache;
-    private readonly IReadOnlyDictionary<Fusion, IFusionChecker> _fusionCheckerCache;
-    private readonly TileOptions _tileOptions;
-    private readonly RunPassContext _passOptions;
-
-    public CheckedConvertMutator(Dictionary<Fusion, BaseFunction> fusion_converted_cache, IReadOnlyDictionary<Fusion, IFusionChecker> fusionchecker_cache, TileOptions tileOptions, RunPassContext passOptions)
-    {
-        _fusionConertedCache = fusion_converted_cache;
-        _fusionCheckerCache = fusionchecker_cache;
-        _tileOptions = tileOptions;
-        _passOptions = passOptions;
-    }
-
-    /// <inheritdoc/>
-    protected override Expr RewriteLeafFusion(Fusion expr)
-    {
-        if (expr is Fusion { ModuleKind: XPUTarget.Kind } fusion)
-        {
-            if (!_fusionConertedCache.TryGetValue(fusion, out _))
-            {
-                TIR.PrimFunction prim_func;
-                if (_fusionCheckerCache.TryGetValue(fusion, out var checker))
-                {
-                    prim_func = checker.Convert(_passOptions);
-                }
-                else
-                {
-                    var converter = new SingleXPUFusionConverter(_tileOptions);
-                    prim_func = converter.Convert(fusion);
-                }
-
-                BaseFunction? convert_func = prim_func;
-                _fusionConertedCache.Add(fusion, convert_func);
-            }
-        }
-
-        return expr;
-    }
-
-    protected override Expr RewriteLeafCall(Call expr)
-    {
-        if (expr.Target is Fusion { ModuleKind: XPUTarget.Kind } fusion)
-        {
-            var convert_func = _fusionConertedCache[fusion];
-            PrimFunctionWrapper wrapper;
-            if (convert_func is TIR.PrimFunction prim_func)
-            {
-                bool is_input = true;
-                int param_count = 0;
-                foreach (var b in prim_func.Parameters)
-                {
-                    if (b.MemSpan.Location == TIR.MemoryLocation.Input)
-                    {
-                        if (is_input)
-                        {
-                            param_count += 1;
-                        }
-                        else
-                        {
-                            throw new InvalidOperationException("The output buffer must behind the input buffer");
-                        }
-                    }
-                    else
-                    {
-                        is_input = false;
-                    }
-                }
-
-                wrapper = new PrimFunctionWrapper(prim_func, param_count);
-                _fusionConertedCache[fusion] = wrapper;
-            }
-            else
-            {
-                wrapper = (PrimFunctionWrapper)convert_func;
-            }
-
-            return expr.With(target: wrapper);
-        }
-
-        return expr;
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/Passes/XPUFusionToTirPass.cs b/modules/Nncase.Modules.XPU/Passes/XPUFusionToTirPass.cs
deleted file mode 100644
index 3cdbf9f40f..0000000000
--- a/modules/Nncase.Modules.XPU/Passes/XPUFusionToTirPass.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.Passes.Analysis;
-using Nncase.Passes.Mutators;
-using Nncase.Passes.Tile;
-using Nncase.Targets;
-using Nncase.TIR;
-
-namespace Nncase.Passes;
-
-internal sealed class XPUFusionToTirPass : ModulePass
-{
-    private readonly TileOptions _tileOptions;
-
-    public XPUFusionToTirPass(TileOptions tileOptions)
-    {
-        _tileOptions = tileOptions;
-    }
-
-    private IAnalyzerManager AnalyzerManager => CompileSession.GetRequiredService<IAnalyzerManager>();
-
-    /// <inheritdoc/>
-    protected override Task<IRModule> RunCoreAsync(IRModule module, RunPassContext options)
-    {
-        Dictionary<Fusion, BaseFunction> fusionConertedCache = new(ReferenceEqualityComparer.Instance);
-
-        for (int i = 0; i < module.Functions.Count; i++)
-        {
-            if (module.Functions[i] is Function { ModuleKind: string kind } func && kind == Callable.StackVMModuleKind)
-            {
-                var analysis = new Dictionary<Type, IAnalysisResult> { [typeof(IExprUserAnalysisResult)] = AnalyzerManager.GetAnaylsis<IExprUserAnalysisResult>(func), };
-                var rewriter = new DataFlowMergeRewriter();
-                var fusionCheckCache = new Dictionary<Fusion, IFusionChecker>(ReferenceEqualityComparer.Instance);
-
-                var post = (Function)rewriter.Rewrite(
-                    func,
-                    new Mutators.IMergeRewriteRule[] { new XPUSameInputFusionMergeRule() },
-                    (rule, option) => new XPUFusionGroupMutator<MultiFusionChecker>(fusionCheckCache, _tileOptions, rule, option),
-                    new() { AnalysisResults = analysis, MatchOptions = new Mutators.FusionGroupMutator.GroupedMatchOptions() });
-
-                var mutator = new CheckedConvertMutator(fusionConertedCache, fusionCheckCache, _tileOptions, options);
-                var new_func = (Function)mutator.Rewrite(post);
-                CompilerServices.InferenceType(new_func);
-                if (mutator.IsMutated)
-                {
-                    module.Replace(i, new_func);
-                }
-            }
-        }
-
-        foreach (var item in fusionConertedCache.Values)
-        {
-            if (item is PrimFunctionWrapper wrapper)
-            {
-                module.Add(wrapper);
-                module.Add(wrapper.Target);
-            }
-        }
-
-        return Task.FromResult(module);
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Binary.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Binary.cs
deleted file mode 100644
index 1673988240..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Binary.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Binary : XPUKernelOp
-{
-    public static readonly ParameterInfo Lhs = new(typeof(Binary), 0, "input");
-
-    public static readonly ParameterInfo Rhs = new(typeof(Binary), 1, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(Binary), 2, "output");
-
-    public BinaryOp BinaryOp { get; }
-
-    public DistributedType LhsType { get; }
-
-    public DistributedType RhsType { get; }
-
-    public DistributedType OutType { get; }
-
-    /// <inheritdoc/>
-    public override string DisplayProperty()
-    {
-        return $"BinaryOp.{BinaryOp}";
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Cast.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Cast.cs
deleted file mode 100644
index 7f05949cc7..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Cast.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Cast : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(Cast), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(Cast), 1, "output");
-
-    public DataType NewType { get; }
-
-    public CastMode CastMode { get; }
-
-    /// <inheritdoc/>
-    public override string DisplayProperty() => $"{NewType.GetCSharpName()}, CastMode.{CastMode}";
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Clamp.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Clamp.cs
deleted file mode 100644
index 58058caa24..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Clamp.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using System.Dynamic;
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Clamp : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(Clamp), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(Clamp), 1, "output");
-
-    public float Min { get; }
-
-    public float Max { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Concat.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Concat.cs
deleted file mode 100644
index 5cf46941e8..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Concat.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Concat : XPUKernelOp
-{
-    public int Axis { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Conv2D.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Conv2D.cs
deleted file mode 100644
index ee1df6afe0..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Conv2D.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Conv2D : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(Conv2D), 0, "input");
-
-    public static readonly ParameterInfo Weights = new(typeof(Conv2D), 1, "weights");
-
-    public static readonly ParameterInfo Bias = new(typeof(Conv2D), 2, "bias");
-
-    public IRArray<int> Stride { get; }
-
-    public IRArray<int> Padding { get; }
-
-    public IRArray<int> Dilation { get; }
-
-    public int Groups { get; }
-
-    public TensorConst FusedClamp { get; }
-
-    public DistributedType DistType { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Expand.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Expand.cs
deleted file mode 100644
index 0cf63b57e1..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Expand.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Expand : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(Expand), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(Expand), 1, "output");
-
-    public IRArray<int> Shape { get; }
-
-    public IRArray<SBP> NdSbp { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Functional.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Functional.cs
deleted file mode 100644
index 215a0103cd..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Functional.cs
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-using Nncase.TIR;
-using Nncase.TIR.XPU;
-
-namespace Nncase.TIR.F;
-
-public partial class XPU
-{
-    public static Call TDMALoad(Expr dest, Expr src, IRArray<SBP> ndsbp, Placement placement)
-    {
-        return new Call(new TDMALoad(ndsbp, placement), dest, src);
-    }
-
-    public static Call TDMAStore(Expr src, Expr dest, IRArray<SBP> ndsbp, Placement placement)
-    {
-        return new Call(new TDMAStore(ndsbp, placement), src, dest);
-    }
-
-    public static Call Unary(string unaryOp, Expr input, Expr output)
-    {
-        return new Call(new Unary(unaryOp), input, output);
-    }
-
-    public static Call Binary(BinaryOp binaryOp, DistributedType ltype, DistributedType rtype, DistributedType outtype, Expr lhs, Expr rhs, Expr output)
-    {
-        return new Call(new Binary(binaryOp, ltype, rtype, outtype), lhs, rhs, output);
-    }
-
-    public static Call Matmul(Expr lhs, Expr rhs, Expr output)
-    {
-        return new Call(new Matmul(), lhs, rhs, output);
-    }
-
-    public static Call LayerNorm(int axis, float eps, bool useMean, Expr input, Expr scale, Expr bias, Expr output, DistributedType distributedType)
-    {
-        return new Call(new LayerNorm(axis, eps, useMean, distributedType), input, scale, bias, output);
-    }
-
-    public static Call InstanceNorm(float eps, Expr input, Expr scale, Expr bias, Expr output, DistributedType distributedType)
-    {
-        return new Call(new InstanceNorm(eps, distributedType), input, scale, bias, output);
-    }
-
-    public static Call Gather(int axis, Expr input, Expr indices, Expr output)
-    {
-        return new Call(new TIR.XPU.Gather(axis), input, indices, output);
-    }
-
-    public static Call Concat(int axis, Expr[] inputs, Expr output)
-    {
-        return new Call(new Concat(axis), inputs.Concat(new[] { output }).ToArray());
-    }
-
-    public static Expr Slice(TIR.Buffer input, TIR.Buffer output, Expr begins, Expr ends, Expr axes, DistributedType distributedType)
-    {
-        return new Call(new Slice(distributedType), input, output, begins, ends, axes);
-    }
-
-    public static Call Softmax(int axis, Expr input, Expr output, DistributedType distributedType)
-    {
-        return new Call(new TIR.XPU.Softmax(axis, distributedType), input, output);
-    }
-
-    public static Call Transpose(int[] perm, Expr input, Expr output)
-    {
-        return new Call(new TIR.XPU.Transpose(perm), input, output);
-    }
-
-    public static Call ReShape(Expr input, Expr output)
-    {
-        return new Call(new TIR.XPU.ReShape(), input, output);
-    }
-
-    public static Call SwishB(Expr input, Expr output, float beta)
-    {
-        return new Call(new TIR.XPU.SwishB(beta), input, output);
-    }
-
-    public static Call GatherReduceScatter(Expr input, Expr output, (int, SBP)[] reducePosition, Placement placement)
-    {
-        return new Call(new GatherReduceScatter(reducePosition, placement), input, output);
-    }
-
-    public static Call Conv2D(Expr input, Expr weights, Expr bias, Expr output, int[] stride, int[] padding, int[] dilation, int groups, TensorConst fusedClamp, DistributedType distributedType)
-    {
-        return new Call(new Conv2D(stride, padding, dilation, groups, fusedClamp, distributedType), input, weights, bias, output);
-    }
-
-    public static Call ReduceArg(Expr input, Expr output, int axis, bool keepdims, bool selectLastIndex, ReduceArgOp op, DataType dataType)
-    {
-        return new Call(new ReduceArg(axis, keepdims, selectLastIndex, op, dataType), input, output);
-    }
-
-    public static Call Resize(Expr input, Expr output, float[] roi, int[] newSize, float cubicCoeffA, int excludeOutside, float extrapolationValue, ImageResizeMode resizeMode, ImageResizeTransformationMode transformationMode, ImageResizeNearestMode nearestMode, bool isTFResize)
-    {
-        return new Call(new Resize(roi, newSize, cubicCoeffA, excludeOutside, extrapolationValue, resizeMode, transformationMode, nearestMode, isTFResize), input, output);
-    }
-
-    public static Call Cast(Expr input, Expr output, DataType dataType, CastMode castMode)
-    {
-        return new Call(new Cast(dataType, castMode), input, output);
-    }
-
-    public static Call Expand(int[] shape, DistributedType distributedType, Expr input, Expr output)
-    {
-        return new Call(new Expand(shape, distributedType.NdSBP), input, output);
-    }
-
-    public static Call Clamp(Expr input, Expr output, float min, float max)
-    {
-        return new Call(new TIR.XPU.Clamp(min, max), input, output);
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Gather.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Gather.cs
deleted file mode 100644
index 7232f0b0b1..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Gather.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Gather : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(Gather), 0, "input");
-
-    public static readonly ParameterInfo Indices = new(typeof(Gather), 1, "indices");
-
-    public static readonly ParameterInfo Output = new(typeof(Gather), 2, "output");
-
-    public int Axis { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/GatherReduceScatter.cs b/modules/Nncase.Modules.XPU/TIR/XPU/GatherReduceScatter.cs
deleted file mode 100644
index 2b69259d24..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/GatherReduceScatter.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class GatherReduceScatter : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(GatherReduceScatter), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(GatherReduceScatter), 1, "output");
-
-    public IRArray<(int Hierarchy, SBP SBP)> ReducePosition { get; }
-
-    public Placement Placement { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/InstanceNorm.cs b/modules/Nncase.Modules.XPU/TIR/XPU/InstanceNorm.cs
deleted file mode 100644
index 3719792d44..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/InstanceNorm.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class InstanceNorm : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(InstanceNorm), 0, "input");
-
-    public static readonly ParameterInfo Scale = new(typeof(InstanceNorm), 1, "scale");
-
-    public static readonly ParameterInfo Bias = new(typeof(InstanceNorm), 2, "bias");
-
-    public static readonly ParameterInfo Output = new(typeof(InstanceNorm), 3, "output");
-
-    public float Epsilon { get; }
-
-    public DistributedType DistType { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/LayerNorm.cs b/modules/Nncase.Modules.XPU/TIR/XPU/LayerNorm.cs
deleted file mode 100644
index ae20eb3feb..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/LayerNorm.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class LayerNorm : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(LayerNorm), 0, "input");
-
-    public static readonly ParameterInfo Scale = new(typeof(LayerNorm), 1, "scale");
-
-    public static readonly ParameterInfo Bias = new(typeof(LayerNorm), 2, "bias");
-
-    public static readonly ParameterInfo Output = new(typeof(LayerNorm), 3, "output");
-
-    public int Axis { get; }
-
-    public float Epsilon { get; }
-
-    public bool UseMean { get; }
-
-    public DistributedType DistType { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Matmul.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Matmul.cs
deleted file mode 100644
index 01ddc3b9a4..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Matmul.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Matmul : XPUKernelOp
-{
-    public static readonly ParameterInfo Lhs = new(typeof(Matmul), 0, "lhs");
-
-    public static readonly ParameterInfo Rhs = new(typeof(Matmul), 1, "rhs");
-
-    public static readonly ParameterInfo Output = new(typeof(Matmul), 2, "output");
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/ReShape.cs b/modules/Nncase.Modules.XPU/TIR/XPU/ReShape.cs
deleted file mode 100644
index 89c7803a82..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/ReShape.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class ReShape : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(ReShape), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(ReShape), 1, "output");
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/ReduceArg.cs b/modules/Nncase.Modules.XPU/TIR/XPU/ReduceArg.cs
deleted file mode 100644
index 55a629ea4f..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/ReduceArg.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Nncase.IR;
-using Nncase.PatternMatch;
-
-namespace Nncase.TIR.XPU;
-
-/// <summary>
-/// ReduceArg expression.
-/// </summary>
-public sealed partial class ReduceArg : XPUKernelOp
-{
-    /// <summary>
-    /// Gets input.
-    /// </summary>
-    public static readonly ParameterInfo Input = new(typeof(ReduceArg), 0, "input", ParameterKind.Input);
-
-    /// <summary>
-    /// Gets Axis.
-    /// </summary>
-    /// <remarks>Named dim in torch.</remarks>
-    public int Axis { get; }
-
-    /// <summary>
-    /// Gets a value indicating whether gets whether to keep dims.
-    /// </summary>
-    public bool KeepDims { get; }
-
-    /// <summary>
-    /// Gets a value indicating whether gets whether to select the last index.
-    /// </summary>
-    /// <remarks>Only used in onnx.</remarks>
-    public bool SelectLastIndex { get; }
-
-    public ReduceArgOp ReduceArgOp { get; }
-
-    public DataType DestType { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Resize.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Resize.cs
deleted file mode 100644
index da15c8da77..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Resize.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.Dynamic;
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Resize : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(Resize), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(Resize), 1, "output");
-
-    public IRArray<float> Roi { get; }
-
-    public IRArray<int> NewSize { get; }
-
-    public float CubicCoeffA { get; }
-
-    public int ExcludeOutsideValue { get; }
-
-    public float ExtrapolationValue { get; }
-
-    public ImageResizeMode ResizeMode { get; }
-
-    public ImageResizeTransformationMode TransformationMode { get; }
-
-    public ImageResizeNearestMode NearestMode { get; }
-
-    public bool IsTFResize { get; }
-
-    /// <inheritdoc/>
-    public override string DisplayProperty() => $"ImageResizeMode.{ResizeMode}, ImageResizeTransformationMode.{TransformationMode}, ImageResizeNearestMode.{NearestMode}, {IsTFResize}";
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Slice.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Slice.cs
deleted file mode 100644
index e797a5dea0..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Slice.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Slice : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(Slice), 0, "input");
-
-    public static readonly ParameterInfo Begins = new(typeof(Slice), 1, "begins");
-
-    public static readonly ParameterInfo Ends = new(typeof(Slice), 2, "ends");
-
-    public static readonly ParameterInfo Axes = new(typeof(Slice), 3, "axes");
-
-    public DistributedType DistributedType { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Softmax.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Softmax.cs
deleted file mode 100644
index d2816e56f9..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Softmax.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Softmax : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(Softmax), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(Softmax), 1, "output");
-
-    public int Axis { get; }
-
-    public DistributedType DistType { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/SwishB.cs b/modules/Nncase.Modules.XPU/TIR/XPU/SwishB.cs
deleted file mode 100644
index cbf6f305fd..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/SwishB.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class SwishB : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(SwishB), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(SwishB), 1, "output");
-
-    public float Beta { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/TDMALoad.cs b/modules/Nncase.Modules.XPU/TIR/XPU/TDMALoad.cs
deleted file mode 100644
index 2bb7238ad5..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/TDMALoad.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class TDMALoad : XPUKernelOp
-{
-    public static readonly ParameterInfo Dest = new(typeof(TDMALoad), 0, "dest");
-
-    public static readonly ParameterInfo Src = new(typeof(TDMALoad), 1, "src");
-
-    public IRArray<SBP> NdSbp { get; }
-
-    public Placement Placement { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/TDMAStore.cs b/modules/Nncase.Modules.XPU/TIR/XPU/TDMAStore.cs
deleted file mode 100644
index bbf12726c1..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/TDMAStore.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class TDMAStore : XPUKernelOp
-{
-    public static readonly ParameterInfo Src = new(typeof(TDMAStore), 0, "src");
-
-    public static readonly ParameterInfo Dest = new(typeof(TDMAStore), 1, "dest");
-
-    public IRArray<SBP> NdSbp { get; }
-
-    public Placement Placement { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Transpose.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Transpose.cs
deleted file mode 100644
index 9579995aa4..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Transpose.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Transpose : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(Transpose), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(Transpose), 1, "output");
-
-    public IRArray<int> Perm { get; }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/Unary.cs b/modules/Nncase.Modules.XPU/TIR/XPU/Unary.cs
deleted file mode 100644
index 4c2c76e277..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/Unary.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public sealed partial class Unary : XPUKernelOp
-{
-    public static readonly ParameterInfo Input = new(typeof(Unary), 0, "input");
-
-    public static readonly ParameterInfo Output = new(typeof(Unary), 1, "output");
-
-    public string UnaryOp { get; }
-
-    /// <inheritdoc/>
-    public override string DisplayProperty()
-    {
-        return $"UnaryOp.{UnaryOp}";
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/TIR/XPU/XPUKernelOp.cs b/modules/Nncase.Modules.XPU/TIR/XPU/XPUKernelOp.cs
deleted file mode 100644
index f52da3471e..0000000000
--- a/modules/Nncase.Modules.XPU/TIR/XPU/XPUKernelOp.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-using Nncase.IR;
-
-namespace Nncase.TIR.XPU;
-
-public abstract class XPUKernelOp : Op
-{
-}
diff --git a/modules/Nncase.Modules.XPU/Targets/XPUTarget.cs b/modules/Nncase.Modules.XPU/Targets/XPUTarget.cs
deleted file mode 100644
index 3d0e0dfaf7..0000000000
--- a/modules/Nncase.Modules.XPU/Targets/XPUTarget.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Microsoft.Extensions.Configuration;
-using Nncase.CodeGen;
-using Nncase.CodeGen.StackVM;
-using Nncase.IR;
-using Nncase.Passes;
-using Nncase.Passes.Rules;
-using Nncase.Quantization;
-
-namespace Nncase.Targets;
-
-/// <summary>
-/// Target for XPU.
-/// </summary>
-public class XPUTarget : ITarget
-{
-    /// <summary>
-    /// Gets kind.
-    /// </summary>
-    public const string Kind = "xpu";
-
-    string ITarget.Kind => Kind;
-
-    /// <inheritdoc/>
-    public void ParseTargetDependentOptions(IConfigurationSection configure)
-    {
-    }
-
-    /// <inheritdoc/>
-    public void RegisterTargetInDependentPass(IPassManager passManager, CompileOptions options)
-    {
-    }
-
-    /// <inheritdoc/>
-    public void RegisterTargetDependentPass(IPassManager passManager, CompileOptions options)
-    {
-        passManager.AddWithName<DataflowPass>("LowerIR").Configure(p =>
-        {
-            p.Add<LowerBinary>();
-            p.Add<LowerUnary>();
-            p.Add<LowerMatMul>();
-        });
-    }
-
-    /// <inheritdoc/>
-    public Task<Dictionary<ENode, List<Tuple<List<DataType>, List<List<QuantParam>>, float>>>> BindQuantMethodCosine(ICalibrationDatasetProvider calibrationDataset, List<ENode> rangeOfs, List<ENode> childrenOfRangeOfs, QuantizeOptions quantizeOptions)
-    {
-        var enodeQuantCosineDict = new Dictionary<ENode, List<Tuple<List<DataType>, List<List<QuantParam>>, float>>>();
-        return Task.FromResult(enodeQuantCosineDict);
-    }
-
-    /// <inheritdoc/>
-    public Task AdaRoundWeights(ICalibrationDatasetProvider calibrationDataset, List<ENode> rangeOfs, List<ENode> childrenOfRangeOfs, QuantizeOptions quantizeOptions)
-    {
-        return Task.CompletedTask;
-    }
-
-    /// <inheritdoc/>
-    public void RegisterQuantizePass(IPassManager passManager, CompileOptions options)
-    {
-        if (options.QuantizeOptions.ModelQuantMode == ModelQuantMode.UsePTQ)
-        {
-            passManager.AddWithName<DataflowPass>("RemoveMarker").Configure(p =>
-            {
-                p.Add<Passes.Rules.Lower.RemoveMarker>();
-            });
-        }
-    }
-
-    /// <inheritdoc/>
-    public void RegisterTargetDependentAfterQuantPass(IPassManager passManager, CompileOptions options)
-    {
-        passManager.AddWithName<DataflowPass>("MakeFusion").Configure(p =>
-        {
-            p.Add<XPUFusion>();
-        });
-
-        passManager.Add<XPUFusionToTirPass>(Passes.Tile.TileOptions.Default);
-
-        passManager.Add<PrimFuncPass>().Configure(p =>
-        {
-            p.Add<Passes.Mutators.UnFoldBlock>();
-            p.Add<Passes.Mutators.FlattenSequential>();
-            p.Add<Passes.Mutators.FoldConstCall>();
-        });
-
-        passManager.AddWithName<DDrBufferSchdeulePass>("DDrBufferSchdeule");
-
-        passManager.AddWithName<PrimFuncPass>("InstStage").Configure(p =>
-        {
-            p.Add<Passes.Mutators.FlattenBuffer>();
-            p.Add<Passes.Mutators.FoldConstCall>();
-            p.Add<Passes.Mutators.RemoveNop>();
-        });
-    }
-
-    public void RegisterTargetDependentBeforeCodeGen(IPassManager passManager, CompileOptions options)
-    {
-    }
-
-    /// <inheritdoc/>
-    public IModuleBuilder CreateModuleBuilder(string moduleKind, CompileOptions options)
-    {
-        if (moduleKind == Callable.StackVMModuleKind)
-        {
-            return new StackVMModuleBuilder();
-        }
-        else if (moduleKind == XPUTarget.Kind)
-        {
-            return new CodeGen.XPU.ModuleBuilder(options);
-        }
-
-        throw new NotSupportedException();
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/XPUApplicationPart.cs b/modules/Nncase.Modules.XPU/XPUApplicationPart.cs
deleted file mode 100644
index ff56fca3ec..0000000000
--- a/modules/Nncase.Modules.XPU/XPUApplicationPart.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
-using DryIoc;
-using Nncase.Hosting;
-
-namespace Nncase;
-
-/// <summary>
-/// XPU application part extensions.
-/// </summary>
-public static class XPUApplicationPart
-{
-    /// <summary>
-    /// Add XPU assembly.
-    /// </summary>
-    /// <param name="registrator">Service registrator.</param>
-    /// <returns>Configured service registrator.</returns>
-    public static IRegistrator AddCPU(this IRegistrator registrator)
-    {
-        return registrator.RegisterModule<XPUModule>()
-            .RegisterModule<Evaluator.IR.CPU.CPUModule>()
-            .RegisterModule<Evaluator.TIR.XPU.XPUModule>();
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/XPUModule.cs b/modules/Nncase.Modules.XPU/XPUModule.cs
deleted file mode 100644
index 63e550a4df..0000000000
--- a/modules/Nncase.Modules.XPU/XPUModule.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using DryIoc;
-using Nncase.Hosting;
-using Nncase.Targets;
-
-namespace Nncase;
-
-/// <summary>
-/// XPU module.
-/// </summary>
-internal class XPUModule : IApplicationPart
-{
-    public void ConfigureServices(IRegistrator registrator)
-    {
-        registrator.Register<ITarget, XPUTarget>(reuse: Reuse.Singleton);
-    }
-}
diff --git a/modules/Nncase.Modules.XPU/packages.lock.json b/modules/Nncase.Modules.XPU/packages.lock.json
deleted file mode 100644
index 5dd73e5bda..0000000000
--- a/modules/Nncase.Modules.XPU/packages.lock.json
+++ /dev/null
@@ -1,295 +0,0 @@
-{
-  "version": 2,
-  "dependencies": {
-    "net7.0": {
-      "StyleCop.Analyzers": {
-        "type": "Direct",
-        "requested": "[1.2.0-beta.435, )",
-        "resolved": "1.2.0-beta.435",
-        "contentHash": "TADk7vdGXtfTnYCV7GyleaaRTQjfoSfZXprQrVMm7cSJtJbFc1QIbWPyLvrgrfGdfHbGmUPvaN4ODKNxg2jgPQ==",
-        "dependencies": {
-          "StyleCop.Analyzers.Unstable": "1.2.0.435"
-        }
-      },
-      "Google.OrTools.runtime.linux-arm64": {
-        "type": "Transitive",
-        "resolved": "9.4.1874",
-        "contentHash": "Z46ndZcZa2Lt5b76xU9kxVYbPLg/LfuMufhUVsu3Qo3L7Bibf7WXd9j7RRldjnuv8RIHWTqb0b+2FwwMxs0c5A=="
-      },
-      "Google.OrTools.runtime.linux-x64": {
-        "type": "Transitive",
-        "resolved": "9.4.1874",
-        "contentHash": "zGeDb8FuvP9HXjrsU7krVXtSDFpR+DUGNEsH51k94jL9tzf2vWYI8+WUBRHZ/cGe50dpLr+vIjfcNo3gFyOpkQ=="
-      },
-      "Google.OrTools.runtime.osx-arm64": {
-        "type": "Transitive",
-        "resolved": "9.4.1874",
-        "contentHash": "Wo0ZfDaH6DhiQw0jZm4HWJm/oPGPpWNwOLUz+EYaoH3MLtocSxItHGQj/Ta3HyhXnYNOv+TliAH8L+8RCXu/2w=="
-      },
-      "Google.OrTools.runtime.osx-x64": {
-        "type": "Transitive",
-        "resolved": "9.4.1874",
-        "contentHash": "IAfGgKR1og6vU87axK1d37Ak/4jy8B4NMoElovG/KZc/2UY+cJEAQDA709UMegtI4lBhuxTWFNUiHQYmRIB9yQ=="
-      },
-      "Google.OrTools.runtime.win-x64": {
-        "type": "Transitive",
-        "resolved": "9.4.1874",
-        "contentHash": "fUs5qDnZA6itygolcX6nPuachQkY9CVvQbakIzIiRAWKcaj8umQAbFdGwbkyzp3qp34BKW5mtPVsmMyfQBBjOQ=="
-      },
-      "libortki": {
-        "type": "Transitive",
-        "resolved": "0.0.2",
-        "contentHash": "svfuG5mxGY/QC/5DVheHOCELmdSP90RtxQ73j23KarPXZ9ZXW+7v1l5J77hGDyQbEh1BGrnGgKBlyn76RauGHg==",
-        "dependencies": {
-          "libortki-linux": "0.0.2",
-          "libortki-osx": "0.0.2",
-          "libortki-osx-arm64": "0.0.2",
-          "libortki-win": "0.0.2"
-        }
-      },
-      "libortki-linux": {
-        "type": "Transitive",
-        "resolved": "0.0.2",
-        "contentHash": "b04LWD4lgGy60tys3hPFhnUpgWDM6dN5r1PI7GOcPj8VupXCaI70LKNQ5/5twbDE6rkowOGanVTw0S2wBGBqBQ=="
-      },
-      "libortki-osx": {
-        "type": "Transitive",
-        "resolved": "0.0.2",
-        "contentHash": "O6Q9GLULkDkZEPAZJVKLPH0ROXGVOE7BxuddgOcHNK2oiTEM7wIRnzp2OIlYgLpaOLyxJMisbGOhtWgdzt2Wng=="
-      },
-      "libortki-osx-arm64": {
-        "type": "Transitive",
-        "resolved": "0.0.2",
-        "contentHash": "4Qn2dirJmRicnUG945oWpq7HVGwgqCKKxYPMISv/MRvmpZBbXrZ1cVvRaF8WwTu4XXgfKTa1sLv+i8zLifUMeQ=="
-      },
-      "libortki-win": {
-        "type": "Transitive",
-        "resolved": "0.0.2",
-        "contentHash": "HAoROgAKn8XBun11X43HZuspKlo5JGy8/OYw5IUPo7FVh5TCaPrLjGmyGYYZ2dqLlv31yv/b6s254PIRGn95cA=="
-      },
-      "Microsoft.Extensions.Configuration.Abstractions": {
-        "type": "Transitive",
-        "resolved": "6.0.0",
-        "contentHash": "qWzV9o+ZRWq+pGm+1dF+R7qTgTYoXvbyowRoBxQJGfqTpqDun2eteerjRQhq5PQ/14S+lqto3Ft4gYaRyl4rdQ==",
-        "dependencies": {
-          "Microsoft.Extensions.Primitives": "6.0.0"
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection.Abstractions": {
-        "type": "Transitive",
-        "resolved": "6.0.0",
-        "contentHash": "xlzi2IYREJH3/m6+lUrQlujzX8wDitm4QGnUu6kUXTQAWPuZY8i+ticFJbzfqaetLA6KR/rO6Ew/HuYD+bxifg=="
-      },
-      "Microsoft.Extensions.FileProviders.Abstractions": {
-        "type": "Transitive",
-        "resolved": "6.0.0",
-        "contentHash": "0pd4/fho0gC12rQswaGQxbU34jOS1TPS8lZPpkFCH68ppQjHNHYle9iRuHeev1LhrJ94YPvzcRd8UmIuFk23Qw==",
-        "dependencies": {
-          "Microsoft.Extensions.Primitives": "6.0.0"
-        }
-      },
-      "Microsoft.Extensions.Primitives": {
-        "type": "Transitive",
-        "resolved": "6.0.0",
-        "contentHash": "9+PnzmQFfEFNR9J2aDTfJGGupShHjOuGw4VUv+JB044biSHrnmCIMD+mJHmb2H7YryrfBEXDurxQ47gJZdCKNQ==",
-        "dependencies": {
-          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
-        }
-      },
-      "NetFabric.Hyperlinq.Abstractions": {
-        "type": "Transitive",
-        "resolved": "1.3.0",
-        "contentHash": "WXnEcGwmXfa8gW9N2MlcaPNUzM3NLMwnAhacbtH554F8YcoXbIkTB+uGa1Aa+9gyb/9JZgYVHnmADgJUKP52nA=="
-      },
-      "StyleCop.Analyzers.Unstable": {
-        "type": "Transitive",
-        "resolved": "1.2.0.435",
-        "contentHash": "ouwPWZxbOV3SmCZxIRqHvljkSzkCyi1tDoMzQtDb/bRP8ctASV/iRJr+A2Gdj0QLaLmWnqTWDrH82/iP+X80Lg=="
-      },
-      "System.Buffers": {
-        "type": "Transitive",
-        "resolved": "4.5.1",
-        "contentHash": "Rw7ijyl1qqRS0YQD/WycNst8hUUMgrMH4FCn1nNm27M4VxchZ1js3fVjQaANHO5f3sN4isvP4a+Met9Y4YomAg=="
-      },
-      "System.Runtime.CompilerServices.Unsafe": {
-        "type": "Transitive",
-        "resolved": "6.0.0",
-        "contentHash": "/iUeP3tq1S0XdNNoMz5C9twLSrM/TH+qElHkXWaPvuNOt+99G75NrV0OS2EqHx5wMN7popYjpc8oTjC1y16DLg=="
-      },
-      "nncase.codegen": {
-        "type": "Project",
-        "dependencies": {
-          "Extension.Mathematics": "[1.2.12, )",
-          "Nncase.Core": "[1.0.0, )",
-          "Nncase.IO": "[1.0.0, )"
-        }
-      },
-      "nncase.core": {
-        "type": "Project",
-        "dependencies": {
-          "DryIoc.dll": "[5.3.1, )",
-          "GiGraph.Dot": "[2.0.0, )",
-          "Microsoft.Extensions.Hosting.Abstractions": "[6.0.0, )",
-          "Microsoft.Extensions.Logging.Abstractions": "[6.0.0, )",
-          "Microsoft.Extensions.Options": "[6.0.0, )",
-          "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
-          "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
-          "System.Reactive": "[5.0.0, )"
-        }
-      },
-      "nncase.diagnostics": {
-        "type": "Project",
-        "dependencies": {
-          "Nncase.Core": "[1.0.0, )"
-        }
-      },
-      "nncase.egraph": {
-        "type": "Project",
-        "dependencies": {
-          "GiGraph.Dot": "[2.0.0, )",
-          "Google.OrTools": "[9.4.1874, )",
-          "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
-          "Nncase.Core": "[1.0.0, )",
-          "Nncase.Evaluator": "[1.0.0, )",
-          "Singulink.Collections.Weak": "[1.0.2, )"
-        }
-      },
-      "nncase.evaluator": {
-        "type": "Project",
-        "dependencies": {
-          "Nncase.Core": "[1.0.0, )",
-          "OrtKISharp": "[0.0.2, )"
-        }
-      },
-      "nncase.graph": {
-        "type": "Project",
-        "dependencies": {
-          "Nncase.Core": "[1.0.0, )",
-          "Nncase.Evaluator": "[1.0.0, )"
-        }
-      },
-      "nncase.io": {
-        "type": "Project"
-      },
-      "nncase.modules.stackvm": {
-        "type": "Project",
-        "dependencies": {
-          "Nncase.CodeGen": "[1.0.0, )",
-          "Nncase.Passes": "[1.0.0, )"
-        }
-      },
-      "nncase.passes": {
-        "type": "Project",
-        "dependencies": {
-          "Nncase.Core": "[1.0.0, )",
-          "Nncase.EGraph": "[1.0.0, )",
-          "Nncase.Evaluator": "[1.0.0, )",
-          "Nncase.Graph": "[1.0.0, )"
-        }
-      },
-      "DryIoc.dll": {
-        "type": "CentralTransitive",
-        "requested": "[5.3.1, )",
-        "resolved": "5.3.1",
-        "contentHash": "E3zclUh2CIBks1t2uBD1k18pyGFJ1YSKCrbCDbB7qCdl2RAB+k68AyDpjeplhF1ot2XPV82AgyCWBXMf0ggL1g=="
-      },
-      "Extension.Mathematics": {
-        "type": "CentralTransitive",
-        "requested": "[1.2.12, )",
-        "resolved": "1.2.12",
-        "contentHash": "D4mn5Cab4ztPLJ0V8uMErDrO/Y61098nwrvyIOLZymVAYOQcwP1vomVWKbTagf1aPU3cX5Q7adZtQEQwOy6XEg=="
-      },
-      "GiGraph.Dot": {
-        "type": "CentralTransitive",
-        "requested": "[2.0.0, )",
-        "resolved": "2.0.0",
-        "contentHash": "ThvS2mQVveSkTMUm04tMbRYzu1XFPV8xBHISrUMp02APjhv9IRbLu3v3upTPCywORx2Ds/c6AqEUL1WU6kPfuQ=="
-      },
-      "Google.OrTools": {
-        "type": "CentralTransitive",
-        "requested": "[9.4.1874, )",
-        "resolved": "9.4.1874",
-        "contentHash": "jqRoI+pYlym+fhoU25u+13oti5h+772bllQ9zDitTVMclDXVTiG6pxzvmYO74wnADBMdpb2SQlgiNQxoNk5dlA==",
-        "dependencies": {
-          "Google.OrTools.runtime.linux-arm64": "9.4.1874",
-          "Google.OrTools.runtime.linux-x64": "9.4.1874",
-          "Google.OrTools.runtime.osx-arm64": "9.4.1874",
-          "Google.OrTools.runtime.osx-x64": "9.4.1874",
-          "Google.OrTools.runtime.win-x64": "9.4.1874",
-          "Google.Protobuf": "3.19.4"
-        }
-      },
-      "Google.Protobuf": {
-        "type": "CentralTransitive",
-        "requested": "[3.19.4, )",
-        "resolved": "3.19.4",
-        "contentHash": "fd07/ykL4O4FhqrZIELm5lmiyOHfdPg9+o+hWr6tcfRdS7tHXnImg/2wtogLzlW2eEmr0J7j6ZrZvaWOLiJbxQ=="
-      },
-      "Microsoft.Extensions.Hosting.Abstractions": {
-        "type": "CentralTransitive",
-        "requested": "[6.0.0, )",
-        "resolved": "6.0.0",
-        "contentHash": "GcT5l2CYXL6Sa27KCSh0TixsRfADUgth+ojQSD5EkzisZxmGFh7CwzkcYuGwvmXLjr27uWRNrJ2vuuEjMhU05Q==",
-        "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
-          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0"
-        }
-      },
-      "Microsoft.Extensions.Logging.Abstractions": {
-        "type": "CentralTransitive",
-        "requested": "[6.0.0, )",
-        "resolved": "6.0.0",
-        "contentHash": "/HggWBbTwy8TgebGSX5DBZ24ndhzi93sHUBDvP1IxbZD7FDokYzdAr6+vbWGjw2XAfR2EJ1sfKUotpjHnFWPxA=="
-      },
-      "Microsoft.Extensions.Options": {
-        "type": "CentralTransitive",
-        "requested": "[6.0.0, )",
-        "resolved": "6.0.0",
-        "contentHash": "dzXN0+V1AyjOe2xcJ86Qbo233KHuLEY0njf/P2Kw8SfJU+d45HNS2ctJdnEnrWbM9Ye2eFgaC5Mj9otRMU6IsQ==",
-        "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
-          "Microsoft.Extensions.Primitives": "6.0.0"
-        }
-      },
-      "Microsoft.Toolkit.HighPerformance": {
-        "type": "CentralTransitive",
-        "requested": "[7.1.1, )",
-        "resolved": "7.1.1",
-        "contentHash": "TRnvDpZPXO30hTOtjfLw6Y9BtTKtTpzk9lefeh4RMCaUihWrVKQR454nYH4/mMJAh+LXqfAPyk0kfkJs0Amopw=="
-      },
-      "NetFabric.Hyperlinq": {
-        "type": "CentralTransitive",
-        "requested": "[3.0.0-beta48, )",
-        "resolved": "3.0.0-beta48",
-        "contentHash": "oYUhXvxNS8bBJWqNkvx5g8y0P/0LtyqS2pN0w4OWjVDNWEpLbdbvPy9w/9z1n2PrqIjX3jxUsEnoCmxxGnI3gw==",
-        "dependencies": {
-          "NetFabric.Hyperlinq.Abstractions": "1.3.0",
-          "System.Buffers": "4.5.1",
-          "System.Runtime.CompilerServices.Unsafe": "5.0.0"
-        }
-      },
-      "OrtKISharp": {
-        "type": "CentralTransitive",
-        "requested": "[0.0.2, )",
-        "resolved": "0.0.2",
-        "contentHash": "q8j0yR5836Zhv9WB9BFkQt1UaEFyibq8bqJcTiULlILF6/sz8z7Wy2N8sgYdDKsdW25zncIz7j6IDbKM5ynePg==",
-        "dependencies": {
-          "libortki": "0.0.2"
-        }
-      },
-      "Singulink.Collections.Weak": {
-        "type": "CentralTransitive",
-        "requested": "[1.0.2, )",
-        "resolved": "1.0.2",
-        "contentHash": "giLAHrjJe0Bh7yhNexR6pmcv02+Fi+lEPxQVdB8zvkuJCmy6rnqu8CZLIpxrUfLcWDuTCSiK0IfGmMhig3UDhA=="
-      },
-      "System.Reactive": {
-        "type": "CentralTransitive",
-        "requested": "[5.0.0, )",
-        "resolved": "5.0.0",
-        "contentHash": "erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ=="
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/modules/xpu/CMakeLists.txt b/modules/xpu/CMakeLists.txt
deleted file mode 100644
index f175de6f14..0000000000
--- a/modules/xpu/CMakeLists.txt
+++ /dev/null
@@ -1,60 +0,0 @@
-cmake_minimum_required (VERSION 3.8)
-
-include_directories(include)
-#add_subdirectory(src/kernels)
-add_subdirectory(src/runtime)
-
-if (BUILDING_RUNTIME)
-    if (ENABLE_XPU_RUNTIME)
-        add_library(nncase_rt_modules_xpu STATIC ${SRCS})
-        target_include_directories(nncase_rt_modules_xpu PRIVATE include)
-        target_link_libraries(nncase_rt_modules_xpu PRIVATE runtime_xpu)
-        set_target_properties(nncase_rt_modules_xpu PROPERTIES
-                                                       OUTPUT_NAME "nncase.rt_modules.xpu")
-
-        install(DIRECTORY include/nncase/kernels
-            DESTINATION include/nncase
-            COMPONENT nncase-headers
-            FILES_MATCHING
-            PATTERN "*.def"
-            PATTERN "*.h"
-            PATTERN "*.hpp"
-            PATTERN "*.td"
-            PATTERN "*.inc"
-            PATTERN "LICENSE.TXT"
-            )
-
-        install(DIRECTORY include/nncase/runtime
-            DESTINATION include/nncase
-            COMPONENT nncase-headers
-            FILES_MATCHING
-            PATTERN "*.def"
-            PATTERN "*.h"
-            PATTERN "*.hpp"
-            PATTERN "*.td"
-            PATTERN "*.inc"
-            PATTERN "LICENSE.TXT"
-            )
-
-        install(TARGETS nncase_rt_modules_xpu EXPORT nncaseruntimeTargets
-            ARCHIVE DESTINATION lib
-            LIBRARY DESTINATION lib
-            RUNTIME DESTINATION bin
-            INCLUDES DESTINATION include
-        )
-
-        configure_file(${CMAKE_CURRENT_LIST_DIR}/cmake/nncase_rt_modules_xpuConfig.cmake.in nncase_rt_modules_xpuConfig.cmake @ONLY)
-        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/nncase_rt_modules_xpuConfig.cmake DESTINATION lib/cmake/nncaseruntime)
-
-        if (K230_LINUX_SDK_DIR)
-            add_subdirectory(examples)
-        endif()
-    endif()
-else()
-    add_library(nncase_modules_xpu SHARED ${SRCS})
-    target_include_directories(nncase_modules_xpu PUBLIC include)
-    target_link_libraries(nncase_modules_xpu PRIVATE simulator_xpu nncasebase)
-    set_target_properties(nncase_modules_xpu PROPERTIES OUTPUT_NAME "nncase.simulator.xpu")
-    install(TARGETS nncase_modules_xpu
-            COMPONENT nncase-runtime)
-endif()
diff --git a/modules/xpu/cmake/nncase_rt_modules_cpuConfig.cmake.in b/modules/xpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
deleted file mode 100644
index 4fb80f7e2b..0000000000
--- a/modules/xpu/cmake/nncase_rt_modules_cpuConfig.cmake.in
+++ /dev/null
@@ -1 +0,0 @@
-include(${CMAKE_CURRENT_LIST_DIR}/nncase_rt_modules_xpuTargets.cmake)
\ No newline at end of file
diff --git a/modules/xpu/examples/CMakeLists.txt b/modules/xpu/examples/CMakeLists.txt
deleted file mode 100644
index 8f9decb2ea..0000000000
--- a/modules/xpu/examples/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-cmake_minimum_required(VERSION 3.13)
-project(examples C CXX)
-
-add_subdirectory(xpu_test)
\ No newline at end of file
diff --git a/modules/xpu/examples/cpu_test/CMakeLists.txt b/modules/xpu/examples/cpu_test/CMakeLists.txt
deleted file mode 100644
index 7babfdcb63..0000000000
--- a/modules/xpu/examples/cpu_test/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-set(SRC main.cpp)
-set(bin xpu_test.elf)
-
-add_executable(${bin} ${SRC})
-target_link_libraries(${bin} runtime_xpu)
\ No newline at end of file
diff --git a/modules/xpu/examples/cpu_test/main.cpp b/modules/xpu/examples/cpu_test/main.cpp
deleted file mode 100644
index 3952270f0e..0000000000
--- a/modules/xpu/examples/cpu_test/main.cpp
+++ /dev/null
@@ -1,201 +0,0 @@
-#include <chrono>
-#include <fstream>
-#include <iostream>
-#include <nncase/runtime/interpreter.h>
-#include <nncase/runtime/runtime_op_utility.h>
-
-using namespace nncase;
-using namespace nncase::runtime;
-using namespace nncase::runtime::detail;
-
-template <class T> std::vector<T> read_binary_file(const char *file_name) {
-    std::ifstream ifs(file_name, std::ios::binary);
-    ifs.seekg(0, ifs.end);
-    size_t len = ifs.tellg();
-    std::vector<T> vec(len / sizeof(T), 0);
-    ifs.seekg(0, ifs.beg);
-    ifs.read(reinterpret_cast<char *>(vec.data()), len);
-    ifs.close();
-    return vec;
-}
-
-void read_binary_file(const char *file_name, char *buffer) {
-    std::ifstream ifs(file_name, std::ios::binary);
-    ifs.seekg(0, ifs.end);
-    size_t len = ifs.tellg();
-    ifs.seekg(0, ifs.beg);
-    ifs.read(buffer, len);
-    ifs.close();
-}
-
-auto read_binary(const char *file_name, char *buffer, size_t begin,
-                 size_t count) {
-    std::ifstream ifs(file_name, std::ios::binary);
-    ifs.seekg(begin, ifs.beg);
-    ifs.read(buffer + begin, count);
-    ifs.close();
-    std::cout << "read bin seg ok" << std::endl;
-}
-
-size_t get_binary_file_size(const char *file_name) {
-    std::ifstream ifs(file_name, std::ios::binary);
-    ifs.seekg(0, ifs.end);
-    size_t len = ifs.tellg();
-    ifs.close();
-    return len;
-}
-
-auto load_bin_to_kmodel(char *file_path, interpreter &interp) {
-    auto model_size = get_binary_file_size(file_path);
-    auto model_data = std::make_unique<char[]>(model_size);
-    for (size_t i = 0; i < model_size;) {
-        size_t count = 8000000;
-        if (count + i >= model_size)
-            count = model_size - i;
-        read_binary(file_path, model_data.get(), i, count);
-        i += 8000000;
-    }
-    // show the identification of kmodel.
-    // print_one_line_data("kmodel identification :", model_data.get(), 4);
-
-    interp.load_model({(const gsl::byte *)model_data.get(), model_size})
-        .expect("cannot load kmodel.");
-    std::cout << "load kmodel success" << std::endl;
-
-    return model_data;
-}
-
-template <typename T> double dot(const T *v1, const T *v2, size_t size) {
-    double ret = 0.f;
-    for (size_t i = 0; i < size; i++) {
-        ret += v1[i] * v2[i];
-    }
-
-    return ret;
-}
-
-template <typename T> double cosine(const T *v1, const T *v2, size_t size) {
-    for (size_t i = 0; i < 10; i++) {
-        std::cout << v1[i] << " " << v2[i] << std::endl;
-    }
-    return dot(v1, v2, size) /
-           ((sqrt(dot(v1, v1, size)) * sqrt(dot(v2, v2, size))));
-}
-
-int main(int argc, char *argv[]) {
-    std::cout << "case " << argv[0] << " build " << __DATE__ << " " << __TIME__
-              << std::endl;
-
-    if (argc < 3) {
-        std::cerr << "Usage: " << std::endl;
-        std::cerr << argv[0]
-                  << " <kmodel> <input_0.bin> <input_1.bin> ... <input_N.bin> "
-                  << std::endl;
-        std::cerr << argv[0]
-                  << " <kmodel> <input_0.bin> <input_1.bin> ... <input_N.bin> "
-                     "<output_0.bin> <output_1.bin> ... <output_N.bin>"
-                  << std::endl;
-        return -1;
-    }
-
-    interpreter interp;
-
-    // 1. load model
-    std::ifstream ifs(argv[1], std::ios::binary);
-    interp.load_model(ifs).expect("Invalid kmodel");
-
-    // 2. set inputs
-    for (size_t i = 2, j = 0; i < 2 + interp.inputs_size(); i++, j++) {
-        auto desc = interp.input_desc(j);
-        auto shape = interp.input_shape(j);
-        auto tensor = hrt::create(desc.datatype, shape, hrt::pool_shared)
-                          .expect("cannot create input tensor");
-        interp.input_tensor(j, tensor).expect("cannot set input tensor");
-
-        auto span = tensor.impl()
-                        ->to_host()
-                        .unwrap()
-                        ->buffer()
-                        .as_host()
-                        .unwrap()
-                        .map(map_access_::map_write)
-                        .unwrap()
-                        .buffer();
-        read_binary_file(argv[i], reinterpret_cast<char *>(span.data()));
-        hrt::sync(tensor, sync_op_t::sync_write_back, true)
-            .expect("sync write_back failed");
-    }
-
-    // 3. set outputs
-    // for (size_t i = 0; i < interp.outputs_size(); i++)
-    // {
-    //     auto desc = interp.output_desc(i);
-    //     auto shape = interp.output_shape(i);
-    //     auto tensor = hrt::create(desc.datatype, shape,
-    //     hrt::pool_shared).expect("cannot create input tensor");
-    //     interp.output_tensor(i, tensor).expect("cannot set output tensor");
-    // }
-
-    // 4. run
-    interp.run().expect("error occurred in running model");
-    auto start = std::chrono::steady_clock::now();
-    interp.run().expect("error occurred in running model");
-    auto stop = std::chrono::steady_clock::now();
-    double duration =
-        std::chrono::duration<double, std::milli>(stop - start).count();
-
-    // 5. get outputs
-    double cos = 0.f;
-    for (int i = 2 + interp.inputs_size(), j = 0; i < argc; i++, j++) {
-        auto desc = interp.output_desc(j);
-        auto out = interp.output_tensor(j).expect("cannot get output tensor");
-        auto mapped_buf =
-            std::move(hrt::map(out, map_access_t::map_read).unwrap());
-        auto vec = read_binary_file<unsigned char>(argv[i]);
-        switch (desc.datatype) {
-        case dt_boolean:
-        case dt_uint8: {
-            cos = cosine((const uint8_t *)mapped_buf.buffer().data(),
-                         (const uint8_t *)vec.data(),
-                         vec.size() / sizeof(uint8_t));
-            break;
-        }
-        case dt_int8: {
-            cos =
-                cosine((const int8_t *)mapped_buf.buffer().data(),
-                       (const int8_t *)vec.data(), vec.size() / sizeof(int8_t));
-            break;
-        }
-        case dt_float32: {
-            cos = cosine((const float *)mapped_buf.buffer().data(),
-                         (const float *)vec.data(), vec.size() / sizeof(float));
-            break;
-        }
-        case dt_int32: {
-            cos = cosine((const int32_t *)mapped_buf.buffer().data(),
-                         (const int32_t *)vec.data(),
-                         vec.size() / sizeof(int32_t));
-            break;
-        }
-        case dt_int64: {
-            cos = cosine((const int64_t *)mapped_buf.buffer().data(),
-                         (const int64_t *)vec.data(),
-                         vec.size() / sizeof(int64_t));
-            break;
-        }
-        default: {
-            std::cerr << "not supported data type: " << desc.datatype
-                      << std::endl;
-            std::abort();
-        }
-        }
-
-        std::cout << "output " << j << " cosine similarity: " << cos
-                  << std::endl;
-    }
-
-    std::cout << "interp run: " << duration << " ms, fps = " << 1000 / duration
-              << std::endl;
-
-    return 0;
-}
\ No newline at end of file
diff --git a/modules/xpu/include/nncase/runtime/xpu/compiler_defs.h b/modules/xpu/include/nncase/runtime/xpu/compiler_defs.h
deleted file mode 100644
index 95e996a076..0000000000
--- a/modules/xpu/include/nncase/runtime/xpu/compiler_defs.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include <cstdint>
-
-#if defined(_MSC_VER)
-#ifdef NNCASE_MODULES_XPU_DLL
-#define NNCASE_MODULES_XPU_API __declspec(dllexport)
-#elif NNCASE_SHARED_LIBS
-#define NNCASE_MODULES_XPU_API __declspec(dllimport)
-#else
-#define NNCASE_MODULES_XPU_API
-#endif
-#else
-#define NNCASE_MODULES_XPU_API __attribute__((visibility("default")))
-#endif
-
-#define BEGIN_NS_NNCASE_RT_MODULE(MODULE)                                      \
-    namespace nncase {                                                         \
-    namespace runtime {                                                        \
-    namespace MODULE {
-
-#define END_NS_NNCASE_RT_MODULE                                                \
-    }                                                                          \
-    }                                                                          \
-    }
diff --git a/modules/xpu/include/nncase/runtime/xpu/runtime_module.h b/modules/xpu/include/nncase/runtime/xpu/runtime_module.h
deleted file mode 100644
index 4eda222854..0000000000
--- a/modules/xpu/include/nncase/runtime/xpu/runtime_module.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include "compiler_defs.h"
-#include <nncase/runtime/runtime_module.h>
-
-BEGIN_NS_NNCASE_RT_MODULE(xpu)
-
-NNCASE_INLINE_VAR constexpr module_kind_t xpu_module_type =
-    to_module_kind("xpu");
-NNCASE_INLINE_VAR constexpr uint32_t xpu_module_version = 0;
-
-NNCASE_MODULES_XPU_API result<std::unique_ptr<runtime_module>>
-create_xpu_runtime_module();
-
-END_NS_NNCASE_RT_MODULE
diff --git a/modules/xpu/src/runtime/CMakeLists.txt b/modules/xpu/src/runtime/CMakeLists.txt
deleted file mode 100644
index 38ba9adc74..0000000000
--- a/modules/xpu/src/runtime/CMakeLists.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-cmake_minimum_required (VERSION 3.13)
-
-add_subdirectory(cmodel)
-
-set(SRCS runtime_module.cpp
-         runtime_function.cpp
-         thread_pool.cpp
-         elfload.cpp
-         elfloader.cpp
-         elfreloc_aarch64.cpp
-         elfreloc_amd64.cpp
-         elfreloc_i386.cpp
-         elfreloc_riscv64.cpp
-         hardware_context.cpp
-         shared_memory.cpp)
-
-if (BUILDING_RUNTIME)
-    if (ENABLE_XPU_RUNTIME)
-        add_library(runtime_xpu OBJECT ${SRCS})
-        target_link_libraries(runtime_xpu PUBLIC nncaseruntime pthread rt)
-        # set_target_properties(runtime_xpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
-        install(TARGETS runtime_xpu EXPORT nncaseruntimeTargets)
-    endif()
-else()
-    add_library(simulator_xpu OBJECT ${SRCS})
-    target_link_libraries(simulator_xpu PUBLIC nncasebase nncaseruntime pthread)
-    target_compile_definitions(simulator_xpu PUBLIC -DNNCASE_MODULES_XPU_DLL -DNNCASE_SIMULATOR)
-    set_target_properties(simulator_xpu PROPERTIES POSITION_INDEPENDENT_CODE ON)
-endif()
diff --git a/modules/xpu/src/runtime/cmodel/CMakeLists.txt b/modules/xpu/src/runtime/cmodel/CMakeLists.txt
deleted file mode 100644
index 7568605751..0000000000
--- a/modules/xpu/src/runtime/cmodel/CMakeLists.txt
+++ /dev/null
@@ -1,76 +0,0 @@
-project(xpu)
-cmake_minimum_required(VERSION 3.13)
-
-add_library(xpu_cmodel STATIC
-  src/dummy.cpp
-  ../hardware_context.cpp
-)
-
-set(CMAKE_CXX_STANDARD 20)
-
-target_include_directories(xpu_cmodel PUBLIC include)
-# target_include_directories(xpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../src/Native/include)
-target_include_directories(xpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../../include)
-target_include_directories(xpu_cmodel PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../runtime)
-# target_include_directories(xpu_cmodel PUBLIC /root/.conan/data/gsl-lite/0.37.0/_/_/package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/)
-# target_link_libraries(xpu_cmodel PUBLIC gsl::gsl-lite)
-# if(NOT APPLE AND NOT MSVC)
-#   target_link_libraries(xpu_cmodel PRIVATE rt)
-# endif()
-set_target_properties(xpu_cmodel PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-# add_executable(xpu_cmodel_cli src/xpu_cmodel.cpp ../shared_memory.cpp)
-# target_link_libraries(xpu_cmodel_cli PUBLIC xpu_cmodel)
-# set_target_properties(xpu_cmodel_cli PROPERTIES POSITION_INDEPENDENT_CODE ON
-#   OUTPUT_NAME "nncase.simulator.xpu.c")
-# install(TARGETS xpu_cmodel_cli COMPONENT nncase-runtime)
-
-# add_definitions(-D__riscv_vector)
-foreach(LIBRARY_PATH ${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES})
-    # Construct the full path to the library file
-    set(CRTI_LIB_PATH "${LIBRARY_PATH}/crti.o")
-
-    # Check if the library file exists
-    if(EXISTS ${CRTI_LIB_PATH})
-        message("crti.o Library found at: ${CRTI_LIB_PATH}")
-        break()  # Stop searching if found
-    endif()
-endforeach()
-
-if(NOT CRTI_LIB_PATH)
-    message("crti.o Library not found")
-endif()
-
-foreach(LIBRARY_PATH ${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES})
-    # Construct the full path to the library file
-    set(CRT1_LIB_PATH "${LIBRARY_PATH}/crt1.o")
-
-    # Check if the library file exists
-    if(EXISTS ${CRT1_LIB_PATH})
-        message("crt1.o Library found at: ${CRT1_LIB_PATH}")
-        break()  # Stop searching if found
-    endif()
-endforeach()
-
-if(NOT CRT1_LIB_PATH)
-    message("crt1.o Library not found")
-endif()
-
-function(add_test name test_path)
-  if (CMAKE_BUILD_TYPE STREQUAL "Release")
-    add_compile_options(-O1)
-  endif()
-  add_link_options(-no-pie -nostartfiles -fPIC -fno-stack-protector -static -Wl,-e,_Z6_startPN6nncase7runtime3xpu19hardware_context_mtEPNS1_15runtime_util_mtEPNS1_19nncase_method_tableEPPh)
-  add_executable(${name} "${test_path}/main.cpp")
-  target_link_libraries(${name} xpu_cmodel ${CRT1_LIB_PATH} ${CRTI_LIB_PATH})
-endfunction(add_test)
-
-# add_test(demo1 tests/demo1)
-# add_test(demo2 tests/demo2)
-if(NOT MSVC AND NOT APPLE)
-  add_test(decoder_layer tests/decoder_layer)
-  add_test(norm tests/norm)
-  add_test(embed tests/embed)
-  add_test(head tests/head)
-  add_test(unary tests/unary)
-endif(NOT MSVC AND NOT APPLE)
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/apply.h b/modules/xpu/src/runtime/cmodel/include/apply.h
deleted file mode 100644
index bfb500444f..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/apply.h
+++ /dev/null
@@ -1,102 +0,0 @@
-#pragma once
-#include "../../gsl-lite.hpp"
-
-namespace detail {
-#define APPLY_IMPL_FOR(i) for (index[i] = 0; index[i] < shape[i]; index[i]++)
-
-template <class Callable>
-void apply_1(gsl::span<const size_t> shape, Callable &&callable) noexcept {
-    size_t index[1];
-    APPLY_IMPL_FOR(0)
-    callable(gsl::span(index));
-}
-
-template <class Callable>
-void apply_2(gsl::span<const size_t> shape, Callable &&callable) noexcept {
-    size_t index[2];
-    APPLY_IMPL_FOR(0)
-    APPLY_IMPL_FOR(1)
-    callable(gsl::span(index));
-}
-
-template <class Callable>
-void apply_3(gsl::span<const size_t> shape, Callable &&callable) noexcept {
-    size_t index[3];
-    APPLY_IMPL_FOR(0)
-    APPLY_IMPL_FOR(1)
-    APPLY_IMPL_FOR(2)
-    callable(gsl::span(index));
-}
-
-template <class Callable>
-void apply_4(gsl::span<const size_t> shape, Callable &&callable) noexcept {
-    size_t index[4];
-    APPLY_IMPL_FOR(0)
-    APPLY_IMPL_FOR(1)
-    APPLY_IMPL_FOR(2)
-    APPLY_IMPL_FOR(3)
-    callable(gsl::span(index));
-}
-
-template <class Callable>
-void apply_5(gsl::span<const size_t> shape, Callable &&callable) noexcept {
-    size_t index[5];
-    APPLY_IMPL_FOR(0)
-    APPLY_IMPL_FOR(1)
-    APPLY_IMPL_FOR(2)
-    APPLY_IMPL_FOR(3)
-    APPLY_IMPL_FOR(4)
-    callable(gsl::span(index));
-}
-
-template <class Callable>
-void apply_generic(gsl::span<const size_t> shape,
-                   Callable &&callable) noexcept {
-    auto index_buffer = (size_t *)
-#ifdef _WIN32
-        _alloca
-#else
-        __builtin_alloca
-#endif
-        (sizeof(size_t) * shape.size());
-
-    gsl::span<size_t> index(index_buffer, shape.size());
-    std::fill(index.begin(), index.end(), 0);
-    auto last_dim_idx = (int32_t)shape.size() - 1;
-    while (true) {
-        int dim = last_dim_idx;
-        while (index[dim] == shape[dim]) {
-            if (dim == 0) {
-            }
-
-            index[dim] = 0;
-            index[--dim]++;
-        }
-
-        callable(index);
-        index[last_dim_idx]++;
-    }
-}
-} // namespace detail
-
-template <class Callable>
-void apply(gsl::span<const size_t> shape, Callable &&callable) noexcept {
-    switch (shape.size()) {
-    case 0:
-        return callable(shape);
-    case 1:
-        return detail::apply_1(shape, std::forward<Callable>(callable));
-    case 2:
-        return detail::apply_2(shape, std::forward<Callable>(callable));
-    case 3:
-        return detail::apply_3(shape, std::forward<Callable>(callable));
-    case 4:
-        return detail::apply_4(shape, std::forward<Callable>(callable));
-    case 5:
-        return detail::apply_5(shape, std::forward<Callable>(callable));
-    default:
-        break;
-    }
-
-    return detail::apply_generic(shape, std::forward<Callable>(callable));
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/binary.h b/modules/xpu/src/runtime/cmodel/include/binary.h
deleted file mode 100644
index 2649ab1ab1..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/binary.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "../../gsl-lite.hpp"
-#include <apply.h>
-#include <runtime_utils.h>
-
-using namespace nncase::runtime::xpu;
-
-namespace kernels {
-
-namespace {
-template <class T, class TOp>
-void binary_impl(TOp &&op, const T *lhs, const T *rhs, T *output,
-                 gsl::span<const size_t> lhs_shape,
-                 gsl::span<const size_t> lhs_strides,
-                 gsl::span<const size_t> rhs_shape,
-                 gsl::span<const size_t> rhs_strides,
-                 gsl::span<const size_t> out_shape,
-                 gsl::span<const size_t> out_strides) noexcept {
-    if (is_scalar(out_shape)) {
-        output[0] = op(lhs[0], rhs[0]);
-        return;
-    }
-    return apply(out_shape, [&](gsl::span<const size_t> index) -> void {
-        const auto lhs_index = get_reduced_offset(index, lhs_shape);
-        const auto rhs_index = get_reduced_offset(index, rhs_shape);
-        const auto a = lhs[offset(lhs_strides, lhs_index)];
-        const auto b = rhs[offset(rhs_strides, rhs_index)];
-        output[offset(out_strides, index)] = op(a, b);
-        return;
-    });
-}
-
-#define BINARY_IMPL_OP(op, funct)                                              \
-    case binary_op_t::op:                                                      \
-        return binary_impl(funct, lhs, rhs, output, lhs_shape, lhs_strides,    \
-                           rhs_shape, rhs_strides, out_shape, out_strides)
-
-template <class T>
-void binary_impl(binary_op_t op, const T *lhs, const T *rhs, T *output,
-                 gsl::span<const size_t> lhs_shape,
-                 gsl::span<const size_t> lhs_strides,
-                 gsl::span<const size_t> rhs_shape,
-                 gsl::span<const size_t> rhs_strides,
-                 gsl::span<const size_t> out_shape,
-                 gsl::span<const size_t> out_strides) {
-    // TODO: only support float for now
-    if (std::is_same_v<T, float>) {
-        switch (op) {
-            BINARY_IMPL_OP(add, nncase_mt->float_binary_add);
-            BINARY_IMPL_OP(sub, nncase_mt->float_binary_sub);
-            BINARY_IMPL_OP(mul, nncase_mt->float_binary_mul);
-            BINARY_IMPL_OP(div, nncase_mt->float_binary_div);
-            BINARY_IMPL_OP(idenity_a,
-                           [](T a, [[maybe_unused]] T b) { return a; });
-            BINARY_IMPL_OP(min, nncase_mt->float_binary_min);
-            BINARY_IMPL_OP(max, nncase_mt->float_binary_max);
-            BINARY_IMPL_OP(pow, nncase_mt->float_binary_pow);
-            BINARY_IMPL_OP(mod, nncase_mt->float_binary_mod);
-            // BINARY_IMPL_OP(logical_and,
-            //                [](T a, T b) { return static_cast<T>(a && b); });
-            // BINARY_IMPL_OP(logical_or,
-            //                [](T a, T b) { return static_cast<T>(a || b); });
-            // BINARY_IMPL_OP(logical_xor,
-            //                [](T a, T b) { return static_cast<T>(a ^ b); });
-        default:
-            runtime_util->rt_assert(false, (char *)"Unsupported Binary Op!");
-        }
-    } else if (std::is_same_v<T, int32_t>) {
-        switch (op) {
-            BINARY_IMPL_OP(add, nncase_mt->int32_binary_add);
-            BINARY_IMPL_OP(sub, nncase_mt->int32_binary_sub);
-            BINARY_IMPL_OP(mul, nncase_mt->int32_binary_mul);
-            BINARY_IMPL_OP(div, nncase_mt->int32_binary_div);
-            BINARY_IMPL_OP(idenity_a,
-                           [](T a, [[maybe_unused]] T b) { return a; });
-            BINARY_IMPL_OP(min, nncase_mt->int32_binary_min);
-            BINARY_IMPL_OP(max, nncase_mt->int32_binary_max);
-            BINARY_IMPL_OP(pow, nncase_mt->int32_binary_pow);
-            BINARY_IMPL_OP(mod, nncase_mt->int32_binary_mod);
-            // BINARY_IMPL_OP(logical_and,
-            //                [](T a, T b) { return static_cast<T>(a && b); });
-            // BINARY_IMPL_OP(logical_or,
-            //                [](T a, T b) { return static_cast<T>(a || b); });
-            // BINARY_IMPL_OP(logical_xor,
-            //                [](T a, T b) { return static_cast<T>(a ^ b); });
-        default:
-            runtime_util->rt_assert(false, (char *)"Unsupported Binary Op!");
-        }
-    } else if (std::is_same_v<T, int64_t>) {
-        switch (op) {
-            BINARY_IMPL_OP(add, nncase_mt->int64_binary_add);
-            BINARY_IMPL_OP(sub, nncase_mt->int64_binary_sub);
-            BINARY_IMPL_OP(mul, nncase_mt->int64_binary_mul);
-            BINARY_IMPL_OP(div, nncase_mt->int64_binary_div);
-            BINARY_IMPL_OP(idenity_a,
-                           [](T a, [[maybe_unused]] T b) { return a; });
-            BINARY_IMPL_OP(min, nncase_mt->int64_binary_min);
-            BINARY_IMPL_OP(max, nncase_mt->int64_binary_max);
-            BINARY_IMPL_OP(pow, nncase_mt->int64_binary_pow);
-            BINARY_IMPL_OP(mod, nncase_mt->int64_binary_mod);
-            // BINARY_IMPL_OP(logical_and,
-            //                [](T a, T b) { return static_cast<T>(a && b); });
-            // BINARY_IMPL_OP(logical_or,
-            //                [](T a, T b) { return static_cast<T>(a || b); });
-            // BINARY_IMPL_OP(logical_xor,
-            //                [](T a, T b) { return static_cast<T>(a ^ b); });
-        default:
-            runtime_util->rt_assert(false, (char *)"Unsupported Binary Op!");
-        }
-    } else {
-        runtime_util->rt_assert(false, (char *)"Unsupported Binary Type!");
-    }
-}
-
-} // namespace
-
-template <class T>
-void binary(binary_op_t op, const T *lhs, const T *rhs, T *output,
-            gsl::span<const size_t> lhs_shape,
-            gsl::span<const size_t> lhs_strides,
-            gsl::span<const size_t> rhs_shape,
-            gsl::span<const size_t> rhs_strides,
-            gsl::span<const size_t> out_shape,
-            gsl::span<const size_t> out_strides) noexcept {
-    binary_impl(op, lhs, rhs, output, lhs_shape, lhs_strides, rhs_shape,
-                rhs_strides, out_shape, out_strides);
-}
-
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/cast.h b/modules/xpu/src/runtime/cmodel/include/cast.h
deleted file mode 100644
index 0d06a2058b..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/cast.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "../../gsl-lite.hpp"
-#include <apply.h>
-#include <runtime_utils.h>
-
-using namespace nncase::runtime::xpu;
-namespace kernels {
-namespace {
-template <class TInput, class TOutput>
-void cast_impl(const TInput *input, TOutput *output,
-               gsl::span<const size_t> in_shape,
-               gsl::span<const size_t> in_strides,
-               gsl::span<const size_t> out_strides) noexcept {
-    if (is_scalar(in_shape)) {
-        output[0] = static_cast<TOutput>(input[0]);
-        return;
-    }
-    return apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        auto value = input[offset(in_strides, index)];
-        output[offset(out_strides, index)] = static_cast<TOutput>(value);
-        return;
-    });
-}
-} // namespace
-
-template <class TI, class TO>
-void cast(const TI *input, TO *output, gsl::span<const size_t> in_shape,
-          gsl::span<const size_t> in_strides,
-          gsl::span<const size_t> out_strides) {
-    // TODO: support other cast mode
-    // TODO: support float32->bfloat16 or float32->float16
-    cast_impl(input, output, in_shape, in_strides, out_strides);
-    return;
-}
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/clamp.h b/modules/xpu/src/runtime/cmodel/include/clamp.h
deleted file mode 100644
index 829eb7bffb..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/clamp.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "../../gsl-lite.hpp"
-#include <apply.h>
-#include <runtime_utils.h>
-#ifdef __riscv_vector
-#include <riscv_vector.h>
-#endif
-
-using namespace nncase::runtime::xpu;
-namespace kernels {
-namespace {
-#ifdef __riscv_vector
-template <class T>
-void clamp_rvv_impl(const T *input, T min, T max, T *output,
-                    gsl::span<const size_t> in_shape,
-                    gsl::span<const size_t> in_strides,
-                    gsl::span<const size_t> out_strides) {
-    auto [new_in_shape, new_in_stride] = to_nd(in_shape, in_strides, 5);
-    auto [new_out_shape, new_out_stride] = to_nd(in_shape, out_strides, 5);
-    for (size_t n = 0; n < new_in_shape[0]; ++n) {
-        for (size_t c = 0; c < new_in_shape[1]; ++c) {
-            for (size_t h = 0; h < new_in_shape[2]; ++h) {
-                for (size_t w = 0; w < new_in_shape[3]; ++w) {
-                    const T *in_ptr = input + n * new_in_stride[0] +
-                                      c * new_in_stride[1] + h * new_in_stride[2] +
-                                      w * new_in_stride[3];
-                    T *out_ptr = output + n * new_out_stride[0] +
-                                       c * new_out_stride[1] + h * new_out_stride[2] +
-                                       w * new_out_stride[3];
-                    size_t vl;
-                    for (size_t i = new_in_shape[4]; i > 0; i -= vl) {
-                        vl = vsetvl_e32m8(i);
-                        vfloat32m8_t vx = vle32_v_f32m8(in_ptr, vl);
-                        vx = vfmax_vf_f32m8(vx, min, vl);
-                        vx = vfmin_vf_f32m8(vx, max, vl);
-                        vse32_v_f32m8(out_ptr, vx, vl);
-                        in_ptr += vl;
-                        out_ptr += vl;
-                    }
-                }
-            }
-        }
-    }
-    return;
-}
-#else
-template <class T>
-void clamp_native_impl(const T *input, T min, T max, T *output,
-                       gsl::span<const size_t> in_shape,
-                       gsl::span<const size_t> in_strides,
-                       gsl::span<const size_t> out_strides) {
-    return apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        const auto v = input[offset(index, in_strides)];
-        output[offset(index, out_strides)] = static_cast<T>(
-            std::min(std::max(static_cast<float>(v), static_cast<float>(min)),
-                     static_cast<float>(max)));
-        return;
-    });
-}
-#endif
-} // namespace
-
-template <class T>
-void clamp(const T *input, T *output, T min, T max,
-           gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
-           gsl::span<const size_t> out_strides) {
-#ifdef __riscv_vector
-    clamp_rvv_impl(input, min, max, output, in_shape, in_strides, out_strides);
-#else
-    clamp_native_impl(input, min, max, output, in_shape, in_strides,
-                      out_strides);
-#endif
-}
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/concat.h b/modules/xpu/src/runtime/cmodel/include/concat.h
deleted file mode 100644
index 381eaf2486..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/concat.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "runtime_utils.h"
-
-namespace kernels {
-
-namespace {
-std::pair<size_t, size_t>
-find_input_id_and_index(size_t index,
-                        gsl::span<const size_t> concat_dims) noexcept {
-    size_t input_id;
-    for (input_id = 0;; input_id++) {
-        auto input_dim = concat_dims[input_id];
-        if (index < input_dim)
-            break;
-        index -= input_dim;
-    }
-
-    return std::make_pair(input_id, index);
-}
-
-} // namespace
-
-template <class T>
-void concat(gsl::span<const gsl::byte *> inputs, T *output,
-            gsl::span<const size_t> out_shape,
-            gsl::span<const strides_t> in_strides,
-            gsl::span<const size_t> out_strides, size_t axis,
-            gsl::span<const size_t> concat_dims) noexcept {
-    return apply(out_shape, [&](gsl::span<const size_t> out_index) -> void {
-        auto in_id_index =
-            find_input_id_and_index(out_index[axis], concat_dims);
-        auto input = reinterpret_cast<const T *>(inputs[in_id_index.first]);
-        auto &sel_in_strides = in_strides[in_id_index.first];
-        dims_t in_index(out_index);
-        in_index[axis] = in_id_index.second;
-
-        output[offset(out_strides, out_index)] =
-            input[offset(sel_in_strides, in_index)];
-    });
-}
-
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/expand.h b/modules/xpu/src/runtime/cmodel/include/expand.h
deleted file mode 100644
index c761b1fea9..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/expand.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "../../gsl-lite.hpp"
-#include <apply.h>
-#include <runtime_utils.h>
-
-using namespace nncase::runtime::xpu;
-namespace kernels {
-namespace {
-template <class T>
-void expand_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
-                 gsl::span<const size_t> input_strides,
-                 gsl::span<const size_t> out_shape,
-                 gsl::span<const size_t> out_strides) noexcept {
-    return apply(out_shape, [&](gsl::span<const size_t> index) -> void {
-        const auto in_index = get_reduced_offset(index, in_shape);
-        output[offset(out_strides, index)] =
-            input[offset(input_strides, in_index)];
-        return;
-    });
-}
-} // namespace
-
-template <class T>
-void expand(const T *input, T *output, gsl::span<const size_t> input_shape,
-            gsl::span<const size_t> input_strides,
-            gsl::span<const size_t> out_shape,
-            gsl::span<const size_t> out_strides) {
-    expand_impl(input, output, input_shape, input_strides, out_shape,
-                out_strides);
-    return;
-}
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/gather.h b/modules/xpu/src/runtime/cmodel/include/gather.h
deleted file mode 100644
index a6cb03902d..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/gather.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "../../gsl-lite.hpp"
-#include <apply.h>
-#include <runtime_utils.h>
-
-namespace kernels {
-
-namespace {
-template <class T, class IndicesT>
-void gather_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
-                 gsl::span<const size_t> out_shape,
-                 gsl::span<const size_t> in_strides,
-                 gsl::span<const size_t> out_strides, const IndicesT *indices,
-                 gsl::span<const size_t> indices_shape, size_t axis) noexcept {
-    // scalar
-    if (out_shape.size() == 0) {
-        *output = input[indices[0]];
-        return;
-    }
-
-    apply(out_shape, [&](gsl::span<const size_t> out_index) -> void {
-        // select batch
-        // [out_index.begin(), out_index.begin() + axis]
-        dims_t in_index(in_shape.size());
-        size_t i_index = 0;
-        for (; i_index < static_cast<size_t>(axis); ++i_index) {
-            in_index[i_index] = out_index[i_index];
-        }
-
-        // which index to be used in indices
-        dims_t indices_index(out_index.begin() + axis,
-                             out_index.begin() + axis + indices_shape.size());
-        auto indices_offset =
-            offset(get_default_strides(indices_shape), indices_index);
-        // select sub block in dim axis
-        in_index[i_index] = indices[indices_offset];
-        ++i_index;
-
-        // select position in sub block
-        for (auto o_index = axis + indices_shape.size();
-             o_index < out_index.size(); ++o_index, ++i_index) {
-            in_index[i_index] = out_index[o_index];
-        }
-        output[offset(out_strides, out_index)] =
-            input[offset(in_strides, in_index)];
-    });
-}
-} // namespace
-
-template <class T, class IndicesT>
-void gather(const T *input, T *output, gsl::span<const size_t> in_shape,
-            gsl::span<const size_t> in_strides,
-            gsl::span<const size_t> out_shape,
-            gsl::span<const size_t> out_strides, const IndicesT *indices,
-            gsl::span<const size_t> indices_shape, size_t axis) noexcept {
-    gather_impl(input, output, in_shape, out_shape, in_strides, out_strides,
-                indices, indices_shape, axis);
-}
-
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/hardware_context.h b/modules/xpu/src/runtime/cmodel/include/hardware_context.h
deleted file mode 100644
index c6120aac6b..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/hardware_context.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include "../../method_table_def.h"
-#include <functional>
-
-using namespace nncase::runtime::xpu;
-class hardware_context {
-  public:
-    // hardware_context(hardware_context_mt *impl) : impl_(impl){};
-    void lock_block(int bid) { impl_->lock_block(bid); }
-    int mark_block_visit(int bid, int tid) {
-        return impl_->mark_block_visit(bid, tid);
-    }
-    void unlock_block(int bid) { impl_->unlock_block(bid); }
-    void wait_block_sync(
-        int bid, int visited,
-        std::function<void()> callable = []() -> void {}) {
-        impl_->wait_block_sync(bid, visited, callable);
-    }
-    void lock_all() { impl_->lock_all(); }
-    int mark_all_visit(int bid, int tid) {
-        return impl_->mark_all_visit(bid, tid);
-    }
-    void unlock_all() { impl_->unlock_all(); }
-    void wait_all_sync(
-        int visited, std::function<void()> callable = []() -> void {}) {
-        impl_->wait_all_sync(visited, callable);
-    }
-    void *global_var = nullptr;
-
-    hardware_context_mt *impl_;
-};
-
-static hardware_context global_hardware_ctx;
-
-inline void global_hardware_init(hardware_context_mt *impl) {
-    global_hardware_ctx.impl_ = impl;
-    impl->init();
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/hardware_def.h b/modules/xpu/src/runtime/cmodel/include/hardware_def.h
deleted file mode 100644
index 9dfdcd946a..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/hardware_def.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-#include <stddef.h>
-
-constexpr size_t BLOCKS = 8;
-constexpr size_t CORES = 4;
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/instance_norm.h b/modules/xpu/src/runtime/cmodel/include/instance_norm.h
deleted file mode 100644
index f07b36ec74..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/instance_norm.h
+++ /dev/null
@@ -1,131 +0,0 @@
-#include "runtime_utils.h"
-#include <apply.h>
-#ifdef __riscv_vector
-#include <riscv_vector.h>
-#endif
-
-using namespace nncase::runtime::xpu;
-namespace kernels {
-
-namespace {
-#ifdef __riscv_vector
-static void instance_norm_restruct2(const float *input, float *output, int len,
-                                    const float gamma, const float beta,
-                                    float mean, float sigma) {
-    size_t vl;
-    for (size_t i = len; i > 0; i -= vl) {
-        vl = vsetvl_e32m8(i);
-        vfloat32m8_t vx = vle32_v_f32m8(input, vl);
-        vx = vfsub_vf_f32m8(vx, mean, vl);
-        vx = vfdiv_vf_f32m8(vx, sigma, vl);
-        vx = vfmul_vf_f32m8(vx, gamma, vl);
-        vx = vfadd_vf_f32m8(vx, beta, vl);
-        vse32_v_f32m8(output, vx, vl);
-        input += vl;
-        output += vl;
-    }
-}
-
-template <typename T>
-void instance_norm_rvv_impl(
-    const T *input, const T *sum, const T *sum_sqr, T *output, const T *gamma,
-    const T *beta, gsl::span<const size_t> input_shape,
-    gsl::span<const size_t> input_stride, gsl::span<const size_t> output_stride,
-    [[maybe_unused]] gsl::span<const size_t> sum_strides,
-    [[maybe_unused]] gsl::span<const size_t> gamma_strides, T eps,
-    int32_t norm_size) noexcept {
-
-    auto get_offset_from_index = [](gsl::span<const size_t> in_shape,
-                                    gsl::span<const size_t> in_strides,
-                                    int index) -> int {
-        strides_t x = get_default_strides(in_shape);
-        int __sum = 0;
-        for (size_t i = 0; i < x.size(); ++i) {
-            __sum += index / x[i] * in_strides[i];
-            index = index % x[i];
-        }
-        return __sum;
-    };
-
-    size_t outer_size = 1;
-    for (auto i = 0; i < 2; i++) {
-        outer_size *= input_shape[i];
-    }
-
-    size_t inner_size = 1;
-    for (int i = 2; i < (int)input_shape.size(); i++) {
-        inner_size *= input_shape[i];
-    }
-    gsl::span<const size_t> in_shape_outer(input_shape.begin(),
-                                           input_shape.begin() + 2);
-    gsl::span<const size_t> in_shape_inner(input_shape.begin() + 2,
-                                           input_shape.end());
-    for (size_t o = 0; o < outer_size; o++) {
-        int __ptr_output =
-            get_offset_from_index(in_shape_outer, output_stride, o);
-        int __ptr_input =
-            get_offset_from_index(in_shape_outer, input_stride, o);
-        int __ptr_sum = get_offset_from_index(in_shape_outer, sum_strides, o);
-        auto mean = sum[__ptr_sum] / norm_size;
-        auto sigma = nncase_mt->float_unary_sqrt(
-            sum_sqr[__ptr_sum] / norm_size - mean * mean + eps);
-        auto in_offset = outer_size % input_shape[1];
-        instance_norm_restruct2(input + __ptr_input, output + __ptr_output,
-                                inner_size, gamma[in_offset], beta[in_offset],
-                                mean, sigma);
-    }
-}
-#else
-template <typename T>
-void instance_norm_naive_impl(
-    const T *input, const T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
-    gsl::span<const size_t> input_shape, gsl::span<const size_t> input_stride,
-    gsl::span<const size_t> output_stride,
-    [[maybe_unused]] gsl::span<const size_t> sum_strides,
-    gsl::span<const size_t> gamma_strides, T eps, int32_t norm_size) noexcept {
-    auto axis = 2;
-    apply(input_shape, [&](gsl::span<const size_t> input_index) -> void {
-        //  input_index
-        auto o_offset = offset(sum_strides, input_index.subspan(0, axis));
-        auto mean = sum[o_offset] / norm_size;
-        auto sigma = nncase_mt->float_unary_sqrt(sum_sqr[o_offset] / norm_size -
-                                                 mean * mean + eps);
-
-        auto input_offset = offset(input_stride, input_index);
-        auto in_offset =
-            offset(gamma_strides, input_index.subspan(axis - 1, 1));
-        output[offset(output_stride, input_index)] =
-            (input[input_offset] - mean) / sigma * gamma[in_offset] +
-            beta[in_offset];
-    });
-}
-#endif
-
-} // namespace
-
-template <class T>
-void instance_norm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma,
-                   T *beta, dims_t input_dims, strides_t input_strides,
-                   strides_t output_strides, strides_t sum_strides,
-                   strides_t gamma_strides, T eps, int32_t norm_size) {
-#ifdef __riscv_vector
-    return instance_norm_rvv_impl(
-        input, sum, sum_sqr, output, gamma, beta,
-        gsl::make_span(input_dims).template as_span<const size_t>(),
-        gsl::make_span(input_strides).template as_span<const size_t>(),
-        gsl::make_span(output_strides).template as_span<const size_t>(),
-        gsl::make_span(sum_strides).template as_span<const size_t>(),
-        gsl::make_span(gamma_strides).template as_span<const size_t>(), eps,
-        norm_size);
-#else
-    return instance_norm_naive_impl(
-        input, sum, sum_sqr, output, gamma, beta,
-        gsl::make_span(input_dims).template as_span<const size_t>(),
-        gsl::make_span(input_strides).template as_span<const size_t>(),
-        gsl::make_span(output_strides).template as_span<const size_t>(),
-        gsl::make_span(sum_strides).template as_span<const size_t>(),
-        gsl::make_span(gamma_strides).template as_span<const size_t>(), eps,
-        norm_size);
-#endif
-}
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/layernorm.h b/modules/xpu/src/runtime/cmodel/include/layernorm.h
deleted file mode 100644
index 75854a62e1..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/layernorm.h
+++ /dev/null
@@ -1,216 +0,0 @@
-#include "runtime_utils.h"
-#include <apply.h>
-#include <cmath>
-#ifdef __riscv_vector
-#include <riscv_vector.h>
-#endif
-
-using namespace nncase::runtime::xpu;
-namespace kernels {
-
-namespace {
-
-#ifdef __riscv_vector
-static void layernor_restruct2(const float *input, float *output, int len,
-                               const float *gamma, const float *beta,
-                               float mean, float sigma) {
-    size_t vl;
-    if (gamma == NULL && beta == NULL) {
-        for (size_t i = len; i > 0; i -= vl) {
-            vl = vsetvl_e32m8(i);
-            vfloat32m8_t vx = vle32_v_f32m8(input, vl);
-            vx = vfsub_vf_f32m8(vx, mean, vl);
-            vx = vfdiv_vf_f32m8(vx, sigma, vl);
-            vse32_v_f32m8(output, vx, vl);
-            input += vl;
-            output += vl;
-        }
-        return;
-    }
-    if (gamma == NULL) {
-        for (size_t i = len; i > 0; i -= vl) {
-            vl = vsetvl_e32m8(i);
-            vfloat32m8_t vx = vle32_v_f32m8(input, vl);
-            vfloat32m8_t vbeta = vle32_v_f32m8(beta, vl);
-            vx = vfsub_vf_f32m8(vx, mean, vl);
-            vx = vfdiv_vf_f32m8(vx, sigma, vl);
-            vx = vfadd_vv_f32m8(vx, vbeta, vl);
-            vse32_v_f32m8(output, vx, vl);
-            input += vl;
-            output += vl;
-            beta += vl;
-        }
-        return;
-    }
-    if (beta == NULL) {
-        for (size_t i = len; i > 0; i -= vl) {
-            vl = vsetvl_e32m8(i);
-            vfloat32m8_t vx = vle32_v_f32m8(input, vl);
-            vfloat32m8_t vgamma = vle32_v_f32m8(gamma, vl);
-            vx = vfsub_vf_f32m8(vx, mean, vl);
-            vx = vfdiv_vf_f32m8(vx, sigma, vl);
-            vx = vfmul_vv_f32m8(vx, vgamma, vl);
-            vse32_v_f32m8(output, vx, vl);
-            input += vl;
-            output += vl;
-            gamma += vl;
-        }
-        return;
-    }
-
-    for (size_t i = len; i > 0; i -= vl) {
-        vl = vsetvl_e32m8(i);
-        vfloat32m8_t vx = vle32_v_f32m8(input, vl);
-        vfloat32m8_t vgamma = vle32_v_f32m8(gamma, vl);
-        vfloat32m8_t vbeta = vle32_v_f32m8(beta, vl);
-        vx = vfsub_vf_f32m8(vx, mean, vl);
-        vx = vfdiv_vf_f32m8(vx, sigma, vl);
-        vx = vfmacc_vv_f32m8(vbeta, vx, vgamma, vl);
-        vse32_v_f32m8(output, vx, vl);
-        input += vl;
-        output += vl;
-        beta += vl;
-        gamma += vl;
-    }
-}
-
-static int get_offset_from_index(gsl::span<const size_t> in_shape,
-                                 gsl::span<const size_t> in_strides,
-                                 int index) {
-    strides_t x = get_default_strides(in_shape);
-    int __sum = 0;
-    for (size_t i = 0; i < x.size(); ++i) {
-        __sum += index / x[i] * in_strides[i];
-        index = index % x[i];
-    }
-    return __sum;
-}
-
-template <typename T>
-void layernorm_rvv_impl(const T *input, const T *sum, const T *sum_sqr,
-                        T *output, const T *gamma, const T *beta,
-                        gsl::span<const size_t> input_shape,
-                        gsl::span<const size_t> input_stride,
-                        gsl::span<const size_t> output_stride,
-                        [[maybe_unused]] gsl::span<const size_t> sum_strides,
-                        [[maybe_unused]] gsl::span<const size_t> gamma_strides,
-                        T eps, int32_t axis, int32_t norm_size,
-                        [[maybe_unused]] bool rms_norm = false) noexcept {
-
-    size_t outer_size = 1;
-    for (auto i = 0; i < axis; i++) {
-        outer_size *= input_shape[i];
-    }
-
-    size_t inner_size = 1;
-    for (int i = axis; i < (int)input_shape.size(); i++) {
-        inner_size *= input_shape[i];
-    }
-    gsl::span<const size_t> in_shape_outer(input_shape.begin(),
-                                           input_shape.begin() + axis);
-    gsl::span<const size_t> in_shape_inner(input_shape.begin() + axis,
-                                           input_shape.end());
-    for (size_t o = 0; o < outer_size; o++) {
-        int __ptr_output =
-            get_offset_from_index(in_shape_outer, output_stride, o);
-        int __ptr_input =
-            get_offset_from_index(in_shape_outer, input_stride, o);
-        int __ptr_sum = get_offset_from_index(in_shape_outer, sum_strides, o);
-        auto mean = sum[__ptr_sum] / norm_size;
-        if (rms_norm)
-            mean = 0;
-        auto sigma =
-            std::sqrt(sum_sqr[__ptr_sum] / norm_size - mean * mean + eps);
-        layernor_restruct2(input + __ptr_input, output + __ptr_output,
-                           inner_size, gamma, beta, mean, sigma);
-    }
-}
-#else
-template <typename T>
-void layernorm_naive_impl(const T *input, const T *sum, T *sum_sqr, T *output,
-                          T *gamma, T *beta,
-                          gsl::span<const size_t> input_shape,
-                          gsl::span<const size_t> input_stride,
-                          gsl::span<const size_t> output_stride,
-                          [[maybe_unused]] gsl::span<const size_t> sum_strides,
-                          gsl::span<const size_t> gamma_strides, T eps,
-                          int32_t axis, int32_t norm_size,
-                          bool rms_norm = false) noexcept {
-    apply(input_shape, [&](gsl::span<const size_t> input_index) -> void {
-        //  input_index
-        auto o_offset = offset(sum_strides, input_index.subspan(0, axis));
-        // auto o_offset = input_index[0];
-        auto mean = sum[o_offset] / norm_size;
-        if (rms_norm) {
-            mean = 0;
-        }
-        auto sigma = nncase_mt->float_unary_sqrt(sum_sqr[o_offset] / norm_size -
-                                                 mean * mean + eps);
-
-        auto input_offset = offset(input_stride, input_index);
-        auto in_offset = offset(gamma_strides, input_index.subspan(axis));
-        output[offset(output_stride, input_index)] =
-            (input[input_offset] - mean) / sigma *
-                (gamma == nullptr ? static_cast<T>(1) : gamma[in_offset]) +
-            (beta == nullptr ? static_cast<T>(0) : beta[in_offset]);
-    });
-
-    // // only process continues tensor for now
-    // size_t outer_size = 1;
-    // for (auto i = 0; i < axis; i++) {
-    //     outer_size *= input_shape[i];
-    // }
-
-    // size_t inner_size = 1;
-    // for (auto i = axis; i < input_shape.size(); i++) {
-    //     inner_size *= input_shape[i];
-    // }
-
-    // for (size_t o = 0; o < outer_size; o++) {
-    //     auto mean = sum[o] / norm_size;
-    //     auto sigma = std::sqrt(sum_sqr[o] / norm_size - mean * mean + eps);
-    //     for (size_t i = 0; i < inner_size; i++) {
-    //         auto x = input + o * inner_size + i;
-    //         *x = (*x - mean) / sigma *
-    //                  (gamma == nullptr ? static_cast<T>(1) : gamma[i]) +
-    //              (beta == nullptr ? static_cast<T>(0) : beta[i]);
-    //     }
-    // }
-}
-#endif
-
-} // namespace
-
-template <class T>
-void layernorm(const T *input, T *sum, T *sum_sqr, T *output, T *gamma, T *beta,
-               dims_t input_dims, strides_t input_strides,
-               strides_t output_strides, strides_t sum_strides,
-               strides_t gamma_strides, T eps, int32_t axis, int32_t norm_size,
-               bool rms_norm = false) {
-    // fafdaf
-#ifdef __riscv_vector
-    // return layernorm_rvv_impl(
-    //     input, sum, sum_sqr, gamma, beta,
-    //     gsl::make_span(input_dims).template as_span<const size_t>(),
-    //     gsl::make_span(input_strides).template as_span<const size_t>(), eps,
-    //     axis, norm_size);
-    return layernorm_rvv_impl(
-        input, sum, sum_sqr, output, gamma, beta,
-        gsl::make_span(input_dims).template as_span<const size_t>(),
-        gsl::make_span(input_strides).template as_span<const size_t>(),
-        gsl::make_span(output_strides).template as_span<const size_t>(),
-        gsl::make_span(sum_strides).template as_span<const size_t>(),
-        gsl::make_span(gamma_strides).template as_span<const size_t>(), eps,
-        axis, norm_size, rms_norm);
-#else
-    return layernorm_naive_impl(
-        input, sum, sum_sqr, output, gamma, beta,
-        gsl::make_span(input_dims).template as_span<const size_t>(),
-        gsl::make_span(input_strides).template as_span<const size_t>(),
-        gsl::make_span(output_strides).template as_span<const size_t>(),
-        gsl::make_span(sum_strides).template as_span<const size_t>(),
-        gsl::make_span(gamma_strides).template as_span<const size_t>(), eps,
-        axis, norm_size, rms_norm);
-#endif
-}
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/matmul.h b/modules/xpu/src/runtime/cmodel/include/matmul.h
deleted file mode 100644
index 3b896109d6..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/matmul.h
+++ /dev/null
@@ -1,196 +0,0 @@
-#include "runtime_utils.h"
-#ifdef __riscv_vector
-#include <riscv_vector.h>
-#endif
-
-namespace kernels {
-
-namespace {
-template <typename T>
-void matmul_unit_impl(const T *input_a, const T *input_b, T *output,
-                      gsl::span<const size_t> in_a_shape,
-                      gsl::span<const size_t> in_b_shape) noexcept {
-    int32_t a_rows = static_cast<int32_t>(in_a_shape[0]);
-    int32_t a_cols = static_cast<int32_t>(in_a_shape[1]);
-    int32_t b_cols = static_cast<int32_t>(in_b_shape[1]);
-
-    for (int32_t oy = 0; oy < a_rows; oy++) {
-        T *values = (T *)runtime_util->malloc(sizeof(T) * b_cols);
-        // runtime_util->memset(values, 0, sizeof(T) * b_cols);
-        for (int32_t i = 0; i < a_cols; i++) {
-            for (int32_t ox = 0; ox < b_cols; ox++) {
-                const auto a = input_a[oy * a_cols + i];
-                const auto b = input_b[i * b_cols + ox];
-                values[ox] += a * b;
-            }
-        }
-        runtime_util->memcpy(output + oy * b_cols, values, sizeof(T) * b_cols);
-        runtime_util->free(values);
-    }
-}
-
-#ifdef __riscv_vector
-inline void matmul_rvv_impl(const float *input_a, const float *input_b,
-                            float *output, size_t size_m, size_t size_k,
-                            size_t size_n, size_t lda, size_t ldb, size_t ldc) {
-    size_t vl;
-    for (size_t m = 0; m < size_m; ++m) {
-        const float *b_n_ptr = input_b;
-        float *c_n_ptr = output;
-        for (size_t c_n_count = size_n; c_n_count; c_n_count -= vl) {
-            vl = vsetvl_e32m1(c_n_count);
-            const float *a_k_ptr = input_a;
-            const float *b_k_ptr = b_n_ptr;
-            vfloat32m1_t acc = vle32_v_f32m1(c_n_ptr, vl);
-            for (size_t k = 0; k < size_k; ++k) {
-                vfloat32m1_t b_n_data = vle32_v_f32m1(b_k_ptr, vl);
-                acc = vfmacc_vf_f32m1(acc, *a_k_ptr, b_n_data, vl);
-                b_k_ptr += ldb;
-                a_k_ptr++;
-            }
-            vse32_v_f32m1(c_n_ptr, acc, vl);
-            c_n_ptr += vl;
-            b_n_ptr += vl;
-        }
-        input_a += lda;
-        output += ldc;
-    }
-}
-#endif
-
-template <typename T>
-void contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
-                            gsl::span<const size_t> in_a_shape,
-                            gsl::span<const size_t> in_b_shape) noexcept {
-    auto new_a_shape = to_nd(in_a_shape, 5);
-    auto new_b_shape = to_nd(in_b_shape, 5);
-    auto a_unit_size = new_a_shape[3] * new_a_shape[4];
-    auto b_unit_size = new_b_shape[3] * new_b_shape[4];
-    auto out_unit_size = new_a_shape[3] * new_b_shape[4];
-
-    auto dim0 =
-        new_a_shape[0] > new_b_shape[0] ? new_a_shape[0] : new_b_shape[0];
-    auto dim1 =
-        new_a_shape[1] > new_b_shape[1] ? new_a_shape[1] : new_b_shape[1];
-    auto dim2 =
-        new_a_shape[2] > new_b_shape[2] ? new_a_shape[2] : new_b_shape[2];
-    auto ah_size = a_unit_size * new_a_shape[2];
-    auto bh_size = b_unit_size * new_b_shape[2];
-    auto oh_size = out_unit_size * dim2;
-
-    auto ab_size = ah_size * new_a_shape[1];
-    auto bb_size = bh_size * new_b_shape[1];
-    auto ob_size = oh_size * dim1;
-
-    for (size_t n = 0; n < dim0; ++n) {
-        auto an = new_a_shape[0] == 1 ? 0 : n;
-        auto bn = new_b_shape[0] == 1 ? 0 : n;
-        for (size_t c = 0; c < dim1; ++c) {
-            auto ac = new_a_shape[1] == 1 ? 0 : c;
-            auto bc = new_b_shape[1] == 1 ? 0 : c;
-            for (size_t h = 0; h < dim2; ++h) {
-                auto ah = new_a_shape[2] == 1 ? 0 : h;
-                auto bh = new_b_shape[2] == 1 ? 0 : h;
-#ifdef __riscv_vector
-                matmul_rvv_impl(
-                    input_a + an * ab_size + ac * ah_size + ah * a_unit_size,
-                    input_b + bn * bb_size + bc * bh_size + bh * b_unit_size,
-                    output + n * ob_size + c * oh_size + h * out_unit_size,
-                    new_a_shape[3], new_a_shape[4], new_b_shape[4],
-                    new_a_shape[4], new_b_shape[4], new_b_shape[4]);
-#else
-                matmul_unit_impl(
-                    input_a + an * ab_size + ac * ah_size + ah * a_unit_size,
-                    input_b + bn * bb_size + bc * bh_size + bh * b_unit_size,
-                    output + n * ob_size + c * oh_size + h * out_unit_size,
-                    std::array<size_t, 2>{new_a_shape[3], new_a_shape[4]},
-                    std::array<size_t, 2>{new_b_shape[3], new_b_shape[4]});
-#endif
-            }
-        }
-    }
-}
-
-template <typename T>
-void no_contiguous_matmul_impl(const T *input_a, const T *input_b, T *output,
-                               gsl::span<const size_t> in_a_shape,
-                               gsl::span<const size_t> in_a_stride,
-                               gsl::span<const size_t> in_b_shape,
-                               gsl::span<const size_t> in_b_stride,
-                               gsl::span<const size_t> out_shape,
-                               gsl::span<const size_t> out_stride) noexcept {
-    auto [new_a_shape, new_a_stride] = to_nd(in_a_shape, in_a_stride, 5);
-    auto [new_b_shape, new_b_stride] = to_nd(in_b_shape, in_b_stride, 5);
-    auto [new_out_shape, new_out_stride] = to_nd(out_shape, out_stride, 5);
-
-    for (size_t n = 0; n < new_out_shape[0]; ++n) {
-        auto an = new_a_shape[0] == 1 ? 0 : n;
-        auto bn = new_b_shape[0] == 1 ? 0 : n;
-        for (size_t c = 0; c < new_out_shape[1]; ++c) {
-            auto ac = new_a_shape[1] == 1 ? 0 : c;
-            auto bc = new_b_shape[1] == 1 ? 0 : c;
-            for (size_t h = 0; h < new_out_shape[2]; ++h) {
-                auto ah = new_a_shape[2] == 1 ? 0 : h;
-                auto bh = new_b_shape[2] == 1 ? 0 : h;
-
-                const T *in_a_ptr = input_a + an * new_a_stride[0] +
-                                    ac * new_a_stride[1] + ah * new_a_stride[2];
-                const T *in_b_ptr = input_b + bn * new_b_stride[0] +
-                                    bc * new_b_stride[1] + bh * new_b_stride[2];
-                T *out_ptr = output + n * new_out_stride[0] +
-                             c * new_out_stride[1] + h * new_out_stride[2];
-#ifdef __riscv_vector
-                matmul_rvv_impl(in_a_ptr, in_b_ptr, out_ptr, new_a_shape[3],
-                                new_a_shape[4], new_b_shape[4], new_a_stride[3],
-                                new_b_stride[3], new_b_stride[3]);
-#else
-                for (size_t m = 0; m < new_a_shape[3]; m++) {
-                    T *values =
-                        (T *)runtime_util->malloc(new_b_shape[4] * sizeof(T));
-                    for (size_t k = 0; k < new_a_shape[4]; k++) {
-                        for (size_t n = 0; n < new_b_shape[4]; n++) {
-                            values[n] += in_a_ptr[m * new_a_stride[3] +
-                                                  k * new_a_stride[4]] *
-                                         in_b_ptr[k * new_b_stride[3] +
-                                                  n * new_b_stride[4]];
-                        }
-                    }
-                    for (size_t n = 0; n < new_b_shape[4]; n++) {
-                        out_ptr[m * new_out_stride[3] + n * new_out_stride[4]] =
-                            values[n];
-                    }
-                    runtime_util->free(values);
-                }
-#endif
-            }
-        }
-    }
-}
-
-} // namespace
-
-template <class T>
-void matmul(const T *input_a, const T *input_b, T *output, dims_t in_a_dims,
-            strides_t in_a_strides, dims_t in_b_dims, strides_t in_b_strides,
-            dims_t output_dims, strides_t output_strides
-
-) {
-    if (is_contiguous(in_a_dims, in_a_strides) &&
-        is_contiguous(in_b_dims, in_b_strides) &&
-        is_contiguous(output_dims, output_strides)) {
-        return contiguous_matmul_impl(
-            input_a, input_b, output,
-            gsl::make_span(in_a_dims).template as_span<const size_t>(),
-            gsl::make_span(in_b_dims).template as_span<const size_t>());
-    } else {
-        return no_contiguous_matmul_impl(
-            input_a, input_b, output,
-            gsl::make_span(in_a_dims).template as_span<const size_t>(),
-            gsl::make_span(in_a_strides).template as_span<const size_t>(),
-            gsl::make_span(in_b_dims).template as_span<const size_t>(),
-            gsl::make_span(in_b_strides).template as_span<const size_t>(),
-            gsl::make_span(output_dims).template as_span<const size_t>(),
-            gsl::make_span(output_strides).template as_span<const size_t>());
-    }
-}
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/reduce.h b/modules/xpu/src/runtime/cmodel/include/reduce.h
deleted file mode 100644
index ff1943a7f7..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/reduce.h
+++ /dev/null
@@ -1,184 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "../../gsl-lite.hpp"
-#include <apply.h>
-#include <runtime_utils.h>
-
-enum class reduce_op_t : uint8_t {
-    mean = 0,
-    min = 1,
-    max = 2,
-    sum = 3,
-    prod = 4,
-    sum_sqr = 5,
-};
-
-namespace kernels {
-
-namespace {
-template <class T> struct identity {
-    T operator()(const T &src) const noexcept { return src; }
-};
-
-template <class TShape>
-size_t get_reduce_block_size(const TShape &in_shape, const TShape &axis) {
-    size_t size = 1;
-    for (size_t i = 0; i < in_shape.size(); i++) {
-        for (size_t j = 0; j < axis.size(); j++) {
-            if (i == axis[j]) {
-                size *= in_shape[i];
-                break;
-            }
-        }
-    }
-
-    return size;
-}
-
-template <class TReducer, class TPostProcess, class T>
-void reduce_impl(TReducer &&reducer, TPostProcess &&post_process,
-                 const T init_value, const T *input, T *output,
-                 gsl::span<const size_t> in_shape, gsl::span<const size_t> axis,
-                 gsl::span<const size_t> in_strides,
-                 gsl::span<const size_t> out_shape,
-                 gsl::span<const size_t> out_strides, bool keep_dims) noexcept {
-    apply(out_shape, [&](gsl::span<const size_t> index) -> void {
-        output[offset(out_strides, index)] = init_value;
-    });
-    apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        const auto v = input[offset(in_strides, index)];
-        const auto out_index = get_reduced_offset(index, axis, keep_dims);
-        auto &dest = output[offset(out_strides, out_index)];
-        dest = reducer(dest, v);
-    });
-    apply(out_shape, [&](gsl::span<const size_t> index) -> void {
-        auto &dest = output[offset(out_strides, index)];
-        dest = post_process(dest);
-    });
-}
-} // namespace
-
-#define REDUCE_IMPL(op, reducer, post_process)                                 \
-    case op:                                                                   \
-        return reduce_impl(reducer, post_process,                              \
-                           *reinterpret_cast<const T *>(init_value), input,    \
-                           output, in_shape, axis, in_strides, out_shape,      \
-                           out_strides, keep_dims)
-
-#define REDUCE_IMPL_NO_POST(op, reducer)                                       \
-    case op:                                                                   \
-        return reduce_impl(reducer, identity<T>(),                             \
-                           *reinterpret_cast<const T *>(init_value), input,    \
-                           output, in_shape, axis, in_strides, out_shape,      \
-                           out_strides, keep_dims)
-
-template <typename T>
-void reduce_prod(const T *input, T *output, gsl::span<const size_t> in_shape,
-                 gsl::span<const size_t> in_strides,
-                 gsl::span<const size_t> out_strides_origin,
-                 gsl::span<const size_t> axes, bool keep_dims) noexcept {
-    auto out_shape = get_reduced_shape(in_shape, axes, keep_dims);
-    auto out_strides =
-        out_strides_origin.size() == 0 ? dims_t{1} : dims_t(out_strides_origin);
-    // init with init_value
-    apply(gsl::make_span(out_shape).as_span<const size_t>(),
-          [&](gsl::span<const size_t> index) -> void {
-              output[offset(out_strides, index)] = 1;
-          });
-
-    apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        const auto src = input[offset(in_strides, index)];
-        auto out_idx =
-            offset(out_strides, get_reduced_offset(index, axes, keep_dims));
-        auto &dst = output[out_idx];
-        dst *= src;
-    });
-}
-
-template <>
-void reduce_prod(const bool *input, bool *output,
-                 gsl::span<const size_t> in_shape,
-                 gsl::span<const size_t> in_strides,
-                 gsl::span<const size_t> out_strides_origin,
-                 gsl::span<const size_t> axes, bool keep_dims) noexcept {
-    auto out_shape = get_reduced_shape(in_shape, axes, keep_dims);
-    auto out_strides =
-        out_strides_origin.size() == 0 ? dims_t{1} : dims_t(out_strides_origin);
-    // init with init_value
-    apply(gsl::make_span(out_shape).as_span<const size_t>(),
-          [&](gsl::span<const size_t> index) -> void {
-              output[offset(out_strides, index)] = 1;
-          });
-
-    apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        const auto src = input[offset(in_strides, index)];
-        auto out_idx =
-            offset(out_strides, get_reduced_offset(index, axes, keep_dims));
-        auto &dst = output[out_idx];
-        dst &= src;
-    });
-}
-
-template void reduce_prod<float>(const float *input, float *output,
-                                 gsl::span<const size_t> in_shape,
-                                 gsl::span<const size_t> in_strides,
-                                 gsl::span<const size_t> out_strides,
-                                 gsl::span<const size_t> axis,
-                                 bool keep_dims) noexcept;
-
-template <class T>
-void reduce(reduce_op_t op, const T *init_value, const T *input, T *output,
-            gsl::span<const size_t> in_shape, gsl::span<const size_t> axis,
-            gsl::span<const size_t> in_strides,
-            gsl::span<const size_t> out_strides, bool keep_dims) noexcept {
-    auto out_shape = get_reduced_shape(in_shape, axis, keep_dims);
-    switch (op) {
-        REDUCE_IMPL(
-            reduce_op_t::mean, [](T a, T b) { return a + b; },
-            [block_size = (T)get_reduce_block_size(in_shape, axis)](T v) {
-                return v / block_size;
-            });
-        REDUCE_IMPL_NO_POST(reduce_op_t::min,
-                            [](T a, T b) { return a > b ? b : a; });
-        REDUCE_IMPL_NO_POST(reduce_op_t::max,
-                            [](T a, T b) { return a > b ? a : b; });
-        REDUCE_IMPL_NO_POST(reduce_op_t::sum, [](T a, T b) { return a + b; });
-        REDUCE_IMPL_NO_POST(reduce_op_t::sum_sqr,
-                            [](T a, T b) { return a + (b * b); });
-    case reduce_op_t::prod:
-        return reduce_prod(reinterpret_cast<const T *>(input),
-                           reinterpret_cast<T *>(output), in_shape, in_strides,
-                           out_strides, axis, keep_dims);
-    default:
-        return;
-    }
-}
-
-template <class T>
-void reduce_sum_and_sum_sqr(const T *input, T *sum, T *sum_sqr,
-                            gsl::span<const size_t> in_shape,
-                            gsl::span<const size_t> in_strides,
-                            gsl::span<const size_t> out_strides) {
-    auto init_v = (T)0;
-    kernels::reduce(reduce_op_t::sum, &init_v, input, sum, in_shape,
-                    dims_t({in_shape.size() - 1}), in_strides, out_strides,
-                    false);
-    kernels::reduce(reduce_op_t::sum_sqr, &init_v, input, sum_sqr, in_shape,
-                    dims_t({in_shape.size() - 1}), in_strides, out_strides,
-                    false);
-}
-
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/reduce_arg.h b/modules/xpu/src/runtime/cmodel/include/reduce_arg.h
deleted file mode 100644
index 2a6337a7c1..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/reduce_arg.h
+++ /dev/null
@@ -1,81 +0,0 @@
-#pragma once
-#include "runtime_utils.h"
-#include <cmath>
-#include <unordered_map>
-
-enum class reduce_arg_op_t : uint8_t {
-    arg_min = 0,
-    arg_max = 1,
-};
-
-namespace kernels {
-template <class TReducer, class TOutput, class T>
-void reduce_arg_impl(TReducer &&reducer, T init_value, const T *input,
-                     TOutput *output, gsl::span<const size_t> in_shape,
-                     gsl::span<const size_t> out_shape,
-                     gsl::span<const size_t> in_strides,
-                     gsl::span<const size_t> out_strides,
-                     gsl::span<const size_t> axes, bool keep_dims,
-                     bool select_last_idx) noexcept {
-    const float epsilon = 0.000001f;
-
-    // init with init_value
-    auto output_size = compute_size(out_shape);
-    auto ptr = (T *)runtime_util->malloc(output_size * sizeof(T));
-    apply(out_shape, [&](gsl::span<const size_t> index) -> void {
-        auto out_idx = offset(out_strides, index);
-        ptr[out_idx] = init_value;
-    });
-
-    // collect all min/max indices
-    auto out_map =
-        (TOutput *)runtime_util->malloc(output_size * 2 * sizeof(TOutput));
-    apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        const auto src = input[offset(in_strides, index)];
-        auto out_idx =
-            offset(out_strides, get_reduced_offset(index, axes, keep_dims));
-        T &dst = ptr[out_idx];
-        auto ret = reducer(src, dst);
-        if (ret) {
-            out_map[out_idx * 2 + 0] = index[axes[0]];
-            out_map[out_idx * 2 + 1] = index[axes[0]];
-            dst = src;
-        } else if (std::fabs(src - dst) < epsilon) {
-            out_map[out_idx * 2 + 1] = index[axes[0]];
-        }
-    });
-
-    // update min/max idx
-    apply(out_shape, [&](gsl::span<const size_t> index) -> void {
-        auto out_idx = offset(out_strides, index);
-        output[out_idx] = select_last_idx ? out_map[out_idx * 2 + 1]
-                                          : out_map[out_idx * 2 + 0];
-    });
-
-    runtime_util->free(out_map);
-    runtime_util->free(ptr);
-}
-
-template <class Tin, class Tout>
-void reduce_arg(reduce_arg_op_t op, const Tin *input, Tout *output,
-                gsl::span<const size_t> in_shape,
-                gsl::span<const size_t> in_strides,
-                gsl::span<const size_t> out_shape,
-                gsl::span<const size_t> out_strides,
-                gsl::span<const size_t> axes, bool keep_dims,
-                bool select_last_idx) noexcept {
-    switch (op) {
-    case reduce_arg_op_t::arg_min:
-        return reduce_arg_impl([](Tin a, Tin b) { return a < b; },
-                               std::numeric_limits<Tin>::max(), input, output,
-                               in_shape, out_shape, in_strides, out_strides,
-                               axes, keep_dims, select_last_idx);
-    case reduce_arg_op_t::arg_max:
-        return reduce_arg_impl([](Tin a, Tin b) { return a > b; },
-                               std::numeric_limits<Tin>::lowest(), input,
-                               output, in_shape, out_shape, in_strides,
-                               out_strides, axes, keep_dims, select_last_idx);
-    }
-}
-
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/resize.h b/modules/xpu/src/runtime/cmodel/include/resize.h
deleted file mode 100644
index 24c073b14f..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/resize.h
+++ /dev/null
@@ -1,141 +0,0 @@
-#include "resize_util.h"
-#include "runtime_utils.h"
-#include <apply.h>
-#include <cmath>
-#ifdef __riscv_vector_
-#include <riscv_vector.h>
-#endif
-
-using namespace nncase::runtime::xpu;
-
-namespace kernels {
-namespace {
-template <class T>
-void resize_bilinear_impl(const T *input, T *output,
-                          gsl::span<const size_t> in_shape,
-                          gsl::span<const size_t> in_strides,
-                          gsl::span<const size_t> out_strides, int32_t out_h,
-                          int32_t out_w, bool align_corners,
-                          bool half_pixel_centers) noexcept {
-    auto [height_scale, width_scale] =
-        get_resize_scales(in_shape, out_h, out_w, align_corners);
-
-    const float rounding_offset =
-        std::numeric_limits<T>::is_integer ? .5f : .0f;
-    dims_t in_index(4), out_index(4);
-
-    auto get_input = [&](int32_t in_y, int32_t in_x) {
-        in_index[2] = in_y;
-        in_index[3] = in_x;
-        return input[offset(in_strides, in_index)];
-    };
-
-    for (size_t batch = 0; batch < in_shape[0]; batch++) {
-        in_index[0] = batch;
-        out_index[0] = batch;
-        for (size_t oc = 0; oc < in_shape[1]; oc++) {
-            in_index[1] = oc;
-            out_index[1] = oc;
-            for (size_t oy = 0; oy < (size_t)out_h; oy++) {
-                out_index[2] = oy;
-                float in_y;
-                int32_t in_y0, in_y1;
-                set_resize_bilinear(oy, height_scale, half_pixel_centers,
-                                    in_shape[2], in_y, in_y0, in_y1);
-
-                for (size_t ox = 0; ox < (size_t)out_w; ox++) {
-                    out_index[3] = ox;
-                    float in_x;
-                    int32_t in_x0, in_x1;
-                    set_resize_bilinear(ox, width_scale, half_pixel_centers,
-                                        in_shape[3], in_x, in_x0, in_x1);
-
-                    auto v0 = get_input(in_y0, in_x0);
-                    auto v1 = get_input(in_y1, in_x0);
-                    auto v2 = get_input(in_y0, in_x1);
-                    auto v3 = get_input(in_y1, in_x1);
-
-                    auto a0 = (1 - (in_y - in_y0)) * (1 - (in_x - in_x0));
-                    auto a1 = (in_y - in_y0) * (1 - (in_x - in_x0));
-                    auto a2 = (1 - (in_y - in_y0)) * (in_x - in_x0);
-                    auto a3 = (in_y - in_y0) * (in_x - in_x0);
-                    output[offset(out_strides, out_index)] =
-                        T(v0 * a0 + v1 * a1 + v2 * a2 + v3 * a3 +
-                          rounding_offset);
-                }
-            }
-        }
-    }
-    return;
-}
-
-template <class T>
-void resize_nearest_neighbor_impl(
-    const T *input, T *output, gsl::span<const size_t> in_shape,
-    gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides,
-    int32_t out_h, int32_t out_w, [[maybe_unused]] bool align_corners,
-    [[maybe_unused]] bool half_pixel_centers,
-    get_coordinate_func_t get_coordinate_func,
-    get_nearest_pixel_func_t get_nearset_func) noexcept {
-    auto [height_scale, width_scale] =
-        get_resize_scales(in_shape, out_h, out_w, align_corners);
-
-    dims_t in_index(4), out_index(4);
-    for (size_t batch = 0; batch < in_shape[0]; batch++) {
-        in_index[0] = batch;
-        out_index[0] = batch;
-        for (size_t oc = 0; oc < in_shape[1]; oc++) {
-            in_index[1] = oc;
-            out_index[1] = oc;
-            for (size_t oy = 0; oy < (size_t)out_h; oy++) {
-                auto iy = get_coordinate_func(oy, height_scale, out_h,
-                                              in_shape[2], 0, 0);
-                int64_t in_y = get_nearset_func(iy);
-                if (in_y < 0)
-                    in_y = 0;
-                if (in_y >= in_shape[2])
-                    in_y = in_shape[2] - 1;
-                in_index[2] = in_y;
-                out_index[2] = oy;
-
-                for (size_t ox = 0; ox < (size_t)out_w; ox++) {
-                    auto ix = get_coordinate_func(ox, width_scale, out_w,
-                                                  in_shape[3], 0, 0);
-                    int64_t in_x = get_nearset_func(ix);
-                    if (in_x < 0)
-                        in_x = 0;
-                    if (in_x >= in_shape[3])
-                        in_x = in_shape[3] - 1;
-                    in_index[3] = in_x;
-                    out_index[3] = ox;
-                    output[offset(out_strides, out_index)] =
-                        input[offset(in_strides, in_index)];
-                }
-            }
-        }
-    }
-    return;
-}
-} // namespace
-
-template <class T>
-void resize_bilinear(const T *input, T *output, dims_t in_shape,
-                     strides_t in_strides, strides_t out_strides, int32_t out_h,
-                     int32_t out_w, bool align_corners,
-                     bool half_pixel_centers) noexcept {
-    resize_bilinear_impl(input, output, in_shape, in_strides, out_strides,
-                         out_h, out_w, align_corners, half_pixel_centers);
-}
-
-template <class T>
-void resize_neareast_neighbor(
-    const T *input, T *output, dims_t in_shape, strides_t in_strides,
-    strides_t out_strides, int32_t out_h, int32_t out_w, bool align_corners,
-    bool half_pixel_centers, get_coordinate_func_t get_coordinate_func,
-    get_nearest_pixel_func_t get_nearset_func) noexcept {
-    resize_nearest_neighbor_impl(input, output, in_shape, in_strides,
-                                 out_strides, out_h, out_w, align_corners,
-                                 half_pixel_centers, get_coordinate_func,
-                                 get_nearset_func);
-}
-} // namespace kernels
diff --git a/modules/xpu/src/runtime/cmodel/include/resize_util.h b/modules/xpu/src/runtime/cmodel/include/resize_util.h
deleted file mode 100644
index 0bf4bdc742..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/resize_util.h
+++ /dev/null
@@ -1,127 +0,0 @@
-/* Copyright 2019-2023 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-#include "runtime_utils.h"
-#include <runtime_types.h>
-
-using namespace nncase::runtime::xpu;
-
-using get_coordinate_func_t = float (*)(float, float, float, float, float,
-                                        float);
-using get_nearest_pixel_func_t = int64_t (*)(float);
-
-get_coordinate_func_t get_coordinate_from_resized(
-    image_resize_transformation_mode_t coordinate_transform_mode);
-
-get_nearest_pixel_func_t
-get_nearest_pixel_from_origin(image_resize_nearest_mode_t nearest_mode);
-
-inline get_coordinate_func_t get_coordinate_from_resized(
-    image_resize_transformation_mode_t coordinate_transform_mode) {
-    switch (coordinate_transform_mode) {
-    case image_resize_transformation_mode_t::asymmetric:
-        return [](float x_resized, float x_scale, float, float, float, float) {
-            return x_resized * x_scale;
-        };
-    case image_resize_transformation_mode_t::pytorch_half_pixel:
-        return [](float x_resized, float x_scale, float length_resized, float,
-                  float, float) {
-            return length_resized > 1 ? (x_resized + 0.5f) * x_scale - 0.5f
-                                      : 0.0f;
-        };
-    case image_resize_transformation_mode_t::align_corners:
-        return [](float x_resized, float, float length_resized,
-                  float length_original, float, float) {
-            return length_resized == 1 ? 0
-                                       : x_resized * (length_original - 1) /
-                                             (length_resized - 1);
-        };
-    case image_resize_transformation_mode_t::tfcrop_and_resize:
-        return [](float x_resized, float, float length_resized,
-                  float length_original, float roi_start, float roi_end) {
-            auto orig =
-                length_resized > 1
-                    ? roi_start * (length_original - 1) +
-                          (x_resized * (roi_end - roi_start) *
-                           (length_original - 1)) /
-                              (length_resized - 1)
-                    : 0.5 * (roi_start + roi_end) * (length_original - 1);
-            return static_cast<float>(orig);
-        };
-    default: // "image_resize_transformation_mode_t::half_pixel"
-        return [](float x_resized, float x_scale, float, float, float, float) {
-            return ((x_resized + 0.5f) * x_scale) - 0.5f;
-        };
-    }
-}
-
-inline get_nearest_pixel_func_t
-get_nearest_pixel_from_origin(image_resize_nearest_mode_t nearest_mode) {
-    switch (nearest_mode) {
-    case image_resize_nearest_mode_t::round_prefer_ceil:
-        return [](float x_original) -> int64_t {
-            return static_cast<int64_t>(
-                nncase_mt->float_unary_round(x_original));
-        };
-    case image_resize_nearest_mode_t::floor:
-        return [](float x_original) -> int64_t {
-            return static_cast<int64_t>(
-                nncase_mt->float_unary_floor(x_original));
-        };
-    case image_resize_nearest_mode_t::ceil:
-        return [](float x_original) -> int64_t {
-            return static_cast<int64_t>(
-                nncase_mt->float_unary_ceil(x_original));
-        };
-    default: // default is round_prefer_floor
-        return [](float x_original) -> int64_t {
-            // for half way cases prefer floor
-            if (x_original == static_cast<int64_t>(x_original) + 0.5f) {
-                return static_cast<int64_t>(
-                    nncase_mt->float_unary_floor(x_original));
-            }
-            return static_cast<int64_t>(
-                nncase_mt->float_unary_round(x_original));
-        };
-    }
-}
-
-inline std::tuple<float, float>
-get_resize_scales(gsl::span<const size_t> in_shape, int32_t out_h,
-                  int32_t out_w, bool align_corners) {
-    auto height_scale = (float)in_shape[2] / out_h;
-    auto width_scale = (float)in_shape[3] / out_w;
-    if (align_corners && out_h > 1)
-        height_scale = (float)(in_shape[2] - 1) / (out_h - 1);
-    if (align_corners && out_w > 1)
-        width_scale = (float)(in_shape[3] - 1) / (out_w - 1);
-    return std::make_tuple(height_scale, width_scale);
-}
-
-inline void set_resize_bilinear(size_t value, float scale,
-                                bool half_pixel_centers, size_t shape_size,
-                                float &scaled_value, int32_t &v0, int32_t &v1) {
-    if (half_pixel_centers) {
-        scaled_value = (value + 0.5f) * scale - 0.5f;
-    } else {
-        scaled_value = value * scale;
-    }
-    float scaled_value_floor = nncase_mt->float_unary_floor(scaled_value);
-    v0 = std::max(static_cast<int32_t>(scaled_value_floor), 0);
-    v1 = std::min(
-        static_cast<int32_t>(nncase_mt->float_unary_ceil(scaled_value)),
-        static_cast<int32_t>(shape_size - 1));
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/runtime_types.h b/modules/xpu/src/runtime/cmodel/include/runtime_types.h
deleted file mode 100644
index b9b8e02aec..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/runtime_types.h
+++ /dev/null
@@ -1,73 +0,0 @@
-#pragma once
-#include "small_vector.hpp"
-
-using dims_t = itlib::small_vector<size_t, 8>;
-using strides_t = itlib::small_vector<size_t, 8>;
-using axes_t = itlib::small_vector<int64_t, 8>;
-
-enum class image_resize_mode_t : uint8_t {
-    bilinear = 0,
-    nearest_neighbor = 1,
-};
-
-enum class image_resize_transformation_mode_t : int32_t {
-    half_pixel = 0,
-    pytorch_half_pixel = 1,
-    align_corners = 2,
-    asymmetric = 3,
-    tfcrop_and_resize = 4,
-};
-
-enum class image_resize_nearest_mode_t : int32_t {
-    round_prefer_floor = 0,
-    round_prefer_ceil = 1,
-    floor = 2,
-    ceil = 3,
-};
-
-enum class unary_op_t : uint8_t {
-    abs = 0,
-    acos = 1,
-    acosh = 2,
-    asin = 3,
-    asinh = 4,
-    ceil = 5,
-    cos = 6,
-    cosh = 7,
-    exp = 8,
-    floor = 9,
-    log = 10,
-    neg = 11,
-    round = 12,
-    rsqrt = 13,
-    sin = 14,
-    sinh = 15,
-    sign = 16,
-    sqrt = 17,
-    square = 18,
-    tanh = 19,
-    bitwise_not = 20,
-    logical_not = 21,
-    swish = 22,
-    gelu = 23
-};
-
-enum class binary_op_t : uint8_t {
-    add = 0,
-    sub = 1,
-    mul = 2,
-    div = 3,
-    mod = 4,
-    min = 5,
-    max = 6,
-    pow = 7,
-    bitwise_and = 8,
-    bitwise_or = 9,
-    bitwise_xor = 10,
-    logical_and = 11,
-    logical_or = 12,
-    logical_xor = 13,
-    left_shift = 14,
-    right_shift = 15,
-    idenity_a = 16,
-};
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/runtime_utils.h b/modules/xpu/src/runtime/cmodel/include/runtime_utils.h
deleted file mode 100644
index 11be007902..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/runtime_utils.h
+++ /dev/null
@@ -1,218 +0,0 @@
-#pragma once
-
-#include "../../gsl-lite.hpp"
-#include "../../method_table_def.h"
-#include <cstddef>
-#include <runtime_types.h>
-
-using namespace nncase::runtime::xpu;
-
-static nncase_mt_t *nncase_mt;
-static runtime_util_mt *runtime_util;
-
-void print_vec(itlib::small_vector<size_t, 8> vec) {
-    for (const size_t v : vec) {
-        runtime_util->printf("%zu, ", v);
-    }
-    runtime_util->printf("\n");
-}
-
-template <class TShape> inline size_t compute_size(const TShape &shape) {
-    size_t size = 1;
-    for (size_t i = 0; i < shape.size(); ++i) {
-        size *= shape[i];
-    }
-    return size;
-}
-
-template <class TShape>
-inline size_t compute_size(const TShape &shape, const TShape &strides) {
-    size_t max_stride = 1, max_shape = 1;
-    for (size_t i = 0; i < shape.size(); i++) {
-        if ((shape[i] == 1 ? 0 : strides[i]) >= max_stride) {
-            max_stride = strides[i];
-            max_shape = shape[i];
-        }
-    }
-    size_t size = max_stride * max_shape;
-    return size;
-}
-
-template <class shape_type, class strides_type>
-inline size_t compute_strides(const shape_type &shape, strides_type &strides) {
-    size_t data_size = 1;
-    for (std::size_t i = shape.size(); i != 0; --i) {
-        strides[i - 1] = data_size;
-        data_size = strides[i - 1] * static_cast<size_t>(shape[i - 1]);
-    }
-    return static_cast<size_t>(data_size);
-}
-
-inline strides_t get_default_strides(dims_t shape) {
-    strides_t strides(shape.size());
-    compute_strides(shape, strides);
-    return strides;
-}
-
-template <class offset_type, class S>
-inline offset_type element_offset(const S &strides, const S &index) noexcept {
-    offset_type size = 0;
-    for (auto i = 0; i < (int)strides.size(); i++) {
-        size += strides[i] * index[i];
-    }
-    return size;
-}
-
-inline size_t offset(gsl::span<const size_t> strides,
-                     gsl::span<const size_t> index) {
-    // scalar
-    if (strides.size() == 0 || index.size() == 0) {
-        return 0;
-    }
-    runtime_util->rt_assert(
-        strides.size() == index.size(),
-        (char *)"strides and index must have the same rank");
-    return element_offset<size_t>(strides, index);
-}
-
-inline bool is_shape_equal(const dims_t &a, const dims_t &b) {
-    for (size_t i = 0; i < a.size(); i++) {
-        if (a[i] != b[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-
-inline bool is_scalar(gsl::span<const size_t> t) noexcept { return t.empty(); }
-
-inline dims_t to_nd(dims_t in_shape, size_t n) {
-    auto size = n - in_shape.size();
-    for (size_t i = 0; i < size; ++i) {
-        in_shape.insert(in_shape.begin(), 1);
-    }
-    return in_shape;
-}
-
-inline std::tuple<dims_t, strides_t> to_nd(dims_t in_shape, strides_t in_stride,
-                                           size_t n) {
-    auto size = n - in_shape.size();
-    auto stride = *in_stride.begin();
-    for (size_t i = 0; i < size; ++i) {
-        in_shape.insert(in_shape.begin(), 1);
-        in_stride.insert(in_stride.begin(), stride);
-    }
-    return std::make_tuple(in_shape, in_stride);
-}
-
-template <class T> inline bool is_contiguous(const T &shape, const T &strides) {
-    size_t data_size = 1;
-    for (std::size_t i = shape.size(); i != 0; --i) {
-        if (strides[i - 1] != data_size) {
-            return false;
-        }
-        data_size *= shape[i - 1];
-    }
-    return true;
-}
-
-inline int
-get_last_not_contiguous_index(gsl::span<const size_t> strides,
-                              gsl::span<const size_t> default_strides) {
-    for (int i = strides.size() - 1; i >= 0; --i) {
-        if (strides[i] != default_strides[i]) {
-            return i + 1;
-        }
-    }
-    return -1;
-}
-
-// template <typename T>
-// inline void span_copy(gsl::span<T> dest, gsl::span<T> src) {
-//     std::copy(src.data(), src.data()+src.size(), dest.data());
-// }
-
-// template <typename T>
-// inline void span_equal(gsl::span<T> dest, gsl::span<T> src) {
-//     std::copy(src.begin(), src.end(), dest.begin());
-// }
-
-template <typename T> double dot(const T *v1, const T *v2, size_t size) {
-    double ret = 0.f;
-    for (size_t i = 0; i < size; i++) {
-        ret += v1[i] * v2[i];
-    }
-
-    return ret;
-}
-
-template <typename T> double cosine(const T *v1, const T *v2, size_t size) {
-    for (size_t i = 0; i < 10; i++) {
-        runtime_util->printf("%f, %f\n", (float)v1[i], (float)v2[i]);
-    }
-    return dot(v1, v2, size) /
-           ((nncase_mt->float_unary_sqrt(dot(v1, v1, size)) *
-             nncase_mt->float_unary_sqrt(dot(v2, v2, size))));
-}
-
-inline dims_t get_reduced_offset(gsl::span<const size_t> in_offset,
-                                 gsl::span<const size_t> axis, bool keep_dims) {
-    if (in_offset.size() == 0) {
-        return in_offset;
-    }
-    dims_t off;
-    off.reserve(in_offset.size() - (keep_dims ? 0 : axis.size()));
-    for (size_t i = 0; i < in_offset.size(); i++) {
-        bool found = false;
-        for (size_t j = 0; j < axis.size(); j++) {
-            if (i == axis[j]) {
-                found = true;
-                break;
-            }
-        }
-        if (!found) {
-            off.push_back(in_offset[i]);
-        } else {
-            if (keep_dims)
-                off.push_back(0);
-        }
-    }
-
-    return off;
-}
-
-inline dims_t get_reduced_offset(gsl::span<const size_t> in_offset,
-                                 gsl::span<const size_t> reduced_shape) {
-    dims_t off(reduced_shape.size());
-    const auto dims_ext = in_offset.size() - reduced_shape.size();
-    for (size_t i = 0; i < reduced_shape.size(); i++) {
-        if (in_offset[i + dims_ext] >= reduced_shape[i])
-            off[i] = 0;
-        else
-            off[i] = in_offset[i + dims_ext];
-    }
-
-    return off;
-}
-
-inline dims_t get_reduced_shape(gsl::span<const size_t> in_shape,
-                                gsl::span<const size_t> axis, bool keep_dims) {
-    dims_t shape(in_shape.size() - (keep_dims ? 0 : axis.size()));
-    auto count = 0;
-    for (size_t i = 0; i < in_shape.size(); i++) {
-        bool found = false;
-        for (size_t j = 0; j < axis.size(); j++) {
-            if (i == axis[j]) {
-                found = true;
-                break;
-            }
-        }
-        if (!found) {
-            shape[count++] = in_shape[i];
-        } else {
-            if (keep_dims)
-                shape[count++] = 1;
-        }
-    }
-    return shape;
-}
diff --git a/modules/xpu/src/runtime/cmodel/include/slice.h b/modules/xpu/src/runtime/cmodel/include/slice.h
deleted file mode 100644
index 2582c9e95a..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/slice.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "../../gsl-lite.hpp"
-#include <apply.h>
-#include <runtime_utils.h>
-
-namespace kernels {
-
-namespace {
-template <class T>
-void slice_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
-                gsl::span<const size_t> in_strides,
-                gsl::span<const size_t> out_strides,
-                gsl::span<const int64_t> &begins,
-                gsl::span<const int64_t> &ends,
-                gsl::span<const int64_t> &strides) noexcept {
-    apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        dims_t out_index(index.size());
-        for (size_t i = 0; i < index.size(); i++) {
-            const auto stride = strides[i];
-            if (stride > 0) {
-                if ((int32_t)index[i] < begins[i] ||
-                    index[i] >= static_cast<size_t>(ends[i]))
-                    return;
-            } else {
-                if ((int32_t)index[i] <= ends[i] ||
-                    (int32_t)index[i] > begins[i])
-                    return;
-            }
-
-            auto out_div =
-                div((int32_t)(index[i] - begins[i]), (int32_t)strides[i]);
-            if (out_div.rem)
-                return;
-            out_index[i] = (size_t)out_div.quot;
-        }
-
-        output[offset(out_strides, out_index)] =
-            input[offset(in_strides, index)];
-    });
-}
-} // namespace
-
-template <class T>
-void slice(const T *input, T *output, gsl::span<const size_t> in_shape,
-           gsl::span<const size_t> in_strides,
-           gsl::span<const size_t> out_strides, gsl::span<const int64_t> begins,
-           gsl::span<const int64_t> ends,
-           gsl::span<const int64_t> strides) noexcept {
-    slice_impl(input, output, in_shape, in_strides, out_strides, begins, ends,
-               strides);
-}
-
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/small_vector.hpp b/modules/xpu/src/runtime/cmodel/include/small_vector.hpp
deleted file mode 100644
index f93e3efc93..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/small_vector.hpp
+++ /dev/null
@@ -1,1003 +0,0 @@
-// itlib-small-vector v1.00
-//
-// std::vector-like class with a static buffer for initial capacity
-//
-// MIT License:
-// Copyright(c) 2016-2018 Chobolabs Inc.
-// Copyright(c) 2020 Borislav Stanimirov
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files(the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and / or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions :
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-//
-//                  VERSION HISTORY
-//
-//  1.00 (2020-10-14) Rebranded release from chobo-small-vector
-//
-//
-//                  DOCUMENTATION
-//
-// Simply include this file wherever you need.
-// It defines the class itlib::small_vector, which is a drop-in replacement of
-// std::vector, but with an initial capacity as a template argument.
-// It gives you the benefits of using std::vector, at the cost of having a
-// statically allocated buffer for the initial capacity, which gives you
-// cache-local data when the vector is small (smaller than the initial
-// capacity).
-//
-// When the size exceeds the capacity, the vector allocates memory via the
-// provided allocator, falling back to classic std::vector behavior.
-//
-// The second size_t template argument, RevertToStaticSize, is used when a
-// small_vector which has already switched to dynamically allocated size reduces
-// its size to a number smaller than that. In this case the vector's buffer
-// switches back to the staticallly allocated one
-//
-// A default value for the initial static capacity is provided so a replacement
-// in an existing code is possible with minimal changes to it.
-//
-// Example:
-//
-// itlib::small_vector<int, 4, 5> myvec; // a small_vector of size 0, initial
-// capacity 4, and revert size 4 (smaller than 5) myvec.resize(2); // vector is
-// {0,0} in static buffer myvec[1] = 11; // vector is {0,11} in static buffer
-// myvec.push_back(7); // vector is {0,11,7}  in static buffer
-// myvec.insert(myvec.begin() + 1, 3); // vector is {0,3,11,7} in static buffer
-// myvec.push_back(5); // vector is {0,3,11,7,5} in dynamically allocated memory
-// buffer myvec.erase(myvec.begin());  // vector is {3,11,7,5} back in static
-// buffer myvec.resize(5); // vector is {3,11,7,5,0} back in dynamically
-// allocated memory
-//
-//
-// Reference:
-//
-// itlib::small_vector is fully compatible with std::vector with
-// the following exceptions:
-// * when reducing the size with erase or resize the new size may fall below
-//   RevertToStaticSize (if it is not 0). In such a case the vector will
-//   revert to using its static buffer, invalidating all iterators (contrary
-//   to the standard)
-// * a method is added `revert_to_static()` which reverts to the static buffer
-//   if possible, but doesn't free the dynamically allocated one
-//
-// Other notes:
-//
-// * the default value for RevertToStaticSize is zero. This means that once a
-// dynamic
-//   buffer is allocated the data will never be put into the static one, even if
-//   the size allows it. Even if clear() is called. The only way to do so is to
-//   call shrink_to_fit() or revert_to_static()
-// * shrink_to_fit will free and reallocate if size != capacity and the data
-//   doesn't fit into the static buffer. It also will revert to the static
-//   buffer whenever possible regardless of the RevertToStaticSize value
-//
-//
-//                  Configuration
-//
-// The library has two configuration options. They can be set as #define-s
-// before including the header file, but it is recommended to change the code
-// of the library itself with the values you want, especially if you include
-// the library in many compilation units (as opposed to, say, a precompiled
-// header or a central header).
-//
-//                  Config out of range error handling
-//
-// An out of range error is a runtime error which is triggered when a method is
-// called with an iterator that doesn't belong to the vector's current range.
-// For example: vec.erase(vec.end() + 1);
-//
-// This is set by defining ITLIB_SMALL_VECTOR_ERROR_HANDLING to one of the
-// following values:
-// * ITLIB_SMALL_VECTOR_ERROR_HANDLING_NONE - no error handling. Crashes WILL
-//      ensue if the error is triggered.
-// * ITLIB_SMALL_VECTOR_ERROR_HANDLING_THROW - std::out_of_range is thrown.
-// * ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT - asserions are triggered.
-// * ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT_AND_THROW - combines assert and
-//      throw to catch errors more easily in debug mode
-//
-// To set this setting by editing the file change the line:
-// ```
-// #   define ITLIB_SMALL_VECTOR_ERROR_HANDLING
-// ITLIB_SMALL_VECTOR_ERROR_HANDLING_THROW
-// ```
-// to the default setting of your choice
-//
-//                  Config bounds checks:
-//
-// By default bounds checks are made in debug mode (via an asser) when accessing
-// elements (with `at` or `[]`). Iterators are not checked (yet...)
-//
-// To disable them, you can define ITLIB_SMALL_VECTOR_NO_DEBUG_BOUNDS_CHECK
-// before including the header.
-//
-//
-//                  TESTS
-//
-// You can find unit tests for small_vector in its official repo:
-// https://github.com/iboB/itlib/blob/master/test/
-//
-#pragma once
-
-#include "gsl-lite.hpp"
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-
-#define ITLIB_SMALL_VECTOR_ERROR_HANDLING_NONE 0
-#define ITLIB_SMALL_VECTOR_ERROR_HANDLING_THROW 1
-#define ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT 2
-#define ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT_AND_THROW 3
-
-#if !defined(ITLIB_SMALL_VECTOR_ERROR_HANDLING)
-#define ITLIB_SMALL_VECTOR_ERROR_HANDLING                                      \
-    ITLIB_SMALL_VECTOR_ERROR_HANDLING_THROW
-#endif
-
-#if ITLIB_SMALL_VECTOR_ERROR_HANDLING == ITLIB_SMALL_VECTOR_ERROR_HANDLING_NONE
-#define I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(cond)
-#elif ITLIB_SMALL_VECTOR_ERROR_HANDLING ==                                     \
-    ITLIB_SMALL_VECTOR_ERROR_HANDLING_THROW
-#include <stdexcept>
-#define I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(cond)                             \
-    if (cond)                                                                  \
-    throw std::out_of_range("itlib::small_vector out of range")
-#elif ITLIB_SMALL_VECTOR_ERROR_HANDLING ==                                     \
-    ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT
-#include <cassert>
-#define I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(cond, rescue_return)              \
-    assert(!(cond) && "itlib::small_vector out of range")
-#elif ITLIB_SMALL_VECTOR_ERROR_HANDLING ==                                     \
-    ITLIB_SMALL_VECTOR_ERROR_HANDLING_ASSERT_AND_THROW
-#include <cassert>
-#include <stdexcept>
-#define I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(cond, rescue_return)              \
-    do {                                                                       \
-        if (cond) {                                                            \
-            assert(false && "itlib::small_vector out of range");               \
-            throw std::out_of_range("itlib::small_vector out of range");       \
-        }                                                                      \
-    } while (false)
-#else
-#error "Unknown ITLIB_SMALL_VECTOR_ERRROR_HANDLING"
-#endif
-
-#if defined(ITLIB_SMALL_VECTOR_NO_DEBUG_BOUNDS_CHECK)
-#define I_ITLIB_SMALL_VECTOR_BOUNDS_CHECK(i)
-#else
-#include <cassert>
-#define I_ITLIB_SMALL_VECTOR_BOUNDS_CHECK(i) assert((i) < this->size())
-#endif
-
-namespace itlib {
-
-template <typename T, size_t StaticCapacity = 16, size_t RevertToStaticSize = 0,
-          class Alloc = std::allocator<T>>
-struct small_vector : Alloc {
-    static_assert(RevertToStaticSize <= StaticCapacity + 1,
-                  "itlib::small_vector: the revert-to-static size shouldn't "
-                  "exceed the static capacity by more than one");
-
-    using atraits = std::allocator_traits<Alloc>;
-
-  public:
-    using allocator_type = Alloc;
-    using value_type = typename atraits::value_type;
-    using size_type = typename atraits::size_type;
-    using difference_type = typename atraits::difference_type;
-    using reference = T &;
-    using const_reference = const T &;
-    using pointer = typename atraits::pointer;
-    using const_pointer = typename atraits::const_pointer;
-    using iterator = pointer;
-    using const_iterator = const_pointer;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-
-    static constexpr size_t static_capacity = StaticCapacity;
-    static constexpr intptr_t revert_to_static_size = RevertToStaticSize;
-
-    small_vector() : small_vector(Alloc()) {}
-
-    small_vector(const Alloc &alloc)
-        : Alloc(alloc),
-          m_capacity(StaticCapacity),
-          m_dynamic_capacity(0),
-          m_dynamic_data(nullptr) {
-        m_begin = m_end = static_begin_ptr();
-    }
-
-    explicit small_vector(size_t count, const Alloc &alloc = Alloc())
-        : small_vector(alloc) {
-        resize(count);
-    }
-
-    explicit small_vector(size_t count, const T &value,
-                          const Alloc &alloc = Alloc())
-        : small_vector(alloc) {
-        assign_impl(count, value);
-    }
-
-    template <class InputIterator,
-              typename = decltype(*std::declval<InputIterator>())>
-    small_vector(InputIterator first, InputIterator last,
-                 const Alloc &alloc = Alloc())
-        : small_vector(alloc) {
-        assign_impl(first, last);
-    }
-
-    small_vector(std::initializer_list<T> l, const Alloc &alloc = Alloc())
-        : small_vector(alloc) {
-        assign_impl(l);
-    }
-
-    template <class U>
-    small_vector(gsl::span<U> c, const Alloc &alloc = Alloc())
-        : small_vector(alloc) {
-        assign_impl(c.begin(), c.end());
-    }
-
-    small_vector(const small_vector &v)
-        : small_vector(v, atraits::select_on_container_copy_construction(
-                              v.get_allocator())) {}
-
-    small_vector(const small_vector &v, const Alloc &alloc)
-        : Alloc(alloc), m_dynamic_capacity(0), m_dynamic_data(nullptr) {
-        if (v.size() > StaticCapacity) {
-            m_dynamic_capacity = v.size();
-            m_begin = m_end = m_dynamic_data =
-                atraits::allocate(get_alloc(), m_dynamic_capacity);
-            m_capacity = v.size();
-        } else {
-            m_begin = m_end = static_begin_ptr();
-            m_capacity = StaticCapacity;
-        }
-
-        for (auto p = v.m_begin; p != v.m_end; ++p) {
-            atraits::construct(get_alloc(), m_end, *p);
-            ++m_end;
-        }
-    }
-
-    small_vector(small_vector &&v)
-        : Alloc(std::move(v.get_alloc())),
-          m_capacity(v.m_capacity),
-          m_dynamic_capacity(v.m_dynamic_capacity),
-          m_dynamic_data(v.m_dynamic_data) {
-        if (v.m_begin == v.static_begin_ptr()) {
-            m_begin = m_end = static_begin_ptr();
-            for (auto p = v.m_begin; p != v.m_end; ++p) {
-                atraits::construct(get_alloc(), m_end, std::move(*p));
-                ++m_end;
-            }
-
-            v.clear();
-        } else {
-            m_begin = v.m_begin;
-            m_end = v.m_end;
-        }
-
-        v.m_dynamic_capacity = 0;
-        v.m_dynamic_data = nullptr;
-        v.m_begin = v.m_end = v.static_begin_ptr();
-        v.m_capacity = StaticCapacity;
-    }
-
-    ~small_vector() {
-        clear();
-
-        if (m_dynamic_data) {
-            atraits::deallocate(get_alloc(), m_dynamic_data,
-                                m_dynamic_capacity);
-        }
-    }
-
-    small_vector &operator=(const small_vector &v) {
-        if (this == &v) {
-            // prevent self usurp
-            return *this;
-        }
-
-        clear();
-
-        m_begin = m_end = choose_data(v.size());
-
-        for (auto p = v.m_begin; p != v.m_end; ++p) {
-            atraits::construct(get_alloc(), m_end, *p);
-            ++m_end;
-        }
-
-        update_capacity();
-
-        return *this;
-    }
-
-    small_vector &operator=(small_vector &&v) {
-        clear();
-
-        get_alloc() = std::move(v.get_alloc());
-        m_capacity = v.m_capacity;
-        m_dynamic_capacity = v.m_dynamic_capacity;
-        m_dynamic_data = v.m_dynamic_data;
-
-        if (v.m_begin == v.static_begin_ptr()) {
-            m_begin = m_end = static_begin_ptr();
-            for (auto p = v.m_begin; p != v.m_end; ++p) {
-                atraits::construct(get_alloc(), m_end, std::move(*p));
-                ++m_end;
-            }
-
-            v.clear();
-        } else {
-            m_begin = v.m_begin;
-            m_end = v.m_end;
-        }
-
-        v.m_dynamic_capacity = 0;
-        v.m_dynamic_data = nullptr;
-        v.m_begin = v.m_end = v.static_begin_ptr();
-        v.m_capacity = StaticCapacity;
-
-        return *this;
-    }
-
-    void assign(size_type count, const T &value) {
-        clear();
-        assign_impl(count, value);
-    }
-
-    template <class InputIterator,
-              typename = decltype(*std::declval<InputIterator>())>
-    void assign(InputIterator first, InputIterator last) {
-        clear();
-        assign_impl(first, last);
-    }
-
-    void assign(std::initializer_list<T> ilist) {
-        clear();
-        assign_impl(ilist);
-    }
-
-    allocator_type get_allocator() const { return get_alloc(); }
-
-    const_reference at(size_type i) const {
-        I_ITLIB_SMALL_VECTOR_BOUNDS_CHECK(i);
-        return *(m_begin + i);
-    }
-
-    reference at(size_type i) {
-        I_ITLIB_SMALL_VECTOR_BOUNDS_CHECK(i);
-        return *(m_begin + i);
-    }
-
-    const_reference operator[](size_type i) const { return at(i); }
-
-    reference operator[](size_type i) { return at(i); }
-
-    const_reference front() const { return at(0); }
-
-    reference front() { return at(0); }
-
-    const_reference back() const { return *(m_end - 1); }
-
-    reference back() { return *(m_end - 1); }
-
-    const_pointer data() const noexcept { return m_begin; }
-
-    pointer data() noexcept { return m_begin; }
-
-    // iterators
-    iterator begin() noexcept { return m_begin; }
-
-    const_iterator begin() const noexcept { return m_begin; }
-
-    const_iterator cbegin() const noexcept { return m_begin; }
-
-    iterator end() noexcept { return m_end; }
-
-    const_iterator end() const noexcept { return m_end; }
-
-    const_iterator cend() const noexcept { return m_end; }
-
-    reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
-
-    const_reverse_iterator rbegin() const noexcept {
-        return const_reverse_iterator(end());
-    }
-
-    const_reverse_iterator crbegin() const noexcept {
-        return const_reverse_iterator(end());
-    }
-
-    reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
-
-    const_reverse_iterator rend() const noexcept {
-        return const_reverse_iterator(begin());
-    }
-
-    const_reverse_iterator crend() const noexcept {
-        return const_reverse_iterator(begin());
-    }
-
-    // capacity
-    bool empty() const noexcept { return m_begin == m_end; }
-
-    size_t size() const noexcept { return m_end - m_begin; }
-
-    size_t max_size() const noexcept { return atraits::max_size(); }
-
-    void reserve(size_type new_cap) {
-        if (new_cap <= m_capacity)
-            return;
-
-        auto new_buf = choose_data(new_cap);
-
-        assert(new_buf !=
-               m_begin); // should've been handled by new_cap <= m_capacity
-        assert(
-            new_buf !=
-            static_begin_ptr()); // we should never reserve into static memory
-
-        const auto s = size();
-        if (s < RevertToStaticSize) {
-            // we've allocated enough memory for the dynamic buffer but don't
-            // move there until we have to
-            return;
-        }
-
-        // now we need to transfer the existing elements into the new buffer
-        for (size_type i = 0; i < s; ++i) {
-            atraits::construct(get_alloc(), new_buf + i,
-                               std::move(*(m_begin + i)));
-        }
-
-        // free old elements
-        for (size_type i = 0; i < s; ++i) {
-            atraits::destroy(get_alloc(), m_begin + i);
-        }
-
-        if (m_begin != static_begin_ptr()) {
-            // we've moved from dyn to dyn memory, so deallocate the old one
-            atraits::deallocate(get_alloc(), m_begin, m_capacity);
-        }
-
-        m_begin = new_buf;
-        m_end = new_buf + s;
-        m_capacity = m_dynamic_capacity;
-    }
-
-    size_t capacity() const noexcept { return m_capacity; }
-
-    void shrink_to_fit() {
-        const auto s = size();
-
-        if (s == m_capacity)
-            return;
-        if (m_begin == static_begin_ptr())
-            return;
-
-        auto old_end = m_end;
-
-        if (s < StaticCapacity) {
-            // revert to static capacity
-            m_begin = m_end = static_begin_ptr();
-            m_capacity = StaticCapacity;
-        } else {
-            // alloc new smaller buffer
-            m_begin = m_end = atraits::allocate(get_alloc(), s);
-            m_capacity = s;
-        }
-
-        for (auto p = m_dynamic_data; p != old_end; ++p) {
-            atraits::construct(get_alloc(), m_end, std::move(*p));
-            ++m_end;
-            atraits::destroy(get_alloc(), p);
-        }
-
-        atraits::deallocate(get_alloc(), m_dynamic_data, m_dynamic_capacity);
-        m_dynamic_data = nullptr;
-        m_dynamic_capacity = 0;
-    }
-
-    void revert_to_static() {
-        const auto s = size();
-        if (m_begin == static_begin_ptr())
-            return; // we're already there
-        if (s > StaticCapacity)
-            return; // nothing we can do
-
-        // revert to static capacity
-        auto old_end = m_end;
-        m_begin = m_end = static_begin_ptr();
-        m_capacity = StaticCapacity;
-        for (auto p = m_dynamic_data; p != old_end; ++p) {
-            atraits::construct(get_alloc(), m_end, std::move(*p));
-            ++m_end;
-            atraits::destroy(get_alloc(), p);
-        }
-    }
-
-    // modifiers
-    void clear() noexcept {
-        for (auto p = m_begin; p != m_end; ++p) {
-            atraits::destroy(get_alloc(), p);
-        }
-
-        if (RevertToStaticSize > 0) {
-            m_begin = m_end = static_begin_ptr();
-            m_capacity = StaticCapacity;
-        } else {
-            m_end = m_begin;
-        }
-    }
-
-    iterator insert(const_iterator position, const value_type &val) {
-        auto pos = grow_at(position, 1);
-        atraits::construct(get_alloc(), pos, val);
-        return pos;
-    }
-
-    iterator insert(const_iterator position, value_type &&val) {
-        auto pos = grow_at(position, 1);
-        atraits::construct(get_alloc(), pos, std::move(val));
-        return pos;
-    }
-
-    iterator insert(const_iterator position, size_type count,
-                    const value_type &val) {
-        auto pos = grow_at(position, count);
-        for (size_type i = 0; i < count; ++i) {
-            atraits::construct(get_alloc(), pos + i, val);
-        }
-        return pos;
-    }
-
-    template <typename InputIterator,
-              typename = decltype(*std::declval<InputIterator>())>
-    iterator insert(const_iterator position, InputIterator first,
-                    InputIterator last) {
-        auto pos = grow_at(position, last - first);
-        auto np = pos;
-        for (auto p = first; p != last; ++p, ++np) {
-            atraits::construct(get_alloc(), np, *p);
-        }
-        return pos;
-    }
-
-    iterator insert(const_iterator position, std::initializer_list<T> ilist) {
-        auto pos = grow_at(position, ilist.size());
-        size_type i = 0;
-        for (auto &elem : ilist) {
-            atraits::construct(get_alloc(), pos + i, elem);
-            ++i;
-        }
-        return pos;
-    }
-
-    template <typename... Args>
-    iterator emplace(const_iterator position, Args &&...args) {
-        auto pos = grow_at(position, 1);
-        atraits::construct(get_alloc(), pos, std::forward<Args>(args)...);
-        return pos;
-    }
-
-    iterator erase(const_iterator position) { return shrink_at(position, 1); }
-
-    iterator erase(const_iterator first, const_iterator last) {
-        I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(first > last);
-        return shrink_at(first, last - first);
-    }
-
-    void push_back(const_reference val) {
-        auto pos = grow_at(m_end, 1);
-        atraits::construct(get_alloc(), pos, val);
-    }
-
-    void push_back(T &&val) {
-        auto pos = grow_at(m_end, 1);
-        atraits::construct(get_alloc(), pos, std::move(val));
-    }
-
-    template <typename... Args> reference emplace_back(Args &&...args) {
-        auto pos = grow_at(m_end, 1);
-        atraits::construct(get_alloc(), pos, std::forward<Args>(args)...);
-        return *pos;
-    }
-
-    void pop_back() { shrink_at(m_end - 1, 1); }
-
-    void resize(size_type n, const value_type &v) {
-        auto new_buf = choose_data(n);
-
-        if (new_buf == m_begin) {
-            // no special transfers needed
-
-            auto new_end = m_begin + n;
-
-            while (m_end > new_end) {
-                atraits::destroy(get_alloc(), --m_end);
-            }
-
-            while (new_end > m_end) {
-                atraits::construct(get_alloc(), m_end++, v);
-            }
-        } else {
-            // we need to transfer the elements into the new buffer
-
-            const auto s = size();
-            const auto num_transfer = n < s ? n : s;
-
-            for (size_type i = 0; i < num_transfer; ++i) {
-                atraits::construct(get_alloc(), new_buf + i,
-                                   std::move(*(m_begin + i)));
-            }
-
-            // free obsoletes
-            for (size_type i = 0; i < s; ++i) {
-                atraits::destroy(get_alloc(), m_begin + i);
-            }
-
-            // construct new elements
-            for (size_type i = num_transfer; i < n; ++i) {
-                atraits::construct(get_alloc(), new_buf + i, v);
-            }
-
-            if (m_begin != static_begin_ptr()) {
-                // we've moved from dyn to dyn memory, so deallocate the old one
-                atraits::deallocate(get_alloc(), m_begin, m_capacity);
-            }
-
-            if (new_buf == static_begin_ptr()) {
-                m_capacity = StaticCapacity;
-            } else {
-                m_capacity = m_dynamic_capacity;
-            }
-
-            m_begin = new_buf;
-            m_end = new_buf + n;
-        }
-    }
-
-    void resize(size_type n) {
-        auto new_buf = choose_data(n);
-
-        if (new_buf == m_begin) {
-            // no special transfers needed
-
-            auto new_end = m_begin + n;
-
-            while (m_end > new_end) {
-                atraits::destroy(get_alloc(), --m_end);
-            }
-
-            while (new_end > m_end) {
-                atraits::construct(get_alloc(), m_end++);
-            }
-        } else {
-            // we need to transfer the elements into the new buffer
-
-            const auto s = size();
-            const auto num_transfer = n < s ? n : s;
-
-            for (size_type i = 0; i < num_transfer; ++i) {
-                atraits::construct(get_alloc(), new_buf + i,
-                                   std::move(*(m_begin + i)));
-            }
-
-            // free obsoletes
-            for (size_type i = 0; i < n; ++i) {
-                atraits::destroy(get_alloc(), m_begin + i);
-            }
-
-            // construct new elements
-            for (size_type i = num_transfer; i < s; ++i) {
-                atraits::construct(get_alloc(), new_buf + i);
-            }
-
-            if (m_begin != static_begin_ptr()) {
-                // we've moved from dyn to dyn memory, so deallocate the old one
-                atraits::deallocate(get_alloc(), m_begin, m_capacity);
-            }
-
-            if (new_buf == static_begin_ptr()) {
-                m_capacity = StaticCapacity;
-            } else {
-                m_capacity = m_dynamic_capacity;
-            }
-
-            m_begin = new_buf;
-            m_end = new_buf + n;
-        }
-    }
-
-  private:
-    T *static_begin_ptr() {
-        return reinterpret_cast<pointer>(m_static_data + 0);
-    }
-
-    // increase the size by splicing the elements in such a way that
-    // a hole of uninitialized elements is left at position, with size num
-    // returns the (potentially new) address of the hole
-    T *grow_at(const T *cp, size_t num) {
-        auto position = const_cast<T *>(cp);
-
-        I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(position < m_begin ||
-                                             position > m_end);
-
-        const auto s = size();
-        auto new_buf = choose_data(s + num);
-
-        if (new_buf == m_begin) {
-            // no special transfers needed
-
-            m_end = m_begin + s + num;
-
-            for (auto p = m_end - num - 1; p >= position; --p) {
-                atraits::construct(get_alloc(), p + num, std::move(*p));
-                atraits::destroy(get_alloc(), p);
-            }
-
-            return position;
-        } else {
-            // we need to transfer the elements into the new buffer
-
-            position = new_buf + (position - m_begin);
-
-            auto p = m_begin;
-            auto np = new_buf;
-
-            for (; np != position; ++p, ++np) {
-                atraits::construct(get_alloc(), np, std::move(*p));
-            }
-
-            np += num;
-            for (; p != m_end; ++p, ++np) {
-                atraits::construct(get_alloc(), np, std::move(*p));
-            }
-
-            // destroy old
-            for (p = m_begin; p != m_end; ++p) {
-                atraits::destroy(get_alloc(), p);
-            }
-
-            if (m_begin != static_begin_ptr()) {
-                // we've moved from dyn to dyn memory, so deallocate the old one
-                atraits::deallocate(get_alloc(), m_begin, m_capacity);
-            }
-
-            m_capacity = m_dynamic_capacity;
-
-            m_begin = new_buf;
-            m_end = new_buf + s + num;
-
-            return position;
-        }
-    }
-
-    T *shrink_at(const T *cp, size_t num) {
-        auto position = const_cast<T *>(cp);
-
-        I_ITLIB_SMALL_VECTOR_OUT_OF_RANGE_IF(
-            position < m_begin || position > m_end || position + num > m_end);
-
-        const auto s = size();
-        if (s - num == 0) {
-            clear();
-            return m_end;
-        }
-
-        auto new_buf = choose_data(s - num);
-
-        if (new_buf == m_begin) {
-            // no special transfers needed
-
-            for (auto p = position, np = position + num; np != m_end;
-                 ++p, ++np) {
-                atraits::destroy(get_alloc(), p);
-                atraits::construct(get_alloc(), p, std::move(*np));
-            }
-
-            for (auto p = m_end - num; p != m_end; ++p) {
-                atraits::destroy(get_alloc(), p);
-            }
-
-            m_end -= num;
-        } else {
-            // we need to transfer the elements into the new buffer
-
-            assert(new_buf ==
-                   static_begin_ptr()); // since we're shrinking that's the only
-                                        // way to have a new buffer
-
-            m_capacity = StaticCapacity;
-
-            auto p = m_begin, np = new_buf;
-            for (; p != position; ++p, ++np) {
-                atraits::construct(get_alloc(), np, std::move(*p));
-                atraits::destroy(get_alloc(), p);
-            }
-
-            for (; p != position + num; ++p) {
-                atraits::destroy(get_alloc(), p);
-            }
-
-            for (; np != new_buf + s - num; ++p, ++np) {
-                atraits::construct(get_alloc(), np, std::move(*p));
-                atraits::destroy(get_alloc(), p);
-            }
-
-            position = new_buf + (position - m_begin);
-            m_begin = new_buf;
-            m_end = np;
-        }
-
-        return ++position;
-    }
-
-    void assign_impl(size_type count, const T &value) {
-        assert(m_begin);
-        assert(m_begin == m_end);
-
-        m_begin = m_end = choose_data(count);
-        for (size_type i = 0; i < count; ++i) {
-            atraits::construct(get_alloc(), m_end, value);
-            ++m_end;
-        }
-
-        update_capacity();
-    }
-
-    template <class InputIterator>
-    void assign_impl(InputIterator first, InputIterator last) {
-        assert(m_begin);
-        assert(m_begin == m_end);
-
-        m_begin = m_end = choose_data(last - first);
-        for (auto p = first; p != last; ++p) {
-            atraits::construct(get_alloc(), m_end, *p);
-            ++m_end;
-        }
-
-        update_capacity();
-    }
-
-    void assign_impl(std::initializer_list<T> ilist) {
-        assert(m_begin);
-        assert(m_begin == m_end);
-
-        m_begin = m_end = choose_data(ilist.size());
-        for (auto &elem : ilist) {
-            atraits::construct(get_alloc(), m_end, elem);
-            ++m_end;
-        }
-
-        update_capacity();
-    }
-
-    void update_capacity() {
-        if (m_begin == static_begin_ptr()) {
-            m_capacity = StaticCapacity;
-        } else {
-            m_capacity = m_dynamic_capacity;
-        }
-    }
-
-    T *choose_data(size_t desired_capacity) {
-        if (m_begin == m_dynamic_data) {
-            // we're at the dyn buffer, so see if it needs resize or revert to
-            // static
-
-            if (desired_capacity > m_dynamic_capacity) {
-                while (m_dynamic_capacity < desired_capacity) {
-                    // grow by roughly 1.5
-                    m_dynamic_capacity *= 3;
-                    ++m_dynamic_capacity;
-                    m_dynamic_capacity /= 2;
-                }
-
-                m_dynamic_data =
-                    atraits::allocate(get_alloc(), m_dynamic_capacity);
-                return m_dynamic_data;
-            } else if (desired_capacity < RevertToStaticSize) {
-                // we're reverting to the static buffer
-                return static_begin_ptr();
-            } else {
-                // if the capacity and we don't revert to static, just do
-                // nothing
-                return m_dynamic_data;
-            }
-        } else {
-            assert(m_begin == static_begin_ptr()); // corrupt begin ptr?
-
-            if (desired_capacity > StaticCapacity) {
-                // we must move to dyn memory
-
-                // see if we have enough
-                if (desired_capacity > m_dynamic_capacity) {
-                    // we need to allocate more
-                    // we don't have anything to destroy, so we can also
-                    // deallocate the buffer
-                    if (m_dynamic_data) {
-                        atraits::deallocate(get_alloc(), m_dynamic_data,
-                                            m_dynamic_capacity);
-                    }
-
-                    m_dynamic_capacity = desired_capacity;
-                    m_dynamic_data =
-                        atraits::allocate(get_alloc(), m_dynamic_capacity);
-                }
-
-                return m_dynamic_data;
-            } else {
-                // we have enough capacity as it is
-                return static_begin_ptr();
-            }
-        }
-    }
-
-    allocator_type &get_alloc() { return static_cast<allocator_type &>(*this); }
-    const allocator_type &get_alloc() const {
-        return static_cast<const allocator_type &>(*this);
-    }
-
-    pointer m_begin;
-    pointer m_end;
-
-    size_t m_capacity;
-    typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type
-        m_static_data[StaticCapacity];
-
-    size_t m_dynamic_capacity;
-    pointer m_dynamic_data;
-};
-
-template <typename T, size_t StaticCapacity, size_t RevertToStaticSize,
-          class Alloc>
-bool operator==(
-    const small_vector<T, StaticCapacity, RevertToStaticSize, Alloc> &a,
-    const small_vector<T, StaticCapacity, RevertToStaticSize, Alloc> &b) {
-    if (a.size() != b.size()) {
-        return false;
-    }
-
-    for (size_t i = 0; i < a.size(); ++i) {
-        if (a[i] != b[i])
-            return false;
-    }
-
-    return true;
-}
-
-template <typename T, size_t StaticCapacity, size_t RevertToStaticSize,
-          class Alloc>
-bool operator!=(
-    const small_vector<T, StaticCapacity, RevertToStaticSize, Alloc> &a,
-    const small_vector<T, StaticCapacity, RevertToStaticSize, Alloc> &b) {
-    if (a.size() != b.size()) {
-        return true;
-    }
-
-    for (size_t i = 0; i < a.size(); ++i) {
-        if (a[i] != b[i])
-            return true;
-    }
-
-    return false;
-}
-
-} // namespace itlib
diff --git a/modules/xpu/src/runtime/cmodel/include/softmax.h b/modules/xpu/src/runtime/cmodel/include/softmax.h
deleted file mode 100644
index f61fded2d5..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/softmax.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include <cmath>
-#include <runtime_utils.h>
-#include <type_traits>
-
-using namespace nncase::runtime::xpu;
-
-namespace kernels {
-
-namespace {
-// softmax(x) = exp(x - reduce_max(x)) / reduce_sum(exp(x - reduce_max(x)))
-template <typename T>
-void softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
-                  gsl::span<const size_t> in_strides,
-                  gsl::span<const size_t> out_strides, int64_t axis, float beta,
-                  bool needLog = false) noexcept {
-    size_t positive_axis = axis < 0 ? in_shape.size() + axis : axis;
-    dims_t axes{positive_axis};
-
-    auto reduced_shape = get_reduced_shape(in_shape, axes, true);
-    auto reduced_strides = get_default_strides(reduced_shape);
-    auto reduced_size = compute_size(reduced_shape);
-    auto tmp = (T *)runtime_util->malloc(reduced_size * sizeof(T));
-    for (size_t i = 0; i < reduced_size; i++) {
-        tmp[i] = std::numeric_limits<T>().lowest();
-    }
-
-    // reduce_max
-    (apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        auto in_idx = offset(in_strides, index);
-        const auto in = input[in_idx];
-
-        const auto out_index = get_reduced_offset(index, axes, true);
-        auto out_idx = offset(reduced_strides, out_index);
-        auto &out = tmp[out_idx];
-
-        out = in > out ? in : out;
-    }));
-
-    // x - reduce_max
-    (apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        auto in_idx = offset(in_strides, index);
-        const auto in = input[in_idx];
-
-        const auto out_index = get_reduced_offset(index, axes, true);
-        auto max_idx = offset(reduced_strides, out_index);
-
-        auto out_idx = offset(out_strides, index);
-        output[out_idx] = (in - tmp[max_idx]) * beta;
-    }));
-
-    // exp(x - reduce_max) and sum
-    for (size_t i = 0; i < reduced_size; i++) {
-        tmp[i] = static_cast<T>(0);
-    }
-    (apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        auto in_idx = offset(out_strides, index);
-        const auto in = output[in_idx];
-
-        const auto out_index = get_reduced_offset(index, axes, true);
-        auto out_idx = offset(reduced_strides, out_index);
-        if (std::is_same_v<T, float>) {
-            output[in_idx] = nncase_mt->float_unary_exp(in);
-        } else {
-            runtime_util->rt_assert(false,
-                                    (char *)"Not supported Type in softmax!");
-        }
-
-        tmp[out_idx] += output[in_idx];
-    }));
-
-    // div
-    (apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        const auto in_index = get_reduced_offset(index, axes, true);
-        auto in_idx = offset(reduced_strides, in_index);
-        auto in = tmp[in_idx];
-
-        auto out_idx = offset(out_strides, index);
-        auto &out = output[out_idx];
-        out /= in;
-        if (needLog) {
-            if (std::is_same_v<T, float>) {
-                out = nncase_mt->float_unary_log(out);
-            } else {
-                runtime_util->rt_assert(
-                    false, (char *)"Not supported Type in softmax!");
-            }
-        }
-    }));
-
-    runtime_util->free(tmp);
-}
-} // namespace
-void softmax(const float *input, float *output,
-             gsl::span<const size_t> in_shape,
-             gsl::span<const size_t> in_strides,
-             gsl::span<const size_t> out_strides, int64_t axis, float beta,
-             bool needLog) noexcept {
-    return softmax_impl(input, output, in_shape, in_strides, out_strides, axis,
-                        beta, needLog);
-}
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/tdma.h b/modules/xpu/src/runtime/cmodel/include/tdma.h
deleted file mode 100644
index a4f36b8826..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/tdma.h
+++ /dev/null
@@ -1,864 +0,0 @@
-#pragma once
-#include "cast.h"
-#include "clamp.h"
-#include "runtime_utils.h"
-#include <apply.h>
-#include <binary.h>
-#include <cassert>
-#include <concat.h>
-#include <expand.h>
-#include <functional>
-#include <gather.h>
-#include <hardware_context.h>
-#include <instance_norm.h>
-#include <layernorm.h>
-#include <matmul.h>
-#include <reduce.h>
-#include <reduce_arg.h>
-#include <resize.h>
-#include <softmax.h>
-#include <tensor.h>
-#include <thread_context.h>
-#include <transpose.h>
-#include <unary.h>
-
-enum class reduce_strategy_t : uint8_t {
-    all,
-    by_block,
-    by_thread,
-    none,
-};
-
-#define __tdma_block_sync_apply_macro(func, ctx, ...)                          \
-    global_hardware_ctx.lock_block(ctx.bid());                                 \
-    int visited = global_hardware_ctx.mark_block_visit(ctx.bid(), ctx.tid());  \
-    func(visited, __VA_ARGS__);                                                \
-    global_hardware_ctx.unlock_block(ctx.bid());                               \
-    global_hardware_ctx.wait_block_sync(ctx.bid(), visited);
-
-template <class T, loc_t Loc> tensor<T, Loc> unsqueeze(tensor<T, Loc> &src) {
-    auto new_dims = dims_t(src.dimension());
-    new_dims.insert(new_dims.begin(), 1);
-    auto new_strides = strides_t(src.strides());
-    new_strides.insert(new_strides.begin(), *new_strides.begin());
-    return tensor<T, Loc>(src.data(), new_dims, new_strides);
-}
-
-template <class T, loc_t Loc>
-tensor<T, Loc> view_transpose(tensor<T, Loc> &src, dims_t perm) {
-    auto new_dims = dims_t();
-    auto new_strides = dims_t();
-    for (auto axis : perm) {
-        new_dims.push_back(src.dimension()[axis]);
-        new_strides.push_back(src.strides()[axis]);
-    }
-    return tensor<T, Loc>(src.data(), new_dims, new_strides);
-}
-
-template <class T, loc_t Loc>
-tensor<T, Loc> view(tensor<T, Loc> &src, dims_t new_dims) {
-    return tensor<T, Loc>(src.data(), new_dims, get_default_strides(new_dims));
-}
-
-template <class T, loc_t Loc>
-tensor<T, Loc> view(tensor<T, Loc> &src, dims_t new_dims, dims_t new_strides) {
-    return tensor<T, Loc>(src.data(), new_dims, new_strides);
-}
-
-template <class T, loc_t Loc>
-void transpose(tensor<T, Loc> &src, tensor<T, Loc> &dest, dims_t perm) {
-    return kernels::transpose(src.cdata().data(), dest.data().data(),
-                              src.dimension(), perm, src.strides(),
-                              dest.strides());
-}
-
-template <loc_t SrcLoc, loc_t DestLoc>
-void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest,
-             int axis) {
-    kernels::softmax(src.cdata().data(), dest.data().data(), src.dimension(),
-                     src.strides(), dest.strides(), axis, 1.0f, false);
-}
-
-template <class T, loc_t DestLoc, loc_t SrcLoc>
-void __tensor_copy_sync(tensor<T, DestLoc> &&dest, tensor<T, SrcLoc> &&src) {
-    runtime_util->rt_assert(
-        dest.dimension() == src.dimension(),
-        (char *)"Dest and Src dimension mismatch in __tensor_copy_sync");
-    apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
-          [&](gsl::span<const size_t> index) -> void {
-              dest.data()[offset(dest.strides(), index)] =
-                  src.data()[offset(src.strides(), index)];
-          });
-}
-
-template <class T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-void binary(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &out,
-            binary_op_t op) {
-    kernels::binary(
-        op, a.cdata().data(), b.cdata().data(), out.data().data(),
-        gsl::make_span(a.dimension()).template as_span<const size_t>(),
-        gsl::make_span(a.strides()).template as_span<const size_t>(),
-        gsl::make_span(b.dimension()).template as_span<const size_t>(),
-        gsl::make_span(b.strides()).template as_span<const size_t>(),
-        gsl::make_span(out.dimension()).template as_span<const size_t>(),
-        gsl::make_span(out.strides()).template as_span<const size_t>());
-}
-
-template <class T, loc_t ALoc, loc_t BLoc>
-void unary(tensor<T, ALoc> &a, tensor<T, BLoc> &out, unary_op_t op) {
-    kernels::unary(
-        op, a.cdata().data(), out.data().data(),
-        gsl::make_span(a.strides()).template as_span<const size_t>(),
-        gsl::make_span(out.dimension()).template as_span<const size_t>(),
-        gsl::make_span(out.strides()).template as_span<const size_t>());
-}
-
-template <loc_t ALoc, loc_t BLoc>
-void swishb(tensor<float, ALoc> &a, tensor<float, BLoc> &out, float beta) {
-    kernels::swishb(
-        a.cdata().data(), out.data().data(), beta,
-        gsl::make_span(a.strides()).template as_span<const size_t>(),
-        gsl::make_span(out.dimension()).template as_span<const size_t>(),
-        gsl::make_span(out.strides()).template as_span<const size_t>());
-}
-
-template <typename T, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-void matmul(tensor<T, ALoc> &a, tensor<T, BLoc> &b, tensor<T, CLoc> &c) {
-    kernels::matmul(a.cdata().data(), b.cdata().data(), c.data().data(),
-                    a.dimension(), a.strides(), b.dimension(), b.strides(),
-                    c.dimension(), c.strides());
-}
-
-template <typename T, loc_t InLoc>
-T *im2col(tensor<T, InLoc> &input, dims_t filter, dims_t padding, dims_t stride,
-          [[maybe_unused]] dims_t dilation = {1, 1},
-          [[maybe_unused]] int32_t groups = 1) {
-    // todo: support group conv2d
-    int32_t N = input.dimension()[0];
-    int32_t C = input.dimension()[1];
-    int32_t H = input.dimension()[2] + padding[0] + padding[1];
-    int32_t W = input.dimension()[3] + padding[2] + padding[3];
-
-    int32_t OH = (H - dilation[0] * (filter[0] - 1) - 1) / stride[0] + 1;
-    int32_t OW = (W - dilation[1] * (filter[1] - 1) - 1) / stride[1] + 1;
-
-    auto cols = (T *)runtime_util->malloc((C * filter[0] * filter[1]) *
-                                          (OH * OW * N) * sizeof(T));
-
-    for (auto c = 0; c < C; c++)
-        for (auto e = 0; e < OH; e++)
-            for (auto f = 0; f < OW; f++)
-                for (auto r = 0; r < filter[0]; r++)
-                    for (auto s = 0; s < filter[1]; s++) {
-                        auto row =
-                            c * filter[0] * filter[1] + r * filter[0] + s;
-                        auto in_h = stride[0] * e + r * dilation[0];
-                        auto in_w = stride[1] * f + s * dilation[1];
-                        for (auto b = 0; b < N; b++) {
-                            auto col = e * OW * N + f * N + b;
-                            auto out_index = row * (OH * OW * N) + col;
-                            if (in_h < padding[0] || in_w < padding[2] ||
-                                in_h >= H - padding[1] ||
-                                in_w >= W - padding[3]) {
-                                cols[out_index] = 0;
-                            } else {
-                                auto in_index =
-                                    b * input.strides()[0] +
-                                    c * input.strides()[1] +
-                                    (in_h - padding[0]) * input.strides()[2] +
-                                    (in_w - padding[2]);
-                                cols[out_index] =
-                                    input.cdata().data()[in_index];
-                            }
-                        }
-                    }
-    return cols;
-}
-
-template <typename T, loc_t InLoc, loc_t WLoc, loc_t BLoc, loc_t OutLoc>
-void conv2d(thread_context &ctx, tensor<T, InLoc> &input,
-            tensor<T, WLoc> &weight, tensor<T, BLoc> &bias,
-            tensor<T, OutLoc> &output, dims_t stride, dims_t padding,
-            dims_t dilation = {1, 1}, int32_t groups = 1,
-            reduce_strategy_t strategy = reduce_strategy_t::none) {
-    // todo: support group conv2d
-    size_t N = input.dimension()[0];
-    size_t C = input.dimension()[1];
-    size_t H = input.dimension()[2] + padding[0] + padding[1];
-    size_t W = input.dimension()[3] + padding[2] + padding[3];
-
-    size_t M = weight.dimension()[0];
-    dims_t filter = {weight.dimension()[2], weight.dimension()[3]};
-
-    size_t OH = (H - dilation[0] * (filter[0] - 1) - 1) / stride[0] + 1;
-    size_t OW = (W - dilation[1] * (filter[1] - 1) - 1) / stride[1] + 1;
-
-    auto input_cols =
-        im2col<T, InLoc>(input, filter, padding, stride, dilation, groups);
-    auto mm = tensor<T>({M, OH * OW * N});
-    kernels::matmul(
-        weight.cdata().data(), input_cols, mm.data().data(),
-        gsl::make_span(dims_t{M, C * filter[0] * filter[1]}),
-        gsl::make_span(dims_t{weight.strides()[0], 1}),
-        gsl::make_span(dims_t{C * filter[0] * filter[1], OH * OW * N}),
-        gsl::make_span(dims_t{OH * OW * N, 1}),
-        gsl::make_span(dims_t{M, OH * OW * N}),
-        gsl::make_span(dims_t{OH * OW * N, 1}));
-    runtime_util->free(input_cols);
-
-    // switch (strategy) {
-    // case reduce_strategy_t::by_thread:
-    //     tdma_reduce_async(mm, mm, reduce_op_t::sum, ctx);
-    //     break;
-    // case reduce_strategy_t::by_block:
-    // case reduce_strategy_t::all:
-    //     tdma_all_reduce_async(mm, mm, reduce_op_t::sum, strategy, ctx);
-    //     break;
-    // default:
-    //     break;
-    // }
-    // kernels::binary(binary_op_t::add, mm.cdata().data(), bias.cdata().data(),
-    //                 mm.data().data(), gsl::make_span(dims_t{M, OH * OW * N}),
-    //                 gsl::make_span(dims_t{OH * OW * N, 1}),
-    //                 gsl::make_span(dims_t{M, 1}), gsl::make_span(dims_t{1,
-    //                 1}), gsl::make_span(dims_t{M, OH * OW * N}),
-    //                 gsl::make_span(dims_t{OH * OW * N, 1}));
-    kernels::transpose(mm.cdata().data(), output.data().data(),
-                       gsl::make_span(dims_t{M, OH, OW, N}),
-                       gsl::make_span(dims_t{3, 0, 1, 2}),
-                       gsl::make_span(dims_t{OH * OW * N, OW * N, N, 1}),
-                       output.strides());
-}
-
-template <typename T, loc_t ALoc, loc_t BLoc>
-void reduce(tensor<T, ALoc> &input, tensor<T, BLoc> &output, reduce_op_t op,
-            T init_value, dims_t axis, bool keep_dims) {
-    kernels::reduce(op, &init_value, input.cdata().data(), output.data().data(),
-                    input.dimension(), axis, input.strides(), output.strides(),
-                    keep_dims);
-}
-
-template <typename T, typename IndicesT, loc_t ALoc, loc_t BLoc, loc_t CLoc>
-void gather(tensor<T, ALoc> &input, tensor<IndicesT, BLoc> &indices,
-            tensor<T, CLoc> &output, int axis) {
-    kernels::gather<T, IndicesT>(
-        input.cdata().data(), output.data().data(), input.dimension(),
-        input.strides(), output.dimension(), output.strides(),
-        indices.data().data(), indices.dimension(), axis);
-}
-
-template <typename T, loc_t ALoc, loc_t BLoc>
-void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
-               tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
-               tensor<T, loc_t::local> &gamma, tensor<T, loc_t::local> &beta,
-               T eps, int32_t axis, int32_t norm_size, bool rms_norm = false) {
-    assert(sum.strides() == sum_sqr.strides());
-    assert(is_contiguous(sum.dimension(), sum.strides()));
-    assert(gamma.strides() == beta.strides());
-    assert(is_contiguous(gamma.dimension(), gamma.strides()));
-    kernels::layernorm(
-        input.cdata().data(), sum.data().data(), sum_sqr.data().data(),
-        output.data().data(), gamma.data().data(), beta.data().data(),
-        input.dimension(), input.strides(), output.strides(), sum.strides(),
-        gamma.strides(), eps, axis, norm_size, rms_norm);
-}
-
-template <typename T, loc_t ALoc, loc_t BLoc>
-void layernorm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
-               tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
-               int32_t axis, int32_t norm_size, bool rms_norm = false) {
-    kernels::layernorm(input.cdata().data(), sum.data().data(),
-                       sum_sqr.data().data(), output.data().data(),
-                       static_cast<T *>(nullptr), static_cast<T *>(nullptr),
-                       input.dimension(), input.strides(), output.strides(),
-                       sum.strides(), dims_t({}), static_cast<T>(1e-5), axis,
-                       norm_size, rms_norm);
-}
-
-template <typename T, loc_t ALoc, loc_t BLoc>
-void instance_norm(tensor<T, ALoc> &input, tensor<T, loc_t::local> &sum,
-                   tensor<T, loc_t::local> &sum_sqr, tensor<T, BLoc> &output,
-                   tensor<T, loc_t::local> &gamma,
-                   tensor<T, loc_t::local> &beta, T eps, int32_t norm_size) {
-    assert(sum.strides() == sum_sqr.strides());
-    assert(is_contiguous(sum.dimension(), sum.strides()));
-    assert(gamma.strides() == beta.strides());
-    assert(is_contiguous(gamma.dimension(), gamma.strides()));
-    kernels::instance_norm(input.cdata().data(), sum.data().data(),
-                           sum_sqr.data().data(), output.data().data(),
-                           gamma.data().data(), beta.data().data(),
-                           input.dimension(), input.strides(), output.strides(),
-                           sum.strides(), gamma.strides(), eps, norm_size);
-}
-
-template <typename T, loc_t ALoc, loc_t BLoc>
-void resize(tensor<T, ALoc> &input, tensor<T, BLoc> &output,
-            [[maybe_unused]] float *roi, int32_t *new_size,
-            [[maybe_unused]] float cubic_coeff_a,
-            [[maybe_unused]] int exclude_outside_value,
-            [[maybe_unused]] float extrapolation_value,
-            image_resize_mode_t resize_mode,
-            image_resize_transformation_mode_t transformation_mode,
-            image_resize_nearest_mode_t nearest_mode,
-            [[maybe_unused]] bool is_tf_resize) {
-    if (resize_mode == image_resize_mode_t::bilinear) {
-        kernels::resize_bilinear(
-            input.cdata().data(), output.data().data(), input.dimension(),
-            input.strides(), output.strides(), new_size[2], new_size[3],
-            transformation_mode ==
-                image_resize_transformation_mode_t::align_corners,
-            transformation_mode ==
-                image_resize_transformation_mode_t::half_pixel);
-    } else {
-        get_coordinate_func_t get_coordinate_func =
-            get_coordinate_from_resized(transformation_mode);
-        get_nearest_pixel_func_t get_nearset_func =
-            get_nearest_pixel_from_origin(nearest_mode);
-        kernels::resize_neareast_neighbor(
-            input.cdata().data(), output.data().data(), input.dimension(),
-            input.strides(), output.strides(), new_size[2], new_size[3],
-            transformation_mode ==
-                image_resize_transformation_mode_t::align_corners,
-            transformation_mode ==
-                image_resize_transformation_mode_t::half_pixel,
-            get_coordinate_func, get_nearset_func);
-    }
-}
-
-template <typename T, loc_t ALoc>
-void reduce_sum_sqr(tensor<T, ALoc> &a, tensor<T, loc_t::local> &sum,
-                    tensor<T, loc_t::local> &sum_sqr) {
-    kernels::reduce_sum_and_sum_sqr(a.cdata().data(), sum.data().data(),
-                                    sum_sqr.data().data(), a.dimension(),
-                                    a.strides(), sum.strides());
-}
-
-template <typename T, loc_t BLoc>
-void concat(itlib::small_vector<tensor<T, loc_t::local> *> inits,
-            tensor<T, BLoc> &output, size_t axis) {
-    itlib::small_vector<const gsl::byte *, 8> inputs(inits.size());
-    itlib::small_vector<strides_t> in_strides(inits.size());
-    auto concat_dims = dims_t(inits.size(), 1);
-    for (size_t i = 0; i < inits.size(); ++i) {
-        if (inits[i]->dimension().size() != 0) {
-            concat_dims[i] = inits[i]->dimension()[axis];
-        }
-    }
-
-    for (size_t i = 0; i < inits.size(); ++i) {
-        inputs[i] = ((const gsl::byte *)(inits[i]->data().data()));
-        in_strides[i] = (inits[i]->strides());
-    }
-
-    kernels::concat(inputs, output.data().data(), output.dimension(),
-                    gsl::make_span(in_strides).as_span<const strides_t>(),
-                    output.strides(), axis, concat_dims);
-}
-
-template <typename T>
-void mma_visit(int visited, tensor<T, loc_t::shared> &c, tensor<T> &tmp,
-               bool &load_psum) {
-    if (load_psum) {
-        binary<T, loc_t::local, loc_t::shared, loc_t::shared>(tmp, c, c,
-                                                              binary_op_t::add);
-    } else {
-        if (visited == 1) {
-            binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
-                tmp, c, c, binary_op_t::add);
-        } else {
-            binary<T, loc_t::local, loc_t::shared, loc_t::shared>(
-                tmp, c, c, binary_op_t::add);
-        }
-    }
-}
-
-/**
- * @brief Block 级别的 mma，每个 thread 执行自己的 mma，最终 psum 累加写入
- * shared memory
- *
- * @tparam T type
- * @tparam ALoc shared or local
- * @tparam BLoc shared or local
- * @param a
- * @param b
- * @param c must be shared
- * @param load_psum
- * @param ctx
- */
-template <typename T, loc_t ALoc, loc_t BLoc>
-void tensor_block_mma_sync(tensor<T, ALoc> &a, tensor<T, BLoc> &b,
-                           tensor<T, loc_t::shared> &c, bool load_psum,
-                           thread_context &ctx) {
-    tensor<T> tmp(c.dimension());
-    matmul(a, b, tmp);
-
-    __tdma_block_sync_apply_macro(mma_visit, ctx, c, tmp, load_psum);
-}
-
-void __tdma_block_sync_apply(std::function<void(int)> func,
-                             thread_context &ctx) {
-    global_hardware_ctx.lock_block(ctx.bid());
-    int visited = global_hardware_ctx.mark_block_visit(ctx.bid(), ctx.tid());
-    func(visited);
-    global_hardware_ctx.unlock_block(ctx.bid());
-    global_hardware_ctx.wait_block_sync(ctx.bid(), visited);
-}
-
-#define __tdma_all_sync_apply_macro(apply_func, broadcast_func, ctx, ...)      \
-    global_hardware_ctx.lock_all();                                            \
-    int visited = global_hardware_ctx.mark_all_visit(ctx.bid(), ctx.tid());    \
-    apply_func(visited, ctx, __VA_ARGS__);                                     \
-    global_hardware_ctx.unlock_all();                                          \
-    global_hardware_ctx.wait_all_sync(visited, broadcast_func);
-
-void __tdma_all_sync_apply(std::function<void(int)> apply_func,
-                           std::function<void()> broadcast_func,
-                           thread_context &ctx) {
-    global_hardware_ctx.lock_all();
-    int visited = global_hardware_ctx.mark_all_visit(ctx.bid(), ctx.tid());
-    apply_func(visited);
-    global_hardware_ctx.unlock_all();
-    global_hardware_ctx.wait_all_sync(visited, broadcast_func);
-}
-
-template <class T, loc_t DestLoc>
-void tdma_load_async(tensor<T, DestLoc> &dest, tensor<T, loc_t::device> &&src) {
-    __tensor_copy_sync(std::forward<tensor<T, DestLoc>>(dest),
-                       std::forward<tensor<T, loc_t::device>>(src));
-}
-
-template <class T, loc_t SrcLoc>
-void tdma_store_async(tensor<T, SrcLoc> &src, tensor<T, loc_t::device> &&dest) {
-    __tensor_copy_sync(std::forward<tensor<T, loc_t::device>>(dest),
-                       std::forward<tensor<T, SrcLoc>>(src));
-}
-
-template <class T>
-void boxing_store_sync_visit_func(int visited,
-                                  [[maybe_unused]] thread_context &ctx,
-                                  tensor<T, loc_t::local> &src,
-                                  dims_t global_dims, dims_t starts,
-                                  dims_t dims) {
-    T *global_span = nullptr;
-    if (visited == 1) {
-        if (global_hardware_ctx.global_var != nullptr) {
-            runtime_util->rt_assert(false,
-                                    (char *)"the global var has been used!");
-        }
-        global_span =
-            (T *)runtime_util->malloc(sizeof(T) * compute_size(global_dims));
-        global_hardware_ctx.global_var = global_span;
-    }
-
-    tensor<T> global_tensor =
-        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
-                                 compute_size(global_dims)),
-                  global_dims);
-    __tensor_copy_sync<T, loc_t::local, loc_t::local>(
-        std::move(global_tensor(starts, dims)), std::move(src));
-}
-
-template <class T>
-void boxing_load_sync_visit_func([[maybe_unused]] int visited,
-                                 [[maybe_unused]] thread_context &ctx,
-                                 tensor<T, loc_t::local> &dest,
-                                 dims_t global_dims, dims_t starts,
-                                 dims_t dims) {
-    T *global_span = nullptr;
-    tensor<T> global_tensor =
-        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
-                                 compute_size(global_dims)),
-                  global_dims);
-    __tensor_copy_sync<T, loc_t::local, loc_t::local>(
-        std::move(dest), std::move(global_tensor(starts, dims)));
-}
-
-template <class T, loc_t DestLoc>
-void tdma_boxing_load_sync(tensor<T, DestLoc> &dest, dims_t global_dims,
-                           dims_t starts, dims_t dims, thread_context &ctx) {
-    __tdma_all_sync_apply_macro(boxing_load_sync_visit_func, ([]() -> void {
-                                    runtime_util->free(
-                                        global_hardware_ctx.global_var);
-                                    global_hardware_ctx.global_var = nullptr;
-                                }),
-                                ctx, dest, global_dims, starts, dims)
-}
-
-template <class T, loc_t SrcLoc>
-void tdma_boxing_store_sync(tensor<T, SrcLoc> &src, dims_t global_dims,
-                            dims_t starts, dims_t dims, thread_context &ctx) {
-    __tdma_all_sync_apply_macro(boxing_store_sync_visit_func, ([]() -> void {}),
-                                ctx, src, global_dims, starts, dims)
-}
-
-template <class T> void tdma_fill_async(tensor<T, loc_t::local> &src, T value) {
-    apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
-          [&](gsl::span<const size_t> index) -> void {
-              src.data()[offset(src.strides(), index)] = value;
-          });
-}
-
-template <class T>
-void tdma_fill_async(tensor<T, loc_t::shared> &src, T value) {
-    apply(gsl::make_span(src.dimension()).template as_span<const size_t>(),
-          [&](gsl::span<const size_t> index) -> void {
-              src.data()[offset(src.strides(), index)] = value;
-          });
-}
-
-template <class T>
-void tdma_broadcast_async(tensor<T, loc_t::local> &src,
-                          tensor<T, loc_t::shared> &dest, thread_context &ctx) {
-
-    global_hardware_ctx.lock_block(ctx.bid());
-    __tensor_copy_sync(dest, src);
-    global_hardware_ctx.unlock_block(ctx.bid());
-    // int cnt = global_hardware_ctx.mark_block_visit(ctx.tid());
-    // global_hardware_ctx.wait_block_sync(ctx.bid(), cnt);
-}
-
-template <class T, loc_t Src, loc_t Dest>
-void tdma_load_broadcast_async([[maybe_unused]] tensor<T, Dest> &dest,
-                               [[maybe_unused]] tensor<T, Src> &src,
-                               [[maybe_unused]] thread_context &ctx) {
-    // throw std::system_error(std::make_error_code(std::errc::not_supported));
-    runtime_util->rt_assert(false, (char *)"not_supported");
-}
-
-template <class T>
-void reduce_async_visit_func1(int visited, thread_context &ctx,
-                              tensor<T, loc_t::local> &src,
-                              [[maybe_unused]] tensor<T, loc_t::local> &dest) {
-    T *gather_span = nullptr;
-    auto new_dims = dims_t(src.dimension());
-    new_dims.insert(new_dims.begin(), BLOCKS * CORES);
-    if (visited == 1) {
-        if (global_hardware_ctx.global_var != nullptr) {
-            runtime_util->rt_assert(false,
-                                    (char *)"the global var has been used!");
-        }
-        gather_span =
-            (T *)runtime_util->malloc(sizeof(T) * compute_size(new_dims));
-        global_hardware_ctx.global_var = gather_span;
-    }
-    dims_t begin(new_dims.size(), 0);
-    dims_t shape(new_dims);
-    begin[0] = ctx.bid() * CORES + ctx.tid();
-    shape[0] = 1;
-    tensor<T> gather_tensor =
-        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
-                                 compute_size(new_dims)),
-                  new_dims);
-    __tensor_copy_sync<T, loc_t::local, loc_t::local>(
-        std::move((gather_tensor)(begin, shape)), std::move(unsqueeze(src)));
-}
-
-template <class T>
-void reduce_async_visit_func2([[maybe_unused]] int visit, thread_context &ctx,
-                              tensor<T, loc_t::local> &src,
-                              tensor<T, loc_t::local> &dest,
-                              reduce_op_t reduce_op) {
-    auto new_dims = dims_t(src.dimension());
-    new_dims.insert(new_dims.begin(), BLOCKS * CORES);
-    tensor<T> gather_tensor =
-        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
-                                 compute_size(new_dims)),
-                  new_dims);
-    // auto new_dims = dims_t(gather_tensor.dimension());
-    new_dims[0] = CORES;
-    auto viewed_gather_tensor =
-        tensor<T>(gather_tensor.data().subspan(
-                      ctx.bid() * CORES * gather_tensor.strides()[0],
-                      CORES * gather_tensor.strides()[0]),
-                  new_dims, gather_tensor.strides());
-
-    T init_value = (T)0;
-    if (reduce_op == reduce_op_t::min) {
-        init_value = std::numeric_limits<T>::max();
-    }
-    if (reduce_op == reduce_op_t::max) {
-        init_value = std::numeric_limits<T>::lowest();
-    }
-    reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(init_value),
-           dims_t({0}), false);
-}
-
-template <class T>
-void tdma_reduce_async(tensor<T, loc_t::local> &src,
-                       tensor<T, loc_t::local> &dest, reduce_op_t reduce_op,
-                       thread_context &ctx) {
-    {__tdma_all_sync_apply_macro(reduce_async_visit_func1, ([]() -> void {}),
-                                 ctx, src, dest)}
-
-    {
-        __tdma_all_sync_apply_macro(
-            reduce_async_visit_func2, ([]() -> void {
-                runtime_util->free(global_hardware_ctx.global_var);
-                global_hardware_ctx.global_var = nullptr;
-            }),
-            ctx, src, dest, reduce_op)
-    }
-}
-
-template <class T, loc_t ALoc>
-void all_reduce_async_visit_func1(int visited, thread_context &ctx,
-                                  tensor<T, ALoc> &src) {
-
-    T *gather_span = nullptr;
-    auto new_dims = dims_t(src.dimension());
-    new_dims.insert(new_dims.begin(), BLOCKS * CORES);
-    if (visited == 1) {
-        if (global_hardware_ctx.global_var != nullptr) {
-            runtime_util->rt_assert(false,
-                                    (char *)"the global var has been used!");
-        }
-        gather_span =
-            (T *)runtime_util->malloc(sizeof(T) * compute_size(new_dims));
-        global_hardware_ctx.global_var = (void *)gather_span;
-    }
-    dims_t begin(new_dims.size(), 0);
-    dims_t shape(new_dims);
-    begin[0] = ctx.bid() * CORES + ctx.tid();
-    shape[0] = 1;
-    tensor<T> gather_tensor =
-        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
-                                 compute_size(new_dims)),
-                  new_dims);
-    __tensor_copy_sync<T, loc_t::local, ALoc>(
-        std::move((gather_tensor)(begin, shape)), std::move(unsqueeze(src)));
-}
-
-template <class T, loc_t ALoc, loc_t BLoc>
-void all_reduce_async_visit_func2_all(int visit,
-                                      [[maybe_unused]] thread_context ctx,
-                                      tensor<T, ALoc> &src,
-                                      tensor<T, BLoc> &dest,
-                                      reduce_op_t reduce_op) {
-    T *gather_span = nullptr;
-    T *reduced_span = nullptr;
-    auto new_dims = dims_t(src.dimension());
-    new_dims.insert(new_dims.begin(), BLOCKS * CORES);
-    auto reduced_shape = get_reduced_shape(new_dims, dims_t({0}), false);
-
-    if (visit == 1) {
-        gather_span = (T *)global_hardware_ctx.global_var;
-        tensor<T> gather_tensor = tensor<T>(
-            gsl::make_span(gather_span, compute_size(new_dims)), new_dims);
-        reduced_span =
-            (T *)runtime_util->malloc(sizeof(T) * compute_size(reduced_shape));
-        tensor<T> reduced_tensor =
-            tensor<T>(gsl::make_span(reduced_span, compute_size(reduced_shape)),
-                      reduced_shape);
-        T init_value = (T)0;
-        if (reduce_op == reduce_op_t::min) {
-            init_value = std::numeric_limits<T>::max();
-        }
-        if (reduce_op == reduce_op_t::max) {
-            init_value = std::numeric_limits<T>::lowest();
-        }
-        reduce(gather_tensor, reduced_tensor, reduce_op, init_value,
-               dims_t({0}), false);
-        runtime_util->free(gather_span);
-        global_hardware_ctx.global_var = reduced_span;
-    }
-    tensor<T> reduced_tensor =
-        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
-                                 compute_size(reduced_shape)),
-                  reduced_shape);
-    __tensor_copy_sync(std::move(dest), std::move(reduced_tensor));
-}
-
-template <class T, loc_t ALoc, loc_t BLoc>
-void all_reduce_async_visit_func2_by_block([[maybe_unused]] int visit,
-                                           [[maybe_unused]] thread_context ctx,
-                                           tensor<T, ALoc> &src,
-                                           tensor<T, BLoc> &dest,
-                                           reduce_op_t reduce_op) {
-    auto new_dims = dims_t(src.dimension());
-    new_dims.insert(new_dims.begin(), CORES * BLOCKS);
-
-    tensor<T> gather_tensor =
-        tensor<T>(gsl::make_span((T *)global_hardware_ctx.global_var,
-                                 compute_size(new_dims)),
-                  new_dims);
-
-    auto new_strides = dims_t(gather_tensor.strides());
-    new_dims[0] = BLOCKS;
-    new_strides[0] *= CORES;
-
-    auto viewed_gather_tensor = tensor<T>(
-        gather_tensor.data().subspan(ctx.tid() * gather_tensor.strides()[0]),
-        new_dims, new_strides, false);
-
-    reduce(viewed_gather_tensor, dest, reduce_op, static_cast<T>(0),
-           dims_t({0}), false);
-}
-
-/**
- * @brief reduce across BLOCKS * CORES
- *  1. stack the src to gather tensor, shape = [BLOCKS , CORES , ...]
- *  2. reduce gather tensor, by_block mean axis 0, all mean axis [0,1]
- *  3. broadcast gather tensor to local tensor.
- * @tparam T
- * @param src local tensor
- * @param dest local tensor
- * @param reduce_op op
- * @param strategy  all = reduce [8*4], out=[0], pre_block = reduce [8*1],
- * out=[4] .
- * @param axis axis of gather tensor, note gather tensor dims = [32,...]
- * @param ctx
- */
-template <class T, loc_t ALoc, loc_t BLoc>
-void tdma_all_reduce_async(tensor<T, ALoc> &src, tensor<T, BLoc> &dest,
-                           reduce_op_t reduce_op, reduce_strategy_t strategy,
-                           thread_context &ctx) {
-    {
-        __tdma_all_sync_apply_macro(all_reduce_async_visit_func1,
-                                    ([]() -> void {}), ctx, src)
-    }
-    switch (strategy) {
-    case reduce_strategy_t::all: {
-        __tdma_all_sync_apply_macro(
-            all_reduce_async_visit_func2_all, ([]() -> void {
-                runtime_util->free(global_hardware_ctx.global_var);
-                global_hardware_ctx.global_var = nullptr;
-            }),
-            ctx, src, dest, reduce_op);
-    } break;
-    case reduce_strategy_t::by_block: {
-        __tdma_all_sync_apply_macro(
-            all_reduce_async_visit_func2_by_block, ([]() -> void {
-                runtime_util->free(global_hardware_ctx.global_var);
-                global_hardware_ctx.global_var = nullptr;
-            }),
-            ctx, src, dest, reduce_op);
-    } break;
-    default:
-        break;
-    }
-}
-
-void tdma_gather_async() {}
-
-void tdma_all_gather_async() {}
-
-void tdma_scatter_async() {}
-
-/**
- * @brief tdma inner block wait.
- *
- * @param ctx
- */
-void tdma_wait(thread_context &ctx) {
-    __tdma_block_sync_apply([]([[maybe_unused]] int visited) -> void {}, ctx);
-}
-
-void tdma_all_wait(thread_context &ctx) {
-    __tdma_all_sync_apply([]([[maybe_unused]] int visited) -> void {},
-                          []() -> void {}, ctx);
-}
-
-void tdma_cancel() {}
-
-void tdma_status() {}
-
-enum class sched_strategy_t : uint8_t { pin_block_tensor, normal };
-
-void set_sched_strategy([[maybe_unused]] sched_strategy_t sch) {}
-
-template <loc_t SrcLoc, loc_t DestLoc, class Tin, class Tout>
-void reduce_arg(tensor<Tin, SrcLoc> &src, tensor<Tout, DestLoc> &dest, int axis,
-                bool keep_dims, bool select_last_idx, reduce_arg_op_t op) {
-    auto axes = dims_t{(size_t)axis};
-    kernels::reduce_arg<Tin, Tout>(op, src.cdata().data(), dest.data().data(),
-                                   src.dimension(), src.strides(),
-                                   dest.dimension(), dest.strides(), axes,
-                                   keep_dims, select_last_idx);
-}
-
-template <loc_t SrcLoc, loc_t DestLoc>
-void softmax(tensor<float, SrcLoc> &src, tensor<float, DestLoc> &dest, int axis,
-             thread_context &ctx,
-             reduce_strategy_t strategy = reduce_strategy_t::none) {
-    if (strategy == reduce_strategy_t::none) {
-        kernels::softmax(src.cdata().data(), dest.data().data(),
-                         src.dimension(), src.strides(), dest.strides(), axis,
-                         1.0f, false);
-    } else {
-        size_t positive_axis = axis < 0 ? src.dimension().size() + axis : axis;
-        dims_t axes{positive_axis};
-        auto reduced_shape = get_reduced_shape(src.dimension(), axes, true);
-        tensor<float> tmp_max(reduced_shape);
-
-        // max
-        auto initial_max = std::numeric_limits<float>::lowest();
-        kernels::reduce(reduce_op_t::max, &initial_max, src.cdata().data(),
-                        tmp_max.data().data(), src.dimension(), positive_axis,
-                        src.strides(), tmp_max.strides(), true);
-        if (strategy == reduce_strategy_t::all ||
-            strategy == reduce_strategy_t::by_block) {
-            tdma_all_reduce_async(tmp_max, tmp_max, reduce_op_t::max, strategy,
-                                  ctx);
-        } else {
-            tdma_reduce_async(tmp_max, tmp_max, reduce_op_t::max, ctx);
-        }
-
-        // x - max
-        kernels::binary(binary_op_t::sub, src.cdata().data(),
-                        tmp_max.cdata().data(), dest.data().data(),
-                        src.dimension(), src.strides(), reduced_shape,
-                        tmp_max.strides(), dest.dimension(), dest.strides());
-
-        // exp(x - max)
-        kernels::unary(unary_op_t::exp, dest.cdata().data(), dest.data().data(),
-                       dest.strides(), dest.dimension(), dest.strides());
-
-        // sum(exp(x - max))
-        float initial_sum = 0;
-        tensor<float> tmp_sum(reduced_shape);
-        kernels::reduce(reduce_op_t::sum, &initial_sum, dest.cdata().data(),
-                        tmp_sum.data().data(), dest.dimension(), positive_axis,
-                        dest.strides(), tmp_sum.strides(), true);
-        if (strategy == reduce_strategy_t::all ||
-            strategy == reduce_strategy_t::by_block) {
-            tdma_all_reduce_async(tmp_sum, tmp_sum, reduce_op_t::sum, strategy,
-                                  ctx);
-        } else {
-            tdma_reduce_async(tmp_sum, tmp_sum, reduce_op_t::sum, ctx);
-        }
-
-        // exp(x - max) / sum(exp(x - max))
-        kernels::binary(binary_op_t::div, dest.data().data(),
-                        tmp_sum.cdata().data(), dest.data().data(),
-                        dest.dimension(), dest.strides(), tmp_sum.dimension(),
-                        tmp_sum.strides(), dest.dimension(), dest.strides());
-    }
-}
-
-template <class TI, class TO, loc_t ALoc, loc_t BLoc>
-void cast(tensor<TI, ALoc> &in, tensor<TO, BLoc> &out) {
-    kernels::cast(
-        in.cdata().data(), out.data().data(),
-        gsl::make_span(in.dimension()).template as_span<const size_t>(),
-        gsl::make_span(in.strides()).template as_span<const size_t>(),
-        gsl::make_span(out.strides()).template as_span<const size_t>());
-}
-
-template <class T, loc_t ALoc, loc_t BLoc>
-void expand(tensor<T, ALoc> &in, tensor<T, BLoc> &out) {
-    kernels::expand(
-        in.cdata().data(), out.data().data(),
-        gsl::make_span(in.dimension()).template as_span<const size_t>(),
-        gsl::make_span(in.strides()).template as_span<const size_t>(),
-        gsl::make_span(out.dimension()).template as_span<const size_t>(),
-        gsl::make_span(out.strides()).template as_span<const size_t>());
-}
-
-template <class T, loc_t ALoc, loc_t BLoc>
-void clamp(tensor<T, ALoc> &in, tensor<T, BLoc> &out, T min, T max) {
-    kernels::clamp(
-        in.cdata().data(), out.data().data(), min, max,
-        gsl::make_span(in.dimension()).template as_span<const size_t>(),
-        gsl::make_span(in.strides()).template as_span<const size_t>(),
-        gsl::make_span(out.strides()).template as_span<const size_t>());
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/tensor.h b/modules/xpu/src/runtime/cmodel/include/tensor.h
deleted file mode 100644
index bfdabca5bf..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/tensor.h
+++ /dev/null
@@ -1,96 +0,0 @@
-#pragma once
-
-#include "../../gsl-lite.hpp"
-#include "../../method_table_def.h"
-#include <cstddef>
-#include <hardware_def.h>
-#include <runtime_utils.h>
-
-enum class loc_t : uint8_t {
-    shared,
-    device,
-    local,
-};
-
-template <typename T, loc_t Loc = loc_t::local> class tensor {
-
-  public:
-    using value_type = T;
-    tensor(tensor<T, Loc> &) = delete;
-    tensor &operator=(tensor<T, Loc> &) = delete;
-
-    tensor(dims_t dims)
-        : dims_(dims),
-          strides_(get_default_strides(dims_)),
-          size_(compute_size(dims_)) {
-        parent_ = nullptr;
-        auto ptr = (T *)runtime_util->malloc(size_ * sizeof(T));
-        data_ = gsl::make_span(ptr, size_);
-    }
-
-    tensor(gsl::span<T> data, dims_t dims)
-        : data_(data),
-          parent_(data.data()),
-          dims_(dims),
-          strides_(get_default_strides(dims_)),
-          size_(compute_size(dims_)) {
-        if (size_ != data_.size()) {
-            runtime_util->rt_assert(false, (char *)"Invalid tensor size");
-        }
-    }
-
-    tensor(gsl::span<T> data, dims_t dims, strides_t strides,
-           bool check_size = true)
-        : data_(data),
-          parent_(data.data()),
-          dims_(dims),
-          strides_(strides),
-          size_(compute_size(dims_, strides_)) {
-        if (check_size && size_ != data_.size()) {
-            runtime_util->rt_assert(false, (char *)"Invalid tensor size");
-        }
-    }
-
-    const dims_t &dimension() { return dims_; }
-    const strides_t &strides() { return strides_; }
-
-    gsl::span<T> data() { return data_; }
-
-    gsl::span<const T> cdata() { return data_.template as_span<const T>(); }
-
-    tensor<T, Loc> operator()(std::initializer_list<size_t> begins,
-                              std::initializer_list<size_t> shapes) {
-        return tensor(this, dims_t(begins.begin(), begins.end()),
-                      dims_t(shapes.begin(), shapes.end()));
-    }
-
-    tensor<T, Loc> operator()(dims_t begins, dims_t shapes) {
-        return tensor(this, begins, shapes);
-    }
-
-    ~tensor() {
-        if (parent_ == nullptr) {
-            runtime_util->free(data_.data());
-        }
-    }
-
-  private:
-    tensor(tensor<T, Loc> *parent, dims_t begins, dims_t shapes)
-        : parent_(parent),
-          dims_(shapes.begin(), shapes.end()),
-          strides_(parent->strides().begin(), parent->strides().end()) {
-        size_ = compute_size(shapes);
-        strides_ = parent->strides();
-        auto subspan_offset = offset(strides_, begins);
-        data_ = parent->data_.subspan(subspan_offset);
-        if (data_.size() < size_) {
-            runtime_util->rt_assert(false, (char *)"Invalid tensor size");
-        }
-    }
-
-    gsl::span<T> data_;
-    void *parent_;
-    dims_t dims_;
-    strides_t strides_;
-    size_t size_;
-};
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/thread_context.h b/modules/xpu/src/runtime/cmodel/include/thread_context.h
deleted file mode 100644
index 22c76fbc78..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/thread_context.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include <cstddef>
-
-class thread_context {
-  public:
-    thread_context(size_t bid, size_t tid) : bid_(bid), tid_(tid) {}
-
-    size_t bid() noexcept { return bid_; }
-
-    size_t tid() noexcept { return tid_; }
-
-  private:
-    size_t bid_;
-    size_t tid_;
-};
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/transpose.h b/modules/xpu/src/runtime/cmodel/include/transpose.h
deleted file mode 100644
index 507f99fdef..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/transpose.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "../../gsl-lite.hpp"
-#include <apply.h>
-#include <runtime_utils.h>
-
-namespace kernels {
-
-namespace {
-template <class T>
-void transpose_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
-                    gsl::span<const size_t> perm,
-                    gsl::span<const size_t> in_strides,
-                    gsl::span<const size_t> out_strides) noexcept {
-    return apply(in_shape, [&](gsl::span<const size_t> index) -> void {
-        dims_t out_index(index.size());
-        for (size_t i = 0; i < index.size(); i++)
-            out_index[i] = index[perm[i]];
-        output[offset(out_strides, out_index)] =
-            input[offset(in_strides, index)];
-    });
-}
-
-} // namespace
-
-template <class T>
-void transpose(const T *src, T *dest, gsl::span<const size_t> in_shape,
-               gsl::span<const size_t> perm, gsl::span<const size_t> in_strides,
-               gsl::span<const size_t> out_strides) noexcept {
-    transpose_impl(src, dest, in_shape, perm, in_strides, out_strides);
-}
-
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/include/unary.h b/modules/xpu/src/runtime/cmodel/include/unary.h
deleted file mode 100644
index 98c3c74eba..0000000000
--- a/modules/xpu/src/runtime/cmodel/include/unary.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "../../gsl-lite.hpp"
-#include <apply.h>
-#include <runtime_utils.h>
-
-using namespace nncase::runtime::xpu;
-namespace kernels {
-
-namespace {
-template <class T, class TOp>
-void unary_impl(TOp &&op, const T *input, T *output,
-                gsl::span<const size_t> input_strides,
-                gsl::span<const size_t> out_shape,
-                gsl::span<const size_t> out_strides) noexcept {
-    apply(out_shape, [&](gsl::span<const size_t> index) -> void {
-        const auto v = input[offset(input_strides, index)];
-        output[offset(out_strides, index)] = (T)op(v);
-    });
-}
-
-#define UNARY_IMPL_OP(op, callable)                                            \
-    case unary_op_t::op:                                                       \
-        return unary_impl(callable, input, output, input_strides, out_shape,   \
-                          out_strides)
-
-template <class T>
-void unary_impl(unary_op_t op, const T *input, T *output,
-                gsl::span<const size_t> input_strides,
-                gsl::span<const size_t> out_shape,
-                gsl::span<const size_t> out_strides) noexcept {
-    if (std::is_same_v<T, float>) {
-        switch (op) {
-            UNARY_IMPL_OP(abs, nncase_mt->float_unary_abs);
-            UNARY_IMPL_OP(acos, nncase_mt->float_unary_cos);
-            UNARY_IMPL_OP(acosh, nncase_mt->float_unary_cosh);
-            UNARY_IMPL_OP(asin, nncase_mt->float_unary_asin);
-            UNARY_IMPL_OP(asinh, nncase_mt->float_unary_asinh);
-            UNARY_IMPL_OP(ceil, nncase_mt->float_unary_ceil);
-            UNARY_IMPL_OP(cos, nncase_mt->float_unary_cos);
-            UNARY_IMPL_OP(cosh, nncase_mt->float_unary_cosh);
-            UNARY_IMPL_OP(exp, nncase_mt->float_unary_exp);
-            UNARY_IMPL_OP(floor, nncase_mt->float_unary_floor);
-            UNARY_IMPL_OP(log, nncase_mt->float_unary_log);
-            UNARY_IMPL_OP(logical_not, nncase_mt->float_unary_logical_not);
-            UNARY_IMPL_OP(neg, nncase_mt->float_unary_neg);
-            UNARY_IMPL_OP(round, nncase_mt->float_unary_round);
-            UNARY_IMPL_OP(rsqrt, nncase_mt->float_unary_rsqrt);
-            UNARY_IMPL_OP(sign, nncase_mt->float_unary_sign);
-            UNARY_IMPL_OP(sin, nncase_mt->float_unary_sin);
-            UNARY_IMPL_OP(sinh, nncase_mt->float_unary_sinh);
-            UNARY_IMPL_OP(sqrt, nncase_mt->float_unary_sqrt);
-            UNARY_IMPL_OP(square, nncase_mt->float_unary_square);
-            UNARY_IMPL_OP(tanh, nncase_mt->float_unary_tanh);
-            UNARY_IMPL_OP(swish, [](float x) {
-                return x / (1 + nncase_mt->float_unary_exp(-x));
-            });
-            UNARY_IMPL_OP(gelu, [](float x) {
-                return 0.5f * (x) *
-                       (1.f + nncase_mt->float_unary_erf(
-                                  x / nncase_mt->float_unary_sqrt(2.f)));
-            });
-        default:
-            runtime_util->rt_assert(false, (char *)"Unsupported Unary Op!");
-        }
-    } else {
-        runtime_util->rt_assert(false, (char *)"Unsupported Unary Type!");
-    }
-} // namespace
-
-} // namespace
-
-template <class T>
-void unary(unary_op_t op, const T *input, T *output,
-           gsl::span<const size_t> in_strides,
-           gsl::span<const size_t> out_shape,
-           gsl::span<const size_t> out_strides) noexcept {
-    unary_impl(op, input, output, in_strides, out_shape, out_strides);
-}
-
-void swishb(const float *input, float *output, float beta,
-            gsl::span<const size_t> input_strides,
-            gsl::span<const size_t> out_shape,
-            gsl::span<const size_t> out_strides) noexcept {
-    unary_impl(
-        [&beta](float x) {
-            return x * (1 / (1 + nncase_mt->float_unary_exp(-(x * beta))));
-        },
-        input, output, input_strides, out_shape, out_strides);
-}
-} // namespace kernels
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/src/cpu_cmodel.cpp b/modules/xpu/src/runtime/cmodel/src/cpu_cmodel.cpp
deleted file mode 100644
index 1201fd8a01..0000000000
--- a/modules/xpu/src/runtime/cmodel/src/cpu_cmodel.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <hardware_context.h>
-#include <nncase/compiler_defs.h>
-#include <tdma.h>
-
-namespace block0 {
-namespace thread0 {}
-namespace thread1 {}
-namespace thread2 {}
-namespace thread3 {}
-} // namespace block0
-namespace block1 {
-namespace thread0 {}
-namespace thread1 {}
-namespace thread2 {}
-namespace thread3 {}
-} // namespace block1
-namespace block2 {
-namespace thread0 {}
-namespace thread1 {}
-namespace thread2 {}
-namespace thread3 {}
-} // namespace block2
-namespace block3 {
-namespace thread0 {}
-namespace thread1 {}
-namespace thread2 {}
-namespace thread3 {}
-} // namespace block3
-namespace block4 {
-namespace thread0 {}
-namespace thread1 {}
-namespace thread2 {}
-namespace thread3 {}
-} // namespace block4
-namespace block5 {
-namespace thread0 {}
-namespace thread1 {}
-namespace thread2 {}
-namespace thread3 {}
-} // namespace block5
-namespace block6 {
-namespace thread0 {}
-namespace thread1 {}
-namespace thread2 {}
-namespace thread3 {}
-} // namespace block6
-namespace block7 {
-namespace thread0 {}
-namespace thread1 {}
-namespace thread2 {}
-namespace thread3 {}
-} // namespace block7
-
-int main(NNCASE_UNUSED int argc, NNCASE_UNUSED char **argv) {
-    // std::array<size_t, 3> shape = {3, 2, 4};
-
-    return 0;
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/src/dummy.cpp b/modules/xpu/src/runtime/cmodel/src/dummy.cpp
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/modules/xpu/src/runtime/cmodel/tests/decoder_layer/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/decoder_layer/cluster_def.h
deleted file mode 100644
index 8fd5d84ed7..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/decoder_layer/cluster_def.h
+++ /dev/null
@@ -1,171 +0,0 @@
-#pragma once
-#include <hardware_context.h>
-#include <tdma.h>
-
-namespace block0 {
-#include "shared_def.h"
-constexpr size_t bid = 0;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block0
-
-namespace block1 {
-#include "shared_def.h"
-constexpr size_t bid = 1;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block1
-
-namespace block2 {
-#include "shared_def.h"
-constexpr size_t bid = 2;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block2
-
-namespace block3 {
-#include "shared_def.h"
-constexpr size_t bid = 3;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block3
-
-namespace block4 {
-#include "shared_def.h"
-constexpr size_t bid = 4;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block4
-
-namespace block5 {
-#include "shared_def.h"
-constexpr size_t bid = 5;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block5
-
-namespace block6 {
-#include "shared_def.h"
-constexpr size_t bid = 6;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block6
-
-namespace block7 {
-#include "shared_def.h"
-constexpr size_t bid = 7;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block7
diff --git a/modules/xpu/src/runtime/cmodel/tests/decoder_layer/golden.py b/modules/xpu/src/runtime/cmodel/tests/decoder_layer/golden.py
deleted file mode 100644
index 1b4295769c..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/decoder_layer/golden.py
+++ /dev/null
@@ -1,106 +0,0 @@
-import numpy as np
-from torch import nn
-import torch
-from scipy.special import softmax
-import os
-
-def rmsnorm(x:np.ndarray, gamma:np.ndarray, beta:np.ndarray, eps=1e-05):
-    x = torch.from_numpy(x)
-    output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
-    output = output * torch.from_numpy(gamma) + torch.from_numpy(beta)
-    return output.detach().numpy()
-
-def layernorm(x:np.ndarray, gamma:np.ndarray, beta:np.ndarray):
-    return nn.functional.layer_norm(torch.from_numpy(x), [x.shape[-1]], torch.from_numpy(gamma), torch.from_numpy(beta)).detach().numpy()
-
-def swish(x:np.ndarray):
-    return x / (1 + np.exp(-x))
-
-def gather(data:np.ndarray, axis:int, indices:np.ndarray):
-    return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
-
-const_dir = "/compiler/huochenghai/GNNE/rebuild-ir/nncase/modules/xpu/src/runtime/cmodel/tests/demo3/golden"
-
-hidden_in = np.reshape(np.fromfile(os.path.join(const_dir,"input_0_0.bin"), dtype=np.float32), (1, 384, 8192))
-attn_mask = np.reshape(np.fromfile(os.path.join(const_dir,"input_1_0.bin"), dtype=np.float32), (1, 1, 384, 384))
-position_ids = np.reshape(np.fromfile(os.path.join(const_dir,"input_2_0.bin"), dtype=np.int64), (1, 384))
-
-input_ln_gamma = np.reshape(np.fromfile(os.path.join(const_dir,"_input_layernorm_Mul_1_output_0_scale.bin"), dtype=np.float32), (8192))
-input_ln_beta = np.reshape(np.fromfile(os.path.join(const_dir,"_input_layernorm_Mul_1_output_0_bias.bin"), dtype=np.float32), (8192))
-
-gather1_data = np.reshape(np.fromfile(os.path.join(const_dir, "_self_attn_Gather_7_output_0_data.bin"), dtype=np.float32), (384,128))
-gather2_data = np.reshape(np.fromfile(os.path.join(const_dir, "_self_attn_Gather_8_output_0_data.bin"), dtype=np.float32), (384,128))
-
-WQ = np.reshape(np.fromfile(os.path.join(const_dir,"_self_attn_Transpose_output_0_weights.bin"), dtype=np.float32), (64, 8192, 128))
-WK = np.reshape(np.fromfile(os.path.join(const_dir,"_self_attn_Transpose_1_output_0_weights.bin"), dtype=np.float32), (64, 8192, 128))
-WV = np.reshape(np.fromfile(os.path.join(const_dir,"_self_attn_Transpose_2_output_0_weights.bin"), dtype=np.float32), (64, 8192, 128))
-WO = np.reshape(np.fromfile(os.path.join(const_dir,"_self_attn_o_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (8192, 8192))
-
-post_ln_gamma = np.reshape(np.fromfile(os.path.join(const_dir,"_post_attention_layernorm_Mul_1_output_0_scale.bin"), dtype=np.float32), (8192))
-post_ln_beta = np.reshape(np.fromfile(os.path.join(const_dir,"_post_attention_layernorm_Mul_1_output_0_bias.bin"), dtype=np.float32), (8192))
-
-mlp_gate_weights = np.reshape(np.fromfile(os.path.join(const_dir,"_mlp_gate_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (8192, 22016))
-mlp_up_weights = np.reshape(np.fromfile(os.path.join(const_dir,"_mlp_up_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (8192, 22016))
-mlp_down_weights = np.reshape(np.fromfile(os.path.join(const_dir,"_mlp_down_proj_MatMul_output_0_weights.bin"), dtype=np.float32), (22016, 8192))
-
-for index in range(1):
-    # np.random.rand(8192).astype(np.float32), np.random.rand(8192).astype(np.float32)
-    v0 = rmsnorm(hidden_in, input_ln_gamma, input_ln_beta) # f32[1,384,8192]
-    # v0.tofile("v0.bin")
-    v1 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
-    v2 = (v1 @ WQ) # f32[1,64,384,128]
-    # v2.tofile("v2.bin")
-    v3 = gather1_data[position_ids] # f32[1,384,128]
-    # v3.tofile("v3.bin")
-    v4 = np.reshape(v3, (1,1,384,128))
-    v5 = v2 * v4 # f32[1,64,384,128]
-    # v5.tofile("v5.bin")
-    v6 = v2[:,:,:,64:] # Slice(v3, const(i64[1] : {64L}), const(i64[1] : {9223372036854775807}), 3, 1) # f32[1,64,384,64]
-    v7 = -(v6) # f32[1,64,384,64]
-    v8 = v2[:,:,:,0:64] # Slice(v3, 0, 64, 3, 1) # f32[1,64,384,64]
-    v9 = (v7, v8) # (f32[1,64,384,64], f32[1,64,384,64]
-
-    v10 = np.concatenate(v9, -1) # f32[1,64,384,128]
-    # v10.tofile("v10.bin")
-    v11 = gather2_data[position_ids] # f32[1,384,128]
-    v12 = np.reshape(v11, (1,1,384,128))
-    v13 = v10 * v12 # f32[1,64,384,128]
-    v14 = v5 + v13 # f32[1,64,384,128]
-    v14.tofile("v14.bin")
-    v15 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
-    v16 = (v15 @ WK) # f32[1,64,384,128]
-    v17 = v16 * v4 # f32[1,64,384,128]
-    v18 = v16[:,:,:,64:] # Slice(v3, const(i64[1] : {64L}), const(i64[1] : {9223372036854775807}), 3, 1) # f32[1,64,384,64]
-    v19 = -(v18) # f32[1,64,384,64]
-    v20 = v16[:,:,:,0:64] # Slice(v3, 0, 64, 3, 1) # f32[1,64,384,64]
-    v21 = (v19, v20) # (f32[1,64,384,64], f32[1,64,384,64])
-
-    v22 = np.concatenate(v21, -1) # f32[1,64,384,128]
-    # v22.tofile("v22.bin")
-    v23 = v22 * v12 # f32[1,64,384,128]
-    v24 = v17 + v23 # f32[1,64,384,128]
-    v25 = np.transpose(v24, [0,1,3,2]) # f32[1,64,128,384]
-    v26 = v14 @ v25 # f32[1,64,384,384]
-    # v26.tofile("v26.bin")
-    v27 = (v26/ 11.31370) # f32[1,64,384,384]
-    v28 = v27 + attn_mask # f32[1,64,384,384]
-    # v28.tofile("v28.bin")
-    v29 = softmax(v28, -1) # f32[1,64,384,384]
-    v30 = np.reshape(v0, [1,1,384, 8192]) # f32[1,1,384,8192]
-    v31 = (v30 @ WV) # f32[1,64,384,128]
-    v32 = v29 @ v31 # f32[1,64,384,128]
-    v33 = np.transpose(v32, [0,2,1,3]) # f32[1,384,64,128]
-    v34 = np.reshape(v33, [1,384,8192]) # f32[1,384,8192]
-    v35 = v34 @ WO # f32[1,384,8192]
-    v36 = (hidden_in + v35) # f32[1,384,8192]
-    v37 = rmsnorm(v36, post_ln_gamma, post_ln_beta) # f32[1,384,8192]
-    v38 = v37 @ mlp_gate_weights # f32[1,384,22016]
-    v39 = swish(v38) # f32[1,384,22016]
-    v40 = v37 @ mlp_up_weights # f32[1,384,22016]
-    v41 = v39 * v40 # f32[1,384,22016]
-    v42 = v41 @ mlp_down_weights # f32[1,384,8192]
-    v43 = v36 + v42 # f32[1,384,8192]
-
-    # v43.tofile("v43.bin")
-    hidden_in = v43
-hidden_in.tofile("hidden_in.bin")
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/decoder_layer/kernel.h b/modules/xpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
deleted file mode 100644
index 043387ea27..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/decoder_layer/kernel.h
+++ /dev/null
@@ -1,406 +0,0 @@
-// llama 65B
-// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
-// 1 chips, 8 blocks per chip, 4 threads per block
-
-#include "thread_context.h"
-using namespace shared;
-
-static bool w_loaded;
-static tensor<float> *v2_w;           // {64, 2048, 128}
-static tensor<float> *v16_w;          // {64, 2048, 128}
-static tensor<float> *v31_w;          // {64, 2048, 128}
-static tensor<float> *v35_w;          // {2048, 8192}
-static tensor<float> *v3_data;        // {384, 32}
-static tensor<float> *v11_data;       // {384, 32}
-static tensor<int64_t> *position_ids; // {1, 48}
-static tensor<float> *v38_w;          // {2048, 22016}
-static tensor<float> *v40_w;          // {2048, 22016}
-static tensor<float> *v42_w;          // {5504, 8192}
-#define DUMP 1
-
-#define MALLOC_STATIC(name, type, shape)                                       \
-    auto name##_tmp = tensor<type>(shape);                                     \
-    name = &name##_tmp;
-
-void stage1_kernel(
-    tensor<float, loc_t::device> &Hidden_in,               /* [1, 384, 8192] */
-    tensor<float, loc_t::device> &V0_gamma,                /* [8192] */
-    tensor<float, loc_t::device> &V0_beta,                 /* [8192] */
-    tensor<float, loc_t::device> &V2_w,                    /* [64, 8192, 128] */
-    tensor<float, loc_t::device> &V16_w,                   /* [64, 8192, 128] */
-    tensor<float, loc_t::device> &V31_w,                   /* [64, 8192, 128] */
-    tensor<float, loc_t::device> &V35_w,                   /* [8192, 8192] */
-    tensor<float, loc_t::device> &V3_data,                 /* [384, 128] */
-    tensor<float, loc_t::device> &V11_data,                /* [384, 128] */
-    tensor<float, loc_t::device> &Attn_mask,               /* [1,1,384,384] */
-    tensor<float, loc_t::device> &V38_w,                   /* [8192, 22016] */
-    tensor<float, loc_t::device> &V40_w,                   /* [8192, 22016] */
-    tensor<float, loc_t::device> &V42_w,                   /* [22016, 8192] */
-    tensor<int64_t, loc_t::device> &Position_ids,          /* [1,384] */
-    [[maybe_unused]] tensor<float, loc_t::device> &Output, /* [1,384,8192] */
-    tensor<float, loc_t::device> &V25, tensor<float, loc_t::device> &GV31,
-    [[maybe_unused]] tensor<float, loc_t::device> **ImmOutputs) {
-    thread_context ctx(bid, tid);
-    tensor<float> v0_gamma({2048});
-    tensor<float> v0_beta({2048});
-    tensor<float> v0({1, 48, 2048});    /* [1, 384, 8192] [1, 48@b, 2048@t]  */
-    tensor<float> var_5({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t]  */
-
-    tensor<float> attn_mask({1, 1, 48, 384});
-
-    MALLOC_STATIC(v2_w, float, dims_t({64, 2048, 128}))
-    MALLOC_STATIC(v16_w, float, dims_t({64, 2048, 128}))
-    MALLOC_STATIC(v31_w, float, dims_t({64, 2048, 128}))
-    MALLOC_STATIC(v35_w, float, dims_t({2048, 8192}))
-    MALLOC_STATIC(v3_data, float, dims_t({384, 32}))
-    MALLOC_STATIC(v11_data, float, dims_t({384, 32}))
-    MALLOC_STATIC(position_ids, int64_t, dims_t({1, 48}))
-    MALLOC_STATIC(v38_w, float, dims_t({2048, 22016}))
-    MALLOC_STATIC(v40_w, float, dims_t({2048, 22016}))
-    MALLOC_STATIC(v42_w, float, dims_t({5504, 8192}))
-
-    if (!w_loaded) {
-        tdma_load_async(v0_gamma, V0_gamma({tid * 2048}, {2048}));
-        tdma_load_async(v0_beta, V0_beta({tid * 2048}, {2048}));
-        tdma_load_async(*v2_w, V2_w({0, 2048 * tid, 0}, {64, 2048, 128}));
-        tdma_load_async(*v16_w, V16_w({0, 2048 * tid, 0}, {64, 2048, 128}));
-        tdma_load_async(*v31_w, V31_w({0, 2048 * tid, 0}, {64, 2048, 128}));
-        tdma_load_async(*v35_w, V35_w({2048 * tid, 0}, {2048, 8192}));
-        tdma_load_async(*v38_w, V38_w({2048 * tid, 0}, {2048, 22016}));
-        tdma_load_async(*v40_w, V40_w({2048 * tid, 0}, {2048, 22016}));
-        tdma_load_async(*v42_w, V42_w({5504 * tid, 0}, {5504, 8192}));
-        tdma_load_async(*v3_data, V3_data({0, 32 * tid}, {384, 32}));
-        tdma_load_async(*v11_data, V11_data({0, 32 * tid}, {384, 32}));
-        tdma_load_async(*position_ids, Position_ids({0, 48 * bid}, {1, 48}));
-        tdma_load_async(attn_mask,
-                        Attn_mask({0, 0, 48 * bid, 0}, {1, 1, 48, 384}));
-
-        tdma_wait(ctx);
-    }
-
-    tdma_load_async(v0, Hidden_in({0, bid * 48, tid * 2048}, {1, 48, 2048}));
-    {
-        tensor<float> v0_sum({1, 48});
-        tensor<float> v0_sum_sqr({1, 48});
-        reduce_sum_sqr(v0, v0_sum, v0_sum_sqr);
-        tdma_reduce_async(v0_sum, v0_sum, reduce_op_t::sum, ctx);
-        tdma_reduce_async(v0_sum_sqr, v0_sum_sqr, reduce_op_t::sum, ctx);
-        layernorm(v0, v0_sum, v0_sum_sqr, v0, 2, 8192, true);
-#if DUMP
-        {
-            tdma_store_async(
-                v0, (*ImmOutputs[0])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}));
-        }
-#endif
-    } // v0 [1, 384, 8192] [1, 48@b, 8192]
-
-    auto v1 = unsqueeze(v0); // [1, 1, 384, 8192] [1, 1, 48@b, 2048@t]
-    /*
-      [1, 1, 384, 8192]    @ [64, 8192, 128]  -> [1, 64, 384, 128]
-      [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1, 64, 48@b, 128] @ shared
-     */
-    tensor_block_mma_sync(v1, *v2_w, (*V2), false, ctx);
-#if DUMP
-    if (tid == 0) {
-        tdma_store_async(
-            *V2, (*ImmOutputs[1])({0, 0, 48 * bid, 0}, {1, 64, 48, 128}));
-    }
-    tdma_all_wait(ctx);
-#endif
-    // #if 0
-
-    /*
-      [384, 128][[1, 384]] -> [1, 384, 128]
-      [384, 32@t][[1, 48@b]] -> [1, 48@b, 32@t]
-    */
-    tensor<float> v3({1, 48, 32});
-    gather(*v3_data, *position_ids, v3, 0);
-#if DUMP
-    {
-        tdma_store_async(
-            v3, (*ImmOutputs[4])({0, 48 * bid, 32 * tid}, {1, 48, 32}));
-    }
-#endif
-    auto v4 = unsqueeze(v3); /* 1, 1, 48, 32 */
-
-    /*
-      [1, 64, 384, 128]           X   [1, 1, 384, 128] ->  [1, 64, 384, 128]
-      [1, 64, 48@b, 32@t] @ shared X   [1, 1, 48@b, 32@t] ->  [1, 64, 48@b,
-      32@t] @ shared
-    */
-    auto v5_ = (*V5)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-    auto v2_ = (*V2)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-    binary(v2_, v4, v5_, binary_op_t::mul);
-
-    /*
-      [1, 64, 384, 64:] -> [1, 64, 384, 64:]
-      [1, 64, 48@b, 16@t]@shared ->  [1, 16@t, 48@b, 16@t]
-    */
-    auto v6 = (*V2)({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16});
-    tensor<float> v7({1, 64, 48, 16});
-    tdma_wait(ctx);
-    unary(v6, v7, unary_op_t::neg);
-
-    __tensor_copy_sync((*V2)({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16}),
-                       (*V2)({0, 0, 0, 16 * tid}, {1, 64, 48, 16}));
-    __tensor_copy_sync((*V2)({0, 0, 0, 16 * tid}, {1, 64, 48, 16}),
-                       std::move(v7));
-    tdma_wait(ctx);
-
-    /* v10 为concat(v7,v8), 实际来源于V2，因此无需实际动作 */
-    auto v10 = (*V2)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-#if DUMP
-    {
-        tdma_store_async(
-            v10, (*ImmOutputs[2])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}));
-    }
-#endif
-
-    /*
-      [384, 128][[1, 384]] -> [1, 384, 128]
-      [384, 32@t][[1, 48@b]] -> [1, 48@b, 32@t]
-    */
-    tensor<float> v11({1, 48, 32});
-    gather(*v11_data, *position_ids, v11, 0);
-    auto v12 = unsqueeze(v11); // [1, 1, 384, 128] [1, 1, 48@b, 32@t]
-
-    /*
-      [1, 64, 384, 128]           X   [1, 1, 384, 128] ->  [1, 64, 384, 128]
-      [1, 64, 48@b, 32@t] @ shared X   [1, 1, 48@b, 32@t] ->  [1, 64, 48@b,
-      32@t] @ shared
-    */
-    auto v13_ = (*V13)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-    // auto v2_ = V2({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-    binary(v2_, v12, v13_, binary_op_t::mul);
-
-    tdma_all_wait(ctx); /* wait v5,v13 */
-
-    /*
-    [1, 64, 384, 128] + [1, 64, 384, 128] -> [1, 64, 384, 128]
-    [1, 64, 48@b, 32@t] + [1, 64, 48@b, 32@t] -> [1, 64, 48@b, 32@t]
-    */
-    tensor<float> v14({1, 64, 48, 32});
-    auto v5__ = (*V5)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-    auto v13__ = (*V13)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-    binary(v5__, v13__, v14, binary_op_t::add);
-#if DUMP
-    {
-        tdma_store_async(
-            v14, (*ImmOutputs[3])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}));
-    }
-#endif
-    tensor<float> &v15 = v0;
-    /*
-      [1,1,384,8192] @ [64, 8192, 128] -> [1,64,384,128]
-      [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1,64,48@b,128]@shared
-    */
-    tensor_block_mma_sync(v15, *v16_w, *V16, false, ctx);
-
-    /*
-      [1,64,384,128] X [1,64,384,128] -> [1,64,384,128]
-      [1,64,48@b,32@t]@shared X [1,1,48@b,32@t] ->  [1,64,48@b,32@t]
-    */
-    tensor<float> v17({1, 64, 48, 32});
-    auto v16 = (*V16)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-    binary(v16, v4, v17, binary_op_t ::mul);
-
-    /*
-      [1, 64, 384, 64:] -> [1, 64, 384, 64:]
-      [1, 64, 48@b, 64]@shared ->  [1, 16@t, 48@b, 64]@shared
-    */
-    tensor<float> v19({1, 64, 48, 16});
-    auto v18 = (*V16)({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16});
-    tdma_wait(ctx);
-    unary(v18, v19, unary_op_t::neg);
-    __tensor_copy_sync((*V16)({0, 0, 0, 64 + 16 * tid}, {1, 64, 48, 16}),
-                       (*V16)({0, 0, 0, 16 * tid}, {1, 64, 48, 16}));
-    __tensor_copy_sync((*V16)({0, 0, 0, 16 * tid}, {1, 64, 48, 16}),
-                       std::move(v19));
-
-    /*
-      [1,64,384,128] x [1,1,384,128] ->  [1,64,384,128]
-      [1, 64, 48@b, 32@t]@shared x [1, 1, 48@b, 32@t] -> [1, 64, 48@b, 32@t]
-    */
-    tensor<float> v23({1, 64, 48, 32});
-    auto v22 = (*V16)({0, 0, 0, 32 * tid}, {1, 64, 48, 32});
-    tdma_wait(ctx);
-    binary(v22, v12, v23, binary_op_t::mul);
-#if DUMP
-    {
-        tdma_store_async(
-            v22, (*ImmOutputs[5])({0, 0, 48 * bid, 32 * tid}, {1, 64, 48, 32}));
-    }
-#endif
-
-    tensor<float> v24({1, 64, 48, 32});
-    /*
-      [1,64,384,128] + [1,1,384,128] ->  [1,64,384,128]
-      [1, 64, 48@b, 32@t] + [1, 1, 48@b, 32@t] -> [1, 64, 48@b, 32@t]
-    */
-    binary(v17, v23, v24, binary_op_t::add);
-
-    tensor<float> v25({1, 64, 32, 48});
-    transpose(v24, v25, dims_t({0, 1, 3, 2}));
-
-    /*
-      [1, 64, 384, 128] @ [1, 64, 128, 384] -> [1, 64, 384, 384]
-      [1, 64, 48@b, 32@t] @ [1, 64, 32@t, 384] -> [1, 64, 48@b, 384]@shared
-    */
-    tdma_store_async(v25, V25({0, 0, 32 * tid, 48 * bid}, {1, 64, 32, 48}));
-    tdma_all_wait(ctx); /* for store */
-    tensor<float> v25_1({1, 64, 32, 384});
-    tdma_load_async(v25_1, V25({0, 0, 32 * tid, 0}, {1, 64, 32, 384}));
-    tdma_all_wait(ctx);
-    tensor_block_mma_sync(v14, v25_1, *V26, false, ctx);
-
-    /* [1, 64, 384, 384]           / 11.31370  -> [1, 64, 384, 384]
-       [1, 16@t, 48@b, 384]@shared   / 11.31370 -> [1, 16@t, 48@b, 384]
-    */
-    auto v26 = (*V26)({0, 16 * tid, 0, 0}, {1, 16, 48, 384});
-    tensor<float> v27({1, 16, 48, 384});
-    auto v26_c = tensor<float>({1, 1, 1, 1});
-    tdma_fill_async(v26_c, 11.313708f);
-    binary(v26, v26_c, v27, binary_op_t::div);
-
-    /* [1, 64, 384, 384] + [1,1,384,384] -> [1, 64, 384, 384]
-       [1, 16@t, 48@b, 384] + [1, 1, 48@b, 384] -> [1, 16@t, 48@b,
-       384]
-    */
-    auto &v28 = v27;
-    binary(v27, attn_mask, v28, binary_op_t::add);
-#if DUMP
-    {
-        tdma_store_async(v28, (*ImmOutputs[6])({0, 16 * tid, 48 * bid, 0},
-                                               {1, 16, 48, 384}));
-    }
-#endif
-    /*
-      [1, 64, 384, 384] -> [1, 64, 384, 384]
-      [1, 16@t, 48@b, 384]@shared -> [1, 16@t, 48@b, 384]
-    */
-    tensor<float> v29({1, 16, 48, 384}); //[1, 64, 384, 384] [1, 8@b, 96@t, 384]
-    softmax(v28, v29, 3);
-
-    /*
-      [1,1,384,8192] @ [64, 8192, 128] -> [1,64,384,128]
-      [1, 1, 48@b, 2048@t] @ [64, 2048@t, 128] -> [1, 64, 48@b, 128]@shared
-    */
-    auto &v30 = v1;
-    tensor_block_mma_sync(v30, *v31_w, *V31, false, ctx);
-
-    /* need resplit V */
-    auto v31 = (*V31)({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
-    tdma_store_async(v31, GV31({0, 16 * tid, 48 * bid, 0}, {1, 16, 48, 128}));
-
-    /*
-      [1,64,384,384] @ [1,64,384,128] ->  [1,64,384,128]
-      [1, 16@t, 48@b, 384] @ [1, 16@t, 384, 128] -> [1, 16@t, 48@b, 128]@shared
-    */
-    tdma_all_wait(ctx);
-    tensor<float> v31_resplit({1, 16, 384, 128});
-    tdma_load_async(v31_resplit, GV31({0, 16 * tid, 0, 0}, {1, 16, 384, 128}));
-    auto v32 = (*V32)({0, 16 * tid, 0, 0}, {1, 16, 48, 128});
-    matmul(v29, v31_resplit, v32);
-    tdma_wait(ctx);
-#if DUMP
-    {
-        tdma_store_async(v32, (*ImmOutputs[7])({0, 16 * tid, 48 * bid, 0},
-                                               {1, 16, 48, 128}));
-    }
-#endif
-    // #if 0
-
-    /*
-      [1, 64, 384, 128] -> [1, 384, 64, 128]
-      [1, 64, 48@b, 128]@shared -> [1, 48@b, 64, 128]@shared
-     */
-    auto v33 = (*V33)({0, 0, 16 * tid, 0}, {1, 48, 16, 128});
-    transpose(v32, v33, {0, 2, 1, 3});
-
-    /*
-    [1, 384, 8192] @ [8192, 8192] -> [1,384,8192]
-    [1, 48@b, 2048@t]@shared @ [2048@t, 8192] -> [1, 48@b, 8192]@shared
-     */
-    auto V34 = view(*V33, {1, 48, 8192});
-    auto v34 = V34({0, 0, 2048 * tid}, {1, 48, 2048});
-    tdma_wait(ctx);
-    tensor_block_mma_sync(v34, *v35_w, *V35, false, ctx);
-#if DUMP
-    {
-        auto v35 = (*V35)({0, 0, tid * 2048}, {1, 48, 2048});
-        tdma_store_async(
-            v35, (*ImmOutputs[8])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}));
-    }
-#endif
-
-    /*
-    [1,384,8192] +  [1,384,8192]  -> [1,384,8192]
-    [1, 48@b, 2048@tid]@shared +  [1, 48@b, 2048@tid] -> [1, 48@b, 2048@tid]
-     */
-    tdma_load_async(var_5, Hidden_in({0, bid * 48, tid * 2048}, {1, 48, 2048}));
-    auto v35 = (*V35)({0, 0, tid * 2048}, {1, 48, 2048});
-    tensor<float> v36({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t] */
-    binary(var_5, v35, v36, binary_op_t::add);
-
-    tensor<float> v37({1, 48, 2048}); /* [1, 384, 8192] [1, 48@b, 2048@t] */
-    {
-        tensor<float> v36_sum({1, 48});
-        tensor<float> v36_sum_sqr({1, 48});
-        reduce_sum_sqr(v36, v36_sum, v36_sum_sqr);
-        tdma_reduce_async(v36_sum, v36_sum, reduce_op_t::sum, ctx);
-        tdma_reduce_async(v36_sum_sqr, v36_sum_sqr, reduce_op_t::sum, ctx);
-        layernorm(v36, v36_sum, v36_sum_sqr, v37, 2, 8192, true);
-    }
-    /*
-      [1,384,8192] @ [8192, 22016] -> [1,384, 22016]
-      [1, 48@b, 2048@t] @ [2048@t, 22016] -> [1, 48@b, 22016]@shared
-    */
-    tensor_block_mma_sync(v37, *v38_w, *V38, false, ctx);
-#if DUMP
-    {
-        auto v38 = (*V38)({0, 0, 5504 * tid}, {1, 48, 5504});
-        tdma_store_async(
-            v38, (*ImmOutputs[9])({0, 48 * bid, 5504 * tid}, {1, 48, 5504}));
-    }
-#endif
-
-    /*
-      [1,384, 22016] -> [1,384, 22016]
-      [1, 48@b, 5504@t]@shared -> [1, 48@b, 5504@t]@shared
-    */
-    auto v39 = (*V38)({0, 0, 5504 * tid}, {1, 48, 5504});
-    unary(v39, v39, unary_op_t::swish);
-
-    /* [1, 384, 8192]    @ [8192, 22016] -> [1, 384, 22016]
-       [1, 48@b, 2048@t] @  [2048@t, 22016] -> [1, 48@b, 22016] @shared
-    */
-    tensor_block_mma_sync(v37, *v40_w, *V40, false, ctx);
-    /*
-    [1, 384, 22016] X  [1, 384, 22016] -> [1, 384, 22016]
-    [1, 48@b, 5504@t]@shared X [1,48@b,5504@t]@shared -> [1, 48@b, 5504@t]@local
-    */
-    tensor<float> v41({1, 48, 5504});
-    auto v40 = (*V40)({0, 0, 5504 * tid}, {1, 48, 5504});
-    binary(v39, v40, v41, binary_op_t::mul);
-
-    /*
-      [1, 384, 22016] @ [22016, 8192] -> [1, 384, 8192]
-      [1, 48@b, 5504@t] @ [5504@t, 8192] -> [1, 48@b, 8192] @shared
-    */
-    tensor_block_mma_sync(v41, *v42_w, *V42, false, ctx);
-
-    /*
-      [1, 384, 8192] + [1, 384, 8192] -> [1, 384, 8192]
-      [1, 48@b, 2048@t] + [1, 48@b, 2048@t] @shared -> [1, 48@b, 2048@t]
-    */
-    tensor<float> v43({1, 48, 2048});
-    auto v42 = (*V42)({0, 0, 2048 * tid}, {1, 48, 2048});
-    binary(v36, v42, v43, binary_op_t::add);
-    tdma_store_async(v43, Hidden_in({0, 48 * bid, 2048 * tid}, {1, 48, 2048}));
-#if DUMP
-    {
-        tdma_store_async(
-            v43, (*ImmOutputs[10])({0, 48 * bid, 2048 * tid}, {1, 48, 2048}));
-    }
-#endif
-}
diff --git a/modules/xpu/src/runtime/cmodel/tests/decoder_layer/main.cpp b/modules/xpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
deleted file mode 100644
index 9d36b8b9a5..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/decoder_layer/main.cpp
+++ /dev/null
@@ -1,352 +0,0 @@
-#include "cluster_def.h"
-#include <runtime_utils.h>
-
-#define DEFINE_TFUNC(b, t)                                                     \
-    void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(                                    \
-            *Hidden_in, *V0_gamma, *V0_beta, *V2_w, *V16_w, *V31_w, *V35_w,    \
-            *V3_data, *V11_data, *Attn_mask, *V38_w, *V40_w, *V42_w,           \
-            *Position_ids, *Output, *V25, *GV31, ImmOutputs);                  \
-        return arg;                                                            \
-    }
-
-#define DEFINE_BFUNC(b)                                                        \
-    DEFINE_TFUNC(b, 0)                                                         \
-    DEFINE_TFUNC(b, 1)                                                         \
-    DEFINE_TFUNC(b, 2)                                                         \
-    DEFINE_TFUNC(b, 3)
-
-static tensor<float, loc_t::device> *Hidden_in;      // ({1, 384, 8192})
-static tensor<float, loc_t::device> *V0_gamma;       // ({8192})
-static tensor<float, loc_t::device> *V0_beta;        // ({8192})
-static tensor<float, loc_t::device> *V2_w;           // ({64, 8192, 128})
-static tensor<float, loc_t::device> *V16_w;          // ({64, 8192, 128})
-static tensor<float, loc_t::device> *V31_w;          // ({64, 8192, 128})
-static tensor<float, loc_t::device> *V35_w;          // ({8192, 8192})
-static tensor<float, loc_t::device> *V3_data;        // ({384, 128})
-static tensor<float, loc_t::device> *V11_data;       // ({384, 128})
-static tensor<float, loc_t::device> *Attn_mask;      // ({1, 1, 384, 384})
-static tensor<float, loc_t::device> *V38_w;          // ({8192, 22016})
-static tensor<float, loc_t::device> *V40_w;          // ({8192, 22016})
-static tensor<float, loc_t::device> *V42_w;          // ({22016, 8192})
-static tensor<int64_t, loc_t::device> *Position_ids; // ({1, 384})
-static tensor<float, loc_t::device> *Output;         // ({1, 384, 8192})
-static tensor<float, loc_t::device> *V25;            // ({1, 64, 128, 384})
-static tensor<float, loc_t::device> *GV31;           // ({1, 64, 384, 128})
-
-constexpr int OutNum = 11;
-// static tensor<float, loc_t::device> ImmOutputs[OutNum] = {
-//     tensor<float, loc_t::device>({1, 384, 8192}),
-//     tensor<float, loc_t::device>({1, 64, 384, 128}),
-//     tensor<float, loc_t::device>({1, 64, 384, 128}),
-//     tensor<float, loc_t::device>({1, 64, 384, 128}),
-//     tensor<float, loc_t::device>({1, 384, 128}),
-//     tensor<float, loc_t::device>({1, 64, 384, 128}),
-//     tensor<float, loc_t::device>({1, 64, 384, 384}),
-//     tensor<float, loc_t::device>({1, 64, 384, 128}),
-//     tensor<float, loc_t::device>({1, 384, 8192}),
-//     tensor<float, loc_t::device>({1, 384, 22016}),
-//     tensor<float, loc_t::device>({1, 384, 8192}),
-// };
-static tensor<float, loc_t::device> *ImmOutputs[OutNum];
-
-DEFINE_BFUNC(0)
-DEFINE_BFUNC(1)
-DEFINE_BFUNC(2)
-DEFINE_BFUNC(3)
-DEFINE_BFUNC(4)
-DEFINE_BFUNC(5)
-DEFINE_BFUNC(6)
-DEFINE_BFUNC(7)
-
-#define MALLOC_GLOBAL(i, name, type, size, shape)                              \
-    auto g_##name = tensor<type, loc_t::device>(                               \
-        gsl::make_span((type *)inputs[i], size), shape);                       \
-    name = &g_##name;
-
-#define MALLOC_IMM(i, name, type, size, shape)                                 \
-    auto g_##i = tensor<type, loc_t::device>(                                  \
-        gsl::make_span((type *)inputs[i], size), shape);                       \
-    name = &g_##i;
-
-#define MALLOC_SHARED(name, b, type, size, shape)                              \
-    auto shared##b##name = tensor<type, loc_t::shared>(shape);                 \
-    block##b::shared::name = &shared##b##name;
-
-#define CLEAR_SHARED(i)                                                        \
-    tdma_fill_async<float>(*block##i::shared::V2, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V5, 0);                          \
-    tdma_fill_async<float>(*block##i::shared::V13, 0);                         \
-    tdma_fill_async<float>(*block##i::shared::V16, 0);                         \
-    tdma_fill_async<float>(*block##i::shared::V25, 0);                         \
-    tdma_fill_async<float>(*block##i::shared::V26, 0);                         \
-    tdma_fill_async<float>(*block##i::shared::V31, 0);                         \
-    tdma_fill_async<float>(*block##i::shared::V32, 0);                         \
-    tdma_fill_async<float>(*block##i::shared::V33, 0);                         \
-    tdma_fill_async<float>(*block##i::shared::V35, 0);                         \
-    tdma_fill_async<float>(*block##i::shared::V38, 0);                         \
-    tdma_fill_async<float>(*block##i::shared::V40, 0);                         \
-    tdma_fill_async<float>(*block##i::shared::V42, 0);
-
-int main() {}
-extern "C" {void __libc_csu_fini(){} void __libc_csu_init(){}}
-
-void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
-    global_hardware_init(hw_ctx_impl);
-    runtime_util = rt_util_mt;
-    nncase_mt = nncase_mt_impl;
-
-    MALLOC_IMM(15, ImmOutputs[0], float, (1 * 384 * 8192),
-               dims_t({1, 384, 8192}))
-    MALLOC_IMM(16, ImmOutputs[1], float, (1 * 64 * 384 * 128),
-               dims_t({1, 64, 384, 128}))
-    MALLOC_IMM(17, ImmOutputs[2], float, (1 * 64 * 384 * 128),
-               dims_t({1, 64, 384, 128}))
-    MALLOC_IMM(18, ImmOutputs[3], float, (1 * 64 * 384 * 128),
-               dims_t({1, 64, 384, 128}))
-    MALLOC_IMM(19, ImmOutputs[4], float, (1 * 384 * 128), dims_t({1, 384, 128}))
-    MALLOC_IMM(20, ImmOutputs[5], float, (1 * 64 * 384 * 128),
-               dims_t({1, 64, 384, 128}))
-    MALLOC_IMM(21, ImmOutputs[6], float, (1 * 64 * 384 * 384),
-               dims_t({1, 64, 384, 384}))
-    // v32
-    MALLOC_IMM(22, ImmOutputs[7], float, (1 * 64 * 384 * 128),
-               dims_t({1, 64, 384, 128}))
-    // v35
-    MALLOC_IMM(23, ImmOutputs[8], float, (1 * 384 * 8192),
-               dims_t({1, 384, 8192}))
-    // v38
-    MALLOC_IMM(24, ImmOutputs[9], float, (1 * 384 * 22016),
-               dims_t({1, 384, 22016}))
-
-    // v43
-    MALLOC_IMM(25, ImmOutputs[10], float, (1 * 384 * 8192),
-               dims_t({1, 384, 8192}))
-
-    MALLOC_GLOBAL(0, Hidden_in, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    MALLOC_GLOBAL(1, V0_gamma, float, (8192), dims_t({8192}))
-    MALLOC_GLOBAL(2, V0_beta, float, (8192), dims_t({8192}))
-    MALLOC_GLOBAL(3, V2_w, float, (64 * 8192 * 128), dims_t({64, 8192, 128}))
-    MALLOC_GLOBAL(4, V16_w, float, (64 * 8192 * 128), dims_t({64, 8192, 128}))
-    MALLOC_GLOBAL(5, V31_w, float, (64 * 8192 * 128), dims_t({64, 8192, 128}))
-    MALLOC_GLOBAL(6, V35_w, float, (8192 * 8192), dims_t({8192, 8192}))
-    MALLOC_GLOBAL(7, V3_data, float, (384 * 128), dims_t({384, 128}))
-    MALLOC_GLOBAL(8, V11_data, float, (384 * 128), dims_t({384, 128}))
-    MALLOC_GLOBAL(9, Attn_mask, float, (1 * 1 * 384 * 384),
-                  dims_t({1, 1, 384, 384}))
-    MALLOC_GLOBAL(10, V38_w, float, (8192 * 22016), dims_t({8192, 22016}))
-    MALLOC_GLOBAL(11, V40_w, float, (8192 * 22016), dims_t({8192, 22016}))
-    MALLOC_GLOBAL(12, V42_w, float, (22016 * 8192), dims_t({22016, 8192}))
-    MALLOC_GLOBAL(13, Position_ids, int64_t, (1 * 384), dims_t({1, 384}))
-    MALLOC_GLOBAL(14, Output, float, (1 * 384 * 8192), dims_t({1, 384, 8192}))
-    auto V25_tmp = tensor<float, loc_t::device>(dims_t({1, 64, 128, 384}));
-    auto GV31_tmp = tensor<float, loc_t::device>(dims_t({1, 64, 384, 128}));
-    V25 = &V25_tmp;
-    GV31 = &GV31_tmp;
-
-    MALLOC_SHARED(V2, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V2, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V2, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V2, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V2, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V2, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V2, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V2, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-
-    MALLOC_SHARED(V5, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V5, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V5, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V5, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V5, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V5, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V5, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V5, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-
-    MALLOC_SHARED(V13, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V13, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V13, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V13, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V13, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V13, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V13, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V13, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-
-    MALLOC_SHARED(V16, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V16, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V16, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V16, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V16, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V16, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V16, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V16, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-
-    MALLOC_SHARED(V25, 0, float, (1 * 64 * 128 * 384),
-                  dims_t({1, 64, 128, 384}))
-    MALLOC_SHARED(V25, 1, float, (1 * 64 * 128 * 384),
-                  dims_t({1, 64, 128, 384}))
-    MALLOC_SHARED(V25, 2, float, (1 * 64 * 128 * 384),
-                  dims_t({1, 64, 128, 384}))
-    MALLOC_SHARED(V25, 3, float, (1 * 64 * 128 * 384),
-                  dims_t({1, 64, 128, 384}))
-    MALLOC_SHARED(V25, 4, float, (1 * 64 * 128 * 384),
-                  dims_t({1, 64, 128, 384}))
-    MALLOC_SHARED(V25, 5, float, (1 * 64 * 128 * 384),
-                  dims_t({1, 64, 128, 384}))
-    MALLOC_SHARED(V25, 6, float, (1 * 64 * 128 * 384),
-                  dims_t({1, 64, 128, 384}))
-    MALLOC_SHARED(V25, 7, float, (1 * 64 * 128 * 384),
-                  dims_t({1, 64, 128, 384}))
-
-    MALLOC_SHARED(V26, 0, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
-    MALLOC_SHARED(V26, 1, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
-    MALLOC_SHARED(V26, 2, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
-    MALLOC_SHARED(V26, 3, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
-    MALLOC_SHARED(V26, 4, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
-    MALLOC_SHARED(V26, 5, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
-    MALLOC_SHARED(V26, 6, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
-    MALLOC_SHARED(V26, 7, float, (1 * 64 * 48 * 384), dims_t({1, 64, 48, 384}))
-
-    MALLOC_SHARED(V31, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V31, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V31, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V31, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V31, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V31, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V31, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V31, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-
-    MALLOC_SHARED(V32, 0, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V32, 1, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V32, 2, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V32, 3, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V32, 4, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V32, 5, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V32, 6, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-    MALLOC_SHARED(V32, 7, float, (1 * 64 * 48 * 128), dims_t({1, 64, 48, 128}))
-
-    MALLOC_SHARED(V33, 0, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
-    MALLOC_SHARED(V33, 1, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
-    MALLOC_SHARED(V33, 2, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
-    MALLOC_SHARED(V33, 3, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
-    MALLOC_SHARED(V33, 4, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
-    MALLOC_SHARED(V33, 5, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
-    MALLOC_SHARED(V33, 6, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
-    MALLOC_SHARED(V33, 7, float, (1 * 48 * 64 * 128), dims_t({1, 48, 64, 128}))
-
-    MALLOC_SHARED(V35, 0, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V35, 1, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V35, 2, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V35, 3, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V35, 4, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V35, 5, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V35, 6, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V35, 7, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-
-    MALLOC_SHARED(V38, 0, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V38, 1, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V38, 2, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V38, 3, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V38, 4, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V38, 5, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V38, 6, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V38, 7, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-
-    MALLOC_SHARED(V40, 0, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V40, 1, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V40, 2, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V40, 3, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V40, 4, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V40, 5, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V40, 6, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-    MALLOC_SHARED(V40, 7, float, (1 * 48 * 22016), dims_t({1, 48, 22016}))
-
-    MALLOC_SHARED(V42, 0, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V42, 1, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V42, 2, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V42, 3, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V42, 4, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V42, 5, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V42, 6, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-    MALLOC_SHARED(V42, 7, float, (1 * 48 * 8192), dims_t({1, 48, 8192}))
-
-    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
-
-    runtime_util->create_thread(t_0_0, NULL, f_0_0);
-    runtime_util->create_thread(t_0_1, NULL, f_0_1);
-    runtime_util->create_thread(t_0_2, NULL, f_0_2);
-    runtime_util->create_thread(t_0_3, NULL, f_0_3);
-    runtime_util->create_thread(t_1_0, NULL, f_1_0);
-    runtime_util->create_thread(t_1_1, NULL, f_1_1);
-    runtime_util->create_thread(t_1_2, NULL, f_1_2);
-    runtime_util->create_thread(t_1_3, NULL, f_1_3);
-    runtime_util->create_thread(t_2_0, NULL, f_2_0);
-    runtime_util->create_thread(t_2_1, NULL, f_2_1);
-    runtime_util->create_thread(t_2_2, NULL, f_2_2);
-    runtime_util->create_thread(t_2_3, NULL, f_2_3);
-    runtime_util->create_thread(t_3_0, NULL, f_3_0);
-    runtime_util->create_thread(t_3_1, NULL, f_3_1);
-    runtime_util->create_thread(t_3_2, NULL, f_3_2);
-    runtime_util->create_thread(t_3_3, NULL, f_3_3);
-    runtime_util->create_thread(t_4_0, NULL, f_4_0);
-    runtime_util->create_thread(t_4_1, NULL, f_4_1);
-    runtime_util->create_thread(t_4_2, NULL, f_4_2);
-    runtime_util->create_thread(t_4_3, NULL, f_4_3);
-    runtime_util->create_thread(t_5_0, NULL, f_5_0);
-    runtime_util->create_thread(t_5_1, NULL, f_5_1);
-    runtime_util->create_thread(t_5_2, NULL, f_5_2);
-    runtime_util->create_thread(t_5_3, NULL, f_5_3);
-    runtime_util->create_thread(t_6_0, NULL, f_6_0);
-    runtime_util->create_thread(t_6_1, NULL, f_6_1);
-    runtime_util->create_thread(t_6_2, NULL, f_6_2);
-    runtime_util->create_thread(t_6_3, NULL, f_6_3);
-    runtime_util->create_thread(t_7_0, NULL, f_7_0);
-    runtime_util->create_thread(t_7_1, NULL, f_7_1);
-    runtime_util->create_thread(t_7_2, NULL, f_7_2);
-    runtime_util->create_thread(t_7_3, NULL, f_7_3);
-
-    runtime_util->join_thread(t_0_0);
-    runtime_util->join_thread(t_0_1);
-    runtime_util->join_thread(t_0_2);
-    runtime_util->join_thread(t_0_3);
-    runtime_util->join_thread(t_1_0);
-    runtime_util->join_thread(t_1_1);
-    runtime_util->join_thread(t_1_2);
-    runtime_util->join_thread(t_1_3);
-    runtime_util->join_thread(t_2_0);
-    runtime_util->join_thread(t_2_1);
-    runtime_util->join_thread(t_2_2);
-    runtime_util->join_thread(t_2_3);
-    runtime_util->join_thread(t_3_0);
-    runtime_util->join_thread(t_3_1);
-    runtime_util->join_thread(t_3_2);
-    runtime_util->join_thread(t_3_3);
-    runtime_util->join_thread(t_4_0);
-    runtime_util->join_thread(t_4_1);
-    runtime_util->join_thread(t_4_2);
-    runtime_util->join_thread(t_4_3);
-    runtime_util->join_thread(t_5_0);
-    runtime_util->join_thread(t_5_1);
-    runtime_util->join_thread(t_5_2);
-    runtime_util->join_thread(t_5_3);
-    runtime_util->join_thread(t_6_0);
-    runtime_util->join_thread(t_6_1);
-    runtime_util->join_thread(t_6_2);
-    runtime_util->join_thread(t_6_3);
-    runtime_util->join_thread(t_7_0);
-    runtime_util->join_thread(t_7_1);
-    runtime_util->join_thread(t_7_2);
-    runtime_util->join_thread(t_7_3);
-
-    CLEAR_SHARED(0);
-    CLEAR_SHARED(1);
-    CLEAR_SHARED(2);
-    CLEAR_SHARED(3);
-    CLEAR_SHARED(4);
-    CLEAR_SHARED(5);
-    CLEAR_SHARED(6);
-    CLEAR_SHARED(7);
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
deleted file mode 100644
index 343b6c2b4f..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/decoder_layer/shared_def.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <tdma.h>
-
-namespace shared {
-static tensor<float, loc_t::shared> *V2; // [1, 64, 384, 128] [1, 64, 48@b, 128]
-
-static tensor<float, loc_t::shared> *V5; // {1, 64, 48, 128}
-
-static tensor<float, loc_t::shared> *V13; // {1, 64, 48, 128}
-
-static tensor<float, loc_t::shared> *V16; // [1, 64, 48, 128] [1, 64, 48@b, 128]
-
-static tensor<float, loc_t::shared>
-    *V25; // [1, 64, 384, 128] [1, 8@b, 384, 384]
-static tensor<float, loc_t::shared>
-    *V26; // [1, 64, 384, 128] [1, 64, 48@b, 384]
-
-static tensor<float, loc_t::shared>
-    *V31; // [1, 64, 384, 128] [1, 64, 48@b, 128]
-
-static tensor<float, loc_t::shared>
-    *V32; // [1, 64, 384, 128] [1, 64, 48@b, 128]
-static tensor<float, loc_t::shared>
-    *V33; // [1, 384, 64, 128] [1, 48@b, 64, 128]
-
-static tensor<float, loc_t::shared> *V35; // [1, 384, 8192]
-
-static tensor<float, loc_t::shared> *V38; // [1, 384, 22016] [1, 48@b, 22016]
-
-static tensor<float, loc_t::shared> *V40; // [1, 384, 8192] [1, 48@b, 22016]
-
-static tensor<float, loc_t::shared> *V42; // [1, 384, 8192] [1, 48@b, 8192]
-} // namespace shared
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/demo1/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/demo1/cluster_def.h
deleted file mode 100644
index 8fd5d84ed7..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/demo1/cluster_def.h
+++ /dev/null
@@ -1,171 +0,0 @@
-#pragma once
-#include <hardware_context.h>
-#include <tdma.h>
-
-namespace block0 {
-#include "shared_def.h"
-constexpr size_t bid = 0;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block0
-
-namespace block1 {
-#include "shared_def.h"
-constexpr size_t bid = 1;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block1
-
-namespace block2 {
-#include "shared_def.h"
-constexpr size_t bid = 2;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block2
-
-namespace block3 {
-#include "shared_def.h"
-constexpr size_t bid = 3;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block3
-
-namespace block4 {
-#include "shared_def.h"
-constexpr size_t bid = 4;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block4
-
-namespace block5 {
-#include "shared_def.h"
-constexpr size_t bid = 5;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block5
-
-namespace block6 {
-#include "shared_def.h"
-constexpr size_t bid = 6;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block6
-
-namespace block7 {
-#include "shared_def.h"
-constexpr size_t bid = 7;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block7
diff --git a/modules/xpu/src/runtime/cmodel/tests/demo1/golden.py b/modules/xpu/src/runtime/cmodel/tests/demo1/golden.py
deleted file mode 100644
index 70ed08a2f2..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/demo1/golden.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import numpy as np
-from torch import nn
-import torch
-    
-X = np.random.rand(384, 8192).astype(np.float32)
-WK = np.random.rand(64, 8192, 128).astype(np.float32) * 5 - 1
-
-K = X @ WK
-
-Sum =np.sum(np.sum(WK, axis=0, keepdims=False), axis=0,keepdims=False)
-
-X.tofile("X.bin")
-WK.tofile("WK.bin")
-K.tofile("K.bin")
-Sum.tofile("Sum.bin")
-
-# Activate module
-Norm = nn.LayerNorm([8192], elementwise_affine=False)(torch.from_numpy( X))
-Norm.detach().numpy().tofile('Norm.bin')
-
-RSums =[]
-for t in range(32):
-      RSums.append(X[:,t*256:(t+1)*256].sum(1,keepdims=False))
-RSum =  np.sum(np.array(RSums),axis=0,keepdims=False)
-      
-RSum.tofile('RSum.bin')
-
-RSumSqrs =[]
-for t in range(32):
-      RSumSqrs.append(np.square(X[:,t*256:(t+1)*256]).sum(1,keepdims=False))
-RSumSqr =  np.sum(np.array(RSumSqrs),axis=0,keepdims=False)
-      
-RSumSqr.tofile('RSumSqr.bin')
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/demo1/kernel.h b/modules/xpu/src/runtime/cmodel/tests/demo1/kernel.h
deleted file mode 100644
index 452a98cd90..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/demo1/kernel.h
+++ /dev/null
@@ -1,152 +0,0 @@
-// llama 65B
-// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
-// 1 chips, 8 blocks per chip, 4 threads per block
-
-// tensor<float, loc_t::shared> X({384, 8192});
-// tensor<float, loc_t::shared> kh({8, 384, 128}), vh({8, 384, 128}); //
-// [8, 384, 128] tensor<float, loc_t::shared> qkh({8, 384, 384});    //
-// [8, 384, 384] tensor<float, loc_t::shared> qkh({8, 384, 384});    //
-// [8, 384, 384]
-#include "thread_context.h"
-using namespace shared;
-
-static bool w_loaded = false;
-// static tensor<float> wqh({8, 2048, 128});
-static tensor<float> wkh({8, 2048, 128});
-// static tensor<float> wvh({8, 2048, 128}); // [8, 2048, 128]
-// static tensor<float> wfc1ih({1024, 2752});
-// static tensor<float> wfc2ih({1024, 2752}); // [1024, 2752]
-// static tensor<float> yih({96, 1024});
-
-// 8 head per block
-// 2048 w-len per thread
-void stage1_kernel(
-    // tensor<float, loc_t::device> &WQ,  /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &WK,      /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &K,       /* 64, 384, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &Sum,     /* 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &RSum,    /* 384 */
-    [[maybe_unused]] tensor<float, loc_t::device> &RSumSqr, /* 384 */
-    [[maybe_unused]] tensor<float, loc_t::device> &Norm     /* 384, 8192 */
-    // [[maybe_unused]] tensor<float, loc_t::device> &Norm /* 384,8192 */
-    //  tensor<float, loc_t::device> &WV,  /* 64, 8192, 128 */
-    //  tensor<float, loc_t::device> &WFC1 /* 384, 8192*/
-) {
-    thread_context ctx(bid, tid);
-    // 1. Get xi
-    auto xi = X({0, tid * 2048}, {384, 2048}); // [384, 2048]
-
-    // 2. load wqh wkh wvh
-    if (!w_loaded) {
-        // tdma_load_async(wqh, WQ({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
-        tdma_load_async(wkh, WK({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
-        // tdma_load_async(wvh, WV({bid * 8, tid * 2048, 0}, {8, 2048, 128}));
-        // tdma_load_async(wfc1ih, WFC1({bid * 1024, tid * 8192}, {1024,
-        // 8192})); tdma_wait(); // 等待 x, wqh, wkh, wvh ready
-        w_loaded = true;
-    }
-
-    // 3. compute k, v
-    // set_sched_strategy(
-    //     sched_strategy_t::pin_block_tensor); // 仅在 block 内调度线程的
-    //     tensor
-    //                                          // 指令
-
-    // tensor_block_mma_sync(xi, wkh, kh, false,
-    //                       ctx); // [384, 2048] x [8, 2048, 64] = [8, 384,
-    //                       128]
-
-    // if (tid == 0) {
-    //     tdma_store_async(kh, K({bid * 8, 0, 0}, {8, 384, 128}), ctx);
-    // }
-    // tdma_wait(ctx);
-
-    // tensor<float> sum({128});
-    // tensor_reduce_sync(wkh, sum, reduce_op_t::sum, 0.0f, dims_t({0, 1}),
-    // false); tdma_all_reduce_async(sum, sum, reduce_op_t::sum, dims_t({0}),
-    // ctx);
-
-    // if (bid == 0 && tid == 0) {
-    //     tdma_store_async(sum, std::move(Sum), ctx);
-    // }
-
-    // X [384,8192] => separate to bid , tid
-    tensor<float> xj({384, 256});
-    __tensor_copy_sync(std::move(xj),
-                       X({0, (bid * CORES + tid) * 256}, {384, 256}));
-    tensor<float> r_sum({384});
-    tensor<float> r_sum_sqr({384});
-    reduce_sum_sqr(xj, r_sum, r_sum_sqr);
-    tdma_all_reduce_async(r_sum, r_sum, reduce_op_t::sum,
-                          reduce_strategy_t::all, ctx);
-    tdma_all_reduce_async(r_sum_sqr, r_sum_sqr, reduce_op_t::sum,
-                          reduce_strategy_t::all, ctx);
-    if (bid == 0 && tid == 0) {
-        tdma_store_async(r_sum, std::move(RSum), ctx);
-        tdma_store_async(r_sum_sqr, std::move(RSumSqr), ctx);
-    }
-
-    tensor<float> gamma({256});
-    tdma_fill_async(gamma, 1.0f);
-    tensor<float> beta({256});
-    tdma_fill_async(beta, 0.0f);
-    layernorm(xj, r_sum, r_sum_sqr, xj, gamma, beta, 1e-5f, 1, 8192);
-    tdma_store_async(xj, Norm({0, (bid * CORES + tid) * 256}, {384, 256}), ctx);
-
-    // tensor_sum_sqr(xj, r_sum, r_sum_sqr);
-
-    // tensor<float> layer_sum({8, 2048});
-    // tensor<float> layer_sum_sqr({8, 2048});
-
-    // vh = tensor_block_mma_sync(
-    //     xi, wvh); // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
-
-    // // 4. compute qk
-    // tensor<float> qih({8, 384, 128});
-    // qih = tensor_mma_sync(
-    //     xi, wqh); // [384, 2048] x [8, 2048, 128] = [8, 384, 128]
-    // qkh = tensor_block_mma_sync(
-    //     qih, kh.T); // [8, 384, 128] x [8, 128, 384] = [8, 384, 384]
-
-    // set_sched_strategy(sched_strategy_t::normal);
-}
-
-// // 8 head per block
-// // 96 seq-len per thread
-// void stage2_kernel() {
-//     // 5. compute softmax
-//     auto qkhi = qkh({bid * 8, tid * 96, 0}, {8, 96, 384});
-
-//     tensor<float, 8, 96, 384> sih;
-//     sih = softmax(qkhi, 2);
-
-//     // 6. compute y
-//     tensor<float, 8, 96, 128> yihT;
-//     yihT = __tensor_mma_sync(sih,
-//                              vh); // [8, 96, 384] x [8, 384, 128] = [8, 96,
-//                              128]
-//     // 下面的 transpose 可以在计算 yih 的过程中通过指定输出 stride
-//     // 无代价地做到。
-//     yih = reshape(transpose(yihT, {1, 0, 2}) /* [96, 8, 128] */,
-//                   {96, 1024}); // [96, 1024]
-
-//     // 7. Add and sum & sqr
-//     tensor<float, 96> sum, sum_sqr;
-//     auto xi = X({tid * 96, bid * 1024}, {96, 1024}); // [96, 1024]
-//     yih = add_and_sum_sqr(yih, xi, sum, sum_sqr);
-//     __tdma_all_reduce_async(sum, sum_sqr,
-//                             reduce_op_t::SUM); // All blocks & threads reduce
-//     __tdma_wait();
-
-//     // 8. compute LayerNorm
-//     yih = layer_norm(yih, sum, sum_sqr); // [96, 1024]
-// }
-
-// //
-// void stage3_kernel(tensor<float> &WFC1, tensor<float> &WFC2) {
-//     // 9. fc1
-//     tensor<float> fc1ih({96, 2752});
-//     fc1ih =
-//         __tensor_mma_sync(yih, fc1ih); // [96, 1024] x [1024, 8192] = [96,
-//         8192]
-// }
diff --git a/modules/xpu/src/runtime/cmodel/tests/demo1/main.cpp b/modules/xpu/src/runtime/cmodel/tests/demo1/main.cpp
deleted file mode 100644
index 58294d2de0..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/demo1/main.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-#include "cluster_def.h"
-#include <io_utils.h>
-#include <runtime_utils.h>
-// #include <pthread.h>
-
-#define DEFINE_TFUNC(b, t)                                                     \
-    void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(WK, K, Sum, RSum, RSumSqr, Norm);   \
-        return arg;                                                            \
-    }
-
-#define DEFINE_BFUNC(b)                                                        \
-    DEFINE_TFUNC(b, 0)                                                         \
-    DEFINE_TFUNC(b, 1)                                                         \
-    DEFINE_TFUNC(b, 2)                                                         \
-    DEFINE_TFUNC(b, 3)
-
-tensor<float, loc_t::device> WK({64, 8192, 128});
-tensor<float, loc_t::device> K({64, 384, 128});
-tensor<float, loc_t::device> Norm({384, 8192});
-tensor<float, loc_t::device> RSum({384});
-tensor<float, loc_t::device> RSumSqr({384});
-tensor<float, loc_t::device> Sum({128});
-
-DEFINE_BFUNC(0)
-DEFINE_BFUNC(1)
-DEFINE_BFUNC(2)
-DEFINE_BFUNC(3)
-DEFINE_BFUNC(4)
-DEFINE_BFUNC(5)
-DEFINE_BFUNC(6)
-DEFINE_BFUNC(7)
-
-/**
- * @brief demo1 X.bin WK.bin K.bin Sum.bin Norm.bin
- *
- * @param argc
- * @param argv
- * @return int
- */
-int main([[maybe_unused]] int argc, char **argv) {
-    assert(argc == 8);
-    spdlog::set_level(spdlog::level::debug);
-    global_hardware_init();
-
-    /* fill tensor */
-    auto src_X = read_file(std::string(argv[1]));
-    auto src_WK = read_file(std::string(argv[2]));
-    auto src_K = read_file(std::string(argv[3]));
-    auto src_Sum = read_file(std::string(argv[4]));
-    auto src_RSum = read_file(std::string(argv[5]));
-    auto src_RSumSqr = read_file(std::string(argv[6]));
-    auto src_Norm = read_file(std::string(argv[7]));
-    span_copy(WK.data(), gsl::make_span(src_WK).as_span<float>());
-    span_copy(block0::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block1::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block2::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block3::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block4::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block5::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block6::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block7::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-
-    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
-
-    pthread_create(&t_0_0, NULL, f_0_0, NULL);
-    pthread_create(&t_0_1, NULL, f_0_1, NULL);
-    pthread_create(&t_0_2, NULL, f_0_2, NULL);
-    pthread_create(&t_0_3, NULL, f_0_3, NULL);
-    pthread_create(&t_1_0, NULL, f_1_0, NULL);
-    pthread_create(&t_1_1, NULL, f_1_1, NULL);
-    pthread_create(&t_1_2, NULL, f_1_2, NULL);
-    pthread_create(&t_1_3, NULL, f_1_3, NULL);
-    pthread_create(&t_2_0, NULL, f_2_0, NULL);
-    pthread_create(&t_2_1, NULL, f_2_1, NULL);
-    pthread_create(&t_2_2, NULL, f_2_2, NULL);
-    pthread_create(&t_2_3, NULL, f_2_3, NULL);
-    pthread_create(&t_3_0, NULL, f_3_0, NULL);
-    pthread_create(&t_3_1, NULL, f_3_1, NULL);
-    pthread_create(&t_3_2, NULL, f_3_2, NULL);
-    pthread_create(&t_3_3, NULL, f_3_3, NULL);
-    pthread_create(&t_4_0, NULL, f_4_0, NULL);
-    pthread_create(&t_4_1, NULL, f_4_1, NULL);
-    pthread_create(&t_4_2, NULL, f_4_2, NULL);
-    pthread_create(&t_4_3, NULL, f_4_3, NULL);
-    pthread_create(&t_5_0, NULL, f_5_0, NULL);
-    pthread_create(&t_5_1, NULL, f_5_1, NULL);
-    pthread_create(&t_5_2, NULL, f_5_2, NULL);
-    pthread_create(&t_5_3, NULL, f_5_3, NULL);
-    pthread_create(&t_6_0, NULL, f_6_0, NULL);
-    pthread_create(&t_6_1, NULL, f_6_1, NULL);
-    pthread_create(&t_6_2, NULL, f_6_2, NULL);
-    pthread_create(&t_6_3, NULL, f_6_3, NULL);
-    pthread_create(&t_7_0, NULL, f_7_0, NULL);
-    pthread_create(&t_7_1, NULL, f_7_1, NULL);
-    pthread_create(&t_7_2, NULL, f_7_2, NULL);
-    pthread_create(&t_7_3, NULL, f_7_3, NULL);
-
-    pthread_join(t_0_0, NULL);
-    pthread_join(t_0_1, NULL);
-    pthread_join(t_0_2, NULL);
-    pthread_join(t_0_3, NULL);
-    pthread_join(t_1_0, NULL);
-    pthread_join(t_1_1, NULL);
-    pthread_join(t_1_2, NULL);
-    pthread_join(t_1_3, NULL);
-    pthread_join(t_2_0, NULL);
-    pthread_join(t_2_1, NULL);
-    pthread_join(t_2_2, NULL);
-    pthread_join(t_2_3, NULL);
-    pthread_join(t_3_0, NULL);
-    pthread_join(t_3_1, NULL);
-    pthread_join(t_3_2, NULL);
-    pthread_join(t_3_3, NULL);
-    pthread_join(t_4_0, NULL);
-    pthread_join(t_4_1, NULL);
-    pthread_join(t_4_2, NULL);
-    pthread_join(t_4_3, NULL);
-    pthread_join(t_5_0, NULL);
-    pthread_join(t_5_1, NULL);
-    pthread_join(t_5_2, NULL);
-    pthread_join(t_5_3, NULL);
-    pthread_join(t_6_0, NULL);
-    pthread_join(t_6_1, NULL);
-    pthread_join(t_6_2, NULL);
-    pthread_join(t_6_3, NULL);
-    pthread_join(t_7_0, NULL);
-    pthread_join(t_7_1, NULL);
-    pthread_join(t_7_2, NULL);
-    pthread_join(t_7_3, NULL);
-
-    auto cos =
-        cosine(K.data().begin(), gsl::make_span(src_K).as_span<float>().begin(),
-               K.data().size());
-    printf("K cosine %f\n", cos);
-
-    cos = cosine(Sum.data().begin(),
-                 gsl::make_span(src_Sum).as_span<float>().begin(),
-                 Sum.data().size());
-    printf("Sum cosine %f\n", cos);
-
-    cos = cosine(RSum.data().begin(),
-                 gsl::make_span(src_RSum).as_span<float>().begin(),
-                 Sum.data().size());
-    printf("src_RSum cosine %f\n", cos);
-
-    cos = cosine(RSumSqr.data().begin(),
-                 gsl::make_span(src_RSumSqr).as_span<float>().begin(),
-                 Sum.data().size());
-    printf("RSumSqr cosine %f\n", cos);
-
-    cos = cosine(Norm.data().begin(),
-                 gsl::make_span(src_Norm).as_span<float>().begin(),
-                 Sum.data().size());
-    printf("Norm cosine %f\n", cos);
-    return 0;
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/demo1/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/demo1/shared_def.h
deleted file mode 100644
index 9635ff25ee..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/demo1/shared_def.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <tdma.h>
-
-namespace shared {
-static tensor<float, loc_t::shared> X({384, 8192});
-static tensor<float, loc_t::shared> kh({8, 384, 128});
-// vh({8, 384, 128});                                         // [8, 384, 128]
-// static tensor<float, tensor_loc_t::shared> qkh({8, 384, 384}); // [8, 384,
-// 384]
-} // namespace shared
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/demo2/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/demo2/cluster_def.h
deleted file mode 100644
index 8fd5d84ed7..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/demo2/cluster_def.h
+++ /dev/null
@@ -1,171 +0,0 @@
-#pragma once
-#include <hardware_context.h>
-#include <tdma.h>
-
-namespace block0 {
-#include "shared_def.h"
-constexpr size_t bid = 0;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block0
-
-namespace block1 {
-#include "shared_def.h"
-constexpr size_t bid = 1;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block1
-
-namespace block2 {
-#include "shared_def.h"
-constexpr size_t bid = 2;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block2
-
-namespace block3 {
-#include "shared_def.h"
-constexpr size_t bid = 3;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block3
-
-namespace block4 {
-#include "shared_def.h"
-constexpr size_t bid = 4;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block4
-
-namespace block5 {
-#include "shared_def.h"
-constexpr size_t bid = 5;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block5
-
-namespace block6 {
-#include "shared_def.h"
-constexpr size_t bid = 6;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block6
-
-namespace block7 {
-#include "shared_def.h"
-constexpr size_t bid = 7;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block7
diff --git a/modules/xpu/src/runtime/cmodel/tests/demo2/golden.py b/modules/xpu/src/runtime/cmodel/tests/demo2/golden.py
deleted file mode 100644
index 724e0cae27..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/demo2/golden.py
+++ /dev/null
@@ -1,39 +0,0 @@
-import numpy as np
-from torch import nn
-import torch
-from scipy.special import softmax
-
-
-X = np.random.rand(384, 8192).astype(np.float32)
-WQ = np.random.rand(64, 8192, 128).astype(np.float32) * 5 - 1
-WK = np.random.rand(64, 8192, 128).astype(np.float32) * 5 - 1
-WV = np.random.rand(64, 8192, 128).astype(np.float32) * 5 - 1
-WM = np.random.rand(8192, 8192).astype(np.float32) * 5 - 1
-
-X.tofile('X.bin')
-WQ.tofile('WQ.bin')
-WK.tofile('WK.bin')
-WV.tofile('WV.bin')
-WM.tofile('WM.bin')
-
-
-Q = X @ WQ  # [64,384,128]
-K = X @ WK  # [64,384,128]
-V = X @ WV  # [64,384,128]
-
-QK = Q @ np.transpose(K, [0, 2, 1])  # [64,384,384]
-
-QK.tofile("QKH.bin")
-
-S = softmax(QK,-1)  # [64,384,384]
-
-S.tofile("Softmax.bin")
-
-Y = np.transpose(S @ V, [1, 0, 2]).reshape([384, -1])  # [64,384,128] ->  [64,8192]
-
-YM = Y @ WM  # [384,8192]
-
-YM.tofile("YM.bin")
-
-Norm = nn.LayerNorm([8192], elementwise_affine=False)(torch.from_numpy(X + YM))
-Norm.detach().numpy().tofile('Norm.bin')
diff --git a/modules/xpu/src/runtime/cmodel/tests/demo2/kernel.h b/modules/xpu/src/runtime/cmodel/tests/demo2/kernel.h
deleted file mode 100644
index 32b9938c28..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/demo2/kernel.h
+++ /dev/null
@@ -1,129 +0,0 @@
-// llama 65B
-// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
-// 1 chips, 8 blocks per chip, 4 threads per block
-
-// tensor<float, loc_t::shared> X({384, 8192});
-// tensor<float, loc_t::shared> kh({8, 384, 128}), vh({8, 384, 128}); //
-// [8, 384, 128] tensor<float, loc_t::shared> qkh({8, 384, 384});    //
-// [8, 384, 384] tensor<float, loc_t::shared> qkh({8, 384, 384});    //
-// [8, 384, 384]
-#include "thread_context.h"
-using namespace shared;
-
-static bool w_loaded;
-static tensor<float> wqh({8, 2048, 128});
-static tensor<float> wkh({8, 2048, 128});
-static tensor<float> wvh({8, 2048, 128}); // [8, 2048, 128]
-static tensor<float> wm({1024, 8192});    // []
-// static tensor<float> wfc1ih({1024, 8192});
-// static tensor<float> wfc2ih({1024, 8192}); // [1024, 8192]
-static tensor<float> yih({96, 1024});
-
-// 8 head per block
-// 2048 w-len per thread
-void stage1_kernel(
-    [[maybe_unused]] tensor<float, loc_t::device> &WQ, /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &WK, /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &WV, /* 64, 8192, 128 */
-    [[maybe_unused]] tensor<float, loc_t::device> &WM, /* 8192, 8192 */
-    [[maybe_unused]] tensor<float, loc_t::device> &QKH /* 64,384,384 */
-) {
-    thread_context ctx(bid, tid);
-    // 1. Get xi
-    auto xi = X({0, tid * 2048}, {384, 2048}); // [384, 2048]
-
-    // 2. load wqh wkh wvh
-    if (!w_loaded) {
-        tdma_load_async(wqh, WQ({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
-        tdma_load_async(wkh, WK({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
-        tdma_load_async(wvh, WV({bid * 8, tid * 2048, 0}, {8, 2048, 128}), ctx);
-        tdma_load_async(wm, WM({bid * 1024, 0}, {1024, 8192}), ctx);
-        // tdma_load_async(wfc1ih, WFC1({bid * 1024, tid * 8192}, {1024,
-        // 8192}));
-        tdma_wait(ctx); // 等待 x, wqh, wkh, wvh ready
-        w_loaded = true;
-    }
-    // 3. compute k, v
-    set_sched_strategy(sched_strategy_t::pin_block_tensor);
-    // 仅在 block 内调度线程的 tensor
-    // 指令
-
-    // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
-    tensor_block_mma_sync(xi, wkh, kh, false, ctx);
-    // [384, 2048] x [8, 2048, 64] = [8, 384, 128]
-    tensor_block_mma_sync(xi, wvh, vh, false, ctx);
-
-    // 4. compute qk
-    tensor<float> qih({8, 384, 128});
-    // [384, 2048] x [8, 2048, 128] = [8, 384, 128]
-    matmul(xi, wqh, qih);
-    // [8, 384, 128] x [8, 128, 384] = [8, 384, 384]
-    auto khT = view_transpose(kh, dims_t({0, 2, 1}));
-    tensor_block_mma_sync(qih, khT, qkh, false, ctx);
-
-    set_sched_strategy(sched_strategy_t::normal);
-    if (tid == 0) {
-        tdma_store_async(qkh, QKH({bid * 8, 0, 0}, {8, 384, 384}), ctx);
-    }
-    tdma_wait(ctx);
-}
-
-// 8 head per block
-// 96 seq-len per thread
-void stage2_kernel(
-    [[maybe_unused]] tensor<float, loc_t::device> &Norm,    /* 8192, 8192 */
-    [[maybe_unused]] tensor<float, loc_t::device> &Softmax, /* 64,384,384 */
-    [[maybe_unused]] tensor<float, loc_t::device> &YM       /* 384,8192 */
-) {
-    thread_context ctx(bid, tid);
-    // 5. compute softmax
-    auto qkhi = qkh({0, tid * 96, 0}, {8, 96, 384});
-
-    tensor<float> sih({8, 96, 384});
-    softmax(qkhi, sih, 2);
-
-    tdma_store_async(sih, Softmax({bid * 8, tid * 96, 0}, {8, 96, 384}), ctx);
-    tdma_wait(ctx);
-
-    // 6. compute y
-    tensor<float> yihT({8, 96, 128});
-    // [8, 96, 384] x [8, 384, 128] = [8, 96, 128]
-    matmul(sih, vh, yihT);
-    // 下面的 transpose 可以在计算 yih 的过程中通过指定输出 stride
-    // 无代价地做到。
-    /* [96, 8, 128] -> [96, 1024] */
-    tensor<float> yih({96, 8, 128});
-    transpose(yihT, yih, dims_t({1, 0, 2}));
-    auto yihv = view(yih, dims_t({96, 1024}));
-
-    tensor<float> ym({96, 8192});
-
-    // [96,1024] * [1024,8192] -> [96, 8192]
-    //  @t, @b       @b, @l        @t, @l
-    // note 如添加上mm的, 此时wm的n不能在thread上切, 只能多算一部分,
-    // 计算结束后倒是可以继续在thread切.
-    matmul(yihv, wm, ym);
-    tdma_all_reduce_async(ym, ym, reduce_op_t::sum, reduce_strategy_t::by_block,
-                          ctx);
-    if (bid == 0) {
-        tdma_store_async(ym, YM({tid * 96, 0}, {96, 8192}), ctx);
-    }
-
-    // 7. Add and sum & sqr
-    tensor<float> sum({96});
-    tensor<float> sum_sqr({96});
-    auto xi = X({tid * 96, bid * 1024}, {96, 1024}); // [96, 1024]
-    auto ym_b = ym({0, bid * 1024}, {96, 1024});
-    binary(xi, ym_b, ym_b, binary_op_t::add);
-    // yih = add_and_sum_sqr(yih, xi, sum, sum_sqr);
-    reduce_sum_sqr(ym_b, sum, sum_sqr);
-    // __tdma_all_reduce_async(sum, sum_sqr); // All blocks & threads reduce
-    tdma_all_reduce_async(sum, sum, reduce_op_t::sum,
-                          reduce_strategy_t::by_block, ctx);
-    tdma_all_reduce_async(sum_sqr, sum_sqr, reduce_op_t::sum,
-                          reduce_strategy_t::by_block, ctx);
-    tdma_wait(ctx);
-    layernorm(ym_b, sum, sum_sqr, ym_b, 1, 8192);
-
-    tdma_store_async(ym_b, Norm({tid * 96, bid * 1024}, {96, 1024}), ctx);
-}
diff --git a/modules/xpu/src/runtime/cmodel/tests/demo2/main.cpp b/modules/xpu/src/runtime/cmodel/tests/demo2/main.cpp
deleted file mode 100644
index e4da440978..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/demo2/main.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-#include "cluster_def.h"
-#include <io_utils.h>
-#include <runtime_utils.h>
-// #include <pthread.h>
-
-#define DEFINE_TFUNC(b, t)                                                     \
-    void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(WQ, WK, WV, WM, QKH);               \
-        block##b::thread##t::stage2_kernel(Norm, Softmax, YM);                 \
-        return arg;                                                            \
-    }
-
-#define DEFINE_BFUNC(b)                                                        \
-    DEFINE_TFUNC(b, 0)                                                         \
-    DEFINE_TFUNC(b, 1)                                                         \
-    DEFINE_TFUNC(b, 2)                                                         \
-    DEFINE_TFUNC(b, 3)
-
-tensor<float, loc_t::device> WQ({64, 8192, 128});
-tensor<float, loc_t::device> WK({64, 8192, 128});
-tensor<float, loc_t::device> WV({64, 8192, 128});
-tensor<float, loc_t::device> WM({8192, 8192});
-tensor<float, loc_t::device> QKH({64, 384, 384});
-tensor<float, loc_t::device> Softmax({64, 384, 384});
-tensor<float, loc_t::device> YM({384, 8192});
-tensor<float, loc_t::device> Norm({384, 8192});
-
-DEFINE_BFUNC(0)
-DEFINE_BFUNC(1)
-DEFINE_BFUNC(2)
-DEFINE_BFUNC(3)
-DEFINE_BFUNC(4)
-DEFINE_BFUNC(5)
-DEFINE_BFUNC(6)
-DEFINE_BFUNC(7)
-
-/**
- * @brief demo2 X.bin WQ.bin WK.bin WV.bin WM.bin
- *
- * @param argc
- * @param argv
- * @return int
- */
-int main([[maybe_unused]] int argc, char **argv) {
-    // spdlog::set_level(spdlog::level::debug);
-    global_hardware_init();
-
-    /* fill tensor */
-    auto src_X = read_file(std::string(argv[1]));
-    auto src_WQ = read_file(std::string(argv[2]));
-    auto src_WK = read_file(std::string(argv[3]));
-    auto src_WV = read_file(std::string(argv[4]));
-    auto src_WM = read_file(std::string(argv[5]));
-    auto src_Norm = read_file(std::string(argv[6]));
-    auto src_QKH = read_file(std::string(argv[7]));
-    auto src_Softmax = read_file(std::string(argv[8]));
-    auto src_YM = read_file(std::string(argv[9]));
-    span_copy(WQ.data(), gsl::make_span(src_WQ).as_span<float>());
-    span_copy(WK.data(), gsl::make_span(src_WK).as_span<float>());
-    span_copy(WV.data(), gsl::make_span(src_WV).as_span<float>());
-    span_copy(WM.data(), gsl::make_span(src_WM).as_span<float>());
-    span_copy(block0::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block1::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block2::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block3::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block4::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block5::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block6::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-    span_copy(block7::shared::X.data(), gsl::make_span(src_X).as_span<float>());
-
-    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
-
-    pthread_create(&t_0_0, NULL, f_0_0, NULL);
-    pthread_create(&t_0_1, NULL, f_0_1, NULL);
-    pthread_create(&t_0_2, NULL, f_0_2, NULL);
-    pthread_create(&t_0_3, NULL, f_0_3, NULL);
-    pthread_create(&t_1_0, NULL, f_1_0, NULL);
-    pthread_create(&t_1_1, NULL, f_1_1, NULL);
-    pthread_create(&t_1_2, NULL, f_1_2, NULL);
-    pthread_create(&t_1_3, NULL, f_1_3, NULL);
-    pthread_create(&t_2_0, NULL, f_2_0, NULL);
-    pthread_create(&t_2_1, NULL, f_2_1, NULL);
-    pthread_create(&t_2_2, NULL, f_2_2, NULL);
-    pthread_create(&t_2_3, NULL, f_2_3, NULL);
-    pthread_create(&t_3_0, NULL, f_3_0, NULL);
-    pthread_create(&t_3_1, NULL, f_3_1, NULL);
-    pthread_create(&t_3_2, NULL, f_3_2, NULL);
-    pthread_create(&t_3_3, NULL, f_3_3, NULL);
-    pthread_create(&t_4_0, NULL, f_4_0, NULL);
-    pthread_create(&t_4_1, NULL, f_4_1, NULL);
-    pthread_create(&t_4_2, NULL, f_4_2, NULL);
-    pthread_create(&t_4_3, NULL, f_4_3, NULL);
-    pthread_create(&t_5_0, NULL, f_5_0, NULL);
-    pthread_create(&t_5_1, NULL, f_5_1, NULL);
-    pthread_create(&t_5_2, NULL, f_5_2, NULL);
-    pthread_create(&t_5_3, NULL, f_5_3, NULL);
-    pthread_create(&t_6_0, NULL, f_6_0, NULL);
-    pthread_create(&t_6_1, NULL, f_6_1, NULL);
-    pthread_create(&t_6_2, NULL, f_6_2, NULL);
-    pthread_create(&t_6_3, NULL, f_6_3, NULL);
-    pthread_create(&t_7_0, NULL, f_7_0, NULL);
-    pthread_create(&t_7_1, NULL, f_7_1, NULL);
-    pthread_create(&t_7_2, NULL, f_7_2, NULL);
-    pthread_create(&t_7_3, NULL, f_7_3, NULL);
-
-    pthread_join(t_0_0, NULL);
-    pthread_join(t_0_1, NULL);
-    pthread_join(t_0_2, NULL);
-    pthread_join(t_0_3, NULL);
-    pthread_join(t_1_0, NULL);
-    pthread_join(t_1_1, NULL);
-    pthread_join(t_1_2, NULL);
-    pthread_join(t_1_3, NULL);
-    pthread_join(t_2_0, NULL);
-    pthread_join(t_2_1, NULL);
-    pthread_join(t_2_2, NULL);
-    pthread_join(t_2_3, NULL);
-    pthread_join(t_3_0, NULL);
-    pthread_join(t_3_1, NULL);
-    pthread_join(t_3_2, NULL);
-    pthread_join(t_3_3, NULL);
-    pthread_join(t_4_0, NULL);
-    pthread_join(t_4_1, NULL);
-    pthread_join(t_4_2, NULL);
-    pthread_join(t_4_3, NULL);
-    pthread_join(t_5_0, NULL);
-    pthread_join(t_5_1, NULL);
-    pthread_join(t_5_2, NULL);
-    pthread_join(t_5_3, NULL);
-    pthread_join(t_6_0, NULL);
-    pthread_join(t_6_1, NULL);
-    pthread_join(t_6_2, NULL);
-    pthread_join(t_6_3, NULL);
-    pthread_join(t_7_0, NULL);
-    pthread_join(t_7_1, NULL);
-    pthread_join(t_7_2, NULL);
-    pthread_join(t_7_3, NULL);
-
-    auto cos = cosine(QKH.data().begin(),
-                      gsl::make_span(src_QKH).as_span<float>().begin(),
-                      QKH.data().size());
-    printf("QKH cosine %f\n", cos);
-
-    cos = cosine(Softmax.data().begin(),
-                 gsl::make_span(src_Softmax).as_span<float>().begin(),
-                 Softmax.data().size());
-    printf("Softmax cosine %f\n", cos);
-
-    cos = cosine(YM.data().begin(),
-                 gsl::make_span(src_YM).as_span<float>().begin(),
-                 YM.data().size());
-    printf("YM cosine %f\n", cos);
-
-    to_file(Norm.data(), "ONorm.bin");
-
-    cos = cosine(Norm.data().begin(),
-                 gsl::make_span(src_Norm).as_span<float>().begin(),
-                 Norm.data().size());
-    printf("Norm cosine %f\n", cos);
-    return 0;
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/demo2/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/demo2/shared_def.h
deleted file mode 100644
index 8dbca0cd80..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/demo2/shared_def.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <tdma.h>
-
-namespace shared {
-static tensor<float, loc_t::shared> X({384, 8192});
-static tensor<float, loc_t::shared> kh({8, 384, 128});
-static tensor<float, loc_t::shared> vh({8, 384, 128});  // []
-static tensor<float, loc_t::shared> qkh({8, 384, 384}); // []
-static tensor<float, loc_t::shared> mh({8, 384, 384});  // []
-} // namespace shared
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/embed/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/embed/cluster_def.h
deleted file mode 100644
index 8fd5d84ed7..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/embed/cluster_def.h
+++ /dev/null
@@ -1,171 +0,0 @@
-#pragma once
-#include <hardware_context.h>
-#include <tdma.h>
-
-namespace block0 {
-#include "shared_def.h"
-constexpr size_t bid = 0;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block0
-
-namespace block1 {
-#include "shared_def.h"
-constexpr size_t bid = 1;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block1
-
-namespace block2 {
-#include "shared_def.h"
-constexpr size_t bid = 2;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block2
-
-namespace block3 {
-#include "shared_def.h"
-constexpr size_t bid = 3;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block3
-
-namespace block4 {
-#include "shared_def.h"
-constexpr size_t bid = 4;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block4
-
-namespace block5 {
-#include "shared_def.h"
-constexpr size_t bid = 5;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block5
-
-namespace block6 {
-#include "shared_def.h"
-constexpr size_t bid = 6;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block6
-
-namespace block7 {
-#include "shared_def.h"
-constexpr size_t bid = 7;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block7
diff --git a/modules/xpu/src/runtime/cmodel/tests/embed/golden.py b/modules/xpu/src/runtime/cmodel/tests/embed/golden.py
deleted file mode 100644
index 4ead78241d..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/embed/golden.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import numpy as np
-from torch import nn
-import torch
-from scipy.special import softmax
-import os
-
-
-def rmsnorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray, eps=1e-05):
-    x = torch.from_numpy(x)
-    output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
-    output = output * torch.from_numpy(gamma) + torch.from_numpy(beta)
-    return output.detach().numpy()
-
-
-def layernorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray):
-    return nn.functional.layer_norm(torch.from_numpy(x), [x.shape[-1]], torch.from_numpy(gamma), torch.from_numpy(beta)).detach().numpy()
-
-
-def swish(x: np.ndarray):
-    return x / (1 + np.exp(-x))
-
-
-def gather(data: np.ndarray, axis: int, indices: np.ndarray):
-    return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
-
-
-hidden_in = np.random.rand(1, 384, 8192).astype(np.float32)
-hidden_in.tofile('hidden_in.bin')
-output = rmsnorm(hidden_in, np.ones([8192], np.float32), np.zeros([8192], np.float32))
-# f32[1,384,8192]
-output.tofile("output.bin")
diff --git a/modules/xpu/src/runtime/cmodel/tests/embed/kernel.h b/modules/xpu/src/runtime/cmodel/tests/embed/kernel.h
deleted file mode 100644
index 0fd6f0a8f6..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/embed/kernel.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// llama 65B
-// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
-// 1 chips, 8 blocks per chip, 4 threads per block
-
-#include "thread_context.h"
-using namespace shared;
-
-#define DUMP 0
-
-void stage1_kernel(
-    [[maybe_unused]] tensor<int64_t, loc_t::device>
-        &Position_ids, /* [1, 384] */
-    [[maybe_unused]] tensor<float, loc_t::device>
-        &GatherData,                                      /* [32000, 8192] */
-    [[maybe_unused]] tensor<float, loc_t::device> &Output /* [1, 384, 8192] */
-) {
-    thread_context ctx(bid, tid);
-    tensor<int64_t> position_ids({1, 384});
-    tensor<float> gather_data({384, 256});
-    tensor<float> output({1, 384, 256});
-
-    tdma_load_async(position_ids, std::move(Position_ids));
-    tdma_load_async(gather_data,
-                    GatherData({0, 256 * (CORES * bid + tid)}, {384, 256}));
-    gather(gather_data, position_ids, output, 0);
-
-    tdma_store_async(output,
-                     Output({0, 0, 256 * (CORES * bid + tid)}, {1, 384, 256}));
-}
diff --git a/modules/xpu/src/runtime/cmodel/tests/embed/main.cpp b/modules/xpu/src/runtime/cmodel/tests/embed/main.cpp
deleted file mode 100644
index d307a5bdf7..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/embed/main.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#include "cluster_def.h"
-#include <runtime_utils.h>
-
-#define DEFINE_TFUNC(b, t)                                                     \
-    void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(*Position_ids, *GatherData,         \
-                                           *Output);                           \
-        return arg;                                                            \
-    }
-
-#define DEFINE_BFUNC(b)                                                        \
-    DEFINE_TFUNC(b, 0)                                                         \
-    DEFINE_TFUNC(b, 1)                                                         \
-    DEFINE_TFUNC(b, 2)                                                         \
-    DEFINE_TFUNC(b, 3)
-
-static tensor<int64_t, loc_t::device> *Position_ids;
-static tensor<float, loc_t::device> *GatherData;
-static tensor<float, loc_t::device> *Output;
-
-DEFINE_BFUNC(0)
-DEFINE_BFUNC(1)
-DEFINE_BFUNC(2)
-DEFINE_BFUNC(3)
-DEFINE_BFUNC(4)
-DEFINE_BFUNC(5)
-DEFINE_BFUNC(6)
-DEFINE_BFUNC(7)
-
-int main() {}
-extern "C" {void __libc_csu_fini(){} void __libc_csu_init(){}}
-
-void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
-    global_hardware_init(hw_ctx_impl);
-    runtime_util = rt_util_mt;
-    nncase_mt = nncase_mt_impl;
-
-    auto Position_ids_ = tensor<int64_t, loc_t::device>(
-        gsl::make_span((int64_t *)inputs[0], 384), {1, 384});
-    runtime_util->printf("1\n");
-
-    auto GatherData_ = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[1], 384 * 8192), {384, 8192});
-
-    runtime_util->printf("2\n");
-    auto Output_ = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[2], 384 * 8192), {1, 384, 8192});
-
-    runtime_util->printf("3\n");
-    Position_ids = &Position_ids_;
-    GatherData = &GatherData_;
-    Output = &Output_;
-    runtime_util->printf("%d\n", Position_ids->data().size());
-
-    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
-
-    runtime_util->create_thread(t_0_0, NULL, f_0_0);
-    runtime_util->create_thread(t_0_1, NULL, f_0_1);
-    runtime_util->create_thread(t_0_2, NULL, f_0_2);
-    runtime_util->create_thread(t_0_3, NULL, f_0_3);
-    runtime_util->create_thread(t_1_0, NULL, f_1_0);
-    runtime_util->create_thread(t_1_1, NULL, f_1_1);
-    runtime_util->create_thread(t_1_2, NULL, f_1_2);
-    runtime_util->create_thread(t_1_3, NULL, f_1_3);
-    runtime_util->create_thread(t_2_0, NULL, f_2_0);
-    runtime_util->create_thread(t_2_1, NULL, f_2_1);
-    runtime_util->create_thread(t_2_2, NULL, f_2_2);
-    runtime_util->create_thread(t_2_3, NULL, f_2_3);
-    runtime_util->create_thread(t_3_0, NULL, f_3_0);
-    runtime_util->create_thread(t_3_1, NULL, f_3_1);
-    runtime_util->create_thread(t_3_2, NULL, f_3_2);
-    runtime_util->create_thread(t_3_3, NULL, f_3_3);
-    runtime_util->create_thread(t_4_0, NULL, f_4_0);
-    runtime_util->create_thread(t_4_1, NULL, f_4_1);
-    runtime_util->create_thread(t_4_2, NULL, f_4_2);
-    runtime_util->create_thread(t_4_3, NULL, f_4_3);
-    runtime_util->create_thread(t_5_0, NULL, f_5_0);
-    runtime_util->create_thread(t_5_1, NULL, f_5_1);
-    runtime_util->create_thread(t_5_2, NULL, f_5_2);
-    runtime_util->create_thread(t_5_3, NULL, f_5_3);
-    runtime_util->create_thread(t_6_0, NULL, f_6_0);
-    runtime_util->create_thread(t_6_1, NULL, f_6_1);
-    runtime_util->create_thread(t_6_2, NULL, f_6_2);
-    runtime_util->create_thread(t_6_3, NULL, f_6_3);
-    runtime_util->create_thread(t_7_0, NULL, f_7_0);
-    runtime_util->create_thread(t_7_1, NULL, f_7_1);
-    runtime_util->create_thread(t_7_2, NULL, f_7_2);
-    runtime_util->create_thread(t_7_3, NULL, f_7_3);
-
-    runtime_util->join_thread(t_0_0);
-    runtime_util->join_thread(t_0_1);
-    runtime_util->join_thread(t_0_2);
-    runtime_util->join_thread(t_0_3);
-    runtime_util->join_thread(t_1_0);
-    runtime_util->join_thread(t_1_1);
-    runtime_util->join_thread(t_1_2);
-    runtime_util->join_thread(t_1_3);
-    runtime_util->join_thread(t_2_0);
-    runtime_util->join_thread(t_2_1);
-    runtime_util->join_thread(t_2_2);
-    runtime_util->join_thread(t_2_3);
-    runtime_util->join_thread(t_3_0);
-    runtime_util->join_thread(t_3_1);
-    runtime_util->join_thread(t_3_2);
-    runtime_util->join_thread(t_3_3);
-    runtime_util->join_thread(t_4_0);
-    runtime_util->join_thread(t_4_1);
-    runtime_util->join_thread(t_4_2);
-    runtime_util->join_thread(t_4_3);
-    runtime_util->join_thread(t_5_0);
-    runtime_util->join_thread(t_5_1);
-    runtime_util->join_thread(t_5_2);
-    runtime_util->join_thread(t_5_3);
-    runtime_util->join_thread(t_6_0);
-    runtime_util->join_thread(t_6_1);
-    runtime_util->join_thread(t_6_2);
-    runtime_util->join_thread(t_6_3);
-    runtime_util->join_thread(t_7_0);
-    runtime_util->join_thread(t_7_1);
-    runtime_util->join_thread(t_7_2);
-    runtime_util->join_thread(t_7_3);
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/embed/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/embed/shared_def.h
deleted file mode 100644
index 30a07a72cb..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/embed/shared_def.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#include <tdma.h>
-
-namespace shared {} // namespace shared
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/head/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/head/cluster_def.h
deleted file mode 100644
index 8fd5d84ed7..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/head/cluster_def.h
+++ /dev/null
@@ -1,171 +0,0 @@
-#pragma once
-#include <hardware_context.h>
-#include <tdma.h>
-
-namespace block0 {
-#include "shared_def.h"
-constexpr size_t bid = 0;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block0
-
-namespace block1 {
-#include "shared_def.h"
-constexpr size_t bid = 1;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block1
-
-namespace block2 {
-#include "shared_def.h"
-constexpr size_t bid = 2;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block2
-
-namespace block3 {
-#include "shared_def.h"
-constexpr size_t bid = 3;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block3
-
-namespace block4 {
-#include "shared_def.h"
-constexpr size_t bid = 4;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block4
-
-namespace block5 {
-#include "shared_def.h"
-constexpr size_t bid = 5;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block5
-
-namespace block6 {
-#include "shared_def.h"
-constexpr size_t bid = 6;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block6
-
-namespace block7 {
-#include "shared_def.h"
-constexpr size_t bid = 7;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block7
diff --git a/modules/xpu/src/runtime/cmodel/tests/head/golden.py b/modules/xpu/src/runtime/cmodel/tests/head/golden.py
deleted file mode 100644
index 7024824698..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/head/golden.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import numpy as np
-from torch import nn
-import torch
-from scipy.special import softmax
-import os
-
-
-def rmsnorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray, eps=1e-05):
-    x = torch.from_numpy(x)
-    output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
-    output = output * torch.from_numpy(gamma) + torch.from_numpy(beta)
-    return output.detach().numpy()
-
-
-def layernorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray):
-    return nn.functional.layer_norm(torch.from_numpy(x), [x.shape[-1]], torch.from_numpy(gamma), torch.from_numpy(beta)).detach().numpy()
-
-
-def swish(x: np.ndarray):
-    return x / (1 + np.exp(-x))
-
-
-def gather(data: np.ndarray, axis: int, indices: np.ndarray):
-    return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
-
-
-# position_ids = np.random.randint(0, 384, (1, 384), np.int64)
-hidden_in = np.random.rand(1, 384, 8192).astype(np.float32)
-hidden_in.tofile('hidden_in.bin')
-W = np.random.rand(8192, 32000).astype(np.float32)
-W.tofile('W.bin')
-output = hidden_in @ W
-# f32[1,384,8192]
-output.tofile("output.bin")
diff --git a/modules/xpu/src/runtime/cmodel/tests/head/kernel.h b/modules/xpu/src/runtime/cmodel/tests/head/kernel.h
deleted file mode 100644
index af67e500d0..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/head/kernel.h
+++ /dev/null
@@ -1,26 +0,0 @@
-// llama 65B
-// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
-// 1 chips, 8 blocks per chip, 4 threads per block
-
-#include "thread_context.h"
-using namespace shared;
-
-#define DUMP 0
-
-void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
-                   tensor<float, loc_t::device> &W,         /* [8192, 32000] */
-                   tensor<float, loc_t::device> &Output /* [1, 384, 32000] */
-) {
-    thread_context ctx(bid, tid);
-    tensor<float> hidden_in({1, 48, 2048});
-    tensor<float> w({2048, 32000});
-
-    tdma_load_async(hidden_in,
-                    Hidden_in({0, 48 * bid, 2048 * tid}, {1, 48, 2048}));
-    tdma_load_async(w, W({2048 * tid, 0}, {2048, 32000}));
-    tensor_block_mma_sync(hidden_in, w, *output, false, ctx);
-
-    auto output_1 = (*output)({0, 0, 8000 * tid}, {1, 48, 8000});
-    tdma_store_async(output_1,
-                     Output({0, 48 * bid, 8000 * tid}, {1, 48, 8000}));
-}
diff --git a/modules/xpu/src/runtime/cmodel/tests/head/main.cpp b/modules/xpu/src/runtime/cmodel/tests/head/main.cpp
deleted file mode 100644
index 424619bec1..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/head/main.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#include "cluster_def.h"
-#include <runtime_utils.h>
-
-#define DEFINE_TFUNC(b, t)                                                     \
-    void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(*Hidden_in, *W, *Output);           \
-        return arg;                                                            \
-    }
-
-#define MALLOC_SHARED(b, name, shape)                                          \
-    auto shared##b = tensor<float, loc_t::shared>(shape);                      \
-    block##b::shared::name = &shared##b;
-
-#define DEFINE_BFUNC(b)                                                        \
-    DEFINE_TFUNC(b, 0)                                                         \
-    DEFINE_TFUNC(b, 1)                                                         \
-    DEFINE_TFUNC(b, 2)                                                         \
-    DEFINE_TFUNC(b, 3)
-
-static tensor<float, loc_t::device> *Hidden_in; // {1, 384, 8192}
-static tensor<float, loc_t::device> *W;         // {8192, 32000}
-static tensor<float, loc_t::device> *Output;    // {1, 384, 32000}
-
-DEFINE_BFUNC(0)
-DEFINE_BFUNC(1)
-DEFINE_BFUNC(2)
-DEFINE_BFUNC(3)
-DEFINE_BFUNC(4)
-DEFINE_BFUNC(5)
-DEFINE_BFUNC(6)
-DEFINE_BFUNC(7)
-
-int main() {}
-extern "C" {void __libc_csu_fini(){} void __libc_csu_init(){}}
-
-void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
-    global_hardware_init(hw_ctx_impl);
-    runtime_util = rt_util_mt;
-    nncase_mt = nncase_mt_impl;
-
-    MALLOC_SHARED(0, output, dims_t({1, 48, 32000}));
-    MALLOC_SHARED(1, output, dims_t({1, 48, 32000}));
-    MALLOC_SHARED(2, output, dims_t({1, 48, 32000}));
-    MALLOC_SHARED(3, output, dims_t({1, 48, 32000}));
-    MALLOC_SHARED(4, output, dims_t({1, 48, 32000}));
-    MALLOC_SHARED(5, output, dims_t({1, 48, 32000}));
-    MALLOC_SHARED(6, output, dims_t({1, 48, 32000}));
-    MALLOC_SHARED(7, output, dims_t({1, 48, 32000}));
-
-    auto input0 = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[0], 384 * 8192), {1, 384, 8192});
-    Hidden_in = &input0;
-
-    auto input1 = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[1], 8192 * 32000), {8192, 32000});
-    W = &input1;
-
-    auto input2 = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[2], 384 * 32000), {1, 384, 32000});
-    Output = &input2;
-
-    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
-
-    runtime_util->create_thread(t_0_0, NULL, f_0_0);
-    runtime_util->create_thread(t_0_1, NULL, f_0_1);
-    runtime_util->create_thread(t_0_2, NULL, f_0_2);
-    runtime_util->create_thread(t_0_3, NULL, f_0_3);
-    runtime_util->create_thread(t_1_0, NULL, f_1_0);
-    runtime_util->create_thread(t_1_1, NULL, f_1_1);
-    runtime_util->create_thread(t_1_2, NULL, f_1_2);
-    runtime_util->create_thread(t_1_3, NULL, f_1_3);
-    runtime_util->create_thread(t_2_0, NULL, f_2_0);
-    runtime_util->create_thread(t_2_1, NULL, f_2_1);
-    runtime_util->create_thread(t_2_2, NULL, f_2_2);
-    runtime_util->create_thread(t_2_3, NULL, f_2_3);
-    runtime_util->create_thread(t_3_0, NULL, f_3_0);
-    runtime_util->create_thread(t_3_1, NULL, f_3_1);
-    runtime_util->create_thread(t_3_2, NULL, f_3_2);
-    runtime_util->create_thread(t_3_3, NULL, f_3_3);
-    runtime_util->create_thread(t_4_0, NULL, f_4_0);
-    runtime_util->create_thread(t_4_1, NULL, f_4_1);
-    runtime_util->create_thread(t_4_2, NULL, f_4_2);
-    runtime_util->create_thread(t_4_3, NULL, f_4_3);
-    runtime_util->create_thread(t_5_0, NULL, f_5_0);
-    runtime_util->create_thread(t_5_1, NULL, f_5_1);
-    runtime_util->create_thread(t_5_2, NULL, f_5_2);
-    runtime_util->create_thread(t_5_3, NULL, f_5_3);
-    runtime_util->create_thread(t_6_0, NULL, f_6_0);
-    runtime_util->create_thread(t_6_1, NULL, f_6_1);
-    runtime_util->create_thread(t_6_2, NULL, f_6_2);
-    runtime_util->create_thread(t_6_3, NULL, f_6_3);
-    runtime_util->create_thread(t_7_0, NULL, f_7_0);
-    runtime_util->create_thread(t_7_1, NULL, f_7_1);
-    runtime_util->create_thread(t_7_2, NULL, f_7_2);
-    runtime_util->create_thread(t_7_3, NULL, f_7_3);
-
-    runtime_util->join_thread(t_0_0);
-    runtime_util->join_thread(t_0_1);
-    runtime_util->join_thread(t_0_2);
-    runtime_util->join_thread(t_0_3);
-    runtime_util->join_thread(t_1_0);
-    runtime_util->join_thread(t_1_1);
-    runtime_util->join_thread(t_1_2);
-    runtime_util->join_thread(t_1_3);
-    runtime_util->join_thread(t_2_0);
-    runtime_util->join_thread(t_2_1);
-    runtime_util->join_thread(t_2_2);
-    runtime_util->join_thread(t_2_3);
-    runtime_util->join_thread(t_3_0);
-    runtime_util->join_thread(t_3_1);
-    runtime_util->join_thread(t_3_2);
-    runtime_util->join_thread(t_3_3);
-    runtime_util->join_thread(t_4_0);
-    runtime_util->join_thread(t_4_1);
-    runtime_util->join_thread(t_4_2);
-    runtime_util->join_thread(t_4_3);
-    runtime_util->join_thread(t_5_0);
-    runtime_util->join_thread(t_5_1);
-    runtime_util->join_thread(t_5_2);
-    runtime_util->join_thread(t_5_3);
-    runtime_util->join_thread(t_6_0);
-    runtime_util->join_thread(t_6_1);
-    runtime_util->join_thread(t_6_2);
-    runtime_util->join_thread(t_6_3);
-    runtime_util->join_thread(t_7_0);
-    runtime_util->join_thread(t_7_1);
-    runtime_util->join_thread(t_7_2);
-    runtime_util->join_thread(t_7_3);
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/head/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/head/shared_def.h
deleted file mode 100644
index b99ccebe11..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/head/shared_def.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#include <tdma.h>
-
-namespace shared {
-tensor<float, loc_t::shared> *output;
-} // namespace shared
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/norm/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/norm/cluster_def.h
deleted file mode 100644
index 8fd5d84ed7..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/norm/cluster_def.h
+++ /dev/null
@@ -1,171 +0,0 @@
-#pragma once
-#include <hardware_context.h>
-#include <tdma.h>
-
-namespace block0 {
-#include "shared_def.h"
-constexpr size_t bid = 0;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block0
-
-namespace block1 {
-#include "shared_def.h"
-constexpr size_t bid = 1;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block1
-
-namespace block2 {
-#include "shared_def.h"
-constexpr size_t bid = 2;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block2
-
-namespace block3 {
-#include "shared_def.h"
-constexpr size_t bid = 3;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block3
-
-namespace block4 {
-#include "shared_def.h"
-constexpr size_t bid = 4;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block4
-
-namespace block5 {
-#include "shared_def.h"
-constexpr size_t bid = 5;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block5
-
-namespace block6 {
-#include "shared_def.h"
-constexpr size_t bid = 6;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block6
-
-namespace block7 {
-#include "shared_def.h"
-constexpr size_t bid = 7;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block7
diff --git a/modules/xpu/src/runtime/cmodel/tests/norm/golden.py b/modules/xpu/src/runtime/cmodel/tests/norm/golden.py
deleted file mode 100644
index 4ead78241d..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/norm/golden.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import numpy as np
-from torch import nn
-import torch
-from scipy.special import softmax
-import os
-
-
-def rmsnorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray, eps=1e-05):
-    x = torch.from_numpy(x)
-    output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)
-    output = output * torch.from_numpy(gamma) + torch.from_numpy(beta)
-    return output.detach().numpy()
-
-
-def layernorm(x: np.ndarray, gamma: np.ndarray, beta: np.ndarray):
-    return nn.functional.layer_norm(torch.from_numpy(x), [x.shape[-1]], torch.from_numpy(gamma), torch.from_numpy(beta)).detach().numpy()
-
-
-def swish(x: np.ndarray):
-    return x / (1 + np.exp(-x))
-
-
-def gather(data: np.ndarray, axis: int, indices: np.ndarray):
-    return torch.gather(torch.from_numpy(data), axis, torch.from_numpy(indices)).detach().numpy()
-
-
-hidden_in = np.random.rand(1, 384, 8192).astype(np.float32)
-hidden_in.tofile('hidden_in.bin')
-output = rmsnorm(hidden_in, np.ones([8192], np.float32), np.zeros([8192], np.float32))
-# f32[1,384,8192]
-output.tofile("output.bin")
diff --git a/modules/xpu/src/runtime/cmodel/tests/norm/kernel.h b/modules/xpu/src/runtime/cmodel/tests/norm/kernel.h
deleted file mode 100644
index 15725a764a..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/norm/kernel.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// llama 65B
-// seq-len = 384, w-len = 8192, heads = 64, head-len = 128
-// 1 chips, 8 blocks per chip, 4 threads per block
-
-#include "thread_context.h"
-using namespace shared;
-
-#define DUMP 0
-
-void stage1_kernel(tensor<float, loc_t::device> &Hidden_in, /* [1, 384, 8192] */
-                   tensor<float, loc_t::device> &Output     /* [1, 384, 8192] */
-) {
-    thread_context ctx(bid, tid);
-    tensor<float> hidden_in({1, 12, 8192});
-    tensor<float> output({1, 12, 8192});
-    tdma_load_async(hidden_in,
-                    Hidden_in({0, 12 * (CORES * bid + tid), 0}, {1, 12, 8192}));
-    tensor<float> sum({1, 12});
-    tensor<float> sum_sqr({1, 12});
-    reduce_sum_sqr(hidden_in, sum, sum_sqr);
-    layernorm(hidden_in, sum, sum_sqr, output, 2, 8192, true);
-    tdma_store_async(output,
-                     Output({0, 12 * (CORES * bid + tid), 0}, {1, 12, 8192}));
-}
diff --git a/modules/xpu/src/runtime/cmodel/tests/norm/main.cpp b/modules/xpu/src/runtime/cmodel/tests/norm/main.cpp
deleted file mode 100644
index 259ea16446..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/norm/main.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#include "cluster_def.h"
-#include <runtime_utils.h>
-
-#define DEFINE_TFUNC(b, t)                                                     \
-    void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::stage1_kernel(*Hidden_in, *Output);               \
-        return arg;                                                            \
-    }
-
-#define DEFINE_BFUNC(b)                                                        \
-    DEFINE_TFUNC(b, 0)                                                         \
-    DEFINE_TFUNC(b, 1)                                                         \
-    DEFINE_TFUNC(b, 2)                                                         \
-    DEFINE_TFUNC(b, 3)
-
-static tensor<float, loc_t::device> *Hidden_in; // {1, 384, 8192}
-static tensor<float, loc_t::device> *Output;    // {1, 384, 8192}
-
-DEFINE_BFUNC(0)
-DEFINE_BFUNC(1)
-DEFINE_BFUNC(2)
-DEFINE_BFUNC(3)
-DEFINE_BFUNC(4)
-DEFINE_BFUNC(5)
-DEFINE_BFUNC(6)
-DEFINE_BFUNC(7)
-
-int main() {}
-extern "C" {void __libc_csu_fini(){} void __libc_csu_init(){}}
-
-void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
-    global_hardware_init(hw_ctx_impl);
-    runtime_util = rt_util_mt;
-    nncase_mt = nncase_mt_impl;
-
-    auto input0 = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[0], 384 * 8192), {1, 384, 8192});
-    Hidden_in = &input0;
-
-    auto input1 = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[1], 384 * 8192), {1, 384, 8192});
-    Output = &input1;
-
-    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
-
-    runtime_util->create_thread(t_0_0, NULL, f_0_0);
-    runtime_util->create_thread(t_0_1, NULL, f_0_1);
-    runtime_util->create_thread(t_0_2, NULL, f_0_2);
-    runtime_util->create_thread(t_0_3, NULL, f_0_3);
-    runtime_util->create_thread(t_1_0, NULL, f_1_0);
-    runtime_util->create_thread(t_1_1, NULL, f_1_1);
-    runtime_util->create_thread(t_1_2, NULL, f_1_2);
-    runtime_util->create_thread(t_1_3, NULL, f_1_3);
-    runtime_util->create_thread(t_2_0, NULL, f_2_0);
-    runtime_util->create_thread(t_2_1, NULL, f_2_1);
-    runtime_util->create_thread(t_2_2, NULL, f_2_2);
-    runtime_util->create_thread(t_2_3, NULL, f_2_3);
-    runtime_util->create_thread(t_3_0, NULL, f_3_0);
-    runtime_util->create_thread(t_3_1, NULL, f_3_1);
-    runtime_util->create_thread(t_3_2, NULL, f_3_2);
-    runtime_util->create_thread(t_3_3, NULL, f_3_3);
-    runtime_util->create_thread(t_4_0, NULL, f_4_0);
-    runtime_util->create_thread(t_4_1, NULL, f_4_1);
-    runtime_util->create_thread(t_4_2, NULL, f_4_2);
-    runtime_util->create_thread(t_4_3, NULL, f_4_3);
-    runtime_util->create_thread(t_5_0, NULL, f_5_0);
-    runtime_util->create_thread(t_5_1, NULL, f_5_1);
-    runtime_util->create_thread(t_5_2, NULL, f_5_2);
-    runtime_util->create_thread(t_5_3, NULL, f_5_3);
-    runtime_util->create_thread(t_6_0, NULL, f_6_0);
-    runtime_util->create_thread(t_6_1, NULL, f_6_1);
-    runtime_util->create_thread(t_6_2, NULL, f_6_2);
-    runtime_util->create_thread(t_6_3, NULL, f_6_3);
-    runtime_util->create_thread(t_7_0, NULL, f_7_0);
-    runtime_util->create_thread(t_7_1, NULL, f_7_1);
-    runtime_util->create_thread(t_7_2, NULL, f_7_2);
-    runtime_util->create_thread(t_7_3, NULL, f_7_3);
-
-    runtime_util->join_thread(t_0_0);
-    runtime_util->join_thread(t_0_1);
-    runtime_util->join_thread(t_0_2);
-    runtime_util->join_thread(t_0_3);
-    runtime_util->join_thread(t_1_0);
-    runtime_util->join_thread(t_1_1);
-    runtime_util->join_thread(t_1_2);
-    runtime_util->join_thread(t_1_3);
-    runtime_util->join_thread(t_2_0);
-    runtime_util->join_thread(t_2_1);
-    runtime_util->join_thread(t_2_2);
-    runtime_util->join_thread(t_2_3);
-    runtime_util->join_thread(t_3_0);
-    runtime_util->join_thread(t_3_1);
-    runtime_util->join_thread(t_3_2);
-    runtime_util->join_thread(t_3_3);
-    runtime_util->join_thread(t_4_0);
-    runtime_util->join_thread(t_4_1);
-    runtime_util->join_thread(t_4_2);
-    runtime_util->join_thread(t_4_3);
-    runtime_util->join_thread(t_5_0);
-    runtime_util->join_thread(t_5_1);
-    runtime_util->join_thread(t_5_2);
-    runtime_util->join_thread(t_5_3);
-    runtime_util->join_thread(t_6_0);
-    runtime_util->join_thread(t_6_1);
-    runtime_util->join_thread(t_6_2);
-    runtime_util->join_thread(t_6_3);
-    runtime_util->join_thread(t_7_0);
-    runtime_util->join_thread(t_7_1);
-    runtime_util->join_thread(t_7_2);
-    runtime_util->join_thread(t_7_3);
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/norm/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/norm/shared_def.h
deleted file mode 100644
index 30a07a72cb..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/norm/shared_def.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#include <tdma.h>
-
-namespace shared {} // namespace shared
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/unary/cluster_def.h b/modules/xpu/src/runtime/cmodel/tests/unary/cluster_def.h
deleted file mode 100644
index 8fd5d84ed7..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/unary/cluster_def.h
+++ /dev/null
@@ -1,171 +0,0 @@
-#pragma once
-#include <hardware_context.h>
-#include <tdma.h>
-
-namespace block0 {
-#include "shared_def.h"
-constexpr size_t bid = 0;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block0
-
-namespace block1 {
-#include "shared_def.h"
-constexpr size_t bid = 1;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block1
-
-namespace block2 {
-#include "shared_def.h"
-constexpr size_t bid = 2;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block2
-
-namespace block3 {
-#include "shared_def.h"
-constexpr size_t bid = 3;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block3
-
-namespace block4 {
-#include "shared_def.h"
-constexpr size_t bid = 4;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block4
-
-namespace block5 {
-#include "shared_def.h"
-constexpr size_t bid = 5;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block5
-
-namespace block6 {
-#include "shared_def.h"
-constexpr size_t bid = 6;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block6
-
-namespace block7 {
-#include "shared_def.h"
-constexpr size_t bid = 7;
-namespace thread0 {
-constexpr size_t tid = 0;
-#include "kernel.h"
-} // namespace thread0
-namespace thread1 {
-constexpr size_t tid = 1;
-#include "kernel.h"
-} // namespace thread1
-namespace thread2 {
-constexpr size_t tid = 2;
-#include "kernel.h"
-} // namespace thread2
-namespace thread3 {
-constexpr size_t tid = 3;
-#include "kernel.h"
-} // namespace thread3
-} // namespace block7
diff --git a/modules/xpu/src/runtime/cmodel/tests/unary/golden.py b/modules/xpu/src/runtime/cmodel/tests/unary/golden.py
deleted file mode 100644
index 94a6b18ae5..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/unary/golden.py
+++ /dev/null
@@ -1,12 +0,0 @@
-import numpy as np
-from torch import nn
-import torch
-from scipy.special import softmax
-import os
-
-hidden_in = np.random.rand(1, 384, 2048).astype(np.float32)
-hidden_in.tofile('hidden_in.bin')
-
-output = np.arcsin(hidden_in)
-
-output.tofile("output.bin")
diff --git a/modules/xpu/src/runtime/cmodel/tests/unary/kernel.h b/modules/xpu/src/runtime/cmodel/tests/unary/kernel.h
deleted file mode 100755
index 95f9112fba..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/unary/kernel.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "thread_context.h"
-using namespace shared;
-void Unary_0(tensor<float, loc_t::device> &buffer_0,
-             tensor<float, loc_t::device> &buffer_3) {
-    thread_context ctx(bid, tid);
-    tensor<float, loc_t::local> buffer_1({1, 12, 2048});
-    tdma_load_async(
-        buffer_1,
-        buffer_0({0, 0 + (12 * 4 * bid) + (12 * 1 * tid), 0}, {1, 12, 2048}));
-    tensor<float, loc_t::local> buffer_2({1, 12, 2048});
-    unary(buffer_1, buffer_2, unary_op_t::asin);
-    // tdma_store_async(
-    //     buffer_2,
-    //     buffer_3({0, 0 + (384 * 4 * bid) + (384 * 1 * tid), 0}, {1, 384,
-    //     2048}), ctx);
-    tdma_store_async(
-        buffer_2,
-        buffer_3({0, 0 + (12 * 4 * bid) + (12 * 1 * tid), 0}, {1, 12, 2048}));
-}
diff --git a/modules/xpu/src/runtime/cmodel/tests/unary/main.cpp b/modules/xpu/src/runtime/cmodel/tests/unary/main.cpp
deleted file mode 100755
index 1ad53c5695..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/unary/main.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-#include "cluster_def.h"
-#include <runtime_utils.h>
-
-#define DEFINE_TFUNC(b, t)                                                     \
-    void *f_##b##_##t(void *arg) {                                             \
-        block##b::thread##t::Unary_0(*buffer_0, *buffer_3);                    \
-        return arg;                                                            \
-    }
-
-#define DEFINE_BFUNC(b)                                                        \
-    DEFINE_TFUNC(b, 0)                                                         \
-    DEFINE_TFUNC(b, 1)                                                         \
-    DEFINE_TFUNC(b, 2)                                                         \
-    DEFINE_TFUNC(b, 3)
-
-static tensor<float, loc_t::device> *buffer_0;
-static tensor<float, loc_t::device> *buffer_3;
-
-DEFINE_BFUNC(0)
-DEFINE_BFUNC(1)
-DEFINE_BFUNC(2)
-DEFINE_BFUNC(3)
-DEFINE_BFUNC(4)
-DEFINE_BFUNC(5)
-DEFINE_BFUNC(6)
-DEFINE_BFUNC(7)
-
-int main() {}
-extern "C" {void __libc_csu_fini(){} void __libc_csu_init(){}}
-
-void _start(hardware_context_mt *hw_ctx_impl, runtime_util_mt *rt_util_mt,
-            nncase_mt_t *nncase_mt_impl, uint8_t **inputs) {
-    global_hardware_init(hw_ctx_impl);
-    runtime_util = rt_util_mt;
-    nncase_mt = nncase_mt_impl;
-
-    auto buffer_0_ = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[0], 786432), {1, 384, 2048});
-    buffer_0 = &buffer_0_;
-    auto buffer_3_ = tensor<float, loc_t::device>(
-        gsl::make_span((float *)inputs[1], 786432), {1, 384, 2048});
-    buffer_3 = &buffer_3_;
-
-    pthread_t t_0_0, t_1_0, t_2_0, t_3_0, t_4_0, t_5_0, t_6_0, t_7_0;
-    pthread_t t_0_1, t_1_1, t_2_1, t_3_1, t_4_1, t_5_1, t_6_1, t_7_1;
-    pthread_t t_0_2, t_1_2, t_2_2, t_3_2, t_4_2, t_5_2, t_6_2, t_7_2;
-    pthread_t t_0_3, t_1_3, t_2_3, t_3_3, t_4_3, t_5_3, t_6_3, t_7_3;
-
-    runtime_util->create_thread(t_0_0, NULL, f_0_0);
-    runtime_util->create_thread(t_0_1, NULL, f_0_1);
-    runtime_util->create_thread(t_0_2, NULL, f_0_2);
-    runtime_util->create_thread(t_0_3, NULL, f_0_3);
-    runtime_util->create_thread(t_1_0, NULL, f_1_0);
-    runtime_util->create_thread(t_1_1, NULL, f_1_1);
-    runtime_util->create_thread(t_1_2, NULL, f_1_2);
-    runtime_util->create_thread(t_1_3, NULL, f_1_3);
-    runtime_util->create_thread(t_2_0, NULL, f_2_0);
-    runtime_util->create_thread(t_2_1, NULL, f_2_1);
-    runtime_util->create_thread(t_2_2, NULL, f_2_2);
-    runtime_util->create_thread(t_2_3, NULL, f_2_3);
-    runtime_util->create_thread(t_3_0, NULL, f_3_0);
-    runtime_util->create_thread(t_3_1, NULL, f_3_1);
-    runtime_util->create_thread(t_3_2, NULL, f_3_2);
-    runtime_util->create_thread(t_3_3, NULL, f_3_3);
-    runtime_util->create_thread(t_4_0, NULL, f_4_0);
-    runtime_util->create_thread(t_4_1, NULL, f_4_1);
-    runtime_util->create_thread(t_4_2, NULL, f_4_2);
-    runtime_util->create_thread(t_4_3, NULL, f_4_3);
-    runtime_util->create_thread(t_5_0, NULL, f_5_0);
-    runtime_util->create_thread(t_5_1, NULL, f_5_1);
-    runtime_util->create_thread(t_5_2, NULL, f_5_2);
-    runtime_util->create_thread(t_5_3, NULL, f_5_3);
-    runtime_util->create_thread(t_6_0, NULL, f_6_0);
-    runtime_util->create_thread(t_6_1, NULL, f_6_1);
-    runtime_util->create_thread(t_6_2, NULL, f_6_2);
-    runtime_util->create_thread(t_6_3, NULL, f_6_3);
-    runtime_util->create_thread(t_7_0, NULL, f_7_0);
-    runtime_util->create_thread(t_7_1, NULL, f_7_1);
-    runtime_util->create_thread(t_7_2, NULL, f_7_2);
-    runtime_util->create_thread(t_7_3, NULL, f_7_3);
-
-    runtime_util->join_thread(t_0_0);
-    runtime_util->join_thread(t_0_1);
-    runtime_util->join_thread(t_0_2);
-    runtime_util->join_thread(t_0_3);
-    runtime_util->join_thread(t_1_0);
-    runtime_util->join_thread(t_1_1);
-    runtime_util->join_thread(t_1_2);
-    runtime_util->join_thread(t_1_3);
-    runtime_util->join_thread(t_2_0);
-    runtime_util->join_thread(t_2_1);
-    runtime_util->join_thread(t_2_2);
-    runtime_util->join_thread(t_2_3);
-    runtime_util->join_thread(t_3_0);
-    runtime_util->join_thread(t_3_1);
-    runtime_util->join_thread(t_3_2);
-    runtime_util->join_thread(t_3_3);
-    runtime_util->join_thread(t_4_0);
-    runtime_util->join_thread(t_4_1);
-    runtime_util->join_thread(t_4_2);
-    runtime_util->join_thread(t_4_3);
-    runtime_util->join_thread(t_5_0);
-    runtime_util->join_thread(t_5_1);
-    runtime_util->join_thread(t_5_2);
-    runtime_util->join_thread(t_5_3);
-    runtime_util->join_thread(t_6_0);
-    runtime_util->join_thread(t_6_1);
-    runtime_util->join_thread(t_6_2);
-    runtime_util->join_thread(t_6_3);
-    runtime_util->join_thread(t_7_0);
-    runtime_util->join_thread(t_7_1);
-    runtime_util->join_thread(t_7_2);
-    runtime_util->join_thread(t_7_3);
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/cmodel/tests/unary/shared_def.h b/modules/xpu/src/runtime/cmodel/tests/unary/shared_def.h
deleted file mode 100644
index 30a07a72cb..0000000000
--- a/modules/xpu/src/runtime/cmodel/tests/unary/shared_def.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#include <tdma.h>
-
-namespace shared {} // namespace shared
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/elf.h b/modules/xpu/src/runtime/elf.h
deleted file mode 100644
index 4db5998b3a..0000000000
--- a/modules/xpu/src/runtime/elf.h
+++ /dev/null
@@ -1,578 +0,0 @@
-/*    $OpenBSD: exec_elf.h,v 1.53 2014/01/03 03:00:39 guenther Exp $    */
-/*
- * Copyright (c) 1995, 1996 Erik Theisen.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/* imported sys/exec_elf.h from OpenBSD */
-
-#ifndef ELF_H
-#define ELF_H
-#include "elfarch.h"
-#include <stdint.h>
-
-typedef uint8_t Elf_Byte;
-
-typedef uint32_t Elf32_Addr; /* Unsigned program address */
-typedef uint32_t Elf32_Off;  /* Unsigned file offset */
-typedef int32_t Elf32_Sword; /* Signed large integer */
-typedef uint32_t Elf32_Word; /* Unsigned large integer */
-typedef uint16_t Elf32_Half; /* Unsigned medium integer */
-
-typedef uint64_t Elf64_Addr;
-typedef uint64_t Elf64_Off;
-typedef int32_t Elf64_Shalf;
-
-#ifdef __alpha__
-typedef int64_t Elf64_Sword;
-typedef uint64_t Elf64_Word;
-#else
-typedef int32_t Elf64_Sword;
-typedef uint32_t Elf64_Word;
-#endif
-
-typedef int64_t Elf64_Sxword;
-typedef uint64_t Elf64_Xword;
-
-typedef uint32_t Elf64_Half;
-typedef uint16_t Elf64_Quarter;
-
-/*
- * e_ident[] identification indexes
- * See http://www.sco.com/developers/gabi/latest/ch4.eheader.html
- */
-#define EI_MAG0 0       /* file ID */
-#define EI_MAG1 1       /* file ID */
-#define EI_MAG2 2       /* file ID */
-#define EI_MAG3 3       /* file ID */
-#define EI_CLASS 4      /* file class */
-#define EI_DATA 5       /* data encoding */
-#define EI_VERSION 6    /* ELF header version */
-#define EI_OSABI 7      /* OS/ABI ID */
-#define EI_ABIVERSION 8 /* ABI version */
-#define EI_PAD 9        /* start of pad bytes */
-#define EI_NIDENT 16    /* Size of e_ident[] */
-
-/* e_ident[] magic number */
-#define ELFMAG0 0x7f     /* e_ident[EI_MAG0] */
-#define ELFMAG1 'E'      /* e_ident[EI_MAG1] */
-#define ELFMAG2 'L'      /* e_ident[EI_MAG2] */
-#define ELFMAG3 'F'      /* e_ident[EI_MAG3] */
-#define ELFMAG "\177ELF" /* magic */
-#define SELFMAG 4        /* size of magic */
-
-/* e_ident[] file class */
-#define ELFCLASSNONE 0 /* invalid */
-#define ELFCLASS32 1   /* 32-bit objs */
-#define ELFCLASS64 2   /* 64-bit objs */
-#define ELFCLASSNUM 3  /* number of classes */
-
-/* e_ident[] data encoding */
-#define ELFDATANONE 0 /* invalid */
-#define ELFDATA2LSB 1 /* Little-Endian */
-#define ELFDATA2MSB 2 /* Big-Endian */
-#define ELFDATANUM 3  /* number of data encode defines */
-
-/* e_ident[] Operating System/ABI */
-#define ELFOSABI_SYSV 0         /* UNIX System V ABI */
-#define ELFOSABI_HPUX 1         /* HP-UX operating system */
-#define ELFOSABI_NETBSD 2       /* NetBSD */
-#define ELFOSABI_LINUX 3        /* GNU/Linux */
-#define ELFOSABI_HURD 4         /* GNU/Hurd */
-#define ELFOSABI_86OPEN 5       /* 86Open common IA32 ABI */
-#define ELFOSABI_SOLARIS 6      /* Solaris */
-#define ELFOSABI_MONTEREY 7     /* Monterey */
-#define ELFOSABI_IRIX 8         /* IRIX */
-#define ELFOSABI_FREEBSD 9      /* FreeBSD */
-#define ELFOSABI_TRU64 10       /* TRU64 UNIX */
-#define ELFOSABI_MODESTO 11     /* Novell Modesto */
-#define ELFOSABI_OPENBSD 12     /* OpenBSD */
-#define ELFOSABI_ARM 97         /* ARM */
-#define ELFOSABI_STANDALONE 255 /* Standalone (embedded) application */
-
-/* e_ident */
-#define IS_ELF(ehdr)                                                           \
-    ((ehdr).e_ident[EI_MAG0] == ELFMAG0 &&                                     \
-     (ehdr).e_ident[EI_MAG1] == ELFMAG1 &&                                     \
-     (ehdr).e_ident[EI_MAG2] == ELFMAG2 && (ehdr).e_ident[EI_MAG3] == ELFMAG3)
-
-/* ELF Header */
-typedef struct {
-    unsigned char e_ident[EI_NIDENT]; /* ELF Identification */
-    Elf32_Half e_type;                /* object file type */
-    Elf32_Half e_machine;             /* machine */
-    Elf32_Word e_version;             /* object file version */
-    Elf32_Addr e_entry;               /* virtual entry point */
-    Elf32_Off e_phoff;                /* program header table offset */
-    Elf32_Off e_shoff;                /* section header table offset */
-    Elf32_Word e_flags;               /* processor-specific flags */
-    Elf32_Half e_ehsize;              /* ELF header size */
-    Elf32_Half e_phentsize;           /* program header entry size */
-    Elf32_Half e_phnum;               /* number of program header entries */
-    Elf32_Half e_shentsize;           /* section header entry size */
-    Elf32_Half e_shnum;               /* number of section header entries */
-    Elf32_Half e_shstrndx;            /* section header table's "section
-                                         header string table" entry offset */
-} Elf32_Ehdr;
-
-typedef struct {
-    unsigned char e_ident[EI_NIDENT]; /* Id bytes */
-    Elf64_Quarter e_type;             /* file type */
-    Elf64_Quarter e_machine;          /* machine type */
-    Elf64_Half e_version;             /* version number */
-    Elf64_Addr e_entry;               /* entry point */
-    Elf64_Off e_phoff;                /* Program hdr offset */
-    Elf64_Off e_shoff;                /* Section hdr offset */
-    Elf64_Half e_flags;               /* Processor flags */
-    Elf64_Quarter e_ehsize;           /* sizeof ehdr */
-    Elf64_Quarter e_phentsize;        /* Program header entry size */
-    Elf64_Quarter e_phnum;            /* Number of program headers */
-    Elf64_Quarter e_shentsize;        /* Section header entry size */
-    Elf64_Quarter e_shnum;            /* Number of section headers */
-    Elf64_Quarter e_shstrndx;         /* String table index */
-} Elf64_Ehdr;
-
-/* e_type */
-#define ET_NONE 0        /* No file type */
-#define ET_REL 1         /* relocatable file */
-#define ET_EXEC 2        /* executable file */
-#define ET_DYN 3         /* shared object file */
-#define ET_CORE 4        /* core file */
-#define ET_NUM 5         /* number of types */
-#define ET_LOPROC 0xff00 /* reserved range for processor */
-#define ET_HIPROC 0xffff /*  specific e_type */
-
-/* e_machine */
-#define EM_NONE 0  /* No Machine */
-#define EM_M32 1   /* AT&T WE 32100 */
-#define EM_SPARC 2 /* SPARC */
-#define EM_386 3   /* Intel 80386 */
-#define EM_68K 4   /* Motorola 68000 */
-#define EM_88K 5   /* Motorola 88000 */
-#define EM_486 6   /* Intel 80486 - unused? */
-#define EM_860 7   /* Intel 80860 */
-#define EM_MIPS 8  /* MIPS R3000 Big-Endian only */
-/*
- * Don't know if EM_MIPS_RS4_BE,
- * EM_SPARC64, EM_PARISC,
- * or EM_PPC are ABI compliant
- */
-#define EM_MIPS_RS4_BE 10 /* MIPS R4000 Big-Endian */
-#define EM_SPARC64 11     /* SPARC v9 64-bit unofficial */
-#define EM_PARISC 15      /* HPPA */
-#define EM_SPARC32PLUS 18 /* Enhanced instruction set SPARC */
-#define EM_PPC 20         /* PowerPC */
-#define EM_ARM 40         /* ARM AArch32 */
-#define EM_ALPHA 41       /* DEC ALPHA */
-#define EM_SH 42          /* Hitachi/Renesas Super-H */
-#define EM_SPARCV9 43     /* SPARC version 9 */
-#define EM_IA_64 50       /* Intel IA-64 Processor */
-#define EM_AMD64 62       /* AMD64 architecture */
-#define EM_VAX 75         /* DEC VAX */
-#define EM_AARCH64 183    /* ARM AArch64 */
-
-/* Non-standard */
-#define EM_ALPHA_EXP 0x9026 /* DEC ALPHA */
-
-#define EM_RISCV 243
-
-/* Version */
-#define EV_NONE 0    /* Invalid */
-#define EV_CURRENT 1 /* Current */
-#define EV_NUM 2     /* number of versions */
-
-/* Section Header */
-typedef struct {
-    Elf32_Word sh_name;      /* name - index into section header
-                              * string table section */
-    Elf32_Word sh_type;      /* type */
-    Elf32_Word sh_flags;     /* flags */
-    Elf32_Addr sh_addr;      /* address */
-    Elf32_Off sh_offset;     /* file offset */
-    Elf32_Word sh_size;      /* section size */
-    Elf32_Word sh_link;      /* section header table index link */
-    Elf32_Word sh_info;      /* extra information */
-    Elf32_Word sh_addralign; /* address alignment */
-    Elf32_Word sh_entsize;   /* section entry size */
-} Elf32_Shdr;
-
-typedef struct {
-    Elf64_Half sh_name;       /* section name */
-    Elf64_Half sh_type;       /* section type */
-    Elf64_Xword sh_flags;     /* section flags */
-    Elf64_Addr sh_addr;       /* virtual address */
-    Elf64_Off sh_offset;      /* file offset */
-    Elf64_Xword sh_size;      /* section size */
-    Elf64_Half sh_link;       /* link to another */
-    Elf64_Half sh_info;       /* misc info */
-    Elf64_Xword sh_addralign; /* memory alignment */
-    Elf64_Xword sh_entsize;   /* table entry size */
-} Elf64_Shdr;
-
-/* Special Section Indexes */
-#define SHN_UNDEF 0          /* undefined */
-#define SHN_LORESERVE 0xff00 /* lower bounds of reserved indexes */
-#define SHN_LOPROC 0xff00    /* reserved range for processor */
-#define SHN_HIPROC 0xff1f    /*   specific section indexes */
-#define SHN_ABS 0xfff1       /* absolute value */
-#define SHN_COMMON 0xfff2    /* common symbol */
-#define SHN_HIRESERVE 0xffff /* upper bounds of reserved indexes */
-
-/* sh_type */
-#define SHT_NULL 0            /* inactive */
-#define SHT_PROGBITS 1        /* program defined information */
-#define SHT_SYMTAB 2          /* symbol table section */
-#define SHT_STRTAB 3          /* string table section */
-#define SHT_RELA 4            /* relocation section with addends*/
-#define SHT_HASH 5            /* symbol hash table section */
-#define SHT_DYNAMIC 6         /* dynamic section */
-#define SHT_NOTE 7            /* note section */
-#define SHT_NOBITS 8          /* no space section */
-#define SHT_REL 9             /* relation section without addends */
-#define SHT_SHLIB 10          /* reserved - purpose unknown */
-#define SHT_DYNSYM 11         /* dynamic symbol table section */
-#define SHT_NUM 12            /* number of section types */
-#define SHT_LOPROC 0x70000000 /* reserved range for processor */
-#define SHT_HIPROC 0x7fffffff /*  specific section header types */
-#define SHT_LOUSER 0x80000000 /* reserved range for application */
-#define SHT_HIUSER 0xffffffff /*  specific indexes */
-
-/* Section names */
-#define ELF_BSS ".bss"               /* uninitialized data */
-#define ELF_DATA ".data"             /* initialized data */
-#define ELF_DEBUG ".debug"           /* debug */
-#define ELF_DYNAMIC ".dynamic"       /* dynamic linking information */
-#define ELF_DYNSTR ".dynstr"         /* dynamic string table */
-#define ELF_DYNSYM ".dynsym"         /* dynamic symbol table */
-#define ELF_FINI ".fini"             /* termination code */
-#define ELF_GOT ".got"               /* global offset table */
-#define ELF_HASH ".hash"             /* symbol hash table */
-#define ELF_INIT ".init"             /* initialization code */
-#define ELF_REL_DATA ".rel.data"     /* relocation data */
-#define ELF_REL_FINI ".rel.fini"     /* relocation termination code */
-#define ELF_REL_INIT ".rel.init"     /* relocation initialization code */
-#define ELF_REL_DYN ".rel.dyn"       /* relocation dynamic link info */
-#define ELF_REL_RODATA ".rel.rodata" /* relocation read-only data */
-#define ELF_REL_TEXT ".rel.text"     /* relocation code */
-#define ELF_RODATA ".rodata"         /* read-only data */
-#define ELF_SHSTRTAB ".shstrtab"     /* section header string table */
-#define ELF_STRTAB ".strtab"         /* string table */
-#define ELF_SYMTAB ".symtab"         /* symbol table */
-#define ELF_TEXT ".text"             /* code */
-
-/* Section Attribute Flags - sh_flags */
-#define SHF_WRITE 0x1     /* Writable */
-#define SHF_ALLOC 0x2     /* occupies memory */
-#define SHF_EXECINSTR 0x4 /* executable */
-#define SHF_TLS 0x400     /* thread local storage */
-#define SHF_MASKPROC                                                           \
-    0xf0000000 /* reserved bits for processor                                  \
-                *  specific section attributes */
-
-/* Symbol Table Entry */
-typedef struct elf32_sym {
-    Elf32_Word st_name;     /* name - index into string table */
-    Elf32_Addr st_value;    /* symbol value */
-    Elf32_Word st_size;     /* symbol size */
-    unsigned char st_info;  /* type and binding */
-    unsigned char st_other; /* 0 - no defined meaning */
-    Elf32_Half st_shndx;    /* section header index */
-} Elf32_Sym;
-
-typedef struct {
-    Elf64_Half st_name;     /* Symbol name index in str table */
-    Elf_Byte st_info;       /* type / binding attrs */
-    Elf_Byte st_other;      /* unused */
-    Elf64_Quarter st_shndx; /* section index of symbol */
-    Elf64_Xword st_value;   /* value of symbol */
-    Elf64_Xword st_size;    /* size of symbol */
-} Elf64_Sym;
-
-/* Symbol table index */
-#define STN_UNDEF 0 /* undefined */
-
-/* Extract symbol info - st_info */
-#define ELF32_ST_BIND(x) ((x) >> 4)
-#define ELF32_ST_TYPE(x) (((unsigned int)x) & 0xf)
-#define ELF32_ST_INFO(b, t) (((b) << 4) + ((t)&0xf))
-
-#define ELF64_ST_BIND(x) ((x) >> 4)
-#define ELF64_ST_TYPE(x) (((unsigned int)x) & 0xf)
-#define ELF64_ST_INFO(b, t) (((b) << 4) + ((t)&0xf))
-
-/* Symbol Binding - ELF32_ST_BIND - st_info */
-#define STB_LOCAL 0   /* Local symbol */
-#define STB_GLOBAL 1  /* Global symbol */
-#define STB_WEAK 2    /* like global - lower precedence */
-#define STB_NUM 3     /* number of symbol bindings */
-#define STB_LOPROC 13 /* reserved range for processor */
-#define STB_HIPROC 15 /*  specific symbol bindings */
-
-/* Symbol type - ELF32_ST_TYPE - st_info */
-#define STT_NOTYPE 0  /* not specified */
-#define STT_OBJECT 1  /* data object */
-#define STT_FUNC 2    /* function */
-#define STT_SECTION 3 /* section */
-#define STT_FILE 4    /* file */
-#define STT_TLS 6     /* thread local storage */
-#define STT_LOPROC 13 /* reserved range for processor */
-#define STT_HIPROC 15 /*  specific symbol types */
-
-/* Relocation entry with implicit addend */
-typedef struct {
-    Elf32_Addr r_offset; /* offset of relocation */
-    Elf32_Word r_info;   /* symbol table index and type */
-} Elf32_Rel;
-
-/* Relocation entry with explicit addend */
-typedef struct {
-    Elf32_Addr r_offset; /* offset of relocation */
-    Elf32_Word r_info;   /* symbol table index and type */
-    Elf32_Sword r_addend;
-} Elf32_Rela;
-
-/* Extract relocation info - r_info */
-#define ELF32_R_SYM(i) ((i) >> 8)
-#define ELF32_R_TYPE(i) ((unsigned char)(i))
-#define ELF32_R_INFO(s, t) (((s) << 8) + (unsigned char)(t))
-
-typedef struct {
-    Elf64_Xword r_offset; /* where to do it */
-    Elf64_Xword r_info;   /* index & type of relocation */
-} Elf64_Rel;
-
-typedef struct {
-    Elf64_Xword r_offset;  /* where to do it */
-    Elf64_Xword r_info;    /* index & type of relocation */
-    Elf64_Sxword r_addend; /* adjustment value */
-} Elf64_Rela;
-
-#define ELF64_R_SYM(info) ((info) >> 32)
-#define ELF64_R_TYPE(info) ((info)&0xFFFFFFFF)
-#define ELF64_R_INFO(s, t) (((s) << 32) + (__uint32_t)(t))
-
-#if defined(__mips64__) && defined(__MIPSEL__)
-/*
- * The 64-bit MIPS ELF ABI uses a slightly different relocation format
- * than the regular ELF ABI: the r_info field is split into several
- * pieces (see gnu/usr.bin/binutils/include/elf/mips.h for details).
- */
-#undef ELF64_R_SYM
-#undef ELF64_R_TYPE
-#undef ELF64_R_INFO
-#define ELF64_R_TYPE(info) (swap32((info) >> 32))
-#define ELF64_R_SYM(info) ((info)&0xFFFFFFFF)
-#define ELF64_R_INFO(s, t) (((__uint64_t)swap32(t) << 32) + (__uint32_t)(s))
-#endif /* __mips64__ && __MIPSEL__ */
-
-/* Program Header */
-typedef struct {
-    Elf32_Word p_type;   /* segment type */
-    Elf32_Off p_offset;  /* segment offset */
-    Elf32_Addr p_vaddr;  /* virtual address of segment */
-    Elf32_Addr p_paddr;  /* physical address - ignored? */
-    Elf32_Word p_filesz; /* number of bytes in file for seg. */
-    Elf32_Word p_memsz;  /* number of bytes in mem. for seg. */
-    Elf32_Word p_flags;  /* flags */
-    Elf32_Word p_align;  /* memory alignment */
-} Elf32_Phdr;
-
-typedef struct {
-    Elf64_Half p_type;    /* entry type */
-    Elf64_Half p_flags;   /* flags */
-    Elf64_Off p_offset;   /* offset */
-    Elf64_Addr p_vaddr;   /* virtual address */
-    Elf64_Addr p_paddr;   /* physical address */
-    Elf64_Xword p_filesz; /* file size */
-    Elf64_Xword p_memsz;  /* memory size */
-    Elf64_Xword p_align;  /* memory & file alignment */
-} Elf64_Phdr;
-
-/* Segment types - p_type */
-#define PT_NULL 0            /* unused */
-#define PT_LOAD 1            /* loadable segment */
-#define PT_DYNAMIC 2         /* dynamic linking section */
-#define PT_INTERP 3          /* the RTLD */
-#define PT_NOTE 4            /* auxiliary information */
-#define PT_SHLIB 5           /* reserved - purpose undefined */
-#define PT_PHDR 6            /* program header */
-#define PT_TLS 7             /* thread local storage */
-#define PT_LOOS 0x60000000   /* reserved range for OS */
-#define PT_HIOS 0x6fffffff   /*  specific segment types */
-#define PT_LOPROC 0x70000000 /* reserved range for processor */
-#define PT_HIPROC 0x7fffffff /*  specific segment types */
-
-#define PT_OPENBSD_RANDOMIZE 0x65a3dbe6 /* fill with random data */
-#define PT_GANDR_KERNEL 0x67646b6c      /* gdkl */
-
-/* Segment flags - p_flags */
-#define PF_X 0x1               /* Executable */
-#define PF_W 0x2               /* Writable */
-#define PF_R 0x4               /* Readable */
-#define PF_MASKPROC 0xf0000000 /* reserved bits for processor */
-                               /*  specific segment flags */
-
-/* Dynamic structure */
-typedef struct {
-    Elf32_Sword d_tag; /* controls meaning of d_val */
-    union {
-        Elf32_Word d_val; /* Multiple meanings - see d_tag */
-        Elf32_Addr d_ptr; /* program virtual address */
-    } d_un;
-} Elf32_Dyn;
-
-typedef struct {
-    Elf64_Xword d_tag; /* controls meaning of d_val */
-    union {
-        Elf64_Addr d_ptr;
-        Elf64_Xword d_val;
-    } d_un;
-} Elf64_Dyn;
-
-/* Dynamic Array Tags - d_tag */
-#define DT_NULL 0     /* marks end of _DYNAMIC array */
-#define DT_NEEDED 1   /* string table offset of needed lib */
-#define DT_PLTRELSZ 2 /* size of relocation entries in PLT */
-#define DT_PLTGOT 3   /* address PLT/GOT */
-#define DT_HASH 4     /* address of symbol hash table */
-#define DT_STRTAB 5   /* address of string table */
-#define DT_SYMTAB 6   /* address of symbol table */
-#define DT_RELA 7     /* address of relocation table */
-#define DT_RELASZ 8   /* size of relocation table */
-#define DT_RELAENT 9  /* size of relocation entry */
-#define DT_STRSZ 10   /* size of string table */
-#define DT_SYMENT 11  /* size of symbol table entry */
-#define DT_INIT 12    /* address of initialization func. */
-#define DT_FINI 13    /* address of termination function */
-#define DT_SONAME 14  /* string table offset of shared obj */
-#define DT_RPATH                                                               \
-    15                       /* string table offset of library                 \
-                              * search path */
-#define DT_SYMBOLIC 16       /* start sym search in shared obj. */
-#define DT_REL 17            /* address of rel. tbl. w addends */
-#define DT_RELSZ 18          /* size of DT_REL relocation table */
-#define DT_RELENT 19         /* size of DT_REL relocation entry */
-#define DT_PLTREL 20         /* PLT referenced relocation entry */
-#define DT_DEBUG 21          /* bugger */
-#define DT_TEXTREL 22        /* Allow rel. mod. to unwritable seg */
-#define DT_JMPREL 23         /* add. of PLT's relocation entries */
-#define DT_BIND_NOW 24       /* Bind now regardless of env setting */
-#define DT_LOOS 0x6000000d   /* reserved range for OS */
-#define DT_HIOS 0x6ffff000   /*  specific dynamic array tags */
-#define DT_LOPROC 0x70000000 /* reserved range for processor */
-#define DT_HIPROC 0x7fffffff /*  specific dynamic array tags */
-
-/* some other useful tags */
-#define DT_RELACOUNT 0x6ffffff9 /* if present, number of RELATIVE */
-#define DT_RELCOUNT 0x6ffffffa  /* relocs, which must come first */
-#define DT_FLAGS_1 0x6ffffffb
-
-/* Dynamic Flags - DT_FLAGS_1 .dynamic entry */
-#define DF_1_NOW 0x00000001
-#define DF_1_GLOBAL 0x00000002
-#define DF_1_GROUP 0x00000004
-#define DF_1_NODELETE 0x00000008
-#define DF_1_LOADFLTR 0x00000010
-#define DF_1_INITFIRST 0x00000020
-#define DF_1_NOOPEN 0x00000040
-#define DF_1_ORIGIN 0x00000080
-#define DF_1_DIRECT 0x00000100
-#define DF_1_TRANS 0x00000200
-#define DF_1_INTERPOSE 0x00000400
-#define DF_1_NODEFLIB 0x00000800
-#define DF_1_NODUMP 0x00001000
-#define DF_1_CONLFAT 0x00002000
-
-/* ld.so: number of low tags that are used saved internally (0 .. DT_NUM-1) */
-#define DT_NUM (DT_JMPREL + 1)
-
-/*
- * Note Definitions
- */
-typedef struct {
-    Elf32_Word namesz;
-    Elf32_Word descsz;
-    Elf32_Word type;
-} Elf32_Note;
-
-typedef struct {
-    Elf64_Half namesz;
-    Elf64_Half descsz;
-    Elf64_Half type;
-} Elf64_Note;
-
-#if defined(ELFSIZE) && (ELFSIZE == 32)
-#define Elf_Ehdr Elf32_Ehdr
-#define Elf_Phdr Elf32_Phdr
-#define Elf_Shdr Elf32_Shdr
-#define Elf_Sym Elf32_Sym
-#define Elf_Rel Elf32_Rel
-#define Elf_RelA Elf32_Rela
-#define Elf_Dyn Elf32_Dyn
-#define Elf_Half Elf32_Half
-#define Elf_Word Elf32_Word
-#define Elf_Sword Elf32_Sword
-#define Elf_Addr Elf32_Addr
-#define Elf_Off Elf32_Off
-#define Elf_Nhdr Elf32_Nhdr
-#define Elf_Note Elf32_Note
-
-#define ELF_R_SYM ELF32_R_SYM
-#define ELF_R_TYPE ELF32_R_TYPE
-#define ELF_R_INFO ELF32_R_INFO
-#define ELFCLASS ELFCLASS32
-
-#define ELF_ST_BIND ELF32_ST_BIND
-#define ELF_ST_TYPE ELF32_ST_TYPE
-#define ELF_ST_INFO ELF32_ST_INFO
-
-#elif defined(ELFSIZE) && (ELFSIZE == 64)
-
-#define Elf_Ehdr Elf64_Ehdr
-#define Elf_Phdr Elf64_Phdr
-#define Elf_Shdr Elf64_Shdr
-#define Elf_Sym Elf64_Sym
-#define Elf_Rel Elf64_Rel
-#define Elf_RelA Elf64_Rela
-#define Elf_Dyn Elf64_Dyn
-#define Elf_Half Elf64_Half
-#define Elf_Word Elf64_Word
-#define Elf_Sword Elf64_Sword
-#define Elf_Addr Elf64_Addr
-#define Elf_Off Elf64_Off
-#define Elf_Nhdr Elf64_Nhdr
-#define Elf_Note Elf64_Note
-
-#define ELF_R_SYM ELF64_R_SYM
-#define ELF_R_TYPE ELF64_R_TYPE
-#define ELF_R_INFO ELF64_R_INFO
-#define ELFCLASS ELFCLASS64
-
-#define ELF_ST_BIND ELF64_ST_BIND
-#define ELF_ST_TYPE ELF64_ST_TYPE
-#define ELF_ST_INFO ELF64_ST_INFO
-
-#endif
-
-#endif
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/elfarch.h b/modules/xpu/src/runtime/elfarch.h
deleted file mode 100644
index 11f666c984..0000000000
--- a/modules/xpu/src/runtime/elfarch.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef ELFARCH_H
-#define ELFARCH_H
-
-#if defined(__i386__)
-#define EM_THIS EM_386
-#define EL_ARCH_USES_REL
-#elif defined(__amd64__)
-#define EM_THIS EM_AMD64
-#define EL_ARCH_USES_RELA
-#elif defined(__arm__)
-#define EM_THIS EM_ARM
-#elif defined(__aarch64__)
-#define EM_THIS EM_AARCH64
-#define EL_ARCH_USES_RELA
-#define EL_ARCH_USES_REL
-#elif defined(__riscv)
-#define EM_THIS EM_RISCV
-#define EL_ARCH_USES_RELA
-#else
-#error specify your ELF architecture
-#endif
-
-#if defined(__LP64__) || defined(__LLP64__)
-#define ELFSIZE 64
-#else
-#define ELFSIZE 32
-#endif
-
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#define ELFDATATHIS ELFDATA2LSB
-#else
-#define ELFDATATHIS ELFDATA2MSB
-#endif
-
-#endif
diff --git a/modules/xpu/src/runtime/elfload.cpp b/modules/xpu/src/runtime/elfload.cpp
deleted file mode 100644
index 23e4b355e9..0000000000
--- a/modules/xpu/src/runtime/elfload.cpp
+++ /dev/null
@@ -1,262 +0,0 @@
-#include "elfload.h"
-#include <cstdio>
-#include <cstring>
-
-el_status el_pread(el_ctx *ctx, void *def, size_t nb, size_t offset) {
-    return ctx->pread(ctx, def, nb, offset) ? EL_OK : EL_EIO;
-}
-
-#define EL_PHOFF(ctx, num)                                                     \
-    (((ctx)->ehdr.e_phoff + (num) * (ctx)->ehdr.e_phentsize))
-
-el_status el_findphdr(el_ctx *ctx, Elf_Phdr *phdr, uint32_t type, unsigned *i) {
-    el_status rv = EL_OK;
-    for (; *i < ctx->ehdr.e_phnum; (*i)++) {
-        if ((rv = el_pread(ctx, phdr, sizeof *phdr, EL_PHOFF(ctx, *i))))
-            return rv;
-
-        if (phdr->p_type == type) {
-            return rv;
-        }
-    }
-
-    *i = -1;
-    return rv;
-}
-
-el_status el_init(el_ctx *ctx) {
-    el_status rv = EL_OK;
-    if ((rv = el_pread(ctx, &ctx->ehdr, sizeof ctx->ehdr, 0)))
-        return rv;
-
-    /* validate header */
-
-    if (!IS_ELF(ctx->ehdr))
-        return EL_NOTELF;
-
-    if (ctx->ehdr.e_ident[EI_CLASS] != ELFCLASS)
-        return EL_WRONGBITS;
-
-    if (ctx->ehdr.e_ident[EI_DATA] != ELFDATATHIS)
-        return EL_WRONGENDIAN;
-
-    if (ctx->ehdr.e_ident[EI_VERSION] != EV_CURRENT)
-        return EL_NOTELF;
-
-#if 0
-    /* gandr binaries use the STANDALONE ABI */
-    if (ctx->ehdr.e_ident[EI_OSABI] != ELFOSABI_STANDALONE)
-        return EL_WRONGOS;
-
-    /* G is for Gandr
-    if (ctx->ehdr.e_ident[EI_ABIVERSION] != 'G')
-        return EL_WRONGOS; */
-#endif
-
-    if (ctx->ehdr.e_type != ET_EXEC && ctx->ehdr.e_type != ET_DYN)
-        return EL_NOTEXEC;
-
-    if (ctx->ehdr.e_machine != EM_THIS)
-        return EL_WRONGARCH;
-
-    if (ctx->ehdr.e_version != EV_CURRENT)
-        return EL_NOTELF;
-
-    /* load phdrs */
-    Elf_Phdr ph;
-
-    /* iterate through, calculate extents */
-    ctx->base_load_paddr = ctx->base_load_vaddr = 0;
-    ctx->align = 1;
-    ctx->memsz = 0;
-
-    unsigned i = 0;
-    for (;;) {
-        if ((rv = el_findphdr(ctx, &ph, PT_LOAD, &i)))
-            return rv;
-
-        if (i == (unsigned)-1)
-            break;
-
-        Elf_Addr phend = ph.p_vaddr + ph.p_memsz;
-        if (phend > ctx->memsz)
-            ctx->memsz = phend;
-
-        if (ph.p_align > ctx->align)
-            ctx->align = ph.p_align;
-
-        i++;
-    }
-
-    if (ctx->ehdr.e_type == ET_DYN) {
-        i = 0;
-
-        if ((rv = el_findphdr(ctx, &ph, PT_DYNAMIC, &i)))
-            return rv;
-
-        if (i == (unsigned)-1)
-            return EL_NODYN;
-
-        ctx->dynoff = ph.p_offset;
-        ctx->dynsize = ph.p_filesz;
-    } else {
-        ctx->dynoff = 0;
-        ctx->dynsize = 0;
-    }
-
-    return rv;
-}
-
-/*
-typedef void* (*el_alloc_cb)(
-    el_ctx *ctx,
-    Elf_Addr phys,
-    Elf_Addr virt,
-    Elf_Addr size);
-*/
-
-el_status el_load(el_ctx *ctx, el_alloc_cb alloc) {
-    el_status rv = EL_OK;
-
-    /* address deltas */
-    Elf_Addr pdelta = ctx->base_load_paddr;
-    Elf_Addr vdelta = ctx->base_load_vaddr;
-
-    /* iterate paddrs */
-    Elf_Phdr ph;
-    unsigned i = 0;
-    for (;;) {
-        if ((rv = el_findphdr(ctx, &ph, PT_LOAD, &i)))
-            return rv;
-
-        if (i == (unsigned)-1)
-            break;
-
-        Elf_Addr pload = ph.p_paddr + pdelta;
-        Elf_Addr vload = ph.p_vaddr + vdelta;
-
-        /* allocate mem */
-        char *dest = (char *)alloc(ctx, pload, vload, ph.p_memsz);
-        if (!dest)
-            return EL_ENOMEM;
-
-        // printf("Loading seg fileoff %lx, vaddr %lx to %lx\n", ph.p_offset,
-        //  ph.p_vaddr, (uintptr_t)dest);
-
-        /* read loaded portion */
-        if ((rv = el_pread(ctx, dest, ph.p_filesz, ph.p_offset)))
-            return rv;
-
-        /* zero mem-only portion */
-        memset(dest + ph.p_filesz, 0, ph.p_memsz - ph.p_filesz);
-
-        i++;
-    }
-
-    return rv;
-}
-
-el_status el_finddyn(el_ctx *ctx, Elf_Dyn *dyn, uint32_t tag) {
-    el_status rv = EL_OK;
-    size_t ndyn = ctx->dynsize / sizeof(Elf_Dyn);
-
-    for (unsigned i = 0; i < ndyn; i++) {
-        if ((rv = el_pread(ctx, dyn, sizeof *dyn,
-                           ctx->dynoff + i * sizeof *dyn)))
-            return rv;
-
-        if (dyn->d_tag == tag)
-            return EL_OK;
-    }
-
-    dyn->d_tag = DT_NULL;
-    return EL_OK;
-}
-
-el_status el_findrelocs(el_ctx *ctx, el_relocinfo *ri, uint32_t type) {
-    el_status rv = EL_OK;
-
-    Elf_Dyn rel, relsz, relent;
-
-    if ((rv = el_finddyn(ctx, &rel, type)))
-        return rv;
-
-    if ((rv = el_finddyn(ctx, &relsz, type + 1)))
-        return rv;
-
-    if ((rv = el_finddyn(ctx, &relent, type + 2)))
-        return rv;
-
-    if (rel.d_tag == DT_NULL || relsz.d_tag == DT_NULL ||
-        relent.d_tag == DT_NULL) {
-        ri->entrysize = 0;
-        ri->tablesize = 0;
-        ri->tableoff = 0;
-    } else {
-        ri->tableoff = rel.d_un.d_ptr;
-        ri->tablesize = relsz.d_un.d_val;
-        ri->entrysize = relent.d_un.d_val;
-    }
-
-    return rv;
-}
-
-extern el_status el_applyrel(el_ctx *ctx, Elf_Rel *rel);
-extern el_status el_applyrela(el_ctx *ctx, Elf_RelA *rela);
-
-el_status el_relocate(el_ctx *ctx) {
-    el_status rv = EL_OK;
-
-    // not dynamic
-    if (ctx->ehdr.e_type != ET_DYN)
-        return EL_OK;
-
-    char *base = (char *)ctx->base_load_paddr;
-
-    el_relocinfo ri;
-#ifdef EL_ARCH_USES_REL
-    if ((rv = el_findrelocs(ctx, &ri, DT_REL)))
-        return rv;
-
-    if (ri.entrysize != sizeof(Elf_Rel) && ri.tablesize) {
-        EL_DEBUG("Relocation size %u doesn't match expected %u\n", ri.entrysize,
-                 sizeof(Elf_Rel));
-        return EL_BADREL;
-    }
-
-    size_t relcnt = ri.tablesize / sizeof(Elf_Rel);
-    Elf_Rel *reltab = (Elf_Rel *)(base + ri.tableoff);
-    for (size_t i = 0; i < relcnt; i++) {
-        if ((rv = el_applyrel(ctx, &reltab[i])))
-            return rv;
-    }
-#else
-    EL_DEBUG("Architecture doesn't use REL\n");
-#endif
-
-#ifdef EL_ARCH_USES_RELA
-    if ((rv = el_findrelocs(ctx, &ri, DT_RELA)))
-        return rv;
-
-    if (ri.entrysize != sizeof(Elf_RelA) && ri.tablesize) {
-        EL_DEBUG("Relocation size %u doesn't match expected %u\n", ri.entrysize,
-                 sizeof(Elf_RelA));
-        return EL_BADREL;
-    }
-
-    size_t relacnt = ri.tablesize / sizeof(Elf_RelA);
-    Elf_RelA *relatab = (Elf_RelA *)(base + ri.tableoff);
-    for (size_t i = 0; i < relacnt; i++) {
-        if ((rv = el_applyrela(ctx, &relatab[i])))
-            return rv;
-    }
-#else
-    EL_DEBUG("Architecture doesn't use RELA\n");
-#endif
-
-#if !defined(EL_ARCH_USES_REL) && !defined(EL_ARCH_USES_RELA)
-#error No relocation type defined!
-#endif
-
-    return rv;
-}
diff --git a/modules/xpu/src/runtime/elfload.h b/modules/xpu/src/runtime/elfload.h
deleted file mode 100644
index 044fd5f967..0000000000
--- a/modules/xpu/src/runtime/elfload.h
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef ELFLOAD_H
-#define ELFLOAD_H
-#include "elf.h"
-#include "elfarch.h"
-#include <stdbool.h>
-#include <stddef.h>
-
-#ifdef DEBUG
-#include <stdio.h>
-#define EL_DEBUG(...) printf(__VA_ARGS__)
-#else
-#define EL_DEBUG(...)                                                          \
-    do {                                                                       \
-    } while (0)
-#endif
-
-typedef enum {
-    EL_OK = 0,
-
-    EL_EIO,
-    EL_ENOMEM,
-
-    EL_NOTELF,
-    EL_WRONGBITS,
-    EL_WRONGENDIAN,
-    EL_WRONGARCH,
-    EL_WRONGOS,
-    EL_NOTEXEC,
-    EL_NODYN,
-    EL_BADREL,
-
-} el_status;
-
-typedef struct el_ctx {
-    bool (*pread)(struct el_ctx *ctx, void *dest, size_t nb, size_t offset);
-
-    /* base_load_* -> address we are actually going to load at
-     */
-    Elf_Addr base_load_paddr, base_load_vaddr;
-
-    /* size in memory of binary */
-    Elf_Addr memsz;
-
-    /* required alignment */
-    Elf_Addr align;
-
-    /* ELF header */
-    Elf_Ehdr ehdr;
-
-    /* Offset of dynamic table (0 if not ET_DYN) */
-    Elf_Off dynoff;
-    /* Size of dynamic table (0 if not ET_DYN) */
-    Elf_Addr dynsize;
-
-    void *elf;
-} el_ctx;
-
-el_status el_pread(el_ctx *ctx, void *def, size_t nb, size_t offset);
-
-el_status el_init(el_ctx *ctx);
-typedef void *(*el_alloc_cb)(el_ctx *ctx, Elf_Addr phys, Elf_Addr virt,
-                             Elf_Addr size);
-
-el_status el_load(el_ctx *ctx, el_alloc_cb alloccb);
-
-/* find the next phdr of type \p type, starting at \p *i.
- * On success, returns EL_OK with *i set to the phdr number, and the phdr loaded
- * in *phdr.
- *
- * If the end of the phdrs table was reached, *i is set to -1 and the contents
- * of *phdr are undefined
- */
-el_status el_findphdr(el_ctx *ctx, Elf_Phdr *phdr, uint32_t type, unsigned *i);
-
-/* Relocate the loaded executable */
-el_status el_relocate(el_ctx *ctx);
-
-/* find a dynamic table entry
- * returns the entry on success, dyn->d_tag = DT_NULL on failure
- */
-el_status el_finddyn(el_ctx *ctx, Elf_Dyn *dyn, uint32_t type);
-
-typedef struct {
-    Elf_Off tableoff;
-    Elf_Addr tablesize;
-    Elf_Addr entrysize;
-} el_relocinfo;
-
-/* find all information regarding relocations of a specific type.
- *
- * pass DT_REL or DT_RELA for type
- * sets ri->entrysize = 0 if not found
- */
-el_status el_findrelocs(el_ctx *ctx, el_relocinfo *ri, uint32_t type);
-
-#endif
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/elfloader.cpp b/modules/xpu/src/runtime/elfloader.cpp
deleted file mode 100644
index 5675838370..0000000000
--- a/modules/xpu/src/runtime/elfloader.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#include "elfloader.h"
-#include "thread_pool.h"
-
-using namespace nncase;
-using namespace nncase::runtime;
-using namespace nncase::runtime::xpu;
-
-int elfloader::invoke_elf(hardware_context_mt *hw_ctx_impl,
-                          runtime_util_mt *rt_util_mt,
-                          nncase_mt_t *nncase_mt_impl, uint8_t **inputs,
-                          uint8_t *rdata) {
-
-    check(el_init(&ctx_), "initialising");
-
-    // align to ctx.align
-    ptr_ = malloc(ctx_.memsz + ctx_.align);
-    buf_ = (void *)(((size_t)ptr_ + (ctx_.align - 1)) & ~(ctx_.align - 1));
-
-#if defined(__linux__)
-    if (mprotect(buf_, ctx_.memsz, PROT_READ | PROT_WRITE | PROT_EXEC)) {
-        perror("mprotect");
-        return 1;
-    }
-#endif
-
-    ctx_.base_load_vaddr = ctx_.base_load_paddr = (uintptr_t)buf_;
-
-    check(el_load(&ctx_, alloccb), "loading");
-    check(el_relocate(&ctx_), "relocating");
-
-    uintptr_t epaddr = ctx_.ehdr.e_entry + (uintptr_t)buf_;
-
-    entrypoint_t ep = (entrypoint_t)epaddr;
-
-    // printf("Binary entrypoint is %" PRIxPTR "; invoking %p\n",
-    //        (uintptr_t)ctx_.ehdr.e_entry, (void *)epaddr);
-
-#if defined(__riscv)
-    Elf_Shdr sym_shdr;
-    for (size_t i = 0; i < ctx_.ehdr.e_shnum; i++) {
-        memcpy(&sym_shdr,
-               (void *)((uintptr_t)ctx_.elf + ctx_.ehdr.e_shoff +
-                        ctx_.ehdr.e_shentsize * i),
-               ctx_.ehdr.e_shentsize);
-        if (sym_shdr.sh_type == SHT_SYMTAB) {
-            break;
-        }
-    }
-
-    Elf_Shdr str_shdr;
-    memcpy(&str_shdr,
-           (void *)((uintptr_t)ctx_.elf + ctx_.ehdr.e_shoff +
-                    ctx_.ehdr.e_shentsize * sym_shdr.sh_link),
-           ctx_.ehdr.e_shentsize);
-
-    size_t sym_num = sym_shdr.sh_size / sym_shdr.sh_entsize;
-    Elf_Sym symbol;
-    for (size_t i = 0; i < sym_num; i++) {
-        memcpy(&symbol,
-               (void *)((uintptr_t)ctx_.elf + sym_shdr.sh_offset +
-                        sym_shdr.sh_entsize * i),
-               sym_shdr.sh_entsize);
-        if (!strncmp((char *)((uintptr_t)ctx_.elf + str_shdr.sh_offset +
-                              symbol.st_name),
-                     "__global_pointer$", 19)) {
-            break;
-        }
-    }
-    asm volatile("addi sp, sp, -8;\
-        sd gp, 0(sp);\
-        mv gp, %0\
-        "
-                 :
-                 : "r"(symbol.st_value + (uintptr_t)buf_)
-                 :);
-#endif
-    ep(hw_ctx_impl, rt_util_mt, nncase_mt_impl, inputs, rdata);
-#if defined(__riscv)
-
-    asm volatile("ld gp, 0(sp);\
-        addi sp, sp, 8;\
-        "
-                 :
-                 :
-                 :);
-#endif
-    free(ptr_);
-
-    return 0;
-}
diff --git a/modules/xpu/src/runtime/elfloader.h b/modules/xpu/src/runtime/elfloader.h
deleted file mode 100644
index fca10e73b9..0000000000
--- a/modules/xpu/src/runtime/elfloader.h
+++ /dev/null
@@ -1,65 +0,0 @@
-#pragma once
-#include "elfload.h"
-#include "hardware_def.h"
-#include "method_table_impl.h"
-#include <inttypes.h>
-#include <math.h>
-#include <nncase/runtime/xpu/compiler_defs.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#if defined(__linux__)
-#include <sys/mman.h>
-#endif
-
-BEGIN_NS_NNCASE_RT_MODULE(xpu)
-
-typedef void (*entrypoint_t)(hardware_context_mt *hw_ctx_impl,
-                             runtime_util_mt *rt_util_mt,
-                             nncase_mt_t *nncase_mt_impl, uint8_t **inputs,
-                             uint8_t *rdata);
-
-class elfloader {
-  public:
-    elfloader(char *elf) {
-        ctx_.pread = bpread;
-        ctx_.elf = elf;
-    }
-
-    // typedef void (*entrypoint_t)(float (*op_t)(float), float *, float *,
-    // int);
-
-    static bool bpread(el_ctx *ctx, void *dest, size_t nb, size_t offset) {
-        (void)ctx;
-
-        memcpy(dest, (char *)ctx->elf + offset, nb);
-
-        return true;
-    }
-
-    static void *alloccb(el_ctx *ctx, Elf_Addr phys, Elf_Addr virt,
-                         Elf_Addr size) {
-        (void)ctx;
-        (void)phys;
-        (void)size;
-        return (void *)virt;
-    }
-
-    static void check(el_status stat, const char *expln) {
-        if (stat) {
-            fprintf(stderr, "%s: error %d\n", expln, stat);
-            exit(1);
-        }
-    }
-
-    int invoke_elf(hardware_context_mt *hw_ctx_impl,
-                   runtime_util_mt *rt_util_mt, nncase_mt_t *nncase_mt_impl,
-                   uint8_t **inputs, uint8_t *rdata);
-
-  private:
-    void *ptr_;
-    void *buf_;
-    el_ctx ctx_;
-};
-
-END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/elfreloc_aarch64.cpp b/modules/xpu/src/runtime/elfreloc_aarch64.cpp
deleted file mode 100644
index 58a5ad1753..0000000000
--- a/modules/xpu/src/runtime/elfreloc_aarch64.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "elfload.h"
-
-#if defined(__aarch64__)
-
-#define R_AARCH64_NONE 0
-#define R_AARCH64_RELATIVE 1027
-
-el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel) {
-    uintptr_t *p = (uintptr_t *)(rel->r_offset + ctx->base_load_paddr);
-    uint32_t type = ELF_R_TYPE(rel->r_info);
-    uint32_t sym = ELF_R_SYM(rel->r_info);
-
-    switch (type) {
-    case R_AARCH64_NONE:
-        EL_DEBUG("R_AARCH64_NONE\n");
-        break;
-    case R_AARCH64_RELATIVE:
-        if (sym) {
-            EL_DEBUG("R_AARCH64_RELATIVE with symbol ref!\n");
-            return EL_BADREL;
-        }
-
-        EL_DEBUG("Applying R_AARCH64_RELATIVE reloc @%p\n", p);
-        *p = rel->r_addend + ctx->base_load_vaddr;
-        break;
-
-    default:
-        EL_DEBUG("Bad relocation %u\n", type);
-        return EL_BADREL;
-    }
-
-    return EL_OK;
-}
-
-el_status el_applyrel(el_ctx *ctx, Elf_Rel *rel) {
-    uintptr_t *p = (uintptr_t *)(rel->r_offset + ctx->base_load_paddr);
-    uint32_t type = ELF_R_TYPE(rel->r_info);
-    uint32_t sym = ELF_R_SYM(rel->r_info);
-
-    switch (type) {
-    case R_AARCH64_NONE:
-        EL_DEBUG("R_AARCH64_NONE\n");
-        break;
-    case R_AARCH64_RELATIVE:
-        if (sym) {
-            EL_DEBUG("R_AARCH64_RELATIVE with symbol ref!\n");
-            return EL_BADREL;
-        }
-
-        EL_DEBUG("Applying R_AARCH64_RELATIVE reloc @%p\n", p);
-        *p += ctx->base_load_vaddr;
-        break;
-
-    default:
-        EL_DEBUG("Bad relocation %u\n", type);
-        return EL_BADREL;
-    }
-
-    return EL_OK;
-}
-
-#endif
diff --git a/modules/xpu/src/runtime/elfreloc_amd64.cpp b/modules/xpu/src/runtime/elfreloc_amd64.cpp
deleted file mode 100644
index 98e638ae44..0000000000
--- a/modules/xpu/src/runtime/elfreloc_amd64.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "elfload.h"
-
-#if defined(__amd64__)
-
-#define R_AMD64_NONE 0
-#define R_AMD64_RELATIVE 8
-
-el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel) {
-    uint64_t *p = (uint64_t *)(rel->r_offset + ctx->base_load_vaddr);
-    uint32_t type = ELF_R_TYPE(rel->r_info);
-
-    switch (type) {
-    case R_AMD64_NONE:
-        break;
-    case R_AMD64_RELATIVE:
-        EL_DEBUG("Applying R_AMD64_RELATIVE reloc @%p\n", p);
-        *p = rel->r_addend + ctx->base_load_vaddr;
-        break;
-    default:
-        EL_DEBUG("Bad relocation %u\n", type);
-        return EL_BADREL;
-    }
-
-    return EL_OK;
-}
-
-#endif
diff --git a/modules/xpu/src/runtime/elfreloc_i386.cpp b/modules/xpu/src/runtime/elfreloc_i386.cpp
deleted file mode 100644
index 2373ab036c..0000000000
--- a/modules/xpu/src/runtime/elfreloc_i386.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "elfload.h"
-
-#if defined(__i386__)
-
-#define R_386_NONE 0
-#define R_386_RELATIVE 8
-
-el_status el_applyrel(el_ctx *ctx, Elf_Rel *rel) {
-    uint32_t *p = (uint32_t *)(rel->r_offset + ctx->base_load_vaddr);
-    uint32_t type = ELF_R_TYPE(rel->r_info);
-    uint32_t sym = ELF_R_SYM(rel->r_info);
-
-    switch (type) {
-    case R_386_NONE:
-        break;
-    case R_386_RELATIVE:
-        EL_DEBUG("Applying R_386_RELATIVE reloc @%p\n", p);
-        *p += ctx->base_load_vaddr;
-        break;
-    default:
-        EL_DEBUG("Bad relocation %u\n", type);
-        return EL_BADREL;
-    }
-
-    return EL_OK;
-}
-
-#endif
diff --git a/modules/xpu/src/runtime/elfreloc_riscv64.cpp b/modules/xpu/src/runtime/elfreloc_riscv64.cpp
deleted file mode 100644
index 487361da2c..0000000000
--- a/modules/xpu/src/runtime/elfreloc_riscv64.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "elfload.h"
-
-#if defined(__riscv)
-
-#define R_riscv64_NONE 0
-#define R_riscv64_RELATIVE 3
-#define R_riscv64_JUMP_SLOT 5
-
-el_status el_applyrela(el_ctx *ctx, Elf_RelA *rel) {
-    uint64_t *p = (uint64_t *)(rel->r_offset + ctx->base_load_vaddr);
-    uint32_t type = ELF_R_TYPE(rel->r_info);
-    EL_DEBUG("rv\n");
-
-    switch (type) {
-    case R_riscv64_NONE:
-        break;
-    case R_riscv64_RELATIVE:
-        EL_DEBUG("Applying R_riscv64_RELATIVE reloc @%p\n", p);
-        *p = rel->r_addend + ctx->base_load_vaddr;
-        break;
-    case R_riscv64_JUMP_SLOT:
-        EL_DEBUG("Applying R_riscv64_JUMP_SLOT reloc @%p\n", p);
-        break;
-    default:
-        EL_DEBUG("Bad relocation %u\n", type);
-        return EL_BADREL;
-    }
-
-    return EL_OK;
-}
-
-#endif
diff --git a/modules/xpu/src/runtime/gsl-lite.hpp b/modules/xpu/src/runtime/gsl-lite.hpp
deleted file mode 100644
index bcddfb1832..0000000000
--- a/modules/xpu/src/runtime/gsl-lite.hpp
+++ /dev/null
@@ -1,4076 +0,0 @@
-//
-// gsl-lite is based on GSL: Guidelines Support Library.
-// For more information see https://github.com/gsl-lite/gsl-lite
-//
-// Copyright (c) 2015-2018 Martin Moene
-// Copyright (c) 2015-2018 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef GSL_GSL_LITE_HPP_INCLUDED
-#define GSL_GSL_LITE_HPP_INCLUDED
-
-#include <algorithm> // for swap() [pre-C++11], equal(), lexicographical_compare()
-#include <cstddef>   // for size_t, ptrdiff_t, nullptr_t
-#include <exception> // for exception, terminate(), uncaught_exceptions()
-#include <ios>       // for ios_base, streamsize
-#include <iosfwd>    // for basic_ostream<>
-#include <iterator> // for data(), size(), reverse_iterator<>, iterator_traits<>
-#include <limits>
-#include <memory>    // for addressof(), unique_ptr<>, shared_ptr<>
-#include <stdexcept> // for logic_error
-#include <string>
-#include <utility> // for move(), forward<>(), swap()
-
-#define gsl_lite_MAJOR 0
-#define gsl_lite_MINOR 37
-#define gsl_lite_PATCH 0
-
-#define gsl_lite_VERSION                                                       \
-    gsl_STRINGIFY(gsl_lite_MAJOR) "." gsl_STRINGIFY(                           \
-        gsl_lite_MINOR) "." gsl_STRINGIFY(gsl_lite_PATCH)
-
-// gsl-lite backward compatibility:
-
-#if !defined(gsl_CONFIG_DEFAULTS_VERSION)
-#define gsl_CONFIG_DEFAULTS_VERSION gsl_lite_MAJOR
-#endif
-
-#ifdef gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR
-#define gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR                    \
-    gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR
-#pragma message(                                                               \
-    "gsl_CONFIG_ALLOWS_SPAN_CONTAINER_CTOR is deprecated since gsl-lite 0.7; replace with gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR, or consider span(with_container, cont).")
-#endif
-
-#if defined(gsl_CONFIG_CONTRACT_LEVEL_ON)
-#pragma message(                                                               \
-    "gsl_CONFIG_CONTRACT_LEVEL_ON is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_ON.")
-#define gsl_CONFIG_CONTRACT_CHECKING_ON
-#endif
-#if defined(gsl_CONFIG_CONTRACT_LEVEL_OFF)
-#pragma message(                                                               \
-    "gsl_CONFIG_CONTRACT_LEVEL_OFF is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_OFF.")
-#define gsl_CONFIG_CONTRACT_CHECKING_OFF
-#endif
-#if defined(gsl_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY)
-#pragma message(                                                               \
-    "gsl_CONFIG_CONTRACT_LEVEL_EXPECTS_ONLY is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF.")
-#define gsl_CONFIG_CONTRACT_CHECKING_ON
-#define gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF
-#elif defined(gsl_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY)
-#pragma message(                                                               \
-    "gsl_CONFIG_CONTRACT_LEVEL_ENSURES_ONLY is deprecated since gsl-lite 0.36; replace with gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF.")
-#define gsl_CONFIG_CONTRACT_CHECKING_ON
-#define gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF
-#endif
-
-// M-GSL compatibility:
-
-#if defined(GSL_THROW_ON_CONTRACT_VIOLATION)
-#define gsl_CONFIG_CONTRACT_VIOLATION_THROWS
-#endif
-
-#if defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION)
-#define gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES
-#endif
-
-#if defined(GSL_UNENFORCED_ON_CONTRACT_VIOLATION)
-#define gsl_CONFIG_CONTRACT_CHECKING_OFF
-#endif
-
-// Configuration: Features
-
-#ifndef gsl_FEATURE_WITH_CONTAINER_TO_STD
-#define gsl_FEATURE_WITH_CONTAINER_TO_STD 99
-#endif
-
-#ifndef gsl_FEATURE_MAKE_SPAN_TO_STD
-#define gsl_FEATURE_MAKE_SPAN_TO_STD 99
-#endif
-
-#ifndef gsl_FEATURE_BYTE_SPAN_TO_STD
-#define gsl_FEATURE_BYTE_SPAN_TO_STD 99
-#endif
-
-#ifndef gsl_FEATURE_IMPLICIT_MACRO
-#define gsl_FEATURE_IMPLICIT_MACRO 0
-#endif
-
-#ifndef gsl_FEATURE_OWNER_MACRO
-#define gsl_FEATURE_OWNER_MACRO (gsl_CONFIG_DEFAULTS_VERSION == 0)
-#endif
-
-#ifndef gsl_FEATURE_EXPERIMENTAL_RETURN_GUARD
-#define gsl_FEATURE_EXPERIMENTAL_RETURN_GUARD 0
-#endif
-
-#ifndef gsl_FEATURE_GSL_LITE_NAMESPACE
-#define gsl_FEATURE_GSL_LITE_NAMESPACE (gsl_CONFIG_DEFAULTS_VERSION >= 1)
-#endif
-
-// Configuration: Other
-
-#if defined(gsl_CONFIG_TRANSPARENT_NOT_NULL) &&                                \
-    gsl_CONFIG_TRANSPARENT_NOT_NULL &&                                         \
-    defined(gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF)
-#error configuration option gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF is meaningless if gsl_CONFIG_TRANSPARENT_NOT_NULL=1
-#endif
-
-#ifndef gsl_CONFIG_DEPRECATE_TO_LEVEL
-#if gsl_CONFIG_DEFAULTS_VERSION >= 1
-#define gsl_CONFIG_DEPRECATE_TO_LEVEL 6
-#else
-#define gsl_CONFIG_DEPRECATE_TO_LEVEL 0
-#endif
-#endif
-
-#ifndef gsl_CONFIG_SPAN_INDEX_TYPE
-#define gsl_CONFIG_SPAN_INDEX_TYPE std::size_t
-#endif
-
-#ifndef gsl_CONFIG_INDEX_TYPE
-#if gsl_CONFIG_DEFAULTS_VERSION >= 1
-// p0122r3 uses std::ptrdiff_t
-#define gsl_CONFIG_INDEX_TYPE std::ptrdiff_t
-#else
-#define gsl_CONFIG_INDEX_TYPE gsl_CONFIG_SPAN_INDEX_TYPE
-#endif
-#endif
-
-#ifndef gsl_CONFIG_NOT_NULL_EXPLICIT_CTOR
-#define gsl_CONFIG_NOT_NULL_EXPLICIT_CTOR (gsl_CONFIG_DEFAULTS_VERSION >= 1)
-#endif
-
-#ifndef gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF
-#define gsl_CONFIG_NOT_NULL_GET_BY_CONST_REF 0
-#endif
-
-#ifndef gsl_CONFIG_TRANSPARENT_NOT_NULL
-#define gsl_CONFIG_TRANSPARENT_NOT_NULL (gsl_CONFIG_DEFAULTS_VERSION >= 1)
-#endif
-
-#ifndef gsl_CONFIG_CONFIRMS_COMPILATION_ERRORS
-#define gsl_CONFIG_CONFIRMS_COMPILATION_ERRORS 0
-#endif
-
-#ifndef gsl_CONFIG_ALLOWS_SPAN_COMPARISON
-#define gsl_CONFIG_ALLOWS_SPAN_COMPARISON (gsl_CONFIG_DEFAULTS_VERSION == 0)
-#endif
-
-#ifndef gsl_CONFIG_ALLOWS_NONSTRICT_SPAN_COMPARISON
-#define gsl_CONFIG_ALLOWS_NONSTRICT_SPAN_COMPARISON 1
-#endif
-
-#ifndef gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR
-#define gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR 0
-#endif
-
-#ifndef gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION
-#define gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION                                 \
-    (gsl_CONFIG_DEFAULTS_VERSION >= 1)
-#endif
-
-#if 1 < defined(gsl_CONFIG_CONTRACT_CHECKING_AUDIT) +                          \
-            defined(gsl_CONFIG_CONTRACT_CHECKING_ON) +                         \
-            defined(gsl_CONFIG_CONTRACT_CHECKING_OFF)
-#error only one of gsl_CONFIG_CONTRACT_CHECKING_AUDIT, gsl_CONFIG_CONTRACT_CHECKING_ON, and gsl_CONFIG_CONTRACT_CHECKING_OFF may be defined
-#endif
-#if 1 < defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS) +                        \
-            defined(gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES) +                \
-            defined(gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER)
-#error only one of gsl_CONFIG_CONTRACT_VIOLATION_THROWS, gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES, and gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER may be defined
-#endif
-#if 1 < defined(gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME) +                      \
-            defined(gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE)
-#error only one of gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME and gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE may be defined
-#endif
-
-// C++ language version detection (C++20 is speculative):
-// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
-
-#ifndef gsl_CPLUSPLUS
-#if defined(_MSVC_LANG) && !defined(__clang__)
-#define gsl_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)
-#else
-#define gsl_CPLUSPLUS __cplusplus
-#endif
-#endif
-
-#define gsl_CPP98_OR_GREATER (gsl_CPLUSPLUS >= 199711L)
-#define gsl_CPP11_OR_GREATER (gsl_CPLUSPLUS >= 201103L)
-#define gsl_CPP14_OR_GREATER (gsl_CPLUSPLUS >= 201402L)
-#define gsl_CPP17_OR_GREATER (gsl_CPLUSPLUS >= 201703L)
-#define gsl_CPP20_OR_GREATER (gsl_CPLUSPLUS >= 202000L)
-
-// C++ language version (represent 98 as 3):
-
-#define gsl_CPLUSPLUS_V                                                        \
-    (gsl_CPLUSPLUS / 100 - (gsl_CPLUSPLUS > 200000 ? 2000 : 1994))
-
-// half-open range [lo..hi):
-#define gsl_BETWEEN(v, lo, hi) ((lo) <= (v) && (v) < (hi))
-
-// Compiler versions:
-
-// MSVC++  6.0  _MSC_VER == 1200  gsl_COMPILER_MSVC_VERSION ==  60  (Visual
-// Studio 6.0) MSVC++  7.0  _MSC_VER == 1300  gsl_COMPILER_MSVC_VERSION ==  70
-// (Visual Studio .NET 2002) MSVC++  7.1  _MSC_VER == 1310
-// gsl_COMPILER_MSVC_VERSION ==  71  (Visual Studio .NET 2003) MSVC++  8.0
-// _MSC_VER == 1400  gsl_COMPILER_MSVC_VERSION ==  80  (Visual Studio 2005)
-// MSVC++  9.0  _MSC_VER == 1500  gsl_COMPILER_MSVC_VERSION ==  90  (Visual
-// Studio 2008) MSVC++ 10.0  _MSC_VER == 1600  gsl_COMPILER_MSVC_VERSION == 100
-// (Visual Studio 2010) MSVC++ 11.0  _MSC_VER == 1700  gsl_COMPILER_MSVC_VERSION
-// == 110  (Visual Studio 2012) MSVC++ 12.0  _MSC_VER == 1800
-// gsl_COMPILER_MSVC_VERSION == 120  (Visual Studio 2013) MSVC++ 14.0  _MSC_VER
-// == 1900  gsl_COMPILER_MSVC_VERSION == 140  (Visual Studio 2015) MSVC++ 14.1
-// _MSC_VER >= 1910  gsl_COMPILER_MSVC_VERSION == 141  (Visual Studio 2017)
-// MSVC++ 14.2  _MSC_VER >= 1920  gsl_COMPILER_MSVC_VERSION == 142  (Visual
-// Studio 2019)
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#define gsl_COMPILER_MSVC_VER (_MSC_VER)
-#define gsl_COMPILER_MSVC_VERSION (_MSC_VER / 10 - 10 * (5 + (_MSC_VER < 1900)))
-#define gsl_COMPILER_MSVC_VERSION_FULL                                         \
-    (_MSC_VER - 100 * (5 + (_MSC_VER < 1900)))
-#else
-#define gsl_COMPILER_MSVC_VER 0
-#define gsl_COMPILER_MSVC_VERSION 0
-#define gsl_COMPILER_MSVC_VERSION_FULL 0
-#endif
-
-#define gsl_COMPILER_VERSION(major, minor, patch)                              \
-    (10 * (10 * (major) + (minor)) + (patch))
-
-// AppleClang  7.0.0  __apple_build_version__ ==  7000172
-// gsl_COMPILER_APPLECLANG_VERSION ==  700  (Xcode 7.0, 7.0.1) (LLVM 3.7.0)
-// AppleClang  7.0.0  __apple_build_version__ ==  7000176
-// gsl_COMPILER_APPLECLANG_VERSION ==  700  (Xcode 7.1) (LLVM 3.7.0)
-// AppleClang  7.0.2  __apple_build_version__ ==  7000181
-// gsl_COMPILER_APPLECLANG_VERSION ==  702  (Xcode 7.2, 7.2.1) (LLVM 3.7.0)
-// AppleClang  7.3.0  __apple_build_version__ ==  7030029
-// gsl_COMPILER_APPLECLANG_VERSION ==  730  (Xcode 7.3) (LLVM 3.8.0)
-// AppleClang  7.3.0  __apple_build_version__ ==  7030031
-// gsl_COMPILER_APPLECLANG_VERSION ==  730  (Xcode 7.3.1) (LLVM 3.8.0)
-// AppleClang  8.0.0  __apple_build_version__ ==  8000038
-// gsl_COMPILER_APPLECLANG_VERSION ==  800  (Xcode 8.0) (LLVM 3.9.0)
-// AppleClang  8.0.0  __apple_build_version__ ==  8000042
-// gsl_COMPILER_APPLECLANG_VERSION ==  800  (Xcode 8.1, 8.2, 8.2.1) (LLVM 3.9.0)
-// AppleClang  8.1.0  __apple_build_version__ ==  8020038
-// gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3) (LLVM 3.9.0)
-// AppleClang  8.1.0  __apple_build_version__ ==  8020041
-// gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3.1) (LLVM 3.9.0)
-// AppleClang  8.1.0  __apple_build_version__ ==  8020042
-// gsl_COMPILER_APPLECLANG_VERSION ==  810  (Xcode 8.3.2, 8.3.3) (LLVM 3.9.0)
-// AppleClang  9.0.0  __apple_build_version__ ==  9000037
-// gsl_COMPILER_APPLECLANG_VERSION ==  900  (Xcode 9.0) (LLVM 4.0.0?) AppleClang
-// 9.0.0  __apple_build_version__ ==  9000038  gsl_COMPILER_APPLECLANG_VERSION
-// ==  900  (Xcode 9.1)                 (LLVM 4.0.0?) AppleClang  9.0.0
-// __apple_build_version__ ==  9000039  gsl_COMPILER_APPLECLANG_VERSION ==  900
-// (Xcode 9.2)                 (LLVM 4.0.0?) AppleClang  9.1.0
-// __apple_build_version__ ==  9020039  gsl_COMPILER_APPLECLANG_VERSION ==  910
-// (Xcode 9.3, 9.3.1)          (LLVM 5.0.2?) AppleClang  9.1.0
-// __apple_build_version__ ==  9020039  gsl_COMPILER_APPLECLANG_VERSION ==  910
-// (Xcode 9.4, 9.4.1)          (LLVM 5.0.2?) AppleClang 10.0.0
-// __apple_build_version__ == 10001145  gsl_COMPILER_APPLECLANG_VERSION == 1000
-// (Xcode 10.0, 10.1)          (LLVM 6.0.1?) AppleClang 10.0.1
-// __apple_build_version__ == 10010046  gsl_COMPILER_APPLECLANG_VERSION == 1001
-// (Xcode 10.2, 10.2.1, 10.3)  (LLVM 7.0.0?) AppleClang 11.0.0
-// __apple_build_version__ == 11000033  gsl_COMPILER_APPLECLANG_VERSION == 1100
-// (Xcode 11.1, 11.2, 11.3)    (LLVM 8.0.0?)
-
-#if defined(__apple_build_version__)
-#define gsl_COMPILER_APPLECLANG_VERSION                                        \
-    gsl_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
-#define gsl_COMPILER_CLANG_VERSION 0
-#elif defined(__clang__)
-#define gsl_COMPILER_APPLECLANG_VERSION 0
-#define gsl_COMPILER_CLANG_VERSION                                             \
-    gsl_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
-#else
-#define gsl_COMPILER_APPLECLANG_VERSION 0
-#define gsl_COMPILER_CLANG_VERSION 0
-#endif
-
-#if defined(__GNUC__) && !defined(__clang__)
-#define gsl_COMPILER_GNUC_VERSION                                              \
-    gsl_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
-#else
-#define gsl_COMPILER_GNUC_VERSION 0
-#endif
-
-// Compiler non-strict aliasing:
-
-#if defined(__clang__) || defined(__GNUC__)
-#define gsl_may_alias __attribute__((__may_alias__))
-#else
-#define gsl_may_alias
-#endif
-
-// Presence of gsl, language and library features:
-
-#define gsl_IN_STD(v) (((v) == 98 ? 3 : (v)) >= gsl_CPLUSPLUS_V)
-
-#define gsl_DEPRECATE_TO_LEVEL(level) (level <= gsl_CONFIG_DEPRECATE_TO_LEVEL)
-#define gsl_FEATURE_TO_STD(feature) (gsl_IN_STD(gsl_FEATURE(feature##_TO_STD)))
-#define gsl_FEATURE(feature) (gsl_FEATURE_##feature)
-#define gsl_CONFIG(feature) (gsl_CONFIG_##feature)
-#define gsl_HAVE(feature) (gsl_HAVE_##feature)
-
-// Presence of wide character support:
-
-#ifdef __DJGPP__
-#define gsl_HAVE_WCHAR 0
-#else
-#define gsl_HAVE_WCHAR 1
-#endif
-
-// Presence of language & library features:
-
-#if gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 500) ||                          \
-    gsl_BETWEEN(gsl_COMPILER_CLANG_VERSION, 1, 360) ||                         \
-    gsl_COMPILER_APPLECLANG_VERSION
-#ifdef __EXCEPTIONS
-#define gsl_HAVE_EXCEPTIONS 1
-#else
-#define gsl_HAVE_EXCEPTIONS 0
-#endif // __EXCEPTIONS
-#elif gsl_COMPILER_GNUC_VERSION >= 500 || gsl_COMPILER_CLANG_VERSION >= 500
-#ifdef __cpp_exceptions
-#define gsl_HAVE_EXCEPTIONS 1
-#else
-#define gsl_HAVE_EXCEPTIONS 0
-#endif // __cpp_exceptions
-#elif gsl_COMPILER_MSVC_VERSION
-#ifdef _CPPUNWIND
-#define gsl_HAVE_EXCEPTIONS 1
-#else
-#define gsl_HAVE_EXCEPTIONS 0
-#endif // _CPPUNWIND
-#else
-// For all other compilers, assume exceptions are always enabled.
-#define gsl_HAVE_EXCEPTIONS 1
-#endif
-
-#if defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS) && !gsl_HAVE(EXCEPTIONS)
-# error Cannot use gsl_CONFIG_CONTRACT_VIOLATION_THROWS if exceptions are disabled.
-#endif // defined( gsl_CONFIG_CONTRACT_VIOLATION_THROWS ) && !gsl_HAVE(
-       // EXCEPTIONS )
-
-#ifdef _HAS_CPP0X
-#define gsl_HAS_CPP0X _HAS_CPP0X
-#else
-#define gsl_HAS_CPP0X 0
-#endif
-
-#define gsl_CPP11_100 (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1600)
-#define gsl_CPP11_110 (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1700)
-#define gsl_CPP11_120 (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1800)
-#define gsl_CPP11_140 (gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
-
-#define gsl_CPP14_000 (gsl_CPP14_OR_GREATER)
-#define gsl_CPP14_120 (gsl_CPP14_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1800)
-#define gsl_CPP14_140 (gsl_CPP14_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
-
-#define gsl_CPP17_000 (gsl_CPP17_OR_GREATER)
-#define gsl_CPP17_140 (gsl_CPP17_OR_GREATER || gsl_COMPILER_MSVC_VER >= 1900)
-
-#define gsl_CPP11_140_CPP0X_90                                                 \
-    (gsl_CPP11_140 || (gsl_COMPILER_MSVC_VER >= 1500 && gsl_HAS_CPP0X))
-#define gsl_CPP11_140_CPP0X_100                                                \
-    (gsl_CPP11_140 || (gsl_COMPILER_MSVC_VER >= 1600 && gsl_HAS_CPP0X))
-
-// Presence of C++11 language features:
-
-#define gsl_HAVE_AUTO gsl_CPP11_100
-#define gsl_HAVE_NULLPTR gsl_CPP11_100
-#define gsl_HAVE_RVALUE_REFERENCE gsl_CPP11_100
-#define gsl_HAVE_FUNCTION_REF_QUALIFIER                                        \
-    (gsl_CPP14_140 && !gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 481))
-
-#define gsl_HAVE_ENUM_CLASS gsl_CPP11_110
-
-#define gsl_HAVE_ALIAS_TEMPLATE gsl_CPP11_120
-#define gsl_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG gsl_CPP11_120
-#define gsl_HAVE_EXPLICIT gsl_CPP11_120
-#define gsl_HAVE_INITIALIZER_LIST gsl_CPP11_120
-#define gsl_HAVE_VARIADIC_TEMPLATE gsl_CPP11_120
-#define gsl_HAVE_IS_DELETE gsl_CPP11_120
-
-#define gsl_HAVE_CONSTEXPR_11 gsl_CPP11_140
-#define gsl_HAVE_IS_DEFAULT gsl_CPP11_140
-#define gsl_HAVE_NOEXCEPT gsl_CPP11_140
-#define gsl_HAVE_NORETURN                                                      \
-    (gsl_CPP11_140 && !gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 480))
-
-#define gsl_HAVE_EXPRESSION_SFINAE gsl_CPP11_140
-
-#if gsl_CPP11_OR_GREATER
-// see above
-#endif
-
-// Presence of C++14 language features:
-
-#define gsl_HAVE_CONSTEXPR_14                                                  \
-    (gsl_CPP14_000 && !gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 600))
-#define gsl_HAVE_DECLTYPE_AUTO gsl_CPP14_140
-#define gsl_HAVE_DEPRECATED                                                    \
-    (gsl_CPP14_140 && !gsl_BETWEEN(gsl_COMPILER_MSVC_VERSION, 1, 142))
-
-// Presence of C++17 language features:
-// MSVC: template parameter deduction guides since Visual Studio 2017 v15.7
-
-#define gsl_HAVE_ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE gsl_CPP17_000
-#define gsl_HAVE_DEDUCTION_GUIDES                                              \
-    (gsl_CPP17_000 && !gsl_BETWEEN(gsl_COMPILER_MSVC_VERSION_FULL, 1, 1414))
-#define gsl_HAVE_NODISCARD gsl_CPP17_000
-#define gsl_HAVE_CONSTEXPR_17 gsl_CPP17_OR_GREATER
-
-// Presence of C++20 language features:
-
-#define gsl_HAVE_CONSTEXPR_20 gsl_CPP20_OR_GREATER
-
-// Presence of C++ library features:
-
-#define gsl_HAVE_ADDRESSOF gsl_CPP17_000
-#define gsl_HAVE_ARRAY gsl_CPP11_110
-#define gsl_HAVE_TYPE_TRAITS gsl_CPP11_110
-#define gsl_HAVE_TR1_TYPE_TRAITS gsl_CPP11_110
-
-#define gsl_HAVE_CONTAINER_DATA_METHOD gsl_CPP11_140_CPP0X_90
-#define gsl_HAVE_STD_DATA gsl_CPP17_000
-#ifdef __cpp_lib_ssize
-#define gsl_HAVE_STD_SSIZE 1
-#else
-#define gsl_HAVE_STD_SSIZE                                                     \
-    (gsl_COMPILER_GNUC_VERSION >= 1000 && __cplusplus > 201703L)
-#endif
-
-#define gsl_HAVE_SIZED_TYPES gsl_CPP11_140
-
-#define gsl_HAVE_MAKE_SHARED gsl_CPP11_140_CPP0X_100
-#define gsl_HAVE_SHARED_PTR gsl_CPP11_140_CPP0X_100
-#define gsl_HAVE_UNIQUE_PTR gsl_CPP11_140_CPP0X_100
-
-#define gsl_HAVE_MAKE_UNIQUE gsl_CPP14_120
-
-#define gsl_HAVE_UNCAUGHT_EXCEPTIONS gsl_CPP17_140
-
-#define gsl_HAVE_ADD_CONST gsl_HAVE_TYPE_TRAITS
-#define gsl_HAVE_INTEGRAL_CONSTANT gsl_HAVE_TYPE_TRAITS
-#define gsl_HAVE_REMOVE_CONST gsl_HAVE_TYPE_TRAITS
-#define gsl_HAVE_REMOVE_REFERENCE gsl_HAVE_TYPE_TRAITS
-#define gsl_HAVE_REMOVE_CVREF gsl_CPP20_OR_GREATER
-
-#define gsl_HAVE_TR1_ADD_CONST gsl_HAVE_TR1_TYPE_TRAITS
-#define gsl_HAVE_TR1_INTEGRAL_CONSTANT gsl_HAVE_TR1_TYPE_TRAITS
-#define gsl_HAVE_TR1_REMOVE_CONST gsl_HAVE_TR1_TYPE_TRAITS
-#define gsl_HAVE_TR1_REMOVE_REFERENCE gsl_HAVE_TR1_TYPE_TRAITS
-
-// C++ feature usage:
-
-#if gsl_HAVE(ADDRESSOF)
-#define gsl_ADDRESSOF(x) std::addressof(x)
-#else
-#define gsl_ADDRESSOF(x) (&x)
-#endif
-
-#if gsl_HAVE(CONSTEXPR_11)
-#define gsl_constexpr constexpr
-#else
-#define gsl_constexpr /*constexpr*/
-#endif
-
-#if gsl_HAVE(CONSTEXPR_14)
-#define gsl_constexpr14 constexpr
-#else
-#define gsl_constexpr14 /*constexpr*/
-#endif
-
-#if gsl_HAVE(CONSTEXPR_17)
-#define gsl_constexpr17 constexpr
-#else
-#define gsl_constexpr17 /*constexpr*/
-#endif
-
-#if gsl_HAVE(CONSTEXPR_20)
-#define gsl_constexpr20 constexpr
-#else
-#define gsl_constexpr20 /*constexpr*/
-#endif
-
-#if gsl_HAVE(EXPLICIT)
-#define gsl_explicit explicit
-#else
-#define gsl_explicit /*explicit*/
-#endif
-
-#if gsl_FEATURE(IMPLICIT_MACRO)
-#define implicit /*implicit*/
-#endif
-
-#if gsl_HAVE(IS_DELETE)
-#define gsl_is_delete = delete
-#else
-#define gsl_is_delete
-#endif
-
-#if gsl_HAVE(IS_DELETE)
-#define gsl_is_delete_access public
-#else
-#define gsl_is_delete_access private
-#endif
-
-#if !gsl_HAVE(NOEXCEPT) || defined(gsl_TESTING_)
-#define gsl_noexcept /*noexcept*/
-#else
-#define gsl_noexcept noexcept
-#endif
-
-#if gsl_HAVE(NULLPTR)
-#define gsl_nullptr nullptr
-#else
-#define gsl_nullptr NULL
-#endif
-
-#if gsl_HAVE(NODISCARD)
-#define gsl_NODISCARD [[nodiscard]]
-#else
-#define gsl_NODISCARD
-#endif
-
-#if gsl_HAVE(NORETURN)
-#define gsl_NORETURN [[noreturn]]
-#elif defined(_MSC_VER)
-#define gsl_NORETURN __declspec(noreturn)
-#else
-#define gsl_NORETURN
-#endif
-
-#if gsl_HAVE(DEPRECATED) && !defined(gsl_TESTING_)
-#define gsl_DEPRECATED [[deprecated]]
-#define gsl_DEPRECATED_MSG(msg) [[deprecated(msg)]]
-#else
-#define gsl_DEPRECATED
-#define gsl_DEPRECATED_MSG(msg)
-#endif
-
-#if gsl_HAVE(TYPE_TRAITS)
-
-#define gsl_DEFINE_ENUM_BITMASK_OPERATORS_(ENUM)                               \
-    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM operator~(ENUM val)        \
-        gsl_noexcept {                                                         \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
-        return ENUM(~U(val));                                                  \
-    }                                                                          \
-    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM operator|(                 \
-        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
-        return ENUM(U(lhs) | U(rhs));                                          \
-    }                                                                          \
-    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM operator&(                 \
-        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
-        return ENUM(U(lhs) & U(rhs));                                          \
-    }                                                                          \
-    gsl_NODISCARD gsl_api inline gsl_constexpr ENUM operator^(                 \
-        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
-        return ENUM(U(lhs) ^ U(rhs));                                          \
-    }                                                                          \
-    gsl_api inline gsl_constexpr14 ENUM &operator|=(ENUM &lhs, ENUM rhs)       \
-        gsl_noexcept {                                                         \
-        return lhs = lhs | rhs;                                                \
-    }                                                                          \
-    gsl_api inline gsl_constexpr14 ENUM &operator&=(ENUM &lhs, ENUM rhs)       \
-        gsl_noexcept {                                                         \
-        return lhs = lhs & rhs;                                                \
-    }                                                                          \
-    gsl_api inline gsl_constexpr14 ENUM &operator^=(ENUM &lhs, ENUM rhs)       \
-        gsl_noexcept {                                                         \
-        return lhs = lhs ^ rhs;                                                \
-    }
-
-#define gsl_DEFINE_ENUM_RELATIONAL_OPERATORS_(ENUM)                            \
-    gsl_NODISCARD gsl_api inline gsl_constexpr bool operator<(                 \
-        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
-        return U(lhs) < U(rhs);                                                \
-    }                                                                          \
-    gsl_NODISCARD gsl_api inline gsl_constexpr bool operator>(                 \
-        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
-        return U(lhs) > U(rhs);                                                \
-    }                                                                          \
-    gsl_NODISCARD gsl_api inline gsl_constexpr bool operator<=(                \
-        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
-        return U(lhs) <= U(rhs);                                               \
-    }                                                                          \
-    gsl_NODISCARD gsl_api inline gsl_constexpr bool operator>=(                \
-        ENUM lhs, ENUM rhs) gsl_noexcept {                                     \
-        typedef typename ::gsl::std11::underlying_type<ENUM>::type U;          \
-        return U(lhs) >= U(rhs);                                               \
-    }
-
-//
-// Defines bitmask operators `|`, `&`, `^`, `~`, `|=`, `&=`, and `^=` for the
-// given enum type.
-//ᅟ
-//ᅟ    enum class Vegetables {
-//ᅟ        tomato   = 0b001,
-//ᅟ        onion    = 0b010,
-//ᅟ        eggplant = 0b100
-//ᅟ    };
-//ᅟ    gsl_DEFINE_ENUM_BITMASK_OPERATORS( Vegetables )
-//
-#define gsl_DEFINE_ENUM_BITMASK_OPERATORS(ENUM)                                \
-    gsl_DEFINE_ENUM_BITMASK_OPERATORS_(ENUM)
-
-//
-// Defines relational operators `<`, `>`, `<=`, `>=` for the given enum type.
-//ᅟ
-//ᅟ    enum class OperatorPrecedence {
-//ᅟ        additive = 0,
-//ᅟ        multiplicative = 1,
-//ᅟ        power = 2
-//ᅟ    };
-//ᅟ    gsl_DEFINE_ENUM_RELATIONAL_OPERATORS( OperatorPrecedence )
-//
-#define gsl_DEFINE_ENUM_RELATIONAL_OPERATORS(ENUM)                             \
-    gsl_DEFINE_ENUM_RELATIONAL_OPERATORS_(ENUM)
-
-#endif // gsl_HAVE( TYPE_TRAITS )
-
-#define gsl_DIMENSION_OF(a) (sizeof(a) / sizeof(0 [a]))
-
-// Method enabling (C++98, VC120 (VS2013) cannot use __VA_ARGS__)
-
-#if gsl_HAVE(EXPRESSION_SFINAE)
-#define gsl_DECLTYPE_(T, EXPR) decltype(EXPR)
-#else
-#define gsl_DECLTYPE_(T, EXPR) T
-#endif
-
-// NOTE: When using SFINAE in gsl-lite, please note that overloads of function
-// templates must always use SFINAE with non-type default arguments
-//       as explained in
-//       https://en.cppreference.com/w/cpp/types/enable_if#Notes.
-//       `gsl_ENABLE_IF_()` implements graceful fallback to default type
-//       arguments (for compilers that don't support non-type default
-//       arguments); please verify that this is appropriate in the given
-//       situation, and add additional checks if necessary.
-//
-//       Also, please note that `gsl_ENABLE_IF_()` doesn't enforce the
-//       constraint at all if no compiler/library support is available (i.e.
-//       pre-C++11).
-
-#if gsl_HAVE(TYPE_TRAITS) && gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG)
-#if !gsl_BETWEEN(gsl_COMPILER_MSVC_VERSION, 1,                                 \
-                 140) // VS 2013 seems to have trouble with SFINAE for default
-                      // non-type arguments
-#define gsl_ENABLE_IF_(VA) , typename std::enable_if<(VA), int>::type = 0
-#else
-#define gsl_ENABLE_IF_(VA)                                                     \
-    , typename = typename std::enable_if<(VA), ::gsl::detail::enabler>::type
-#endif
-#else
-#define gsl_ENABLE_IF_(VA)
-#endif
-
-// Other features:
-
-#define gsl_HAVE_CONSTRAINED_SPAN_CONTAINER_CTOR                               \
-    (gsl_HAVE_DEFAULT_FUNCTION_TEMPLATE_ARG && gsl_HAVE_CONTAINER_DATA_METHOD)
-
-// Note: !defined(__NVCC__) doesn't work with nvcc here:
-#define gsl_HAVE_UNCONSTRAINED_SPAN_CONTAINER_CTOR                             \
-    (gsl_CONFIG_ALLOWS_UNCONSTRAINED_SPAN_CONTAINER_CTOR && (__NVCC__ == 0))
-
-// GSL API (e.g. for CUDA platform):
-
-// Guidelines for using `gsl_api`:
-//
-// NVCC imposes the restriction that a function annotated `__host__ __device__`
-// cannot call host-only or device-only functions. This makes `gsl_api`
-// inappropriate for generic functions that call unknown code, e.g. the template
-// constructors of `span<>` or functions like `finally()` which accept an
-// arbitrary  function object. It is often preferable to annotate functions only
-// with `gsl_constexpr` or `gsl_constexpr14`. The "extended constexpr" mode of
-// NVCC (currently an experimental feature) will implicitly consider constexpr
-// functions `__host__ __device__` functions but tolerates calls to host-only or
-// device-only functions.
-
-#ifndef gsl_api
-#ifdef __CUDACC__
-#define gsl_api __host__ __device__
-#else
-#define gsl_api /*gsl_api*/
-#endif
-#endif
-
-// Additional includes:
-
-#if gsl_HAVE(ARRAY)
-#include <array>
-#endif
-
-#if !gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR) || !gsl_HAVE(AUTO)
-#include <vector>
-#endif
-
-#if gsl_HAVE(INITIALIZER_LIST)
-#include <initializer_list>
-#endif
-
-#if gsl_HAVE(TYPE_TRAITS)
-#include <type_traits> // for enable_if<>,
-// add_const<>, add_pointer<>, common_type<>, make_signed<>, remove_cv<>,
-// remove_const<>, remove_volatile<>, remove_reference<>, remove_cvref<>,
-// remove_pointer<>, underlying_type<>, is_assignable<>, is_constructible<>,
-// is_const<>, is_convertible<>, is_integral<>, is_pointer<>, is_signed<>,
-// integral_constant<>, declval()
-#elif gsl_HAVE(TR1_TYPE_TRAITS)
-#include <tr1/type_traits> // for add_const<>, remove_cv<>, remove_const<>, remove_volatile<>, remove_reference<>, integral_constant<>
-#endif
-
-// MSVC warning suppression macros:
-
-#if gsl_COMPILER_MSVC_VERSION >= 140 && !defined(__NVCC__)
-#define gsl_SUPPRESS_MSGSL_WARNING(expr) [[gsl::suppress(expr)]]
-#define gsl_SUPPRESS_MSVC_WARNING(code, descr)                                 \
-    __pragma(warning(suppress : code))
-#define gsl_DISABLE_MSVC_WARNINGS(codes)                                       \
-    __pragma(warning(push)) __pragma(warning(disable : codes))
-#define gsl_RESTORE_MSVC_WARNINGS() __pragma(warning(pop))
-#else
-// TODO: define for Clang
-#define gsl_SUPPRESS_MSGSL_WARNING(expr)
-#define gsl_SUPPRESS_MSVC_WARNING(code, descr)
-#define gsl_DISABLE_MSVC_WARNINGS(codes)
-#define gsl_RESTORE_MSVC_WARNINGS()
-#endif
-
-// Suppress the following MSVC GSL warnings:
-// - C26432: gsl::c.21 : if you define or delete any default operation in the
-// type '...', define or delete them all
-// - C26410: gsl::r.32 : the parameter 'ptr' is a reference to const unique
-// pointer, use const T* or const T& instead
-// - C26415: gsl::r.30 : smart pointer parameter 'ptr' is used only to access
-// contained pointer. Use T* or T& instead
-// - C26418: gsl::r.36 : shared pointer parameter 'ptr' is not copied or moved.
-// Use T* or T& instead
-// - C26472: gsl::t.1  : don't use a static_cast for arithmetic conversions;
-//                       use brace initialization, gsl::narrow_cast or
-//                       gsl::narrow
-// - C26439: gsl::f.6  : special function 'function' can be declared 'noexcept'
-// - C26440: gsl::f.6  : function 'function' can be declared 'noexcept'
-// - C26455: gsl::f.6  : default constructor may not throw. Declare it
-// 'noexcept'
-// - C26473: gsl::t.1  : don't cast between pointer types where the source type
-// and the target type are the same
-// - C26481: gsl::b.1  : don't use pointer arithmetic. Use span instead
-// - C26482: gsl::b.2  : only index into arrays using constant expressions
-// - C26446: gdl::b.4  : prefer to use gsl::at() instead of unchecked subscript
-// operator
-// - C26490: gsl::t.1  : don't use reinterpret_cast
-// - C26487: gsl::l.4  : don't return a pointer '(<some number>'s result)' that
-// may be invalid
-
-gsl_DISABLE_MSVC_WARNINGS(
-    26432 26410 26415 26418 26472 26439 26440 26455 26473 26481 26482 26446 26490 26487)
-
-    namespace gsl {
-
-    // forward declare span<>:
-
-    template <class T> class span;
-
-    // C++11 emulation:
-
-    namespace std11 {
-
-#if gsl_HAVE(ADD_CONST)
-
-    using std::add_const;
-
-#elif gsl_HAVE(TR1_ADD_CONST)
-
-    using std::tr1::add_const;
-
-#else
-
-    template <class T> struct add_const { typedef const T type; };
-
-#endif // gsl_HAVE( ADD_CONST )
-
-#if gsl_HAVE(REMOVE_CONST)
-
-    using std::remove_const;
-    using std::remove_cv;
-    using std::remove_volatile;
-
-#elif gsl_HAVE(TR1_REMOVE_CONST)
-
-    using std::tr1::remove_const;
-    using std::tr1::remove_cv;
-    using std::tr1::remove_volatile;
-
-#else
-
-    template <class T> struct remove_const { typedef T type; };
-    template <class T> struct remove_const<T const> { typedef T type; };
-
-    template <class T> struct remove_volatile { typedef T type; };
-    template <class T> struct remove_volatile<T volatile> { typedef T type; };
-
-    template <class T> struct remove_cv {
-        typedef
-            typename remove_volatile<typename remove_const<T>::type>::type type;
-    };
-
-#endif // gsl_HAVE( REMOVE_CONST )
-
-#if gsl_HAVE(REMOVE_REFERENCE)
-
-    using std::remove_reference;
-
-#elif gsl_HAVE(TR1_REMOVE_REFERENCE)
-
-    using std::tr1::remove_reference;
-
-#else
-
-    template <class T> struct remove_reference { typedef T type; };
-    template <class T> struct remove_reference<T &> { typedef T type; };
-#if gsl_HAVE(RVALUE_REFERENCE)
-    template <class T> struct remove_reference<T &&> { typedef T type; };
-#endif
-
-#endif // gsl_HAVE( REMOVE_REFERENCE )
-
-#if gsl_HAVE(INTEGRAL_CONSTANT)
-
-    using std::false_type;
-    using std::integral_constant;
-    using std::true_type;
-
-#elif gsl_HAVE(TR1_INTEGRAL_CONSTANT)
-
-    using std::tr1::false_type;
-    using std::tr1::integral_constant;
-    using std::tr1::true_type;
-
-#else
-
-    template <class T, T v> struct integral_constant {
-        enum { value = v };
-    };
-    typedef integral_constant<bool, true> true_type;
-    typedef integral_constant<bool, false> false_type;
-
-#endif
-
-#if gsl_HAVE(TYPE_TRAITS)
-
-    using std::underlying_type;
-
-#elif gsl_HAVE(TR1_TYPE_TRAITS)
-
-    using std::tr1::underlying_type;
-
-#else
-
-    // We could try to define `underlying_type<>` for pre-C++11 here, but let's
-    // not until someone actually needs it.
-
-#endif
-
-    } // namespace std11
-
-    // C++14 emulation:
-
-    namespace std14 {
-
-#if gsl_HAVE(UNIQUE_PTR)
-#if gsl_HAVE(MAKE_UNIQUE)
-
-    using std::make_unique;
-
-#elif gsl_HAVE(VARIADIC_TEMPLATE)
-
-    template <class T, class... Args>
-    std::unique_ptr<T> make_unique(Args &&...args) {
-        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-    }
-
-#endif // gsl_HAVE( MAKE_UNIQUE ), gsl_HAVE( VARIADIC_TEMPLATE )
-#endif // gsl_HAVE( UNIQUE_PTR )
-
-    } // namespace std14
-
-    namespace detail {
-
-#if gsl_HAVE(VARIADIC_TEMPLATE)
-
-    template <bool V0, class T0, class... Ts> struct conjunction_ {
-        using type = T0;
-    };
-    template <class T0, class T1, class... Ts>
-    struct conjunction_<true, T0, T1, Ts...>
-        : conjunction_<T1::value, T1, Ts...> {};
-    template <bool V0, class T0, class... Ts> struct disjunction_ {
-        using type = T0;
-    };
-    template <class T0, class T1, class... Ts>
-    struct disjunction_<false, T0, T1, Ts...>
-        : disjunction_<T1::value, T1, Ts...> {};
-
-#endif
-
-    } // namespace detail
-
-    // C++17 emulation:
-
-    namespace std17 {
-
-    template <bool v>
-    struct bool_constant : std11::integral_constant<bool, v> {};
-
-#if gsl_CPP11_120
-
-    template <class... Ts> struct conjunction;
-    template <> struct conjunction<> : std11::true_type {};
-    template <class T0, class... Ts>
-    struct conjunction<T0, Ts...>
-        : detail::conjunction_<T0::value, T0, Ts...>::type {};
-    template <class... Ts> struct disjunction;
-    template <> struct disjunction<> : std11::false_type {};
-    template <class T0, class... Ts>
-    struct disjunction<T0, Ts...>
-        : detail::disjunction_<T0::value, T0, Ts...>::type {};
-    template <class T>
-    struct negation : std11::integral_constant<bool, !T::value> {};
-
-#if gsl_CPP14_OR_GREATER
-
-    template <class... Ts>
-    constexpr bool conjunction_v = conjunction<Ts...>::value;
-    template <class... Ts>
-    constexpr bool disjunction_v = disjunction<Ts...>::value;
-    template <class T> constexpr bool negation_v = negation<T>::value;
-
-#endif // gsl_CPP14_OR_GREATER
-
-    template <class... Ts> struct make_void { typedef void type; };
-
-    template <class... Ts> using void_t = typename make_void<Ts...>::type;
-
-#endif // gsl_CPP11_120
-
-#if gsl_HAVE(STD_DATA)
-
-    using std::data;
-    using std::size;
-
-#elif gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR)
-
-    template <class T, size_t N>
-    gsl_api inline gsl_constexpr auto size(T const (&)[N]) gsl_noexcept
-        -> size_t {
-        return N;
-    }
-
-    template <class C>
-    inline gsl_constexpr auto size(C const &cont) -> decltype(cont.size()) {
-        return cont.size();
-    }
-
-    template <class T, size_t N>
-    gsl_api inline gsl_constexpr auto data(T (&arr)[N]) gsl_noexcept -> T * {
-        return &arr[0];
-    }
-
-    template <class C>
-    inline gsl_constexpr auto data(C &cont) -> decltype(cont.data()) {
-        return cont.data();
-    }
-
-    template <class C>
-    inline gsl_constexpr auto data(C const &cont) -> decltype(cont.data()) {
-        return cont.data();
-    }
-
-    template <class E>
-    inline gsl_constexpr auto data(std::initializer_list<E> il) gsl_noexcept
-        -> E const * {
-        return il.begin();
-    }
-
-#endif // span_HAVE( DATA )
-
-    } // namespace std17
-
-    // C++20 emulation:
-
-    namespace std20 {
-
-#if gsl_CPP11_100
-
-    struct identity {
-        template <class T>
-        gsl_constexpr T &&operator()(T &&arg) const gsl_noexcept {
-            return std::forward<T>(arg);
-        }
-    };
-
-#endif // gsl_CPP11_100
-
-    template <class T> struct type_identity { typedef T type; };
-#if gsl_HAVE(ALIAS_TEMPLATE)
-    template <class T> using type_identity_t = typename type_identity<T>::type;
-#endif // gsl_HAVE( ALIAS_TEMPLATE )
-
-#if gsl_HAVE(STD_SSIZE)
-
-    using std::ssize;
-
-#elif gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR)
-
-    template <class C>
-    gsl_constexpr auto ssize(C const &c) -> typename std::common_type<
-        std::ptrdiff_t,
-        typename std::make_signed<decltype(c.size())>::type>::type {
-        using R = typename std::common_type<
-            std::ptrdiff_t,
-            typename std::make_signed<decltype(c.size())>::type>::type;
-        return static_cast<R>(c.size());
-    }
-
-    template <class T, std::size_t N>
-    gsl_constexpr auto ssize(T const (&)[N]) gsl_noexcept -> std::ptrdiff_t {
-        return std::ptrdiff_t(N);
-    }
-
-#endif // gsl_HAVE( STD_SSIZE )
-
-#if gsl_HAVE(REMOVE_CVREF)
-
-    using std::remove_cvref;
-
-#else
-
-    template <class T> struct remove_cvref {
-        typedef typename std11::remove_cv<
-            typename std11::remove_reference<T>::type>::type type;
-    };
-
-#endif // gsl_HAVE( REMOVE_CVREF )
-
-    } // namespace std20
-
-    namespace detail {
-
-    /// for nsel_REQUIRES_T
-
-    /*enum*/ class enabler {};
-
-#if gsl_HAVE(TYPE_TRAITS)
-
-    template <class Q> struct is_span_oracle : std::false_type {};
-
-    template <class T> struct is_span_oracle<span<T>> : std::true_type {};
-
-    template <class Q>
-    struct is_span : is_span_oracle<typename std::remove_cv<Q>::type> {};
-
-    template <class Q> struct is_std_array_oracle : std::false_type {};
-
-#if gsl_HAVE(ARRAY)
-
-    template <class T, std::size_t Extent>
-    struct is_std_array_oracle<std::array<T, Extent>> : std::true_type {};
-
-#endif
-
-    template <class Q>
-    struct is_std_array
-        : is_std_array_oracle<typename std::remove_cv<Q>::type> {};
-
-    template <class Q> struct is_array : std::false_type {};
-
-    template <class T> struct is_array<T[]> : std::true_type {};
-
-    template <class T, std::size_t N> struct is_array<T[N]> : std::true_type {};
-
-#if gsl_CPP11_140 && !gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 1, 500)
-
-    template <class, class = void>
-    struct has_size_and_data : std::false_type {};
-
-    template <class C>
-    struct has_size_and_data<
-        C, std17::void_t<decltype(std17::size(std::declval<C>())),
-                         decltype(std17::data(std::declval<C>()))>>
-        : std::true_type {};
-
-    template <class, class, class = void>
-    struct is_compatible_element : std::false_type {};
-
-    template <class C, class E>
-    struct is_compatible_element<
-        C, E,
-        std17::void_t<decltype(std17::data(std::declval<C>())),
-                      typename std::remove_pointer<decltype(
-                          std17::data(std::declval<C &>()))>::type (*)[]>>
-        : std::is_convertible<typename std::remove_pointer<decltype(std17::data(
-                                  std::declval<C &>()))>::type (*)[],
-                              E (*)[]> {};
-
-    template <class C>
-    struct is_container
-        : std17::bool_constant<!is_span<C>::value && !is_array<C>::value &&
-                               !is_std_array<C>::value &&
-                               has_size_and_data<C>::value> {};
-
-    template <class C, class E>
-    struct is_compatible_container
-        : std17::bool_constant<is_container<C>::value &&
-                               is_compatible_element<C, E>::value> {};
-
-#else // ^^^ gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 )
-      // ^^^ / vvv ! gsl_CPP11_140 || gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1,
-      // 500 ) vvv
-
-    template <class C, class E,
-              typename = typename std::enable_if<
-                  !is_span<C>::value && !is_array<C>::value &&
-                      !is_std_array<C>::value &&
-                      (std::is_convertible<
-                          typename std::remove_pointer<decltype(
-                              std17::data(std::declval<C &>()))>::type (*)[],
-                          E (*)[]>::value)
-                  //  &&   has_size_and_data< C >::value
-                  ,
-                  enabler>::type,
-              class = decltype(std17::size(std::declval<C>())),
-              class = decltype(std17::data(std::declval<C>()))>
-#if gsl_BETWEEN(gsl_COMPILER_MSVC_VERSION, 1, 140)
-    // VS2013 has insufficient support for expression SFINAE; we cannot make
-    // `is_compatible_container<>` a proper type trait here
-    struct is_compatible_container : std::true_type {
-    };
-#else
-    struct is_compatible_container_r {
-        is_compatible_container_r(int);
-    };
-    template <class C, class E>
-    std::true_type is_compatible_container_f(is_compatible_container_r<C, E>);
-    template <class C, class E> std::false_type is_compatible_container_f(...);
-
-    template <class C, class E>
-    struct is_compatible_container
-        : decltype(is_compatible_container_f<C, E>(0)) {};
-#endif // gsl_BETWEEN( gsl_COMPILER_MSVC_VERSION, 1, 140 )
-
-#endif // gsl_CPP11_140 && ! gsl_BETWEEN( gsl_COMPILER_GNUC_VERSION, 1, 500 )
-
-#endif // gsl_HAVE( TYPE_TRAITS )
-
-    } // namespace detail
-
-    //
-    // GSL.util: utilities
-    //
-
-    // Integer type for indices (e.g. in a loop).
-    typedef gsl_CONFIG_INDEX_TYPE index;
-
-//
-// GSL.owner: ownership pointers
-//
-#if gsl_HAVE(SHARED_PTR)
-    using std::make_shared;
-    using std::shared_ptr;
-    using std::unique_ptr;
-#if gsl_HAVE(MAKE_UNIQUE) || gsl_HAVE(VARIADIC_TEMPLATE)
-    using std14::make_unique;
-#endif
-#endif
-
-#if gsl_HAVE(ALIAS_TEMPLATE)
-    template <class T
-#if gsl_HAVE(TYPE_TRAITS)
-              ,
-              typename =
-                  typename std::enable_if<std::is_pointer<T>::value>::type
-#endif
-              >
-    using owner = T;
-#elif gsl_CONFIG_DEFAULTS_VERSION == 0
-    // TODO vNext: remove
-    template <class T> struct owner { typedef T type; };
-#endif
-
-#define gsl_HAVE_OWNER_TEMPLATE gsl_HAVE_ALIAS_TEMPLATE
-
-// TODO vNext: remove
-#if gsl_FEATURE(OWNER_MACRO)
-#if gsl_HAVE(OWNER_TEMPLATE)
-#define Owner(t) ::gsl::owner<t>
-#else
-#define Owner(t) ::gsl::owner<t>::type
-#endif
-#endif
-
-    //
-    // GSL.assert: assertions
-    //
-
-#if gsl_HAVE(TYPE_TRAITS)
-#define gsl_ELIDE_CONTRACT_(x)                                                 \
-    static_assert(::std::is_constructible<bool, decltype(x)>::value,           \
-                  "argument of contract check must be convertible to bool")
-#else
-#define gsl_ELIDE_CONTRACT_(x)
-#endif
-
-#if defined(__CUDACC__) && defined(__CUDA_ARCH__)
-#define gsl_ASSUME(x)                                                          \
-    gsl_ELIDE_CONTRACT_(                                                       \
-        x) /* there is no assume intrinsic in CUDA device code */
-#elif gsl_COMPILER_MSVC_VERSION
-#define gsl_ASSUME(x) __assume(x)
-#elif gsl_COMPILER_GNUC_VERSION
-#define gsl_ASSUME(x) ((x) ? static_cast<void>(0) : __builtin_unreachable())
-#elif defined(__has_builtin)
-#if __has_builtin(__builtin_unreachable)
-#define gsl_ASSUME(x) ((x) ? static_cast<void>(0) : __builtin_unreachable())
-#endif
-#else
-#define gsl_ASSUME(x)                                                          \
-    gsl_ELIDE_CONTRACT_(                                                       \
-        x) /* unknown compiler; cannot rely on assume intrinsic */
-#endif
-
-#if defined(gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER)
-#define gsl_CONTRACT_CHECK_(str, x)                                            \
-    ((x) ? static_cast<void>(0)                                                \
-         : ::gsl::fail_fast_assert_handler(#x, "GSL: " str, __FILE__,          \
-                                           __LINE__))
-#elif defined(__CUDACC__) && defined(__CUDA_ARCH__)
-#define gsl_CONTRACT_CHECK_(str, x) assert((x) && str)
-#elif defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS)
-#define gsl_CONTRACT_CHECK_(str, x)                                            \
-    ((x) ? static_cast<void>(0)                                                \
-         : ::gsl::detail::fail_fast_throw("GSL: " str " at " __FILE__          \
-                                          ":" gsl_STRINGIFY(__LINE__)))
-#else // defined( gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES ) [default]
-#define gsl_CONTRACT_CHECK_(str, x)                                            \
-    ((x) ? static_cast<void>(0) : ::gsl::detail::fail_fast_terminate())
-#endif
-
-#if defined(gsl_CONFIG_CONTRACT_CHECKING_OFF) ||                               \
-    defined(gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF)
-#if defined(gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME)
-#define gsl_Expects(x) gsl_ASSUME(x)
-#else // defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE ) [default]
-#define gsl_Expects(x) gsl_ELIDE_CONTRACT_(x)
-#endif
-#else
-#define gsl_Expects(x) gsl_CONTRACT_CHECK_("Precondition failure", x)
-#endif
-#define Expects(x) gsl_Expects(x)
-
-#if !defined(gsl_CONFIG_CONTRACT_CHECKING_AUDIT) ||                            \
-    defined(gsl_CONFIG_CONTRACT_CHECKING_EXPECTS_OFF)
-#define gsl_ExpectsAudit(x) gsl_ELIDE_CONTRACT_(x)
-#else
-#define gsl_ExpectsAudit(x)                                                    \
-    gsl_CONTRACT_CHECK_("Precondition failure (audit)", x)
-#endif
-
-#if defined(gsl_CONFIG_CONTRACT_CHECKING_OFF) ||                               \
-    defined(gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF)
-#if defined(gsl_CONFIG_UNENFORCED_CONTRACTS_ASSUME)
-#define gsl_Ensures(x) gsl_ASSUME(x)
-#else // defined( gsl_CONFIG_UNENFORCED_CONTRACTS_ELIDE ) [default]
-#define gsl_Ensures(x) gsl_ELIDE_CONTRACT_(x)
-#endif
-#else
-#define gsl_Ensures(x) gsl_CONTRACT_CHECK_("Postcondition failure", x)
-#endif
-#define Ensures(x) gsl_Ensures(x)
-
-#if !defined(gsl_CONFIG_CONTRACT_CHECKING_AUDIT) ||                            \
-    defined(gsl_CONFIG_CONTRACT_CHECKING_ENSURES_OFF)
-#define gsl_EnsuresAudit(x) gsl_ELIDE_CONTRACT_(x)
-#else
-#define gsl_EnsuresAudit(x)                                                    \
-    gsl_CONTRACT_CHECK_("Postcondition failure (audit)", x)
-#endif
-
-#define gsl_STRINGIFY(x) gsl_STRINGIFY_(x)
-#define gsl_STRINGIFY_(x) #x
-
-    struct fail_fast : public std::logic_error {
-        explicit fail_fast(char const *message) : std::logic_error(message) {}
-    };
-
-    namespace detail {
-
-#if gsl_HAVE(EXCEPTIONS)
-    gsl_NORETURN inline void fail_fast_throw(char const *message) {
-        throw fail_fast(message);
-    }
-#endif // gsl_HAVE( EXCEPTIONS )
-    gsl_NORETURN inline void fail_fast_terminate() gsl_noexcept {
-        std::terminate();
-    }
-
-    } // namespace detail
-
-    // Should be defined by user
-    gsl_api void fail_fast_assert_handler(char const *const expression,
-                                          char const *const message,
-                                          char const *const file, int line);
-
-#if defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS)
-
-#if gsl_HAVE(EXCEPTIONS)
-    gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use "
-                       "contract checking macros instead")
-        gsl_constexpr14 inline void
-        fail_fast_assert(bool cond, char const *const message) {
-        if (!cond)
-            throw fail_fast(message);
-    }
-#endif // gsl_HAVE( EXCEPTIONS )
-
-#elif defined(gsl_CONFIG_CONTRACT_VIOLATION_CALLS_HANDLER)
-
-    gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use "
-                       "contract checking macros instead")
-        gsl_api gsl_constexpr14 inline void
-        fail_fast_assert(bool cond, char const *const expression,
-                         char const *const message, char const *const file,
-                         int line) {
-        if (!cond)
-            ::gsl::fail_fast_assert_handler(expression, message, file, line);
-    }
-
-#else // defined( gsl_CONFIG_CONTRACT_VIOLATION_TERMINATES ) [default]
-
-    gsl_DEPRECATED_MSG("don't call gsl::fail_fast_assert() directly; use "
-                       "contract checking macros instead")
-        gsl_constexpr14 inline void
-        fail_fast_assert(bool cond) gsl_noexcept {
-        if (!cond)
-            std::terminate();
-    }
-
-#endif
-
-    //
-    // GSL.util: utilities
-    //
-
-#if gsl_FEATURE(EXPERIMENTAL_RETURN_GUARD)
-
-    // Add uncaught_exceptions for pre-2017 MSVC, GCC and Clang
-    // Return unsigned char to save stack space, uncaught_exceptions can only
-    // increase by 1 in a scope
-
-    namespace detail {
-
-    gsl_api inline unsigned char to_uchar(unsigned x) gsl_noexcept {
-        return static_cast<unsigned char>(x);
-    }
-
-    } // namespace detail
-
-    namespace std11 {
-
-#if gsl_HAVE(UNCAUGHT_EXCEPTIONS)
-
-    inline unsigned char uncaught_exceptions() gsl_noexcept {
-        return detail::to_uchar(std::uncaught_exceptions());
-    }
-
-#elif gsl_COMPILER_MSVC_VERSION
-
-    extern "C" char *__cdecl _getptd();
-    inline unsigned char uncaught_exceptions() gsl_noexcept {
-        return detail::to_uchar(*reinterpret_cast<unsigned *>(
-            _getptd() + (sizeof(void *) == 8 ? 0x100 : 0x90)));
-    }
-
-#elif gsl_COMPILER_CLANG_VERSION || gsl_COMPILER_GNUC_VERSION ||               \
-    gsl_COMPILER_APPLECLANG_VERSION
-
-    extern "C" char *__cxa_get_globals();
-    inline unsigned char uncaught_exceptions() gsl_noexcept {
-        return detail::to_uchar(*reinterpret_cast<unsigned *>(
-            __cxa_get_globals() + sizeof(void *)));
-    }
-#endif
-    } // namespace std11
-#endif
-
-#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 110
-
-    template <class F> class final_action {
-      public:
-        explicit final_action(F action) gsl_noexcept
-            : action_(std::move(action)),
-              invoke_(true) {}
-
-        final_action(final_action &&other) gsl_noexcept
-            : action_(std::move(other.action_)),
-              invoke_(other.invoke_) {
-            other.invoke_ = false;
-        }
-
-        gsl_SUPPRESS_MSGSL_WARNING(f .6) virtual ~final_action() gsl_noexcept {
-            if (invoke_)
-                action_();
-        }
-
-        gsl_is_delete_access : final_action(final_action const &) gsl_is_delete;
-        final_action &operator=(final_action const &) gsl_is_delete;
-        final_action &operator=(final_action &&) gsl_is_delete;
-
-      protected:
-        void dismiss() gsl_noexcept { invoke_ = false; }
-
-      private:
-        F action_;
-        bool invoke_;
-    };
-
-    template <class F>
-    inline final_action<F> finally(F const &action) gsl_noexcept {
-        return final_action<F>(action);
-    }
-
-    template <class F>
-    inline final_action<F> finally(F && action) gsl_noexcept {
-        return final_action<F>(std::forward<F>(action));
-    }
-
-#if gsl_FEATURE(EXPERIMENTAL_RETURN_GUARD)
-
-    template <class F> class final_action_return : public final_action<F> {
-      public:
-        explicit final_action_return(F &&action) gsl_noexcept
-            : final_action<F>(std::move(action)),
-              exception_count(std11::uncaught_exceptions()) {}
-
-        final_action_return(final_action_return &&other) gsl_noexcept
-            : final_action<F>(std::move(other)),
-              exception_count(std11::uncaught_exceptions()) {}
-
-        ~final_action_return() override {
-            if (std11::uncaught_exceptions() != exception_count)
-                this->dismiss();
-        }
-
-        gsl_is_delete_access
-            : final_action_return(final_action_return const &) gsl_is_delete;
-        final_action_return &
-        operator=(final_action_return const &) gsl_is_delete;
-
-      private:
-        unsigned char exception_count;
-    };
-
-    template <class F>
-    inline final_action_return<F> on_return(F const &action) gsl_noexcept {
-        return final_action_return<F>(action);
-    }
-
-    template <class F>
-    inline final_action_return<F> on_return(F && action) gsl_noexcept {
-        return final_action_return<F>(std::forward<F>(action));
-    }
-
-    template <class F> class final_action_error : public final_action<F> {
-      public:
-        explicit final_action_error(F &&action) gsl_noexcept
-            : final_action<F>(std::move(action)),
-              exception_count(std11::uncaught_exceptions()) {}
-
-        final_action_error(final_action_error &&other) gsl_noexcept
-            : final_action<F>(std::move(other)),
-              exception_count(std11::uncaught_exceptions()) {}
-
-        ~final_action_error() override {
-            if (std11::uncaught_exceptions() == exception_count)
-                this->dismiss();
-        }
-
-        gsl_is_delete_access
-            : final_action_error(final_action_error const &) gsl_is_delete;
-        final_action_error &operator=(final_action_error const &) gsl_is_delete;
-
-      private:
-        unsigned char exception_count;
-    };
-
-    template <class F>
-    inline final_action_error<F> on_error(F const &action) gsl_noexcept {
-        return final_action_error<F>(action);
-    }
-
-    template <class F>
-    inline final_action_error<F> on_error(F && action) gsl_noexcept {
-        return final_action_error<F>(std::forward<F>(action));
-    }
-
-#endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
-
-#else // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 110
-
-    class final_action {
-      public:
-        typedef void (*Action)();
-
-        final_action(Action action) : action_(action), invoke_(true) {}
-
-        final_action(final_action const &other)
-            : action_(other.action_), invoke_(other.invoke_) {
-            other.invoke_ = false;
-        }
-
-        virtual ~final_action() {
-            if (invoke_)
-                action_();
-        }
-
-      protected:
-        void dismiss() { invoke_ = false; }
-
-      private:
-        final_action &operator=(final_action const &);
-
-      private:
-        Action action_;
-        mutable bool invoke_;
-    };
-
-    template <class F> inline final_action finally(F const &f) {
-        return final_action((f));
-    }
-
-#if gsl_FEATURE(EXPERIMENTAL_RETURN_GUARD)
-
-    class final_action_return : public final_action {
-      public:
-        explicit final_action_return(Action action)
-            : final_action(action),
-              exception_count(std11::uncaught_exceptions()) {}
-
-        ~final_action_return() {
-            if (std11::uncaught_exceptions() != exception_count)
-                this->dismiss();
-        }
-
-      private:
-        final_action_return &operator=(final_action_return const &);
-
-      private:
-        unsigned char exception_count;
-    };
-
-    template <class F> inline final_action_return on_return(F const &action) {
-        return final_action_return(action);
-    }
-
-    class final_action_error : public final_action {
-      public:
-        explicit final_action_error(Action action)
-            : final_action(action),
-              exception_count(std11::uncaught_exceptions()) {}
-
-        ~final_action_error() {
-            if (std11::uncaught_exceptions() == exception_count)
-                this->dismiss();
-        }
-
-      private:
-        final_action_error &operator=(final_action_error const &);
-
-      private:
-        unsigned char exception_count;
-    };
-
-    template <class F> inline final_action_error on_error(F const &action) {
-        return final_action_error(action);
-    }
-
-#endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
-
-#endif // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION == 110
-
-#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
-
-    template <class T, class U>
-    gsl_api inline gsl_constexpr T narrow_cast(U && u) gsl_noexcept {
-        return static_cast<T>(std::forward<U>(u));
-    }
-
-#else
-
-    template <class T, class U> gsl_api inline T narrow_cast(U u) gsl_noexcept {
-        return static_cast<T>(u);
-    }
-
-#endif // gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
-
-    struct narrowing_error : public std::exception {};
-
-#if gsl_HAVE(TYPE_TRAITS)
-
-    namespace detail {
-
-    template <class T, class U>
-    struct is_same_signedness
-        : public std::integral_constant<bool, std::is_signed<T>::value ==
-                                                  std::is_signed<U>::value> {};
-
-#if defined(__NVCC__)
-    // We do this to circumvent NVCC warnings about pointless unsigned
-    // comparisons with 0.
-    template <class T>
-    gsl_constexpr gsl_api bool
-    is_negative(T value, std::true_type /*isSigned*/) gsl_noexcept {
-        return value < T();
-    }
-    template <class T>
-    gsl_constexpr gsl_api bool
-    is_negative(T /*value*/, std::false_type /*isUnsigned*/) gsl_noexcept {
-        return false;
-    }
-    template <class T, class U>
-    gsl_constexpr gsl_api bool
-    have_same_sign(T t, U u, std::true_type /*isSameSignedness*/) gsl_noexcept {
-        return true;
-    }
-    template <class T, class U>
-    gsl_constexpr gsl_api bool
-    have_same_sign(T t, U u,
-                   std::false_type /*isSameSignedness*/) gsl_noexcept {
-        return detail::is_negative(t, std::is_signed<T>()) ==
-               detail::is_negative(u, std::is_signed<U>());
-    }
-#endif // defined( __NVCC__ )
-
-    } // namespace detail
-
-#endif
-
-#if gsl_HAVE(EXCEPTIONS) || !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION
-    template <class T, class U>
-#if !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION &&                                 \
-    !defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS)
-    gsl_api
-#endif // !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION && !defined(
-       // gsl_CONFIG_CONTRACT_VIOLATION_THROWS )
-        inline T
-        narrow(U u) {
-        T t = static_cast<T>(u);
-
-        if (static_cast<U>(t) != u) {
-#if gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION ||                                  \
-    defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS)
-            throw narrowing_error();
-#else
-            std::terminate();
-#endif
-        }
-
-#if gsl_HAVE(TYPE_TRAITS)
-#if defined(__NVCC__)
-        if (!detail::have_same_sign(t, u, detail::is_same_signedness<T, U>()))
-#else
-        gsl_SUPPRESS_MSVC_WARNING(
-            4127,
-            "conditional expression is constant") if (!detail::
-                                                          is_same_signedness<
-                                                              T, U>::value &&
-                                                      (t < T()) != (u < U()))
-#endif
-#else
-        // Don't assume T() works:
-        gsl_SUPPRESS_MSVC_WARNING(
-            4127, "conditional expression is constant") if ((t < 0) != (u < 0))
-#endif
-        {
-#if gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION ||                                  \
-    defined(gsl_CONFIG_CONTRACT_VIOLATION_THROWS)
-            throw narrowing_error();
-#else
-            std::terminate();
-#endif
-        }
-
-        return t;
-    }
-#endif // gsl_HAVE( EXCEPTIONS ) || !gsl_CONFIG_NARROW_THROWS_ON_TRUNCATION
-
-    template <class T, class U> gsl_api inline T narrow_failfast(U u) {
-        T t = static_cast<T>(u);
-
-        gsl_Expects(static_cast<U>(t) == u);
-
-#if gsl_HAVE(TYPE_TRAITS)
-#if defined(__NVCC__)
-        gsl_Expects(::gsl::detail::have_same_sign(
-            t, u, ::gsl::detail::is_same_signedness<T, U>()));
-#else
-        gsl_SUPPRESS_MSVC_WARNING(4127, "conditional expression is constant")
-            gsl_Expects((::gsl::detail::is_same_signedness<T, U>::value ||
-                         (t < T()) == (u < U())));
-#endif
-#else
-        // Don't assume T() works:
-        gsl_SUPPRESS_MSVC_WARNING(4127, "conditional expression is constant")
-            gsl_Expects((t < 0) == (u < 0));
-#endif
-
-        return t;
-    }
-
-    //
-    // at() - Bounds-checked way of accessing static arrays, std::array,
-    // std::vector.
-    //
-
-    template <class T, size_t N>
-    gsl_api inline gsl_constexpr14 T &at(T(&arr)[N], size_t pos) {
-        gsl_Expects(pos < N);
-        return arr[pos];
-    }
-
-    template <class Container>
-    inline gsl_constexpr14 typename Container::value_type &at(Container & cont,
-                                                              size_t pos) {
-        gsl_Expects(pos < cont.size());
-        return cont[pos];
-    }
-
-    template <class Container>
-    inline gsl_constexpr14 typename Container::value_type const &at(
-        Container const &cont, size_t pos) {
-        gsl_Expects(pos < cont.size());
-        return cont[pos];
-    }
-
-#if gsl_HAVE(INITIALIZER_LIST)
-
-    template <class T>
-    inline const gsl_constexpr14 T at(std::initializer_list<T> cont,
-                                      size_t pos) {
-        gsl_Expects(pos < cont.size());
-        return *(cont.begin() + pos);
-    }
-#endif
-
-    template <class T>
-    gsl_api inline gsl_constexpr14 T &at(span<T> s, size_t pos) {
-        return s[pos];
-    }
-
-    //
-    // GSL.views: views
-    //
-
-    //
-    // not_null<> - Wrap any indirection and enforce non-null.
-    //
-
-    template <class T> class not_null;
-
-    namespace detail {
-
-// helper class to figure out the pointed-to type of a pointer
-#if gsl_CPP11_OR_GREATER
-    template <class T, class E = void> struct element_type_helper {
-        // For types without a member element_type (this will handle raw
-        // pointers)
-        typedef
-            typename std::remove_reference<decltype(*std::declval<T>())>::type
-                type;
-    };
-
-    template <class T>
-    struct element_type_helper<T, std17::void_t<typename T::element_type>> {
-        // For types with a member element_type
-        typedef typename T::element_type type;
-    };
-#else
-    // Pre-C++11, we cannot have decltype, so we cannot handle types without a
-    // member element_type
-    template <class T, class E = void> struct element_type_helper {
-        typedef typename T::element_type type;
-    };
-
-    template <class T> struct element_type_helper<T *> { typedef T type; };
-#endif
-
-    template <class T> struct is_not_null_oracle : std11::false_type {};
-    template <class T>
-    struct is_not_null_oracle<not_null<T>> : std11::true_type {};
-
-    template <class T, bool IsCopyable = true> struct not_null_data;
-#if gsl_HAVE(RVALUE_REFERENCE) && gsl_HAVE(TYPE_TRAITS)
-    template <class T> struct not_null_data<T, false> {
-        T ptr_;
-
-        gsl_constexpr14 not_null_data(T &&_ptr) gsl_noexcept
-            : ptr_(std::move(_ptr)) {}
-
-        gsl_constexpr14 not_null_data(not_null_data &&other) gsl_noexcept
-            : ptr_(std::move(other.ptr_)) {}
-        gsl_constexpr14 not_null_data &
-        operator=(not_null_data &&other) gsl_noexcept {
-            ptr_ = std::move(other.ptr_);
-            return *this;
-        }
-
-        gsl_is_delete_access
-            : not_null_data(not_null_data const &other) gsl_is_delete;
-        not_null_data &operator=(not_null_data const &other) gsl_is_delete;
-    };
-#endif // gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS )
-    template <class T> struct not_null_data<T, true> {
-        T ptr_;
-
-        gsl_constexpr14 not_null_data(T const &_ptr) gsl_noexcept : ptr_(_ptr) {
-        }
-
-#if gsl_HAVE(RVALUE_REFERENCE)
-        gsl_constexpr14 not_null_data(T &&_ptr) gsl_noexcept
-            : ptr_(std::move(_ptr)) {}
-
-        gsl_constexpr14 not_null_data(not_null_data &&other) gsl_noexcept
-            : ptr_(std::move(other.ptr_)) {}
-        gsl_constexpr14 not_null_data &
-        operator=(not_null_data &&other) gsl_noexcept {
-            ptr_ = std::move(other.ptr_);
-            return *this;
-        }
-#endif // gsl_HAVE( RVALUE_REFERENCE )
-
-        gsl_constexpr14 not_null_data(not_null_data const &other)
-            : ptr_(other.ptr_) {
-            gsl_Expects(ptr_ != gsl_nullptr);
-        }
-        gsl_constexpr14 not_null_data &operator=(not_null_data const &other) {
-            gsl_Expects(other.ptr_ != gsl_nullptr);
-            ptr_ = other.ptr_;
-            return *this;
-        }
-    };
-
-    template <class T>
-    struct is_copyable
-#if gsl_HAVE(TYPE_TRAITS)
-        : std11::integral_constant<bool, std::is_copy_constructible<T>::value &&
-                                             std::is_copy_assignable<T>::value>
-#else
-        : std11::true_type
-#endif
-    {
-    };
-#if gsl_HAVE(TYPE_TRAITS) && gsl_HAVE(UNIQUE_PTR) &&                           \
-    gsl_BETWEEN(gsl_COMPILER_MSVC_VERSION, 1, 140)
-    // Type traits are buggy in VC++ 2013, so we explicitly declare
-    // `unique_ptr<>` non-copyable.
-    template <class T, class Deleter>
-    struct is_copyable<std::unique_ptr<T, Deleter>> : std11::false_type {};
-#endif
-
-    } // namespace detail
-
-    template <class T> class not_null {
-      private:
-        detail::not_null_data<T, detail::is_copyable<T>::value> data_;
-
-        // need to access `not_null<U>::data_`
-        template <class U> friend class not_null;
-
-      public:
-        typedef typename detail::element_type_helper<T>::type element_type;
-
-#if gsl_HAVE(TYPE_TRAITS)
-        static_assert(std::is_assignable<T &, std::nullptr_t>::value,
-                      "T cannot be assigned nullptr.");
-#endif
-
-#if gsl_CONFIG(NOT_NULL_EXPLICIT_CTOR)
-#if gsl_HAVE(RVALUE_REFERENCE)
-        template <class U
-        // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>,
-        // unique_ptr<X>>` tries to instantiate the copy constructor of
-        // `unique_ptr<>`, triggering an error. Note that Apple Clang's
-        // `__clang_major__` etc. are different from regular Clang.
-#if gsl_HAVE(TYPE_TRAITS) && gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) &&        \
-    !gsl_BETWEEN(gsl_COMPILER_CLANG_VERSION, 1, 400) &&                        \
-    !gsl_BETWEEN(gsl_COMPILER_APPLECLANG_VERSION, 1, 1001)
-                  // We *have* to use SFINAE with an NTTP arg here, otherwise
-                  // the overload is ambiguous.
-                  ,
-                  typename std::enable_if<(std::is_constructible<T, U>::value),
-                                          int>::type = 0
-#endif
-                  >
-        gsl_constexpr14 explicit not_null(U other)
-            : data_(T(std::move(other))) {
-            gsl_Expects(data_.ptr_ != gsl_nullptr);
-        }
-#else  // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
-        template <class U>
-        gsl_constexpr14 explicit not_null(U const &other) : data_(T(other)) {
-            gsl_Expects(data_.ptr_ != gsl_nullptr);
-        }
-#endif // gsl_HAVE( RVALUE_REFERENCE )
-#else  // a.k.a. !gsl_CONFIG( NOT_NULL_EXPLICIT_CTOR )
-#if gsl_HAVE(RVALUE_REFERENCE)
-        // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>,
-        // unique_ptr<X>>` tries to instantiate the copy constructor of
-        // `unique_ptr<>`, triggering an error. Note that Apple Clang's
-        // `__clang_major__` etc. are different from regular Clang.
-#if gsl_HAVE(TYPE_TRAITS) && gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) &&        \
-    !gsl_BETWEEN(gsl_COMPILER_CLANG_VERSION, 1, 400) &&                        \
-    !gsl_BETWEEN(gsl_COMPILER_APPLECLANG_VERSION, 1, 1001)
-        template <class U
-                  // We *have* to use SFINAE with an NTTP arg here, otherwise
-                  // the overload is ambiguous.
-                  ,
-                  typename std::enable_if<(std::is_constructible<T, U>::value &&
-                                           !std::is_convertible<U, T>::value),
-                                          int>::type = 0>
-        gsl_constexpr14 explicit not_null(U other)
-            : data_(T(std::move(other))) {
-            gsl_Expects(data_.ptr_ != gsl_nullptr);
-        }
-
-        template <class U
-                  // We *have* to use SFINAE with an NTTP arg here, otherwise
-                  // the overload is ambiguous.
-                  ,
-                  typename std::enable_if<(std::is_convertible<U, T>::value),
-                                          int>::type = 0>
-        gsl_constexpr14 not_null(U other) : data_(T(std::move(other))) {
-            gsl_Expects(data_.ptr_ != gsl_nullptr);
-        }
-#else  // a.k.a. !( gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE(
-       // DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN(
-       // gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN(
-       // gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-       // If type_traits are not available, then we can't distinguish
-       // `is_convertible<>` and `is_constructible<>`, so we unconditionally
-       // permit implicit construction.
-        template <class U>
-        gsl_constexpr14 not_null(U other) : data_(T(std::move(other))) {
-            gsl_Expects(data_.ptr_ != gsl_nullptr);
-        }
-#endif // gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
-       // && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN(
-       // gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-#else  // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
-        template <class U>
-        gsl_constexpr14 not_null(U const &other) : data_(T(other)) {
-            gsl_Expects(data_.ptr_ != gsl_nullptr);
-        }
-#endif // gsl_HAVE( RVALUE_REFERENCE )
-#endif // gsl_CONFIG( NOT_NULL_EXPLICIT_CTOR )
-
-#if gsl_HAVE(RVALUE_REFERENCE)
-        // In Clang 3.x, `is_constructible<not_null<unique_ptr<X>>,
-        // unique_ptr<X>>` tries to instantiate the copy constructor of
-        // `unique_ptr<>`, triggering an error. Note that Apple Clang's
-        // `__clang_major__` etc. are different from regular Clang.
-#if gsl_HAVE(TYPE_TRAITS) && gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) &&        \
-    !gsl_BETWEEN(gsl_COMPILER_CLANG_VERSION, 1, 400) &&                        \
-    !gsl_BETWEEN(gsl_COMPILER_APPLECLANG_VERSION, 1, 1001)
-        template <class U
-                  // We *have* to use SFINAE with an NTTP arg here, otherwise
-                  // the overload is ambiguous.
-                  ,
-                  typename std::enable_if<(std::is_constructible<T, U>::value &&
-                                           !std::is_convertible<U, T>::value),
-                                          int>::type = 0>
-        gsl_constexpr14 explicit not_null(not_null<U> other)
-            : data_(T(std::move(other.data_.ptr_))) {
-            gsl_Expects(data_.ptr_ != gsl_nullptr);
-        }
-
-        template <class U
-                  // We *have* to use SFINAE with an NTTP arg here, otherwise
-                  // the overload is ambiguous.
-                  ,
-                  typename std::enable_if<(std::is_convertible<U, T>::value),
-                                          int>::type = 0>
-        gsl_constexpr14 not_null(not_null<U> other)
-            : data_(T(std::move(other.data_.ptr_))) {
-            gsl_Expects(data_.ptr_ != gsl_nullptr);
-        }
-#else  // a.k.a. !( gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE(
-       // DEFAULT_FUNCTION_TEMPLATE_ARG ) && !gsl_BETWEEN(
-       // gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN(
-       // gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-       // If type_traits are not available, then we can't distinguish
-       // `is_convertible<>` and `is_constructible<>`, so we unconditionally
-       // permit implicit construction.
-        template <class U>
-        gsl_constexpr14 not_null(not_null<U> other)
-            : data_(T(std::move(other.data_.ptr_))) {
-            gsl_Expects(data_.ptr_ != gsl_nullptr);
-        }
-        template <class U>
-        gsl_constexpr14 not_null<T> &operator=(not_null<U> other) {
-            gsl_Expects(other.data_.ptr_ != gsl_nullptr);
-            data_.ptr_ = std::move(other.data_.ptr_);
-            return *this;
-        }
-#endif // gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
-       // && !gsl_BETWEEN( gsl_COMPILER_CLANG_VERSION, 1, 400 ) && !gsl_BETWEEN(
-       // gsl_COMPILER_APPLECLANG_VERSION, 1, 1001 )
-#else  // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
-        template <class U>
-        gsl_constexpr14 not_null(not_null<U> const &other)
-            : data_(T(other.data_.ptr_)) {
-            gsl_Expects(data_.ptr_ != gsl_nullptr);
-        }
-        template <class U>
-        gsl_constexpr14 not_null<T> &operator=(not_null<U> const &other) {
-            gsl_Expects(other.data_.ptr_ != gsl_nullptr);
-            data_.ptr_ = other.data_.ptr_;
-            return *this;
-        }
-#endif // gsl_HAVE( RVALUE_REFERENCE )
-
-#if gsl_CONFIG(TRANSPARENT_NOT_NULL)
-        gsl_constexpr14 element_type *get() const {
-            gsl_Ensures(data_.ptr_ != gsl_nullptr);
-            return data_.ptr_.get();
-        }
-#else
-#if gsl_CONFIG(NOT_NULL_GET_BY_CONST_REF)
-        gsl_constexpr14 T const &get() const {
-            gsl_Ensures(data_.ptr_ != gsl_nullptr);
-            return data_.ptr_;
-        }
-#else
-        gsl_constexpr14 T get() const {
-            gsl_Ensures(data_.ptr_ != gsl_nullptr);
-            return data_.ptr_;
-        }
-#endif
-#endif
-
-        // We want an implicit conversion operator that can be used to convert
-        // from both lvalues (by const reference or by copy) and rvalues (by
-        // move). So it seems like we could define
-        //
-        //     template< class U >
-        //     operator U const &() const & { ... }
-        //     template< class U >
-        //     operator U &&() && { ... }
-        //
-        // However, having two conversion operators with different return types
-        // renders the assignment operator of the result type ambiguous:
-        //
-        //     not_null<std::unique_ptr<T>> p( ... );
-        //     std::unique_ptr<U> q;
-        //     q = std::move( p ); // ambiguous
-        //
-        // To avoid this ambiguity, we have both overloads of the conversion
-        // operator return `U` rather than `U const &` or `U &&`. This implies
-        // that converting an lvalue always induces a copy, which can cause
-        // unnecessary copies or even fail to compile in some situations:
-        //
-        //     not_null<std::shared_ptr<T>> sp( ... );
-        //     std::shared_ptr<U> const & rs = sp; // unnecessary copy
-        //     std::unique_ptr<U> const & ru = p; // error: cannot copy
-        //     `unique_ptr<T>`
-        //
-        // However, these situations are rather unusual, and the following, more
-        // frequent situations remain unimpaired:
-        //
-        //     std::shared_ptr<U> vs = sp; // no extra copy
-        //     std::unique_ptr<U> vu = std::move( p );
-
-#if gsl_HAVE(RVALUE_REFERENCE) && gsl_HAVE(TYPE_TRAITS) &&                     \
-    gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) && gsl_HAVE(EXPLICIT)
-        // explicit conversion operator
-
-        template <class U
-                  // We *have* to use SFINAE with an NTTP arg here, otherwise
-                  // the overload is ambiguous.
-                  ,
-                  typename std::enable_if<
-                      (std::is_constructible<U, T const &>::value &&
-                       !std::is_convertible<T, U>::value &&
-                       !detail::is_not_null_oracle<U>::value),
-                      int>::type = 0>
-        gsl_constexpr14 explicit operator U() const
-#if gsl_HAVE(FUNCTION_REF_QUALIFIER)
-            &
-#endif
-        {
-            gsl_Ensures(data_.ptr_ != gsl_nullptr);
-            return U(data_.ptr_);
-        }
-#if gsl_HAVE(FUNCTION_REF_QUALIFIER)
-        template <
-            class U
-            // We *have* to use SFINAE with an NTTP arg here, otherwise the
-            // overload is ambiguous.
-            ,
-            typename std::enable_if<(std::is_constructible<U, T>::value &&
-                                     !std::is_convertible<T, U>::value &&
-                                     !detail::is_not_null_oracle<U>::value),
-                                    int>::type = 0>
-        gsl_constexpr14 explicit operator U() && {
-            gsl_Ensures(data_.ptr_ != gsl_nullptr);
-            return U(std::move(data_.ptr_));
-        }
-#endif
-
-        // implicit conversion operator
-        template <class U
-                  // We *have* to use SFINAE with an NTTP arg here, otherwise
-                  // the overload is ambiguous.
-                  ,
-                  typename std::enable_if<
-                      (std::is_constructible<U, T const &>::value &&
-                       std::is_convertible<T, U>::value &&
-                       !detail::is_not_null_oracle<U>::value),
-                      int>::type = 0>
-        gsl_constexpr14 operator U() const
-#if gsl_HAVE(FUNCTION_REF_QUALIFIER)
-            &
-#endif
-        {
-            gsl_Ensures(data_.ptr_ != gsl_nullptr);
-            return data_.ptr_;
-        }
-#if gsl_HAVE(FUNCTION_REF_QUALIFIER)
-        template <
-            class U
-            // We *have* to use SFINAE with an NTTP arg here, otherwise the
-            // overload is ambiguous.
-            ,
-            typename std::enable_if<(std::is_convertible<T, U>::value &&
-                                     !detail::is_not_null_oracle<U>::value),
-                                    int>::type = 0>
-        gsl_constexpr14 operator U() && {
-            gsl_Ensures(data_.ptr_ != gsl_nullptr);
-            return std::move(data_.ptr_);
-        }
-#endif
-#else  // a.k.a. #if !( gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS )
-       // && gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG ) && gsl_HAVE( EXPLICIT ) )
-        template <class U> gsl_constexpr14 operator U() const {
-            gsl_Ensures(data_.ptr_ != gsl_nullptr);
-            return data_.ptr_;
-        }
-#endif // gsl_HAVE( RVALUE_REFERENCE ) && gsl_HAVE( TYPE_TRAITS ) && gsl_HAVE(
-       // DEFAULT_FUNCTION_TEMPLATE_ARG ) && gsl_HAVE( EXPLICIT )
-
-        gsl_constexpr14 T const &operator->() const {
-            gsl_Ensures(data_.ptr_ != gsl_nullptr);
-            return data_.ptr_;
-        }
-
-        gsl_constexpr14 element_type &operator*() const {
-            gsl_Ensures(data_.ptr_ != gsl_nullptr);
-            return *data_.ptr_;
-        }
-
-#if gsl_HAVE(RVALUE_REFERENCE)
-        // Visual C++ 2013 doesn't generate default move constructors, so we
-        // declare them explicitly.
-        gsl_constexpr14 not_null(not_null &&other) gsl_noexcept
-            : data_(std::move(other.data_)) {
-            gsl_Expects(data_.ptr_ != gsl_nullptr);
-        }
-        gsl_constexpr14 not_null &operator=(not_null &&other) gsl_noexcept {
-            gsl_Expects(other.data_.ptr_ != gsl_nullptr);
-            data_ = std::move(other.data_);
-            return *this;
-        }
-#endif // gsl_HAVE( RVALUE_REFERENCE )
-
-#if gsl_HAVE(IS_DEFAULT)
-        gsl_constexpr14 not_null(not_null const &other) = default;
-        gsl_constexpr14 not_null &operator=(not_null const &other) = default;
-#endif
-
-        gsl_is_delete_access : not_null() gsl_is_delete;
-        // prevent compilation when initialized with a nullptr or literal 0:
-#if gsl_HAVE(NULLPTR)
-        not_null(std::nullptr_t) gsl_is_delete;
-        not_null &operator=(std::nullptr_t) gsl_is_delete;
-#else
-        not_null(int) gsl_is_delete;
-        not_null &operator=(int) gsl_is_delete;
-#endif
-
-        // unwanted operators...pointers only point to single objects!
-        not_null &operator++() gsl_is_delete;
-        not_null &operator--() gsl_is_delete;
-        not_null operator++(int) gsl_is_delete;
-        not_null operator--(int) gsl_is_delete;
-        not_null &operator+(size_t) gsl_is_delete;
-        not_null &operator+=(size_t) gsl_is_delete;
-        not_null &operator-(size_t) gsl_is_delete;
-        not_null &operator-=(size_t) gsl_is_delete;
-        not_null &operator+=(std::ptrdiff_t) gsl_is_delete;
-        not_null &operator-=(std::ptrdiff_t) gsl_is_delete;
-        void operator[](std::ptrdiff_t) const gsl_is_delete;
-    };
-#if gsl_HAVE(DEDUCTION_GUIDES)
-    template <class U> not_null(U) -> not_null<U>;
-    template <class U> not_null(not_null<U>) -> not_null<U>;
-#endif
-
-#if gsl_HAVE(NULLPTR)
-    void make_not_null(std::nullptr_t) gsl_is_delete;
-#endif // gsl_HAVE( NULLPTR )
-#if gsl_HAVE(RVALUE_REFERENCE)
-    template <class U> not_null<U> make_not_null(U u) {
-        return not_null<U>(std::move(u));
-    }
-    template <class U> not_null<U> make_not_null(not_null<U> u) {
-        return std::move(u);
-    }
-#else  // a.k.a. !gsl_HAVE( RVALUE_REFERENCE )
-    template <class U> not_null<U> make_not_null(U const &u) {
-        return not_null<U>(u);
-    }
-    template <class U> not_null<U> make_not_null(not_null<U> const &u) {
-        return u;
-    }
-#endif // gsl_HAVE( RVALUE_REFERENCE )
-
-    // not_null with implicit constructor, allowing copy-initialization:
-
-    template <class T> class not_null_ic : public not_null<T> {
-      public:
-        template <class U gsl_ENABLE_IF_((std::is_constructible<T, U>::value))>
-        gsl_constexpr14
-#if gsl_HAVE(RVALUE_REFERENCE)
-        not_null_ic(U &&u)
-            : not_null<T>(std::forward<U>(u))
-#else
-        not_null_ic(U const &u)
-            : not_null<T>(u)
-#endif
-        {
-        }
-    };
-
-    // more not_null unwanted operators
-
-    template <class T, class U>
-    std::ptrdiff_t operator-(not_null<T> const &, not_null<U> const &)
-        gsl_is_delete;
-
-    template <class T>
-    not_null<T> operator-(not_null<T> const &, std::ptrdiff_t) gsl_is_delete;
-
-    template <class T>
-    not_null<T> operator+(not_null<T> const &, std::ptrdiff_t) gsl_is_delete;
-
-    template <class T>
-    not_null<T> operator+(std::ptrdiff_t, not_null<T> const &) gsl_is_delete;
-
-    // not_null comparisons
-
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() ==
-                                                 std::declval<U const>())
-    operator==(not_null<T> const &l, not_null<U> const &r) {
-        return l.operator->() == r.operator->();
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() ==
-                                                 std::declval<U const>())
-    operator==(not_null<T> const &l, U const &r) {
-        return l.operator->() == r;
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() ==
-                                                 std::declval<U const>())
-    operator==(T const &l, not_null<U> const &r) {
-        return l == r.operator->();
-    }
-
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() <
-                                                 std::declval<U const>())
-    operator<(not_null<T> const &l, not_null<U> const &r) {
-        return l.operator->() < r.operator->();
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() <
-                                                 std::declval<U const>())
-    operator<(not_null<T> const &l, U const &r) {
-        return l.operator->() < r;
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<T const>() <
-                                                 std::declval<U const>())
-    operator<(T const &l, not_null<U> const &r) {
-        return l < r.operator->();
-    }
-
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(
-        bool, !(std::declval<T const>() == std::declval<U const>()))
-    operator!=(not_null<T> const &l, not_null<U> const &r) {
-        return !(l == r);
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(
-        bool, !(std::declval<T const>() == std::declval<U const>()))
-    operator!=(not_null<T> const &l, U const &r) {
-        return !(l == r);
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(
-        bool, !(std::declval<T const>() == std::declval<U const>()))
-    operator!=(T const &l, not_null<U> const &r) {
-        return !(l == r);
-    }
-
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(
-        bool, !(std::declval<U const>() < std::declval<T const>()))
-    operator<=(not_null<T> const &l, not_null<U> const &r) {
-        return !(r < l);
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(
-        bool, !(std::declval<U const>() < std::declval<T const>()))
-    operator<=(not_null<T> const &l, U const &r) {
-        return !(r < l);
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(
-        bool, !(std::declval<U const>() < std::declval<T const>()))
-    operator<=(T const &l, not_null<U> const &r) {
-        return !(r < l);
-    }
-
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<U const>() <
-                                                 std::declval<T const>())
-    operator>(not_null<T> const &l, not_null<U> const &r) {
-        return r < l;
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<U const>() <
-                                                 std::declval<T const>())
-    operator>(not_null<T> const &l, U const &r) {
-        return r < l;
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(bool, std::declval<U const>() <
-                                                 std::declval<T const>())
-    operator>(T const &l, not_null<U> const &r) {
-        return r < l;
-    }
-
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(
-        bool, !(std::declval<T const>() < std::declval<U const>()))
-    operator>=(not_null<T> const &l, not_null<U> const &r) {
-        return !(l < r);
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(
-        bool, !(std::declval<T const>() < std::declval<U const>()))
-    operator>=(not_null<T> const &l, U const &r) {
-        return !(l < r);
-    }
-    template <class T, class U>
-    inline gsl_constexpr gsl_DECLTYPE_(
-        bool, !(std::declval<T const>() < std::declval<U const>()))
-    operator>=(T const &l, not_null<U> const &r) {
-        return !(l < r);
-    }
-
-    // print not_null
-
-    template <class CharType, class Traits, class T>
-    std::basic_ostream<CharType, Traits> &operator<<(
-        std::basic_ostream<CharType, Traits> &os, not_null<T> const &p) {
-        return os << p.operator->();
-    }
-
-//
-// Byte-specific type.
-//
-#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
-    enum class gsl_may_alias byte : unsigned char {};
-#else
-    struct gsl_may_alias byte {
-        typedef unsigned char type;
-        type v;
-    };
-#endif
-
-    template <class T>
-    gsl_api inline gsl_constexpr byte to_byte(T v) gsl_noexcept {
-#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
-        return static_cast<byte>(v);
-#elif gsl_HAVE(CONSTEXPR_11)
-        return {static_cast<typename byte::type>(v)};
-#else
-        byte b = {static_cast<typename byte::type>(v)};
-        return b;
-#endif
-    }
-
-    template <class IntegerType gsl_ENABLE_IF_(
-        (std::is_integral<IntegerType>::value))>
-    gsl_api inline gsl_constexpr IntegerType to_integer(byte b) gsl_noexcept {
-#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
-        return static_cast<typename std::underlying_type<byte>::type>(b);
-#else
-        return b.v;
-#endif
-    }
-
-    gsl_api inline gsl_constexpr unsigned char to_uchar(byte b) gsl_noexcept {
-        return to_integer<unsigned char>(b);
-    }
-
-    gsl_api inline gsl_constexpr unsigned char to_uchar(int i) gsl_noexcept {
-        return static_cast<unsigned char>(i);
-    }
-
-    template <class IntegerType gsl_ENABLE_IF_(
-        (std::is_integral<IntegerType>::value))>
-    gsl_api inline gsl_constexpr14 byte &operator<<=(byte &b, IntegerType shift)
-        gsl_noexcept {
-#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
-        return b = ::gsl::to_byte(::gsl::to_uchar(b) << shift);
-#else
-        b.v = ::gsl::to_uchar(b.v << shift);
-        return b;
-#endif
-    }
-
-    template <class IntegerType gsl_ENABLE_IF_(
-        (std::is_integral<IntegerType>::value))>
-    gsl_api inline gsl_constexpr byte operator<<(byte b, IntegerType shift)
-        gsl_noexcept {
-        return ::gsl::to_byte(::gsl::to_uchar(b) << shift);
-    }
-
-    template <class IntegerType gsl_ENABLE_IF_(
-        (std::is_integral<IntegerType>::value))>
-    gsl_api inline gsl_constexpr14 byte &operator>>=(byte &b, IntegerType shift)
-        gsl_noexcept {
-#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
-        return b = ::gsl::to_byte(::gsl::to_uchar(b) >> shift);
-#else
-        b.v = ::gsl::to_uchar(b.v >> shift);
-        return b;
-#endif
-    }
-
-    template <class IntegerType gsl_ENABLE_IF_(
-        (std::is_integral<IntegerType>::value))>
-    gsl_api inline gsl_constexpr byte operator>>(byte b, IntegerType shift)
-        gsl_noexcept {
-        return ::gsl::to_byte(::gsl::to_uchar(b) >> shift);
-    }
-
-#if gsl_HAVE(ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE)
-    gsl_DEFINE_ENUM_BITMASK_OPERATORS(byte)
-        gsl_DEFINE_ENUM_RELATIONAL_OPERATORS(byte)
-#else  // a.k.a. !gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
-    gsl_api inline gsl_constexpr bool operator==(byte l, byte r) gsl_noexcept {
-        return l.v == r.v;
-    }
-
-    gsl_api inline gsl_constexpr bool operator!=(byte l, byte r) gsl_noexcept {
-        return !(l == r);
-    }
-
-    gsl_api inline gsl_constexpr bool operator<(byte l, byte r) gsl_noexcept {
-        return l.v < r.v;
-    }
-
-    gsl_api inline gsl_constexpr bool operator<=(byte l, byte r) gsl_noexcept {
-        return !(r < l);
-    }
-
-    gsl_api inline gsl_constexpr bool operator>(byte l, byte r) gsl_noexcept {
-        return (r < l);
-    }
-
-    gsl_api inline gsl_constexpr bool operator>=(byte l, byte r) gsl_noexcept {
-        return !(l < r);
-    }
-
-    gsl_api inline gsl_constexpr14 byte &operator|=(byte &l, byte r)
-        gsl_noexcept {
-        l.v |= r.v;
-        return l;
-    }
-
-    gsl_api inline gsl_constexpr byte operator|(byte l, byte r) gsl_noexcept {
-        return ::gsl::to_byte(l.v | r.v);
-    }
-
-    gsl_api inline gsl_constexpr14 byte &operator&=(byte &l, byte r)
-        gsl_noexcept {
-        l.v &= r.v;
-        return l;
-    }
-
-    gsl_api inline gsl_constexpr byte operator&(byte l, byte r) gsl_noexcept {
-        return ::gsl::to_byte(l.v & r.v);
-    }
-
-    gsl_api inline gsl_constexpr14 byte &operator^=(byte &l, byte r)
-        gsl_noexcept {
-        l.v ^= r.v;
-        return l;
-    }
-
-    gsl_api inline gsl_constexpr byte operator^(byte l, byte r) gsl_noexcept {
-        return ::gsl::to_byte(l.v ^ r.v);
-    }
-
-    gsl_api inline gsl_constexpr byte operator~(byte b) gsl_noexcept {
-        return ::gsl::to_byte(~b.v);
-    }
-#endif // gsl_HAVE( ENUM_CLASS_CONSTRUCTION_FROM_UNDERLYING_TYPE )
-
-#if gsl_FEATURE_TO_STD(WITH_CONTAINER)
-
-        // Tag to select span constructor taking a container:
-
-        struct with_container_t {
-        gsl_constexpr with_container_t() gsl_noexcept {}
-    };
-    const gsl_constexpr with_container_t
-        with_container; // TODO: this can lead to ODR violations because the
-                        // symbol will be defined in multiple translation units
-
-#endif
-
-    //
-    // span<> - A 1D view of contiguous T's, replace (*,len).
-    //
-    template <class T> class span {
-        template <class U> friend class span;
-
-      public:
-        typedef gsl_CONFIG_SPAN_INDEX_TYPE index_type;
-
-        typedef T element_type;
-        typedef typename std11::remove_cv<T>::type value_type;
-
-        typedef T &reference;
-        typedef T *pointer;
-        typedef T const *const_pointer;
-        typedef T const &const_reference;
-
-        typedef pointer iterator;
-        typedef const_pointer const_iterator;
-
-        typedef std::reverse_iterator<iterator> reverse_iterator;
-        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
-        typedef typename std::iterator_traits<iterator>::difference_type
-            difference_type;
-
-        // 26.7.3.2 Constructors, copy, and assignment [span.cons]
-
-        gsl_api gsl_constexpr14 span() gsl_noexcept : first_(gsl_nullptr),
-                                                      last_(gsl_nullptr) {}
-
-#if !gsl_DEPRECATE_TO_LEVEL(5)
-
-#if gsl_HAVE(NULLPTR)
-        gsl_api gsl_constexpr14 span(std::nullptr_t, index_type size_in)
-            : first_(nullptr), last_(nullptr) {
-            gsl_Expects(size_in == 0);
-        }
-#endif
-
-#if gsl_HAVE(IS_DELETE)
-        gsl_DEPRECATED gsl_api gsl_constexpr span(reference data_in)
-            : span(&data_in, 1) {}
-
-        gsl_api gsl_constexpr span(element_type &&) = delete;
-#endif
-
-#endif // deprecate
-
-        gsl_api gsl_constexpr14 span(pointer data_in, index_type size_in)
-            : first_(data_in), last_(data_in + size_in) {
-            gsl_Expects(size_in == 0 ||
-                        (size_in > 0 && data_in != gsl_nullptr));
-        }
-
-        gsl_api gsl_constexpr14 span(pointer first_in, pointer last_in)
-            : first_(first_in), last_(last_in) {
-            gsl_Expects(first_in <= last_in);
-        }
-
-#if !gsl_DEPRECATE_TO_LEVEL(5)
-
-        template <class U>
-        gsl_api gsl_constexpr14 span(U *data_in, index_type size_in)
-            : first_(data_in), last_(data_in + size_in) {
-            gsl_Expects(size_in == 0 ||
-                        (size_in > 0 && data_in != gsl_nullptr));
-        }
-
-#endif // deprecate
-
-#if !gsl_DEPRECATE_TO_LEVEL(5)
-        template <class U, size_t N>
-        gsl_api gsl_constexpr span(U (&arr)[N]) gsl_noexcept
-            : first_(gsl_ADDRESSOF(arr[0])),
-              last_(gsl_ADDRESSOF(arr[0]) + N) {}
-#else
-        template <size_t N gsl_ENABLE_IF_(
-            (std::is_convertible<value_type (*)[], element_type (*)[]>::value))>
-        gsl_api gsl_constexpr span(element_type (&arr)[N]) gsl_noexcept
-            : first_(gsl_ADDRESSOF(arr[0])),
-              last_(gsl_ADDRESSOF(arr[0]) + N) {}
-#endif // deprecate
-
-#if gsl_HAVE(ARRAY)
-#if !gsl_DEPRECATE_TO_LEVEL(5)
-
-        template <class U, size_t N>
-        gsl_constexpr span(std::array<U, N> &arr)
-            : first_(arr.data()), last_(arr.data() + N) {}
-
-        template <class U, size_t N>
-        gsl_constexpr span(std::array<U, N> const &arr)
-            : first_(arr.data()), last_(arr.data() + N) {}
-
-#else
-
-        template <size_t N gsl_ENABLE_IF_(
-            (std::is_convertible<value_type (*)[], element_type (*)[]>::value))>
-        gsl_constexpr span(std::array<value_type, N> &arr)
-            : first_(arr.data()), last_(arr.data() + N) {}
-
-        template <size_t N gsl_ENABLE_IF_(
-            (std::is_convertible<value_type (*)[], element_type (*)[]>::value))>
-        gsl_constexpr span(std::array<value_type, N> const &arr)
-            : first_(arr.data()), last_(arr.data() + N) {}
-
-#endif // deprecate
-#endif // gsl_HAVE( ARRAY )
-
-#if gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR)
-        template <class Container gsl_ENABLE_IF_(
-            (detail::is_compatible_container<Container, element_type>::value))>
-        gsl_constexpr span(Container &cont) gsl_noexcept
-            : first_(std17::data(cont)),
-              last_(std17::data(cont) + std17::size(cont)) {}
-
-        template <class Container gsl_ENABLE_IF_(
-            (std::is_const<element_type>::value &&
-             detail::is_compatible_container<Container, element_type>::value))>
-        gsl_constexpr span(Container const &cont) gsl_noexcept
-            : first_(std17::data(cont)),
-              last_(std17::data(cont) + std17::size(cont)) {}
-
-#elif gsl_HAVE(UNCONSTRAINED_SPAN_CONTAINER_CTOR)
-
-        template <class Container>
-        gsl_constexpr span(Container &cont)
-            : first_(cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF(cont[0])),
-              last_(cont.size() == 0 ? gsl_nullptr
-                                     : gsl_ADDRESSOF(cont[0]) + cont.size()) {}
-
-        template <class Container>
-        gsl_constexpr span(Container const &cont)
-            : first_(cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF(cont[0])),
-              last_(cont.size() == 0 ? gsl_nullptr
-                                     : gsl_ADDRESSOF(cont[0]) + cont.size()) {}
-
-#endif
-
-#if gsl_FEATURE_TO_STD(WITH_CONTAINER)
-
-        template <class Container>
-        gsl_constexpr span(with_container_t, Container &cont) gsl_noexcept
-            : first_(cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF(cont[0])),
-              last_(cont.size() == 0 ? gsl_nullptr
-                                     : gsl_ADDRESSOF(cont[0]) + cont.size()) {}
-
-        template <class Container>
-        gsl_constexpr span(with_container_t, Container const &cont) gsl_noexcept
-            : first_(cont.size() == 0 ? gsl_nullptr : gsl_ADDRESSOF(cont[0])),
-              last_(cont.size() == 0 ? gsl_nullptr
-                                     : gsl_ADDRESSOF(cont[0]) + cont.size()) {}
-
-#endif
-
-#if !gsl_DEPRECATE_TO_LEVEL(4)
-        // constructor taking shared_ptr deprecated since 0.29.0
-
-#if gsl_HAVE(SHARED_PTR)
-        gsl_DEPRECATED gsl_constexpr span(shared_ptr<element_type> const &ptr)
-            : first_(ptr.get()),
-              last_(ptr.get() ? ptr.get() + 1 : gsl_nullptr) {}
-#endif
-
-        // constructors taking unique_ptr deprecated since 0.29.0
-
-#if gsl_HAVE(UNIQUE_PTR)
-#if gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG)
-        template <class ArrayElementType =
-                      typename std::add_pointer<element_type>::type>
-#else
-        template <class ArrayElementType>
-#endif
-        gsl_DEPRECATED gsl_constexpr
-        span(unique_ptr<ArrayElementType> const &ptr, index_type count)
-            : first_(ptr.get()), last_(ptr.get() + count) {
-        }
-
-        gsl_DEPRECATED gsl_constexpr span(unique_ptr<element_type> const &ptr)
-            : first_(ptr.get()),
-              last_(ptr.get() ? ptr.get() + 1 : gsl_nullptr) {}
-#endif
-
-#endif // deprecate shared_ptr, unique_ptr
-
-#if gsl_HAVE(IS_DEFAULT) && !gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 430, 600)
-        gsl_constexpr span(span &&) gsl_noexcept = default;
-        gsl_constexpr span(span const &) = default;
-#else
-        gsl_api gsl_constexpr span(span const &other)
-            : first_(other.begin()), last_(other.end()) {}
-#endif
-
-#if gsl_HAVE(IS_DEFAULT)
-        gsl_constexpr14 span &operator=(span &&) gsl_noexcept = default;
-        gsl_constexpr14 span &operator=(span const &) gsl_noexcept = default;
-#else
-        gsl_constexpr14 span &operator=(span other) gsl_noexcept {
-            first_ = other.first_;
-            last_ = other.last_;
-            return *this;
-        }
-#endif
-
-        template <class U gsl_ENABLE_IF_(
-            (std::is_convertible<U (*)[], element_type (*)[]>::value))>
-        gsl_api gsl_constexpr span(span<U> const &other)
-            : first_(other.begin()), last_(other.end()) {}
-
-#if 0
-    // Converting from other span ?
-    template< class U > operator=();
-#endif
-
-        // 26.7.3.3 Subviews [span.sub]
-
-        gsl_api gsl_constexpr14 span first(index_type count) const {
-            gsl_Expects(std::size_t(count) <= std::size_t(this->size()));
-            return span(this->data(), count);
-        }
-
-        gsl_api gsl_constexpr14 span last(index_type count) const {
-            gsl_Expects(std::size_t(count) <= std::size_t(this->size()));
-            return span(this->data() + this->size() - count, count);
-        }
-
-        gsl_api gsl_constexpr14 span subspan(index_type offset) const {
-            gsl_Expects(std::size_t(offset) <= std::size_t(this->size()));
-            return span(this->data() + offset, this->size() - offset);
-        }
-
-        gsl_api gsl_constexpr14 span subspan(index_type offset,
-                                             index_type count) const {
-            gsl_Expects(std::size_t(offset) <= std::size_t(this->size()) &&
-                        std::size_t(count) <=
-                            std::size_t(this->size() - offset));
-            return span(this->data() + offset, count);
-        }
-
-        // 26.7.3.4 Observers [span.obs]
-
-        gsl_api gsl_constexpr index_type size() const gsl_noexcept {
-            return narrow_cast<index_type>(last_ - first_);
-        }
-
-        gsl_api gsl_constexpr std::ptrdiff_t ssize() const gsl_noexcept {
-            return narrow_cast<std::ptrdiff_t>(last_ - first_);
-        }
-
-        gsl_api gsl_constexpr index_type size_bytes() const gsl_noexcept {
-            return size() * narrow_cast<index_type>(sizeof(element_type));
-        }
-
-        gsl_api gsl_constexpr bool empty() const gsl_noexcept {
-            return size() == 0;
-        }
-
-        // 26.7.3.5 Element access [span.elem]
-
-        gsl_api gsl_constexpr14 reference operator[](index_type pos) const {
-            gsl_Expects(pos < size());
-            return first_[pos];
-        }
-
-#if !gsl_DEPRECATE_TO_LEVEL(6)
-        gsl_DEPRECATED_MSG("use subscript indexing instead") gsl_api
-            gsl_constexpr14 reference
-            operator()(index_type pos) const {
-            return (*this)[pos];
-        }
-
-        gsl_DEPRECATED_MSG("use subscript indexing instead") gsl_api
-            gsl_constexpr14 reference at(index_type pos) const {
-            return (*this)[pos];
-        }
-#endif // deprecate
-
-        gsl_api gsl_constexpr14 reference front() const {
-            gsl_Expects(first_ != last_);
-            return *first_;
-        }
-
-        gsl_api gsl_constexpr14 reference back() const {
-            gsl_Expects(first_ != last_);
-            return *(last_ - 1);
-        }
-
-        gsl_api gsl_constexpr pointer data() const gsl_noexcept {
-            return first_;
-        }
-
-        // 26.7.3.6 Iterator support [span.iterators]
-
-        gsl_api gsl_constexpr iterator begin() const gsl_noexcept {
-            return iterator(first_);
-        }
-
-        gsl_api gsl_constexpr iterator end() const gsl_noexcept {
-            return iterator(last_);
-        }
-
-        gsl_api gsl_constexpr const_iterator cbegin() const gsl_noexcept {
-#if gsl_CPP11_OR_GREATER
-            return {begin()};
-#else
-            return const_iterator(begin());
-#endif
-        }
-
-        gsl_api gsl_constexpr const_iterator cend() const gsl_noexcept {
-#if gsl_CPP11_OR_GREATER
-            return {end()};
-#else
-            return const_iterator(end());
-#endif
-        }
-
-        gsl_constexpr17 reverse_iterator rbegin() const gsl_noexcept {
-            return reverse_iterator(end());
-        }
-
-        gsl_constexpr17 reverse_iterator rend() const gsl_noexcept {
-            return reverse_iterator(begin());
-        }
-
-        gsl_constexpr17 const_reverse_iterator crbegin() const gsl_noexcept {
-            return const_reverse_iterator(cend());
-        }
-
-        gsl_constexpr17 const_reverse_iterator crend() const gsl_noexcept {
-            return const_reverse_iterator(cbegin());
-        }
-
-        gsl_constexpr14 void swap(span &other) gsl_noexcept {
-            std::swap(first_, other.first_);
-            std::swap(last_, other.last_);
-        }
-
-#if !gsl_DEPRECATE_TO_LEVEL(3)
-        // member length() deprecated since 0.29.0
-
-        gsl_DEPRECATED_MSG("use size() instead") gsl_api gsl_constexpr
-            index_type length() const gsl_noexcept {
-            return size();
-        }
-
-        // member length_bytes() deprecated since 0.29.0
-
-        gsl_DEPRECATED_MSG("use size_bytes() instead") gsl_api gsl_constexpr
-            index_type length_bytes() const gsl_noexcept {
-            return size_bytes();
-        }
-#endif
-
-#if !gsl_DEPRECATE_TO_LEVEL(2)
-        // member as_bytes(), as_writeable_bytes deprecated since 0.17.0
-
-        gsl_DEPRECATED_MSG("use free function gsl::as_bytes() instead")
-            gsl_api span<const byte> as_bytes() const gsl_noexcept {
-            return span<const byte>(reinterpret_cast<const byte *>(data()),
-                                    size_bytes()); // NOLINT
-        }
-
-        gsl_DEPRECATED_MSG("use free function gsl::as_writable_bytes() instead")
-            gsl_api span<byte> as_writeable_bytes() const gsl_noexcept {
-            return span<byte>(reinterpret_cast<byte *>(data()),
-                              size_bytes()); // NOLINT
-        }
-
-#endif
-
-        template <class U> gsl_api span<U> as_span() const {
-            gsl_Expects((this->size_bytes() % sizeof(U)) == 0);
-            return span<U>(reinterpret_cast<U *>(this->data()),
-                           this->size_bytes() / sizeof(U)); // NOLINT
-        }
-
-      private:
-        pointer first_;
-        pointer last_;
-    };
-
-    // class template argument deduction guides:
-
-#if gsl_HAVE(DEDUCTION_GUIDES) // gsl_CPP17_OR_GREATER
-
-    template <class T, size_t N> span(T(&)[N]) -> span<T /*, N*/>;
-
-    template <class T, size_t N> span(std::array<T, N> &) -> span<T /*, N*/>;
-
-    template <class T, size_t N>
-    span(std::array<T, N> const &) -> span<const T /*, N*/>;
-
-    template <class Container>
-    span(Container &) -> span<typename Container::value_type>;
-
-    template <class Container>
-    span(Container const &) -> span<const typename Container::value_type>;
-
-#endif // gsl_HAVE( DEDUCTION_GUIDES )
-
-    // 26.7.3.7 Comparison operators [span.comparison]
-
-#if gsl_CONFIG(ALLOWS_SPAN_COMPARISON)
-#if gsl_CONFIG(ALLOWS_NONSTRICT_SPAN_COMPARISON)
-
-    template <class T, class U>
-    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr bool operator==(
-        span<T> const &l, span<U> const &r) {
-        return l.size() == r.size() &&
-               (l.begin() == r.begin() ||
-                std::equal(l.begin(), l.end(), r.begin()));
-    }
-
-    template <class T, class U>
-    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr bool operator<(
-        span<T> const &l, span<U> const &r) {
-        return std::lexicographical_compare(l.begin(), l.end(), r.begin(),
-                                            r.end());
-    }
-
-#else  // a.k.a. !gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
-
-    template <class T>
-    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr bool operator==(
-        span<T> const &l, span<T> const &r) {
-        return l.size() == r.size() &&
-               (l.begin() == r.begin() ||
-                std::equal(l.begin(), l.end(), r.begin()));
-    }
-
-    template <class T>
-    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr bool operator<(
-        span<T> const &l, span<T> const &r) {
-        return std::lexicographical_compare(l.begin(), l.end(), r.begin(),
-                                            r.end());
-    }
-#endif // gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
-
-    template <class T, class U>
-    inline gsl_constexpr bool operator!=(span<T> const &l, span<U> const &r) {
-        return !(l == r);
-    }
-
-    template <class T, class U>
-    inline gsl_constexpr bool operator<=(span<T> const &l, span<U> const &r) {
-        return !(r < l);
-    }
-
-    template <class T, class U>
-    inline gsl_constexpr bool operator>(span<T> const &l, span<U> const &r) {
-        return (r < l);
-    }
-
-    template <class T, class U>
-    inline gsl_constexpr bool operator>=(span<T> const &l, span<U> const &r) {
-        return !(l < r);
-    }
-#endif // gsl_CONFIG( ALLOWS_SPAN_COMPARISON )
-
-    // span algorithms
-
-    template <class T>
-    gsl_api inline gsl_constexpr std::size_t size(span<T> const &spn) {
-        return static_cast<std::size_t>(spn.size());
-    }
-
-    template <class T>
-    gsl_api inline gsl_constexpr std::ptrdiff_t ssize(span<T> const &spn) {
-        return spn.ssize();
-    }
-
-    namespace detail {
-
-    template <class II, class N, class OI>
-    gsl_api gsl_constexpr14 inline OI copy_n(II first, N count, OI result) {
-        if (count > 0) {
-            *result++ = *first;
-            for (N i = 1; i < count; ++i) {
-                *result++ = *++first;
-            }
-        }
-        return result;
-    }
-    } // namespace detail
-
-    template <class T, class U>
-    gsl_api gsl_constexpr14 inline void copy(span<T> src, span<U> dest) {
-#if gsl_CPP14_OR_GREATER // gsl_HAVE( TYPE_TRAITS ) (circumvent Travis
-                         // clang 3.4)
-        static_assert(std::is_assignable<U &, T const &>::value,
-                      "Cannot assign elements of source span to elements of "
-                      "destination span");
-#endif
-        gsl_Expects(dest.size() >= src.size());
-        detail::copy_n(src.data(), src.size(), dest.data());
-    }
-
-    // span creator functions (see ctors)
-
-    template <class T>
-    gsl_api inline span<const byte> as_bytes(span<T> spn) gsl_noexcept {
-        return span<const byte>(reinterpret_cast<const byte *>(spn.data()),
-                                spn.size_bytes()); // NOLINT
-    }
-
-    template <class T>
-    gsl_api inline span<byte> as_writable_bytes(span<T> spn) gsl_noexcept {
-        return span<byte>(reinterpret_cast<byte *>(spn.data()),
-                          spn.size_bytes()); // NOLINT
-    }
-
-#if !gsl_DEPRECATE_TO_LEVEL(6)
-    template <class T>
-    gsl_DEPRECATED_MSG("use as_writable_bytes() (different spelling) instead")
-        gsl_api inline span<byte>
-        as_writeable_bytes(span<T> spn) gsl_noexcept {
-        return span<byte>(reinterpret_cast<byte *>(spn.data()),
-                          spn.size_bytes()); // NOLINT
-    }
-#endif // deprecate
-
-#if gsl_FEATURE_TO_STD(MAKE_SPAN)
-
-    template <class T>
-    gsl_api inline gsl_constexpr span<T> make_span(
-        T * ptr, typename span<T>::index_type count) {
-        return span<T>(ptr, count);
-    }
-
-    template <class T>
-    gsl_api inline gsl_constexpr span<T> make_span(T * first, T * last) {
-        return span<T>(first, last);
-    }
-
-    template <class T, size_t N>
-    gsl_api inline gsl_constexpr span<T> make_span(T(&arr)[N]) {
-        return span<T>(gsl_ADDRESSOF(arr[0]), N);
-    }
-
-#if gsl_HAVE(ARRAY)
-
-    template <class T, size_t N>
-    inline gsl_constexpr span<T> make_span(std::array<T, N> & arr) {
-        return span<T>(arr);
-    }
-
-    template <class T, size_t N>
-    inline gsl_constexpr span<const T> make_span(std::array<T, N> const &arr) {
-        return span<const T>(arr);
-    }
-#endif
-
-#if gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR) && gsl_HAVE(AUTO)
-
-    template <class Container,
-              class EP = decltype(std17::data(std::declval<Container &>()))>
-    inline gsl_constexpr auto make_span(Container & cont)
-        ->span<typename std::remove_pointer<EP>::type> {
-        return span<typename std::remove_pointer<EP>::type>(cont);
-    }
-
-    template <class Container,
-              class EP = decltype(std17::data(std::declval<Container &>()))>
-    inline gsl_constexpr auto make_span(Container const &cont)
-        ->span<const typename std::remove_pointer<EP>::type> {
-        return span<const typename std::remove_pointer<EP>::type>(cont);
-    }
-
-#else
-
-    template <class T> inline span<T> make_span(std::vector<T> & cont) {
-        return span<T>(with_container, cont);
-    }
-
-    template <class T>
-    inline span<const T> make_span(std::vector<T> const &cont) {
-        return span<const T>(with_container, cont);
-    }
-#endif
-
-#if gsl_FEATURE_TO_STD(WITH_CONTAINER)
-
-    template <class Container>
-    inline gsl_constexpr span<typename Container::value_type> make_span(
-        with_container_t, Container & cont) gsl_noexcept {
-        return span<typename Container::value_type>(with_container, cont);
-    }
-
-    template <class Container>
-    inline gsl_constexpr span<const typename Container::value_type> make_span(
-        with_container_t, Container const &cont) gsl_noexcept {
-        return span<const typename Container::value_type>(with_container, cont);
-    }
-
-#endif // gsl_FEATURE_TO_STD( WITH_CONTAINER )
-
-#if !gsl_DEPRECATE_TO_LEVEL(4)
-    template <class Ptr>
-    gsl_DEPRECATED inline span<typename Ptr::element_type> make_span(Ptr &
-                                                                     ptr) {
-        return span<typename Ptr::element_type>(ptr);
-    }
-#endif // !gsl_DEPRECATE_TO_LEVEL( 4 )
-
-    template <class Ptr>
-    gsl_DEPRECATED inline span<typename Ptr::element_type> make_span(
-        Ptr & ptr,
-        typename span<typename Ptr::element_type>::index_type count) {
-        return span<typename Ptr::element_type>(ptr, count);
-    }
-
-#endif // gsl_FEATURE_TO_STD( MAKE_SPAN )
-
-#if gsl_FEATURE_TO_STD(BYTE_SPAN)
-
-    template <class T>
-    gsl_api inline gsl_constexpr span<byte> byte_span(T & t) gsl_noexcept {
-        return span<byte>(reinterpret_cast<byte *>(&t), sizeof(T));
-    }
-
-    template <class T>
-    gsl_api inline gsl_constexpr span<const byte> byte_span(T const &t)
-        gsl_noexcept {
-        return span<const byte>(reinterpret_cast<byte const *>(&t), sizeof(T));
-    }
-
-#endif // gsl_FEATURE_TO_STD( BYTE_SPAN )
-
-    //
-    // basic_string_span:
-    //
-
-    template <class T> class basic_string_span;
-
-    namespace detail {
-
-    template <class T>
-    struct is_basic_string_span_oracle : std11::false_type {};
-
-    template <class T>
-    struct is_basic_string_span_oracle<basic_string_span<T>>
-        : std11::true_type {};
-
-    template <class T>
-    struct is_basic_string_span
-        : is_basic_string_span_oracle<typename std11::remove_cv<T>::type> {};
-
-    template <class T>
-    gsl_api inline gsl_constexpr14 std::size_t string_length(T *ptr,
-                                                             std::size_t max) {
-        if (ptr == gsl_nullptr || max <= 0)
-            return 0;
-
-        std::size_t len = 0;
-        while (len < max && ptr[len]) // NOLINT
-            ++len;
-
-        return len;
-    }
-
-    } // namespace detail
-
-    //
-    // basic_string_span<> - A view of contiguous characters, replace (*,len).
-    //
-    template <class T> class basic_string_span {
-      public:
-        typedef T element_type;
-        typedef span<T> span_type;
-
-        typedef typename span_type::index_type index_type;
-        typedef typename span_type::difference_type difference_type;
-
-        typedef typename span_type::pointer pointer;
-        typedef typename span_type::reference reference;
-
-        typedef typename span_type::iterator iterator;
-        typedef typename span_type::const_iterator const_iterator;
-        typedef typename span_type::reverse_iterator reverse_iterator;
-        typedef
-            typename span_type::const_reverse_iterator const_reverse_iterator;
-
-        // construction:
-
-#if gsl_HAVE(IS_DEFAULT)
-        gsl_constexpr basic_string_span() gsl_noexcept = default;
-#else
-        gsl_api gsl_constexpr basic_string_span() gsl_noexcept {}
-#endif
-
-#if gsl_HAVE(NULLPTR)
-        gsl_api gsl_constexpr basic_string_span(std::nullptr_t) gsl_noexcept
-            : span_(nullptr, static_cast<index_type>(0)) {}
-#endif
-
-#ifdef __CUDACC_RELAXED_CONSTEXPR__
-        gsl_api
-#endif // __CUDACC_RELAXED_CONSTEXPR__
-            gsl_constexpr
-            basic_string_span(pointer ptr)
-            : span_(remove_z(ptr, (std::numeric_limits<index_type>::max)())) {
-        }
-
-        gsl_api gsl_constexpr basic_string_span(pointer ptr, index_type count)
-            : span_(ptr, count) {}
-
-        gsl_api gsl_constexpr basic_string_span(pointer firstElem,
-                                                pointer lastElem)
-            : span_(firstElem, lastElem) {}
-
-        template <std::size_t N>
-        gsl_api gsl_constexpr basic_string_span(element_type (&arr)[N])
-            : span_(remove_z(gsl_ADDRESSOF(arr[0]), N)) {}
-
-#if gsl_HAVE(ARRAY)
-
-        template <std::size_t N>
-        gsl_constexpr basic_string_span(
-            std::array<typename std11::remove_const<element_type>::type, N>
-                &arr)
-            : span_(remove_z(arr)) {}
-
-        template <std::size_t N>
-        gsl_constexpr basic_string_span(
-            std::array<typename std11::remove_const<element_type>::type,
-                       N> const &arr)
-            : span_(remove_z(arr)) {}
-
-#endif
-
-#if gsl_HAVE(CONSTRAINED_SPAN_CONTAINER_CTOR)
-
-        // Exclude: array, [basic_string,] basic_string_span
-
-        template <class Container gsl_ENABLE_IF_(
-            (!detail::is_std_array<Container>::value &&
-             !detail::is_basic_string_span<Container>::value &&
-             std::is_convertible<typename Container::pointer, pointer>::value &&
-             std::is_convertible<
-                 typename Container::pointer,
-                 decltype(std::declval<Container>().data())>::value))>
-        gsl_constexpr basic_string_span(Container &cont) : span_((cont)) {}
-
-        // Exclude: array, [basic_string,] basic_string_span
-
-        template <class Container gsl_ENABLE_IF_(
-            (!detail::is_std_array<Container>::value &&
-             !detail::is_basic_string_span<Container>::value &&
-             std::is_convertible<typename Container::pointer, pointer>::value &&
-             std::is_convertible<
-                 typename Container::pointer,
-                 decltype(std::declval<Container const &>().data())>::value))>
-        gsl_constexpr basic_string_span(Container const &cont)
-            : span_((cont)) {}
-
-#elif gsl_HAVE(UNCONSTRAINED_SPAN_CONTAINER_CTOR)
-
-        template <class Container>
-        gsl_constexpr basic_string_span(Container &cont) : span_(cont) {}
-
-        template <class Container>
-        gsl_constexpr basic_string_span(Container const &cont) : span_(cont) {}
-
-#else
-
-        template <class U>
-        gsl_api gsl_constexpr basic_string_span(span<U> const &rhs)
-            : span_(rhs) {}
-
-#endif
-
-#if gsl_FEATURE_TO_STD(WITH_CONTAINER)
-
-        template <class Container>
-        gsl_constexpr basic_string_span(with_container_t, Container &cont)
-            : span_(with_container, cont) {}
-#endif
-
-#if gsl_HAVE(IS_DEFAULT)
-#if gsl_BETWEEN(gsl_COMPILER_GNUC_VERSION, 440, 600)
-        gsl_constexpr basic_string_span(basic_string_span const &rhs) = default;
-
-        gsl_constexpr basic_string_span(basic_string_span &&rhs) = default;
-#else
-        gsl_constexpr
-        basic_string_span(basic_string_span const &rhs) gsl_noexcept = default;
-
-        gsl_constexpr
-        basic_string_span(basic_string_span &&rhs) gsl_noexcept = default;
-#endif
-#endif
-
-        template <class U gsl_ENABLE_IF_(
-            (std::is_convertible<typename basic_string_span<U>::pointer,
-                                 pointer>::value))>
-        gsl_api gsl_constexpr basic_string_span(basic_string_span<U> const &rhs)
-            : span_(reinterpret_cast<pointer>(rhs.data()),
-                    rhs.length()) // NOLINT
-        {}
-
-#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
-        template <class U gsl_ENABLE_IF_(
-            (std::is_convertible<typename basic_string_span<U>::pointer,
-                                 pointer>::value))>
-        gsl_api gsl_constexpr basic_string_span(basic_string_span<U> &&rhs)
-            : span_(reinterpret_cast<pointer>(rhs.data()),
-                    rhs.length()) // NOLINT
-        {}
-#endif
-
-        template <class CharTraits, class Allocator>
-        gsl_constexpr basic_string_span(
-            std::basic_string<typename std11::remove_const<element_type>::type,
-                              CharTraits, Allocator> &str)
-            : span_(gsl_ADDRESSOF(str[0]), str.length()) {}
-
-        template <class CharTraits, class Allocator>
-        gsl_constexpr basic_string_span(
-            std::basic_string<typename std11::remove_const<element_type>::type,
-                              CharTraits, Allocator> const &str)
-            : span_(gsl_ADDRESSOF(str[0]), str.length()) {}
-
-        // assignment:
-
-#if gsl_HAVE(IS_DEFAULT)
-        gsl_constexpr14 basic_string_span &
-        operator=(basic_string_span const &rhs) gsl_noexcept = default;
-
-        gsl_constexpr14 basic_string_span &
-        operator=(basic_string_span &&rhs) gsl_noexcept = default;
-#endif
-
-        // sub span:
-
-        /*gsl_api*/ // currently disabled due to an apparent NVCC bug
-        gsl_constexpr14 basic_string_span first(index_type count) const {
-            return span_.first(count);
-        }
-
-        /*gsl_api*/ // currently disabled due to an apparent NVCC bug
-        gsl_constexpr14 basic_string_span last(index_type count) const {
-            return span_.last(count);
-        }
-
-        /*gsl_api*/ // currently disabled due to an apparent NVCC bug
-        gsl_constexpr14 basic_string_span subspan(index_type offset) const {
-            return span_.subspan(offset);
-        }
-
-        /*gsl_api*/ // currently disabled due to an apparent NVCC bug
-        gsl_constexpr14 basic_string_span subspan(index_type offset,
-                                                  index_type count) const {
-            return span_.subspan(offset, count);
-        }
-
-        // observers:
-
-        gsl_api gsl_constexpr index_type length() const gsl_noexcept {
-            return span_.size();
-        }
-
-        gsl_api gsl_constexpr index_type size() const gsl_noexcept {
-            return span_.size();
-        }
-
-        gsl_api gsl_constexpr index_type length_bytes() const gsl_noexcept {
-            return span_.size_bytes();
-        }
-
-        gsl_api gsl_constexpr index_type size_bytes() const gsl_noexcept {
-            return span_.size_bytes();
-        }
-
-        gsl_api gsl_constexpr bool empty() const gsl_noexcept {
-            return size() == 0;
-        }
-
-        gsl_api gsl_constexpr14 reference operator[](index_type idx) const {
-            return span_[idx];
-        }
-
-#if !gsl_DEPRECATE_TO_LEVEL(6)
-        gsl_DEPRECATED_MSG("use subscript indexing instead") gsl_api
-            gsl_constexpr14 reference
-            operator()(index_type idx) const {
-            return span_[idx];
-        }
-#endif // deprecate
-
-        gsl_api gsl_constexpr14 reference front() const {
-            return span_.front();
-        }
-
-        gsl_api gsl_constexpr14 reference back() const { return span_.back(); }
-
-        gsl_api gsl_constexpr pointer data() const gsl_noexcept {
-            return span_.data();
-        }
-
-        gsl_api gsl_constexpr iterator begin() const gsl_noexcept {
-            return span_.begin();
-        }
-
-        gsl_api gsl_constexpr iterator end() const gsl_noexcept {
-            return span_.end();
-        }
-
-        gsl_constexpr17 reverse_iterator rbegin() const gsl_noexcept {
-            return span_.rbegin();
-        }
-
-        gsl_constexpr17 reverse_iterator rend() const gsl_noexcept {
-            return span_.rend();
-        }
-
-        // const version not in p0123r2:
-
-        gsl_api gsl_constexpr const_iterator cbegin() const gsl_noexcept {
-            return span_.cbegin();
-        }
-
-        gsl_api gsl_constexpr const_iterator cend() const gsl_noexcept {
-            return span_.cend();
-        }
-
-        gsl_constexpr17 const_reverse_iterator crbegin() const gsl_noexcept {
-            return span_.crbegin();
-        }
-
-        gsl_constexpr17 const_reverse_iterator crend() const gsl_noexcept {
-            return span_.crend();
-        }
-
-      private:
-        gsl_api static gsl_constexpr14 span_type remove_z(pointer const &sz,
-                                                          std::size_t max) {
-            return span_type(sz, detail::string_length(sz, max));
-        }
-
-#if gsl_HAVE(ARRAY)
-        template <size_t N>
-        static gsl_constexpr14 span_type
-        remove_z(std::array<typename std11::remove_const<element_type>::type, N>
-                     &arr) {
-            return remove_z(gsl_ADDRESSOF(arr[0]), narrow_cast<std::size_t>(N));
-        }
-
-        template <size_t N>
-        static gsl_constexpr14 span_type
-        remove_z(std::array<typename std11::remove_const<element_type>::type,
-                            N> const &arr) {
-            return remove_z(gsl_ADDRESSOF(arr[0]), narrow_cast<std::size_t>(N));
-        }
-#endif
-
-      private:
-        span_type span_;
-    };
-
-    // basic_string_span comparison functions:
-
-#if gsl_CONFIG(ALLOWS_NONSTRICT_SPAN_COMPARISON)
-
-    template <class T, class U>
-    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator==(
-        basic_string_span<T> const &l, U const &u) gsl_noexcept {
-        const basic_string_span<typename std11::add_const<T>::type> r(u);
-
-        return l.size() == r.size() &&
-               std::equal(l.begin(), l.end(), r.begin());
-    }
-
-    template <class T, class U>
-    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator<(
-        basic_string_span<T> const &l, U const &u) gsl_noexcept {
-        const basic_string_span<typename std11::add_const<T>::type> r(u);
-
-        return std::lexicographical_compare(l.begin(), l.end(), r.begin(),
-                                            r.end());
-    }
-
-#if gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG)
-
-    template <class T,
-              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
-    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator==(
-        U const &u, basic_string_span<T> const &r) gsl_noexcept {
-        const basic_string_span<typename std11::add_const<T>::type> l(u);
-
-        return l.size() == r.size() &&
-               std::equal(l.begin(), l.end(), r.begin());
-    }
-
-    template <class T,
-              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
-    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator<(
-        U const &u, basic_string_span<T> const &r) gsl_noexcept {
-        const basic_string_span<typename std11::add_const<T>::type> l(u);
-
-        return std::lexicographical_compare(l.begin(), l.end(), r.begin(),
-                                            r.end());
-    }
-#endif
-
-#else // gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
-
-    template <class T>
-    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator==(
-        basic_string_span<T> const &l, basic_string_span<T> const &r)
-        gsl_noexcept {
-        return l.size() == r.size() &&
-               std::equal(l.begin(), l.end(), r.begin());
-    }
-
-    template <class T>
-    gsl_SUPPRESS_MSGSL_WARNING(stl .1) inline gsl_constexpr14 bool operator<(
-        basic_string_span<T> const &l, basic_string_span<T> const &r)
-        gsl_noexcept {
-        return std::lexicographical_compare(l.begin(), l.end(), r.begin(),
-                                            r.end());
-    }
-
-#endif // gsl_CONFIG( ALLOWS_NONSTRICT_SPAN_COMPARISON )
-
-    template <class T, class U>
-    inline gsl_constexpr14 bool operator!=(basic_string_span<T> const &l,
-                                           U const &r) gsl_noexcept {
-        return !(l == r);
-    }
-
-    template <class T, class U>
-    inline gsl_constexpr14 bool operator<=(basic_string_span<T> const &l,
-                                           U const &r) gsl_noexcept {
-#if gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) ||                                 \
-    !gsl_CONFIG(ALLOWS_NONSTRICT_SPAN_COMPARISON)
-        return !(r < l);
-#else
-        basic_string_span<typename std11::add_const<T>::type> rr(r);
-        return !(rr < l);
-#endif
-    }
-
-    template <class T, class U>
-    inline gsl_constexpr14 bool operator>(basic_string_span<T> const &l,
-                                          U const &r) gsl_noexcept {
-#if gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG) ||                                 \
-    !gsl_CONFIG(ALLOWS_NONSTRICT_SPAN_COMPARISON)
-        return (r < l);
-#else
-        basic_string_span<typename std11::add_const<T>::type> rr(r);
-        return (rr < l);
-#endif
-    }
-
-    template <class T, class U>
-    inline gsl_constexpr14 bool operator>=(basic_string_span<T> const &l,
-                                           U const &r) gsl_noexcept {
-        return !(l < r);
-    }
-
-#if gsl_HAVE(DEFAULT_FUNCTION_TEMPLATE_ARG)
-
-    template <class T,
-              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
-    inline gsl_constexpr14 bool operator!=(
-        U const &l, basic_string_span<T> const &r) gsl_noexcept {
-        return !(l == r);
-    }
-
-    template <class T,
-              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
-    inline gsl_constexpr14 bool operator<=(
-        U const &l, basic_string_span<T> const &r) gsl_noexcept {
-        return !(r < l);
-    }
-
-    template <class T,
-              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
-    inline gsl_constexpr14 bool operator>(
-        U const &l, basic_string_span<T> const &r) gsl_noexcept {
-        return (r < l);
-    }
-
-    template <class T,
-              class U gsl_ENABLE_IF_((!detail::is_basic_string_span<U>::value))>
-    inline gsl_constexpr14 bool operator>=(
-        U const &l, basic_string_span<T> const &r) gsl_noexcept {
-        return !(l < r);
-    }
-
-#endif // gsl_HAVE( DEFAULT_FUNCTION_TEMPLATE_ARG )
-
-    // convert basic_string_span to byte span:
-
-    template <class T>
-    gsl_api inline span<const byte> as_bytes(basic_string_span<T> spn)
-        gsl_noexcept {
-        return span<const byte>(reinterpret_cast<const byte *>(spn.data()),
-                                spn.size_bytes()); // NOLINT
-    }
-
-    //
-    // String types:
-    //
-
-    typedef char *zstring;
-    typedef const char *czstring;
-
-#if gsl_HAVE(WCHAR)
-    typedef wchar_t *wzstring;
-    typedef const wchar_t *cwzstring;
-#endif
-
-    typedef basic_string_span<char> string_span;
-    typedef basic_string_span<char const> cstring_span;
-
-#if gsl_HAVE(WCHAR)
-    typedef basic_string_span<wchar_t> wstring_span;
-    typedef basic_string_span<wchar_t const> cwstring_span;
-#endif
-
-    // to_string() allow (explicit) conversions from string_span to string
-
-#if 0
-
-template< class T >
-inline std::basic_string< typename std::remove_const<T>::type > to_string( basic_string_span<T> spn )
-{
-     std::string( spn.data(), spn.length() );
-}
-
-#else
-
-    inline std::string to_string(string_span const &spn) {
-        return std::string(spn.data(), spn.length());
-    }
-
-    inline std::string to_string(cstring_span const &spn) {
-        return std::string(spn.data(), spn.length());
-    }
-
-#if gsl_HAVE(WCHAR)
-
-    inline std::wstring to_string(wstring_span const &spn) {
-        return std::wstring(spn.data(), spn.length());
-    }
-
-    inline std::wstring to_string(cwstring_span const &spn) {
-        return std::wstring(spn.data(), spn.length());
-    }
-
-#endif // gsl_HAVE( WCHAR )
-#endif // to_string()
-
-    //
-    // Stream output for string_span types
-    //
-
-    namespace detail {
-
-    template <class Stream> void write_padding(Stream &os, std::streamsize n) {
-        for (std::streamsize i = 0; i < n; ++i)
-            os.rdbuf()->sputc(os.fill());
-    }
-
-    template <class Stream, class Span>
-    Stream &write_to_stream(Stream &os, Span const &spn) {
-        typename Stream::sentry sentry(os);
-
-        if (!os)
-            return os;
-
-        const std::streamsize length = narrow<std::streamsize>(spn.length());
-
-        // Whether, and how, to pad
-        const bool pad = (length < os.width());
-        const bool left_pad =
-            pad &&
-            (os.flags() & std::ios_base::adjustfield) == std::ios_base::right;
-
-        if (left_pad)
-            write_padding(os, os.width() - length);
-
-        // Write span characters
-        os.rdbuf()->sputn(spn.begin(), length);
-
-        if (pad && !left_pad)
-            write_padding(os, os.width() - length);
-
-        // Reset output stream width
-        os.width(0);
-
-        return os;
-    }
-
-    } // namespace detail
-
-    template <typename Traits>
-    std::basic_ostream<char, Traits> &operator<<(
-        std::basic_ostream<char, Traits> &os, string_span const &spn) {
-        return detail::write_to_stream(os, spn);
-    }
-
-    template <typename Traits>
-    std::basic_ostream<char, Traits> &operator<<(
-        std::basic_ostream<char, Traits> &os, cstring_span const &spn) {
-        return detail::write_to_stream(os, spn);
-    }
-
-#if gsl_HAVE(WCHAR)
-
-    template <typename Traits>
-    std::basic_ostream<wchar_t, Traits> &operator<<(
-        std::basic_ostream<wchar_t, Traits> &os, wstring_span const &spn) {
-        return detail::write_to_stream(os, spn);
-    }
-
-    template <typename Traits>
-    std::basic_ostream<wchar_t, Traits> &operator<<(
-        std::basic_ostream<wchar_t, Traits> &os, cwstring_span const &spn) {
-        return detail::write_to_stream(os, spn);
-    }
-
-#endif // gsl_HAVE( WCHAR )
-
-    //
-    // ensure_sentinel()
-    //
-    // Provides a way to obtain a span from a contiguous sequence
-    // that ends with a (non-inclusive) sentinel value.
-    //
-    // Will fail-fast if sentinel cannot be found before max elements are
-    // examined.
-    //
-    namespace detail {
-
-    template <class T, class SizeType, const T Sentinel>
-    gsl_api static span<T>
-    ensure_sentinel(T *seq,
-                    SizeType max = (std::numeric_limits<SizeType>::max)()) {
-        typedef T *pointer;
-
-        gsl_SUPPRESS_MSVC_WARNING(
-            26429, "f.23: symbol 'cur' is never tested for nullness, it can be "
-                   "marked as not_null") pointer cur = seq;
-
-        while (static_cast<SizeType>(cur - seq) < max && *cur != Sentinel)
-            ++cur;
-
-        gsl_Expects(*cur == Sentinel);
-
-        return span<T>(seq,
-                       narrow_cast<typename span<T>::index_type>(cur - seq));
-    }
-    } // namespace detail
-
-    //
-    // ensure_z - creates a string_span for a czstring or cwzstring.
-    // Will fail fast if a null-terminator cannot be found before
-    // the limit of size_type.
-    //
-
-    template <class T>
-    gsl_api inline span<T> ensure_z(
-        T *const &sz, size_t max = (std::numeric_limits<size_t>::max)()) {
-        return detail::ensure_sentinel<T, size_t, 0>(sz, max);
-    }
-
-    template <class T, size_t N> gsl_api inline span<T> ensure_z(T(&sz)[N]) {
-        return ::gsl::ensure_z(gsl_ADDRESSOF(sz[0]), N);
-    }
-
-#if gsl_HAVE(TYPE_TRAITS)
-
-    template <class Container>
-    inline span<typename std::remove_pointer<typename Container::pointer>::type>
-    ensure_z(Container & cont) {
-        return ::gsl::ensure_z(cont.data(), cont.length());
-    }
-#endif
-
-    //
-    // basic_zstring_span<> - A view of contiguous null-terminated characters,
-    // replace (*,len).
-    //
-
-    template <typename T> class basic_zstring_span {
-      public:
-        typedef T element_type;
-        typedef span<T> span_type;
-
-        typedef typename span_type::index_type index_type;
-        typedef typename span_type::difference_type difference_type;
-
-        typedef element_type *czstring_type;
-        typedef basic_string_span<element_type> string_span_type;
-
-        gsl_api gsl_constexpr14 basic_zstring_span(span_type s) : span_(s) {
-            // expects a zero-terminated span
-            gsl_Expects(s[s.size() - 1] == '\0');
-        }
-
-#if gsl_HAVE(IS_DEFAULT)
-        gsl_constexpr
-        basic_zstring_span(basic_zstring_span const &other) = default;
-        gsl_constexpr basic_zstring_span(basic_zstring_span &&other) = default;
-        gsl_constexpr14 basic_zstring_span &
-        operator=(basic_zstring_span const &other) = default;
-        gsl_constexpr14 basic_zstring_span &
-        operator=(basic_zstring_span &&other) = default;
-#else
-        gsl_api gsl_constexpr
-        basic_zstring_span(basic_zstring_span const &other)
-            : span_(other.span_) {}
-        gsl_api gsl_constexpr basic_zstring_span &
-        operator=(basic_zstring_span const &other) {
-            span_ = other.span_;
-            return *this;
-        }
-#endif
-
-        gsl_api gsl_constexpr bool empty() const gsl_noexcept {
-            return span_.size() == 0;
-        }
-
-        gsl_api gsl_constexpr string_span_type
-        as_string_span() const gsl_noexcept {
-            return string_span_type(span_.data(),
-                                    span_.size() > 1 ? span_.size() - 1 : 0);
-        }
-
-        /*gsl_api*/ // currently disabled due to an apparent NVCC bug
-        gsl_constexpr string_span_type ensure_z() const {
-            return ::gsl::ensure_z(span_.data(), span_.size());
-        }
-
-        gsl_api gsl_constexpr czstring_type assume_z() const gsl_noexcept {
-            return span_.data();
-        }
-
-      private:
-        span_type span_;
-    };
-
-    //
-    // zString types:
-    //
-
-    typedef basic_zstring_span<char> zstring_span;
-    typedef basic_zstring_span<char const> czstring_span;
-
-#if gsl_HAVE(WCHAR)
-    typedef basic_zstring_span<wchar_t> wzstring_span;
-    typedef basic_zstring_span<wchar_t const> cwzstring_span;
-#endif
-
-} // namespace gsl
-
-#if gsl_CPP11_OR_GREATER || gsl_COMPILER_MSVC_VERSION >= 120
-
-namespace std {
-
-template <> struct hash<::gsl::byte> {
-  public:
-    gsl_constexpr std::size_t operator()(::gsl::byte v) const gsl_noexcept {
-        return ::gsl::to_integer<std::size_t>(v);
-    }
-};
-
-} // namespace std
-
-#endif
-
-#if gsl_FEATURE_GSL_LITE_NAMESPACE
-
-// gsl_lite namespace:
-
-// gsl-lite currently keeps all symbols in the namespace `gsl`. The `gsl_lite`
-// namespace contains all the symbols in the `gsl` namespace, plus some
-// extensions that are not specified in the Core Guidelines.
-//
-// Going forward, we want to support coexistence of gsl-lite with M-GSL, so we
-// want to encourage using the `gsl_lite` namespace when consuming gsl-lite.
-// Typical use in library code would be:
-//
-//     #include <gsl-lite/gsl-lite.hpp> // instead of <gsl/gsl-lite.hpp>
-//
-//     namespace foo {
-//         namespace gsl = ::gsl_lite; // convenience alias
-//         double mean(gsl::span<double const> elements) {
-//             gsl_Expects(!elements.empty()); // instead of Expects()
-//             ...
-//         }
-//     } // namespace foo
-//
-// In a future version, the new <gsl-lite/gsl-lite.hpp> header will only define
-// the `gsl_lite` namespace and no unprefixed `Expects()` and `Ensures()` macros
-// to avoid collision with M-GSL. To ensure backward compatibility, the old
-// header <gsl/gsl-lite.hpp> will keep defining the `gsl` namespace and the
-// `Expects()` and `Ensures()` macros.
-
-namespace gsl_lite {
-
-namespace std11 = ::gsl::std11;
-namespace std14 = ::gsl::std14;
-namespace std17 = ::gsl::std17;
-namespace std20 = ::gsl::std20;
-
-using namespace std11;
-using namespace std14;
-using namespace std17;
-using namespace std20;
-
-#if gsl_HAVE(SHARED_PTR)
-using std::make_shared;
-using std::shared_ptr;
-using std::unique_ptr;
-#endif
-
-using ::gsl::index;
-
-// Integer type for dimensions.
-typedef gsl_CONFIG_INDEX_TYPE dim;
-
-// Integer type for array strides.
-typedef gsl_CONFIG_INDEX_TYPE stride;
-
-// Integer type for pointer, iterator, or index differences.
-typedef gsl_CONFIG_INDEX_TYPE diff;
-
-#if gsl_HAVE(ALIAS_TEMPLATE)
-using ::gsl::owner;
-#endif
-
-using ::gsl::fail_fast;
-
-using ::gsl::finally;
-#if gsl_FEATURE(EXPERIMENTAL_RETURN_GUARD)
-using ::gsl::on_error;
-using ::gsl::on_return;
-#endif // gsl_FEATURE( EXPERIMENTAL_RETURN_GUARD )
-
-using ::gsl::narrow;
-using ::gsl::narrow_cast;
-using ::gsl::narrow_failfast;
-using ::gsl::narrowing_error;
-
-using ::gsl::at;
-
-using ::gsl::make_not_null;
-using ::gsl::not_null;
-
-using ::gsl::byte;
-
-using ::gsl::with_container;
-using ::gsl::with_container_t;
-
-using ::gsl::as_bytes;
-using ::gsl::as_writable_bytes;
-using ::gsl::byte_span;
-using ::gsl::copy;
-using ::gsl::make_span;
-using ::gsl::span;
-#if !gsl_DEPRECATE_TO_LEVEL(6)
-using ::gsl::as_writeable_bytes;
-#endif
-
-using ::gsl::basic_string_span;
-using ::gsl::cstring_span;
-using ::gsl::string_span;
-
-using ::gsl::basic_zstring_span;
-using ::gsl::czstring_span;
-using ::gsl::zstring_span;
-
-using ::gsl::czstring;
-using ::gsl::zstring;
-
-#if gsl_HAVE(WCHAR)
-using ::gsl::cwzstring;
-using ::gsl::wzstring;
-
-using ::gsl::cwzstring_span;
-using ::gsl::wzstring_span;
-#endif // gsl_HAVE( WCHAR )
-
-} // namespace gsl_lite
-
-#endif // gsl_FEATURE_GSL_LITE_NAMESPACE
-
-gsl_RESTORE_MSVC_WARNINGS()
-
-#endif // GSL_GSL_LITE_HPP_INCLUDED
-
-    // end of file
diff --git a/modules/xpu/src/runtime/hardware_context.cpp b/modules/xpu/src/runtime/hardware_context.cpp
deleted file mode 100644
index 4fdb86a613..0000000000
--- a/modules/xpu/src/runtime/hardware_context.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-#include "hardware_context.h"
-#include "hardware_def.h"
-#include <pthread.h>
-
-using namespace nncase::runtime::xpu;
-std::unique_ptr<hardware_context_impl> hardware_context::impl_;
-
-class condition_variable {
-  public:
-    condition_variable() {
-        pthread_cond_init(&cond, NULL);
-        pthread_mutex_init(&mutex, NULL);
-    }
-
-    pthread_mutex_t mutex;
-    pthread_cond_t cond;
-
-    ~condition_variable() {
-        pthread_mutex_destroy(&mutex);
-        pthread_cond_destroy(&cond);
-    }
-};
-
-struct hardware_context_impl {
-  public:
-    hardware_context_impl() {
-        global_cond = condition_variable();
-        pthread_mutex_init(&global_mutex, NULL);
-
-        for (size_t i = 0; i < BLOCKS; i++) {
-            pthread_mutex_init(&block_mutexs[i], NULL);
-            block_conds[i] = condition_variable();
-            for (size_t j = 0; j < CORES; j++) {
-                block_visited[i][j] = false;
-                global_visited[i][j] = false;
-            }
-        }
-    }
-
-    void reset_block_visited(int bid) {
-        for (size_t i = 0; i < CORES; i++) {
-            block_visited[bid][i] = false;
-        }
-    }
-
-    void reset_global_visited() {
-        for (size_t i = 0; i < BLOCKS; i++) {
-            for (size_t j = 0; j < CORES; j++) {
-                global_visited[i][j] = false;
-            }
-        }
-    }
-
-    pthread_mutex_t global_mutex;
-    condition_variable global_cond;
-    bool global_visited[BLOCKS][CORES];
-    pthread_mutex_t block_mutexs[BLOCKS];
-    condition_variable block_conds[BLOCKS];
-    bool block_visited[BLOCKS][CORES];
-
-    ~hardware_context_impl() {
-        pthread_mutex_destroy(&global_mutex);
-        for (size_t i = 0; i < BLOCKS; i++) {
-            pthread_mutex_destroy(&block_mutexs[i]);
-        }
-    }
-};
-
-void hardware_context::init() {
-    impl_ = std::make_unique<hardware_context_impl>();
-}
-
-void hardware_context::lock_block(int bid) {
-    pthread_mutex_lock(&impl_->block_mutexs[bid]);
-}
-
-void hardware_context::unlock_block(int bid) {
-    pthread_mutex_unlock(&impl_->block_mutexs[bid]);
-}
-
-int hardware_context::mark_block_visit(int bid, int tid) {
-    impl_->block_visited[bid][tid] = true;
-    int visited = 0;
-    for (size_t i = 0; i < CORES; i++) {
-        visited += impl_->block_visited[bid][i] == true ? 1 : 0;
-    }
-    return visited;
-}
-
-void hardware_context::wait_block_sync(int bid, int visited,
-                                       std::function<void()> callable) {
-    pthread_mutex_lock(&impl_->block_conds[bid].mutex);
-    if (visited == CORES) {
-        callable();
-        impl_->reset_block_visited(bid);
-        pthread_cond_broadcast(&impl_->block_conds[bid].cond);
-    } else {
-        pthread_cond_wait(&impl_->block_conds[bid].cond,
-                          &impl_->block_conds[bid].mutex);
-    }
-    pthread_mutex_unlock(&impl_->block_conds[bid].mutex);
-}
-
-void hardware_context::lock_all() { pthread_mutex_lock(&impl_->global_mutex); }
-
-void hardware_context::unlock_all() {
-    pthread_mutex_unlock(&impl_->global_mutex);
-}
-
-int hardware_context::mark_all_visit(int bid, int tid) {
-    impl_->global_visited[bid][tid] = true;
-    int visited = 0;
-    for (size_t i = 0; i < BLOCKS; i++) {
-        for (size_t j = 0; j < CORES; j++) {
-            visited += impl_->global_visited[i][j] == true ? 1 : 0;
-        }
-    }
-    return visited;
-}
-
-void hardware_context::wait_all_sync(int visited,
-                                     std::function<void()> callable) {
-    pthread_mutex_lock(&impl_->global_cond.mutex);
-    if (visited == BLOCKS * CORES) {
-        callable();
-        impl_->reset_global_visited();
-        pthread_cond_broadcast(&impl_->global_cond.cond);
-    } else {
-        pthread_cond_wait(&impl_->global_cond.cond, &impl_->global_cond.mutex);
-    }
-    pthread_mutex_unlock(&impl_->global_cond.mutex);
-}
-
-// std::unique_ptr<hardware_context> global_hardware_ctx = nullptr;
-
-// void global_hardware_init() {
-//     global_hardware_ctx = std::make_unique<hardware_context>();
-// }
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/hardware_context.h b/modules/xpu/src/runtime/hardware_context.h
deleted file mode 100644
index 6cb45a2224..0000000000
--- a/modules/xpu/src/runtime/hardware_context.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <memory>
-#include <nncase/runtime/xpu/compiler_defs.h>
-
-struct hardware_context_impl;
-
-BEGIN_NS_NNCASE_RT_MODULE(xpu)
-namespace hardware_context {
-void init();
-
-void lock_block(int bid);
-int mark_block_visit(int bid, int tid);
-void unlock_block(int bid);
-void wait_block_sync(
-    int bid, int visited, std::function<void()> callable = []() -> void {});
-void lock_all();
-int mark_all_visit(int bid, int tid);
-void unlock_all();
-void wait_all_sync(
-    int visited, std::function<void()> callable = []() -> void {});
-
-extern std::unique_ptr<hardware_context_impl> impl_;
-} // namespace hardware_context
-END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/hardware_def.h b/modules/xpu/src/runtime/hardware_def.h
deleted file mode 100644
index 9dfdcd946a..0000000000
--- a/modules/xpu/src/runtime/hardware_def.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-#include <stddef.h>
-
-constexpr size_t BLOCKS = 8;
-constexpr size_t CORES = 4;
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/io_utils.h b/modules/xpu/src/runtime/io_utils.h
deleted file mode 100644
index 6e6ef7c6f5..0000000000
--- a/modules/xpu/src/runtime/io_utils.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-#include "gsl-lite.hpp"
-#include <filesystem>
-#include <fstream>
-#include <vector>
-
-inline std::vector<uint8_t> read_stream(std::istream &stream) {
-    stream.seekg(0, std::ios::end);
-    size_t length = stream.tellg();
-    stream.seekg(0, std::ios::beg);
-    std::vector<uint8_t> data(length);
-    stream.read(reinterpret_cast<char *>(data.data()), length);
-    return data;
-}
-
-inline std::vector<uint8_t> read_file(const std::filesystem::path &filename) {
-    std::ifstream infile(filename.string(), std::ios::binary | std::ios::in);
-    if (!infile.good())
-        throw std::runtime_error("Cannot open file: " + filename.string());
-    return read_stream(infile);
-}
-
-template <class T>
-inline void to_file(gsl::span<T> src, const std::filesystem::path &filename) {
-    std::ofstream ofile(filename.string(), std::ios::binary | std::ios::out);
-    ofile.write(src.template as_span<const char>().data(), src.size_bytes());
-    ofile.close();
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/method_table_def.h b/modules/xpu/src/runtime/method_table_def.h
deleted file mode 100644
index a388011dd4..0000000000
--- a/modules/xpu/src/runtime/method_table_def.h
+++ /dev/null
@@ -1,105 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <nncase/runtime/xpu/compiler_defs.h>
-
-BEGIN_NS_NNCASE_RT_MODULE(xpu)
-
-typedef struct nncase_method_table {
-    // float unary
-    float (*float_unary_abs)(float);
-    float (*float_unary_acos)(float);
-    float (*float_unary_acosh)(float);
-    float (*float_unary_asin)(float);
-    float (*float_unary_asinh)(float);
-    float (*float_unary_ceil)(float);
-    float (*float_unary_cos)(float);
-    float (*float_unary_cosh)(float);
-    float (*float_unary_exp)(float);
-    float (*float_unary_floor)(float);
-    float (*float_unary_log)(float);
-    float (*float_unary_logical_not)(float);
-    float (*float_unary_neg)(float);
-    float (*float_unary_round)(float);
-    float (*float_unary_rsqrt)(float);
-    float (*float_unary_sign)(float);
-    float (*float_unary_sin)(float);
-    float (*float_unary_sinh)(float);
-    float (*float_unary_sqrt)(float);
-    float (*float_unary_square)(float);
-    float (*float_unary_tanh)(float);
-    float (*float_unary_erf)(float);
-    // float bianry
-    float (*float_binary_add)(float, float);
-    float (*float_binary_sub)(float, float);
-    float (*float_binary_mul)(float, float);
-    float (*float_binary_div)(float, float);
-    float (*float_binary_min)(float, float);
-    float (*float_binary_max)(float, float);
-    float (*float_binary_pow)(float, float);
-    float (*float_binary_logical_and)(float, float);
-    float (*float_binary_mod)(float, float);
-    // int32 bianry
-    int32_t (*int32_binary_add)(int32_t, int32_t);
-    int32_t (*int32_binary_sub)(int32_t, int32_t);
-    int32_t (*int32_binary_mul)(int32_t, int32_t);
-    int32_t (*int32_binary_div)(int32_t, int32_t);
-    int32_t (*int32_binary_min)(int32_t, int32_t);
-    int32_t (*int32_binary_max)(int32_t, int32_t);
-    int32_t (*int32_binary_pow)(int32_t, int32_t);
-    int32_t (*int32_binary_logical_and)(int32_t, int32_t);
-    int32_t (*int32_binary_mod)(int32_t, int32_t);
-    // int64 bianry
-    int64_t (*int64_binary_add)(int64_t, int64_t);
-    int64_t (*int64_binary_sub)(int64_t, int64_t);
-    int64_t (*int64_binary_mul)(int64_t, int64_t);
-    int64_t (*int64_binary_div)(int64_t, int64_t);
-    int64_t (*int64_binary_min)(int64_t, int64_t);
-    int64_t (*int64_binary_max)(int64_t, int64_t);
-    int64_t (*int64_binary_pow)(int64_t, int64_t);
-    int64_t (*int64_binary_logical_and)(int64_t, int64_t);
-    int64_t (*int64_binary_mod)(int64_t, int64_t);
-    // bool binary
-    bool (*bool_binary_and)(bool, bool);
-    bool (*bool_binary_or)(bool, bool);
-    bool (*bool_binary_xor)(bool, bool);
-
-    // multi-thread
-    void *(*thread_start)(void *(*callable)(void *), void *user,
-                          size_t user_size);
-    void *(*thread_end)();
-} nncase_mt_t;
-
-typedef struct buffer {
-    void *vaddr;
-    size_t paddr;
-    uint32_t *shape;
-    uint32_t *stride;
-    uint32_t rank;
-} buffer_t;
-
-struct runtime_util_mt {
-    int (*printf)(const char *__restrict __format, ...);
-    void *(*malloc)(size_t size);
-    void (*free)(void *ptr);
-    void (*create_thread)(pthread_t &pt, void *param_, void *(*call)(void *));
-    void (*join_thread)(pthread_t &pt);
-    void (*rt_assert)(bool condition, char *message);
-    void *(*memcpy)(void *dest, const void *src, size_t n);
-    void *(*memset)(void *ptr, int value, size_t num);
-};
-
-struct hardware_context_mt {
-    void (*lock_block)(int bid);
-    int (*mark_block_visit)(int bid, int tid);
-    void (*unlock_block)(int bid);
-    void (*wait_block_sync)(int bid, int visited,
-                            std::function<void()> callable);
-    void (*lock_all)();
-    int (*mark_all_visit)(int bid, int tid);
-    void (*unlock_all)();
-    void (*wait_all_sync)(int visited, std::function<void()> callable);
-    void (*init)();
-};
-
-END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/method_table_impl.h b/modules/xpu/src/runtime/method_table_impl.h
deleted file mode 100644
index fd4668ac4d..0000000000
--- a/modules/xpu/src/runtime/method_table_impl.h
+++ /dev/null
@@ -1,137 +0,0 @@
-#pragma once
-#include "hardware_context.h"
-#include "method_table_def.h"
-#include "runtime_utils.h"
-#include "thread_pool.h"
-#include <functional>
-#include <math.h>
-#include <nncase/runtime/xpu/compiler_defs.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-BEGIN_NS_NNCASE_RT_MODULE(xpu)
-
-inline float float_unary_logical_not(float x) { return !x; }
-inline float float_unary_neg(float x) { return std::negate<float>()(x); }
-inline float float_unary_rsqrt(float x) { return 1.f / sqrtf(x); }
-inline float float_unary_sign(float x) { return (0.f < x) - (x < 0.f); }
-inline float float_unary_square(float x) { return x * x; }
-
-inline float float_binary_add(float x, float y) { return x + y; }
-inline float float_binary_sub(float x, float y) { return x - y; }
-inline float float_binary_mul(float x, float y) { return x * y; }
-inline float float_binary_div(float x, float y) { return x / y; }
-inline float float_binary_min(float x, float y) { return std::min(x, y); }
-inline float float_binary_max(float x, float y) { return std::max(x, y); }
-inline float float_binary_pow(float x, float y) { return powf(x, y); }
-inline float float_binary_logical_and(float x, float y) { return x && y; }
-inline float float_binary_mod(float x, float y) { return fmod(x, y); }
-
-inline int32_t int32_binary_add(int32_t x, int32_t y) { return x + y; }
-inline int32_t int32_binary_sub(int32_t x, int32_t y) { return x - y; }
-inline int32_t int32_binary_mul(int32_t x, int32_t y) { return x * y; }
-inline int32_t int32_binary_div(int32_t x, int32_t y) { return x / y; }
-inline int32_t int32_binary_min(int32_t x, int32_t y) { return std::min(x, y); }
-inline int32_t int32_binary_max(int32_t x, int32_t y) { return std::max(x, y); }
-#if defined(__APPLE__)
-inline int32_t int32_binary_pow(int32_t x, int32_t y) {
-    return (int32_t)pow(x, y);
-}
-#else
-inline int32_t int32_binary_pow(int32_t x, int32_t y) { return std::pow(x, y); }
-#endif
-inline int32_t int32_binary_logical_and(int32_t x, int32_t y) { return x && y; }
-inline int32_t int32_binary_mod(int32_t x, int32_t y) { return x % y; }
-
-inline int64_t int64_binary_add(int64_t x, int64_t y) { return x + y; }
-inline int64_t int64_binary_sub(int64_t x, int64_t y) { return x - y; }
-inline int64_t int64_binary_mul(int64_t x, int64_t y) { return x * y; }
-inline int64_t int64_binary_div(int64_t x, int64_t y) { return x / y; }
-inline int64_t int64_binary_min(int64_t x, int64_t y) { return std::min(x, y); }
-inline int64_t int64_binary_max(int64_t x, int64_t y) { return std::max(x, y); }
-#if defined(__APPLE__)
-inline int64_t int64_binary_pow(int64_t x, int64_t y) {
-    return (int64_t)pow(x, y);
-}
-#else
-inline int64_t int64_binary_pow(int64_t x, int64_t y) { return std::pow(x, y); }
-#endif
-inline int64_t int64_binary_logical_and(int64_t x, int64_t y) { return x && y; }
-inline int64_t int64_binary_mod(int64_t x, int64_t y) { return x % y; }
-
-inline bool bool_binary_logical_and(bool x, bool y) { return x && y; }
-inline bool bool_binary_logical_or(bool x, bool y) { return x || y; }
-inline bool bool_binary_logical_xor(bool x, bool y) { return x ^ y; }
-
-[[maybe_unused]] static nncase_mt_t nncase_mt = {
-    fabsf,
-    acosf,
-    acoshf,
-    asinf,
-    asinhf,
-    ceilf,
-    cosf,
-    coshf,
-    expf,
-    floorf,
-    logf,
-    float_unary_logical_not,
-    float_unary_neg,
-    roundf,
-    float_unary_rsqrt,
-    float_unary_sign,
-    sinf,
-    sinhf,
-    sqrtf,
-    float_unary_square,
-    tanhf,
-    erff,
-    float_binary_add,
-    float_binary_sub,
-    float_binary_mul,
-    float_binary_div,
-    float_binary_min,
-    float_binary_max,
-    float_binary_pow,
-    float_binary_logical_and,
-    float_binary_mod,
-    int32_binary_add,
-    int32_binary_sub,
-    int32_binary_mul,
-    int32_binary_div,
-    int32_binary_min,
-    int32_binary_max,
-    int32_binary_pow,
-    int32_binary_logical_and,
-    int32_binary_mod,
-    int64_binary_add,
-    int64_binary_sub,
-    int64_binary_mul,
-    int64_binary_div,
-    int64_binary_min,
-    int64_binary_max,
-    int64_binary_pow,
-    int64_binary_logical_and,
-    int64_binary_mod,
-    bool_binary_logical_and,
-    bool_binary_logical_or,
-    bool_binary_logical_xor,
-    thread_pool::thread_start,
-    thread_pool::thread_end,
-};
-
-inline void *rt_malloc(size_t size) { return (void *)new uint8_t[size](); }
-
-[[maybe_unused]] static runtime_util_mt runtime_util = {
-    printf,      rt_malloc, free,   create_thread,
-    join_thread, rt_assert, memcpy, memset};
-
-[[maybe_unused]] static hardware_context_mt hw_ctx_mt = {
-    hardware_context::lock_block,   hardware_context::mark_block_visit,
-    hardware_context::unlock_block, hardware_context::wait_block_sync,
-    hardware_context::lock_all,     hardware_context::mark_all_visit,
-    hardware_context::unlock_all,   hardware_context::wait_all_sync,
-    hardware_context::init};
-
-END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/runtime_function.cpp b/modules/xpu/src/runtime/runtime_function.cpp
deleted file mode 100644
index c35cf2b3aa..0000000000
--- a/modules/xpu/src/runtime/runtime_function.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "runtime_function.h"
-#include "elfloader.h"
-#include <nncase/runtime/dbg.h>
-#include <nncase/runtime/runtime_loader.h>
-#include <nncase/runtime/runtime_op_utility.h>
-#include <nncase/runtime/util.h>
-
-using namespace nncase;
-using namespace nncase::runtime;
-using namespace nncase::runtime::xpu;
-
-namespace {
-typedef struct memory_range {
-    uint32_t start;
-    uint32_t size;
-} memory_range_t;
-
-typedef struct desc_header {
-    uint32_t input_pool_size;
-
-    uint32_t output_pool_size;
-
-    uint32_t inputs;
-
-    uint32_t outputs;
-} desc_header_t;
-
-} // namespace
-
-xpu_runtime_module &xpu_runtime_function::module() const noexcept {
-    return static_cast<xpu_runtime_module &>(runtime_function::module());
-}
-
-result<void> xpu_runtime_function::initialize_core(
-    NNCASE_UNUSED runtime_function_init_context &context) noexcept {
-    text_ = module().text_physical().subspan(context.header().entrypoint,
-                                             context.header().text_size);
-    rdata_ = module().rdata_physical();
-    // try_(context.read_section(".desc", [this](auto sr, size_t) ->
-    // result<void> {
-    //     auto header = sr.template read<desc_header>();
-    //     if (parameters_size() != header.inputs + header.outputs)
-    //         return nncase::err(std::errc::invalid_argument);
-
-    //     for (uint32_t i = 0; i < header.inputs; i++) {
-    //         sr.template read<memory_range>();
-    //         auto rank = sr.template read<uint32_t>();
-    //         std::vector<uint32_t> shape(rank);
-    //         std::cout << "shape: ";
-    //         for (uint32_t j = 0; j < rank; j++) {
-    //             shape[j] = sr.template read<uint32_t>();
-    //             std::cout << shape[j] << ", ";
-    //         }
-    //         std::cout << std::endl;
-
-    //         std::vector<uint32_t> stride(rank);
-    //         std::cout << "stride: ";
-    //         for (uint32_t j = 0; j < rank; j++) {
-    //             stride[j] = sr.template read<uint32_t>();
-    //             std::cout << stride[j] << ", ";
-    //         }
-    //         std::cout << std::endl;
-
-    //         input_ranks_.emplace_back(rank);
-    //         input_shapes_.emplace_back(shape);
-    //         input_strides_.emplace_back(stride);
-    //     }
-
-    //     for (uint32_t i = 0; i < header.outputs; i++) {
-    //         sr.template read<memory_range>();
-    //         auto rank = sr.template read<uint32_t>();
-    //         std::vector<uint32_t> shape(rank);
-    //         std::cout << "shape: ";
-    //         for (uint32_t j = 0; j < rank; j++) {
-    //             shape[j] = sr.template read<uint32_t>();
-    //             std::cout << shape[j] << ", ";
-    //         }
-    //         std::cout << std::endl;
-
-    //         std::vector<uint32_t> stride(rank);
-    //         std::cout << "stride: ";
-    //         for (uint32_t j = 0; j < rank; j++) {
-    //             stride[j] = sr.template read<uint32_t>();
-    //             std::cout << stride[j] << ", ";
-    //         }
-    //         std::cout << std::endl;
-
-    //         output_ranks_.emplace_back(rank);
-    //         output_shapes_.emplace_back(shape);
-    //         output_strides_.emplace_back(stride);
-    //     }
-
-    //     return ok();
-    // }));
-
-    return ok();
-}
-
-result<value_t>
-xpu_runtime_function::invoke_core(NNCASE_UNUSED gsl::span<value_t> parameters,
-                                  NNCASE_UNUSED value_t return_value) noexcept {
-    // try_var(id, module().find_id_by_function(this));
-
-    uint8_t **buffers = new uint8_t *[parameters.size()];
-    // input buffer
-    for (size_t i = 0; i < parameters.size(); i++) {
-        try_var(input_tensor, parameters[i].as<tensor>());
-        try_var(input_span, get_input_span(input_tensor));
-        buffers[i] = (uint8_t *)(input_span.data());
-    }
-
-    auto elfloader_ = elfloader{(char *)text_.data()};
-    elfloader_.invoke_elf(&hw_ctx_mt, &runtime_util, &nncase_mt, buffers,
-                          (uint8_t *)rdata_.data());
-
-    delete[] buffers;
-
-    return ok<value_t>(tuple(std::in_place));
-}
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/runtime_function.h b/modules/xpu/src/runtime/runtime_function.h
deleted file mode 100644
index b92b0ed295..0000000000
--- a/modules/xpu/src/runtime/runtime_function.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include "runtime_module.h"
-#include <nncase/kernels/kernel_context.h>
-#include <nncase/runtime/runtime_function.h>
-
-BEGIN_NS_NNCASE_RT_MODULE(xpu)
-
-class xpu_runtime_function : public runtime_function {
-  public:
-    using runtime_function::runtime_function;
-
-    xpu_runtime_module &module() const noexcept;
-
-  protected:
-    result<void>
-    initialize_core(runtime_function_init_context &context) noexcept override;
-    result<value_t> invoke_core(gsl::span<value_t> parameters,
-                                value_t return_value) noexcept override;
-
-  private:
-    gsl::span<const gsl::byte> text_;
-    gsl::span<const gsl::byte> rdata_;
-    // std::vector<uint32_t> input_ranks_;
-    // std::vector<std::vector<uint32_t>> input_shapes_;
-    // std::vector<std::vector<uint32_t>> input_strides_;
-    // std::vector<uint32_t> output_ranks_;
-    // std::vector<std::vector<uint32_t>> output_shapes_;
-    // std::vector<std::vector<uint32_t>> output_strides_;
-};
-
-END_NS_NNCASE_RT_MODULE
diff --git a/modules/xpu/src/runtime/runtime_module.cpp b/modules/xpu/src/runtime/runtime_module.cpp
deleted file mode 100644
index 0d9a44c653..0000000000
--- a/modules/xpu/src/runtime/runtime_module.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "runtime_module.h"
-#include "runtime_function.h"
-#include <nncase/runtime/dbg.h>
-#include <nncase/runtime/runtime_loader.h>
-#include <nncase/runtime/runtime_op_utility.h>
-
-using namespace nncase;
-using namespace nncase::runtime;
-using namespace nncase::runtime::xpu;
-
-result<void> xpu_runtime_module::initialize_before_functions(
-    runtime_module_init_context &context) noexcept {
-    // if (!context.is_section_pinned())
-    //     return nncase::err(std::errc::bad_address);
-    // try_var(data, context.get_or_read_section(".data", data_storage_,
-    // false));
-    try_set(rdata_,
-            context.get_or_read_section(".rdata", rdata_storage_, true));
-    try_set(text_, context.get_or_read_section(".text", text_storage_, true));
-
-    return ok();
-}
-
-result<std::unique_ptr<runtime_function>>
-xpu_runtime_module::create_function() noexcept {
-    std::unique_ptr<runtime_function> mod(new (std::nothrow)
-                                              xpu_runtime_function(*this));
-    if (mod)
-        return ok(std::move(mod));
-    return err(std::errc::not_enough_memory);
-}
-
-result<std::unique_ptr<runtime_module>> xpu::create_xpu_runtime_module() {
-    std::unique_ptr<runtime_module> mod(new (std::nothrow)
-                                            xpu_runtime_module());
-    if (mod)
-        return ok(std::move(mod));
-    return err(std::errc::not_enough_memory);
-}
-
-extern "C" {
-NNCASE_MODULES_XPU_API void
-RUNTIME_MODULE_ACTIVATOR_NAME(result<std::unique_ptr<runtime_module>> &result) {
-    result = create_xpu_runtime_module();
-}
-}
-
-#ifndef NNCASE_SIMULATOR
-runtime_registration nncase::runtime::builtin_runtimes[] = {
-    {xpu_module_type, RUNTIME_MODULE_ACTIVATOR_NAME}, {}};
-#endif
diff --git a/modules/xpu/src/runtime/runtime_module.h b/modules/xpu/src/runtime/runtime_module.h
deleted file mode 100644
index 2c40734520..0000000000
--- a/modules/xpu/src/runtime/runtime_module.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/* Copyright 2019-2021 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include <nncase/runtime/xpu/runtime_module.h>
-
-BEGIN_NS_NNCASE_RT_MODULE(xpu)
-
-class xpu_runtime_module : public runtime_module {
-  public:
-    gsl::span<const gsl::byte> rdata_physical() noexcept { return rdata_; }
-    gsl::span<gsl::byte> data_physical() noexcept { return data_; }
-    gsl::span<const gsl::byte> text_physical() noexcept { return text_; }
-
-  protected:
-    result<void> initialize_before_functions(
-        runtime_module_init_context &context) noexcept override;
-    result<std::unique_ptr<runtime_function>>
-    create_function() noexcept override;
-
-  private:
-    gsl::span<gsl::byte> data_;
-    gsl::span<const gsl::byte> text_;
-    gsl::span<const gsl::byte> rdata_;
-    host_buffer_t text_storage_;
-    host_buffer_t rdata_storage_;
-    host_buffer_t data_storage_;
-};
-
-END_NS_NNCASE_RT_MODULE
diff --git a/modules/xpu/src/runtime/runtime_utils.h b/modules/xpu/src/runtime/runtime_utils.h
deleted file mode 100644
index 4aaf10edb4..0000000000
--- a/modules/xpu/src/runtime/runtime_utils.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include "gsl-lite.hpp"
-#include <array>
-#include <cassert>
-#include <cmath>
-#include <cstddef>
-#include <iostream>
-#if defined(__linux__)
-#include <linux/limits.h>
-#elif defined(__APPLE__)
-#include <pthread.h>
-#endif
-#include <nncase/runtime/xpu/compiler_defs.h>
-#include <numeric>
-#include <vector>
-
-BEGIN_NS_NNCASE_RT_MODULE(xpu)
-inline void create_thread(pthread_t &pt, void *param_, void *(*call)(void *)) {
-    void *(*new_call)(void *) = call; // + (intptr_t)buf;
-    int ret = pthread_create(&pt, NULL, new_call, param_);
-    if (ret != 0) {
-        printf("thread create failed\n");
-    }
-}
-
-inline void join_thread(pthread_t &pt) { pthread_join(pt, NULL); }
-
-inline void rt_assert([[maybe_unused]] bool condition,
-                      [[maybe_unused]] char *message) {
-    if (!condition)
-        printf("%s\n", message);
-    assert(condition && message);
-}
-END_NS_NNCASE_RT_MODULE
\ No newline at end of file
diff --git a/modules/xpu/src/runtime/shared_memory.cpp b/modules/xpu/src/runtime/shared_memory.cpp
deleted file mode 100644
index 437e4c8e2d..0000000000
--- a/modules/xpu/src/runtime/shared_memory.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/* Copyright 2020 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "shared_memory.h"
-#include <iostream>
-
-#ifdef WIN32
-#include <Windows.h>
-#else
-#include <cerrno>
-#include <cstring>
-#include <fcntl.h>    // for O_* constants
-#include <sys/mman.h> // mmap, munmap
-#include <sys/stat.h> // for mode constants
-#include <unistd.h>   // unlink
-#endif
-
-using namespace nncase;
-using namespace nncase::runtime;
-using namespace nncase::runtime::xpu;
-
-shared_memory::shared_memory(const std::filesystem::path &path, size_t size,
-                             shared_memory_openmode mode)
-    :
-#ifdef WIN32
-      handle_(nullptr)
-#else
-      fd_(-1),
-      path_(path.c_str())
-#endif
-      ,
-      data_(nullptr),
-      size_(size) {
-    if (mode == shared_memory_openmode::create) {
-#ifdef WIN32
-        handle_ = CreateFileMappingW(nullptr, nullptr, PAGE_READWRITE, 0,
-                                     (DWORD)size, path.c_str());
-        if (!handle_)
-            throw std::runtime_error("Failed to create shared memory.");
-#else
-        // shm segments persist across runs, and macOS will refuse
-        // to ftruncate an existing shm segment, so to be on the safe
-        // side, we unlink it beforehand.
-        // TODO(amos) check errno while ignoring ENOENT?
-        int ret = shm_unlink(path.c_str());
-        if (ret < 0) {
-            if (errno != ENOENT)
-                throw std::runtime_error(
-                    "Failed to unlink shared memory when create : " +
-                    std::string(std::strerror(errno)));
-        }
-
-        fd_ = shm_open(path.c_str(), O_CREAT | O_RDWR, 0755);
-        if (fd_ < 0)
-            throw std::runtime_error(
-                "Failed to open shared memory when create : " +
-                std::string(std::strerror(errno)));
-
-        // this is the only way to specify the size of a
-        // newly-created POSIX shared memory object
-        ret = ftruncate(fd_, size);
-        if (ret != 0)
-            throw std::runtime_error(
-                "Failed to ftruncate shared memory when create : " +
-                std::string(std::strerror(errno)) + " " +
-                std::to_string(size_) + " " + std::to_string(fd_));
-#endif
-    } else if (mode == shared_memory_openmode::open) {
-#ifdef WIN32
-        handle_ = OpenFileMappingW(FILE_MAP_READ | FILE_MAP_WRITE, FALSE,
-                                   path.c_str());
-        if (!handle_)
-            throw std::runtime_error("Failed to open shared memory.");
-#else
-        fd_ = shm_open(path.c_str(), O_RDWR, 0755);
-        if (fd_ < 0)
-            throw std::runtime_error("Failed to open shared memory.");
-#endif
-    } else {
-        throw std::runtime_error("Invalid shared memory openmode.");
-    }
-
-#ifdef WIN32
-    data_ = (gsl::byte *)MapViewOfFile(handle_, FILE_MAP_READ | FILE_MAP_WRITE,
-                                       0, 0, size);
-#else
-    auto memory = mmap(nullptr,                // addr
-                       size,                   // length
-                       PROT_READ | PROT_WRITE, // prot
-                       MAP_SHARED,             // flags
-                       fd_,                    // fd
-                       0                       // offset
-    );
-
-    if (memory == MAP_FAILED)
-        throw std::runtime_error("Failed to map shared memory.");
-    data_ = (gsl::byte *)memory;
-#endif
-}
-
-shared_memory ::~shared_memory() {
-    if (data_) {
-#ifdef WIN32
-        UnmapViewOfFile(data_);
-#else
-        munmap(data_, size_);
-#endif
-    }
-
-#ifdef WIN32
-    CloseHandle(handle_);
-    handle_ = nullptr;
-#else
-    close(fd_);
-    shm_unlink(path_.c_str());
-#endif
-}
diff --git a/modules/xpu/src/runtime/shared_memory.h b/modules/xpu/src/runtime/shared_memory.h
deleted file mode 100644
index 029d7bb4ba..0000000000
--- a/modules/xpu/src/runtime/shared_memory.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/* Copyright 2020 Canaan Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-#include "gsl-lite.hpp"
-#include <filesystem>
-#include <nncase/runtime/xpu/compiler_defs.h>
-
-#ifdef WIN32
-#include <Windows.h>
-#endif
-
-BEGIN_NS_NNCASE_RT_MODULE(xpu)
-
-enum class shared_memory_openmode { create, open };
-
-class shared_memory {
-  public:
-    shared_memory(const std::filesystem::path &path, size_t size,
-                  shared_memory_openmode mode);
-    ~shared_memory();
-
-    gsl::byte *data() noexcept { return data_; };
-    size_t size() const noexcept { return size_; }
-
-  private:
-#ifdef WIN32
-    HANDLE handle_;
-#else
-    int fd_;
-    std::string path_;
-#endif
-    gsl::byte *data_;
-    size_t size_;
-};
-
-END_NS_NNCASE_RT_MODULE
diff --git a/modules/xpu/src/runtime/thread_pool.cpp b/modules/xpu/src/runtime/thread_pool.cpp
deleted file mode 100644
index 6efaa5f2fb..0000000000
--- a/modules/xpu/src/runtime/thread_pool.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "thread_pool.h"
-#include <stdexcept>
-
-using namespace nncase::runtime::xpu::thread_pool;
-
-int threads_size =
-    atoi(getenv("NNCASE_MAX_THREADS") ? getenv("NNCASE_MAX_THREADS") : "0");
-int threads_count;
-std::vector<pthread_t> threads;
-std::vector<void *> users;
-uintptr_t nncase::runtime::xpu::thread_pool::paddr_offset;
-
-void *nncase::runtime::xpu::thread_pool::thread_start(thread_func callable,
-                                                      void *user,
-                                                      size_t user_size) {
-    auto user_ = malloc(user_size);
-    std::memcpy(user_, user, user_size);
-    thread_func new_call = thread_func((char *)callable + paddr_offset);
-    if (threads_size == 0) {
-        new_call(user_);
-    } else {
-        auto idx = threads_count % threads_size;
-        if (threads_count >= threads_size) {
-            pthread_join(threads[idx], NULL);
-            free(users[idx]);
-        }
-        pthread_t pt;
-        auto ret = pthread_create(&pt, NULL, new_call, user_);
-        if (ret != 0) {
-            throw std::runtime_error("thread creation failed\n");
-        }
-
-        if (threads_count == 0) {
-            threads.resize(threads_size);
-            users.resize(threads_size);
-        }
-        threads[idx] = pt;
-        users[idx] = user_;
-        threads_count++;
-    }
-    return nullptr;
-}
-
-void *nncase::runtime::xpu::thread_pool::thread_end() {
-    if (threads_size) {
-        for (int i = 0; i < std::min(threads_size, threads_count); i++) {
-            // if (threads[i].joinable()) {
-            pthread_join(threads[i], NULL);
-            free(users[i]);
-            // }
-        }
-        threads_count = 0;
-        threads.clear();
-        users.clear();
-    }
-    return nullptr;
-}
diff --git a/modules/xpu/src/runtime/thread_pool.h b/modules/xpu/src/runtime/thread_pool.h
deleted file mode 100644
index 45d427dadf..0000000000
--- a/modules/xpu/src/runtime/thread_pool.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef THREAD_POOL_
-#define THREAD_POOL_
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <nncase/runtime/xpu/compiler_defs.h>
-#include <pthread.h>
-#include <utility>
-#include <vector>
-
-BEGIN_NS_NNCASE_RT_MODULE(xpu)
-namespace thread_pool {
-
-using thread_func = void *(*)(void *);
-
-// static int threads_size = atoi(getenv("NNCASE_MAX_THREADS") ?
-// getenv("NNCASE_MAX_THREADS") : "0"); static int threads_count; static
-// std::vector<pthread_t> threads; static std::vector<void *> users;
-extern uintptr_t paddr_offset;
-
-void *thread_start(thread_func callable, void *user, size_t user_size);
-void *thread_end();
-
-} // namespace thread_pool
-END_NS_NNCASE_RT_MODULE
-
-#endif
diff --git a/nncase.sln b/nncase.sln
index 4a984a4408..065feb6959 100644
--- a/nncase.sln
+++ b/nncase.sln
@@ -77,8 +77,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nncase.Tests.TestFixture",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nncase.Passes", "src\Nncase.Passes\Nncase.Passes.csproj", "{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nncase.Modules.XPU", "modules\Nncase.Modules.XPU\Nncase.Modules.XPU.csproj", "{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -173,10 +171,6 @@ Global
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42}.Release|Any CPU.Build.0 = Release|Any CPU
-		{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -207,7 +201,6 @@ Global
 		{E365B1B1-4D13-4839-9763-A7A7C5F32FD4} = {BCA74168-F015-4B5B-B4CD-C83AE06B9822}
 		{98A03405-CA53-4EC4-9B18-94D1C8DF9453} = {E5A4516C-4080-4346-991D-57A7AA76ADA6}
 		{E6462E82-B48F-4AFA-AE34-725EF0A9CB42} = {BCA74168-F015-4B5B-B4CD-C83AE06B9822}
-		{6DD1FE1E-5765-4BED-90DD-3F4EF888CF45} = {9859F5E8-5504-4AFE-B955-9497A0A0CD66}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {9492E141-292E-4D60-9C6E-3738AB234DB2}
diff --git a/src/Nncase.Cli/packages.lock.json b/src/Nncase.Cli/packages.lock.json
index 7b53b77dd2..e44016380c 100644
--- a/src/Nncase.Cli/packages.lock.json
+++ b/src/Nncase.Cli/packages.lock.json
@@ -681,7 +681,6 @@
           "Nncase.Graph": "[1.0.0, )",
           "Nncase.Importer": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
-          "Nncase.Modules.XPU": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )",
           "Nncase.Quantization": "[1.0.0, )",
           "Nncase.Simulator": "[1.0.0, )"
@@ -750,15 +749,6 @@
           "Nncase.Passes": "[1.0.0, )"
         }
       },
-      "nncase.modules.xpu": {
-        "type": "Project",
-        "dependencies": {
-          "Nncase.CodeGen": "[1.0.0, )",
-          "Nncase.Diagnostics": "[1.0.0, )",
-          "Nncase.Modules.StackVM": "[1.0.0, )",
-          "Nncase.Passes": "[1.0.0, )"
-        }
-      },
       "nncase.passes": {
         "type": "Project",
         "dependencies": {
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 4dbf6274d6..2117ec68c5 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -187,27 +187,6 @@ public void TargetIndependentPass(IPassManager passManager)
             p.Add<Passes.Rules.Neutral.SpaceToBatchToPad>();
         });
 
-        passManager.AddWithName<DataflowPass>("MHAFusion").Configure(p =>
-        {
-            p.Add<Passes.Rules.CombineMHA>();
-            p.Add<Passes.Rules.Neutral.FoldConstCall>();
-
-            // p.Add<Passes.Rules.DumpMM>();
-            // p.Add<Passes.Rules.DumpLayerNorm>();
-            // p.Add<Passes.Rules.DumpGather>();
-            p.Add<Passes.Rules.FuseMHA1>();
-            p.Add<Passes.Rules.FuseMHA2>();
-            p.Add<Passes.Rules.FuseMHA3>();
-            p.Add<Passes.Rules.FuseUnetSpatialTransformer>();
-            p.Add<Passes.Rules.FuseUnetResBlock>();
-            p.Add<Passes.Rules.FuseUnetTimeEmb>();
-            p.Add<Passes.Rules.FuseVAEDecRes>();
-            p.Add<Passes.Rules.FuseVAEDecHead>();
-            p.Add<Passes.Rules.FuseVAEDecMHA>();
-            p.Add<Passes.Rules.FuseSDTextEncoderTail>();
-            p.Add<Passes.Rules.FuseSDTextEncoderHeader>();
-        });
-
         _compileSession.Target.RegisterTargetInDependentPass(passManager, _compileSession.CompileOptions);
 
         passManager.AddWithName<DataflowPass>("BroadcastMarker").Configure(p =>
diff --git a/src/Nncase.Compiler/Hosting/CompilerHostBuilderExtensions.cs b/src/Nncase.Compiler/Hosting/CompilerHostBuilderExtensions.cs
index 70f110f2e5..5fa0e4ba0f 100644
--- a/src/Nncase.Compiler/Hosting/CompilerHostBuilderExtensions.cs
+++ b/src/Nncase.Compiler/Hosting/CompilerHostBuilderExtensions.cs
@@ -53,8 +53,7 @@ private static void ConfigureBuiltinModules(Container builder)
                 .AddEGraph()
                 .AddCodeGen()
                 .AddPasses()
-                .AddStackVM()
-                .AddCPU();
+                .AddStackVM();
     }
 
     private static void ConfigureServices(HostBuilderContext context, IServiceCollection services)
diff --git a/src/Nncase.Compiler/Nncase.Compiler.csproj b/src/Nncase.Compiler/Nncase.Compiler.csproj
index 3be85fb5fa..8d02d21ec4 100644
--- a/src/Nncase.Compiler/Nncase.Compiler.csproj
+++ b/src/Nncase.Compiler/Nncase.Compiler.csproj
@@ -14,7 +14,6 @@
     </ItemGroup>
 
     <ItemGroup>
-        <ProjectReference Include="..\..\modules\Nncase.Modules.XPU\Nncase.Modules.XPU.csproj" />
         <ProjectReference Include="..\Nncase.CodeGen\Nncase.CodeGen.csproj" />
         <ProjectReference Include="..\Nncase.Core\Nncase.Core.csproj" />
         <ProjectReference Include="..\Nncase.Diagnostics\Nncase.Diagnostics.csproj" />
diff --git a/src/Nncase.Core/DistributedType.cs b/src/Nncase.Core/DistributedType.cs
index 6cbb61cb50..8fb293c9f1 100644
--- a/src/Nncase.Core/DistributedType.cs
+++ b/src/Nncase.Core/DistributedType.cs
@@ -49,19 +49,19 @@ private SBPBroadCast()
     public override string ToString() => "B";
 }
 
-public sealed record Placement(Placement.DeviceKind Kind, IRArray<int> Hierarchy, string Name)
+// public sealed record Placement(Placement.DeviceKind Kind, IRArray<int> Hierarchy, string Name)
+public sealed record Placement(IRArray<int> Hierarchy, string Name)
 {
-    /// <summary>
-    /// The device kind type.
-    /// </summary>
-    public enum DeviceKind : uint
-    {
-        CPU = 0,
-    }
+
+    // public enum DeviceKind : uint
+    // {
+    //     CPU = 0,
+    // }
 
     public int Rank => Hierarchy.Count;
 
-    public override string ToString() => $"@{Kind} [{string.Join(',', Hierarchy.Zip(Name).Select(t => t.First.ToString() + '@' + t.Second.ToString()))}]";
+    // public override string ToString() => $"@{Kind} [{string.Join(',', Hierarchy.Zip(Name).Select(t => t.First.ToString() + '@' + t.Second.ToString()))}]";
+    public override string ToString() => $"@ [{string.Join(',', Hierarchy.Zip(Name).Select(t => t.First.ToString() + '@' + t.Second.ToString()))}]";
 }
 
 public sealed record DistributedType(TensorType TensorType, IRArray<SBP> NdSBP, Placement Placement) : IRType
diff --git a/src/Nncase.Tests/Core/UnitTestExpression.cs b/src/Nncase.Tests/Core/UnitTestExpression.cs
index 6a9dc2b8b3..b6103de1fe 100644
--- a/src/Nncase.Tests/Core/UnitTestExpression.cs
+++ b/src/Nncase.Tests/Core/UnitTestExpression.cs
@@ -529,14 +529,14 @@ public void TestIf()
     [Fact]
     public void TestBoxingEqual()
     {
-        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
+        Placement placement = new(new int[] { 4, 2 }, "bt");
         var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
         var a = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
         var b = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
 
         var input = new Var(ttype);
-        var ea = IR.F.CPU.Boxing(input, a);
-        var eb = IR.F.CPU.Boxing(input, b);
+        var ea = IR.F.XPU.Boxing(input, a);
+        var eb = IR.F.XPU.Boxing(input, b);
 
         Assert.Equal(ea.Target, eb.Target);
         Assert.StrictEqual(ea.Target, eb.Target);
diff --git a/src/Nncase.Tests/Distributed/UnitTestConstruct.cs b/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
index d493375cf6..51ea176848 100644
--- a/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
@@ -20,7 +20,7 @@ public sealed class UnitTestConstruct : TestClassBase
     [Fact]
     public void TestCreate()
     {
-        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 2, 2 }, "bt");
+        Placement placement = new(new int[] { 2, 2 }, "bt");
         IRArray<SBP> sbps = new[] { SBP.S(2), SBP.S(1), };
         DistributedType t = new(new TensorType(DataTypes.Float32, new[] { 1, 2, 8 }), sbps, placement);
         var input = new Var("input", t);
@@ -58,7 +58,7 @@ public IReadOnlyList<CallableType> GetCandidateSignatures(Unary unary, TensorTyp
     [Fact]
     public void TestGetLeafCandidateNDSBPs()
     {
-        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
+        Placement placement = new(new int[] { 4, 2 }, "bt");
         var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
         var input = new Var(ttype);
         var set = new HashSet<DistributedType>(DistributedUtility.GetLeafCandidateNDSBPs(ttype, placement).Select(ndsbp => new DistributedType(ttype, ndsbp, placement)));
@@ -68,7 +68,7 @@ public void TestGetLeafCandidateNDSBPs()
     [Fact]
     public void TestDistributeTypeEqual()
     {
-        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
+        Placement placement = new(new int[] { 4, 2 }, "bt");
         var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
         var a = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
         var b = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
@@ -79,10 +79,10 @@ public void TestDistributeTypeEqual()
     [Fact]
     public void TestBoxingEqual()
     {
-        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
+        Placement placement = new(new int[] { 4, 2 }, "bt");
         var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
-        var a = new IR.CPU.Boxing(new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement));
-        var b = new IR.CPU.Boxing(new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement));
+        var a = new IR.XPU.Boxing(new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement));
+        var b = new IR.XPU.Boxing(new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement));
         Assert.Equal(a, b);
         Assert.StrictEqual(a, b);
     }
@@ -90,7 +90,7 @@ public void TestBoxingEqual()
     [Fact]
     public void TestUnary()
     {
-        Placement placement = new(Placement.DeviceKind.CPU, new int[] { 4, 2 }, "bt");
+        Placement placement = new(new int[] { 4, 2 }, "bt");
         var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
         var input = new Var(ttype);
         var output = IR.F.Math.Unary(UnaryOp.Neg, input);
diff --git a/src/Nncase.Tests/Distributed/UnitTestCost.cs b/src/Nncase.Tests/Distributed/UnitTestCost.cs
index 72710f55ad..89d9793032 100644
--- a/src/Nncase.Tests/Distributed/UnitTestCost.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestCost.cs
@@ -17,7 +17,7 @@ public sealed class UnitTestCost
     public void TestPartialToBroadCastCost()
     {
         var tensorType = new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 128 });
-        var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+        var placement = new Placement(new[] { 8, 4 }, "bt");
 
         List<CostModel.Cost> costs = new();
         foreach (var ndsbp in new IRArray<SBP>[] {
@@ -32,7 +32,7 @@ public void TestPartialToBroadCastCost()
         {
             var type = new DistributedType(tensorType, ndsbp, placement);
             var input0 = new Var(type);
-            var candidates = Utilities.DistributedUtility.GetPartialCandidateNDSBPs(type).Select(ndsbp => IR.F.CPU.Boxing(input0, type with { NdSBP = ndsbp }));
+            var candidates = Utilities.DistributedUtility.GetPartialCandidateNDSBPs(type).Select(ndsbp => IR.F.XPU.Boxing(input0, type with { NdSBP = ndsbp }));
             foreach (var item in candidates)
             {
                 var cost = CompilerServices.EvaluateCost(item);
diff --git a/src/Nncase.Tests/Distributed/UnitTestKernels.cs b/src/Nncase.Tests/Distributed/UnitTestKernels.cs
index efdfd13efa..a24eab0d9c 100644
--- a/src/Nncase.Tests/Distributed/UnitTestKernels.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestKernels.cs
@@ -110,13 +110,13 @@ internal sealed class BinaryCase1 : IDistributedKernelCase
     public BinaryCase1()
     {
         var type = new TensorType(DataTypes.Float32, new[] { 1, 16, 768 });
-        var place = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+        var place = new Placement(new[] { 8, 4 }, "bt");
         var lhs = new Var(type);
         var rhs = new Var(type);
         {
-            var l0 = IR.F.CPU.Boxing(lhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.S(2) }, place));
-            var r0 = IR.F.CPU.Boxing(rhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.S(2) }, place));
-            Fusion = new Fusion(Name + "_fusion", XPUTarget.Kind, IR.F.CPU.Boxing(l0 + r0, type), new[] { lhs, rhs });
+            var l0 = IR.F.XPU.Boxing(lhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.S(2) }, place));
+            var r0 = IR.F.XPU.Boxing(rhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.S(2) }, place));
+            Fusion = new Fusion(Name + "_fusion", XPUTarget.Kind, IR.F.XPU.Boxing(l0 + r0, type), new[] { lhs, rhs });
         }
 
         Vars = new[] { lhs, rhs };
@@ -155,11 +155,11 @@ public Fusion Fusion
         get
         {
             var type = new TensorType(DataTypes.Float32, new[] { 16, 1024, 1024 });
-            var place = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+            var place = new Placement(new[] { 8, 4 }, "bt");
             var axis = 2L;
             {
-                var input0 = IR.F.CPU.Boxing(Vars[0], new DistributedType(type, new SBP[] { SBP.S(0), SBP.S(1) }, place));
-                return new Fusion(Name + "_fusion", CPUTarget.Kind, IR.F.CPU.Boxing(IR.F.NN.Softmax(input0, axis), type), new[] { Vars[0] });
+                var input0 = IR.F.XPU.Boxing(Vars[0], new DistributedType(type, new SBP[] { SBP.S(0), SBP.S(1) }, place));
+                return new Fusion(Name + "_fusion", XPUTarget.Kind, IR.F.XPU.Boxing(IR.F.NN.Softmax(input0, axis), type), new[] { Vars[0] });
             }
         }
     }
diff --git a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
index 2ea8d31c86..d1715e58c2 100644
--- a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
@@ -17,39 +17,39 @@ public sealed class UnitTestTypeInfer : TestClassBase
 {
     public static TheoryData<UnaryOp, DistributedType, IRType> InferUnaryData => new() {
         { UnaryOp.Exp,
-          new(new(DataTypes.Float32, new[] { 48, 32 }), new[] { SBP.B, SBP.B }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 48, 32 }), new[] { SBP.B, SBP.B }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt"))
+          new(new(DataTypes.Float32, new[] { 48, 32 }), new[] { SBP.B, SBP.B }, new(new[] { 2, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 48, 32 }), new[] { SBP.B, SBP.B }, new(new[] { 2, 4 }, "bt"))
         },
         { UnaryOp.Exp,
-          new(new(DataTypes.Float32, new[] { 384, 128 }), new SBP[] { SBP.S(0), SBP.P }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
+          new(new(DataTypes.Float32, new[] { 384, 128 }), new SBP[] { SBP.S(0), SBP.P }, new(new[] { 2, 4 }, "bt")),
           new InvalidType(string.Empty)
         },
     };
 
     public static TheoryData<BinaryOp, DistributedType, DistributedType, IRType> InferBinaryData => new() {
         { BinaryOp.Add,
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.B, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.B, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
           new InvalidType(string.Empty)
         },
         { BinaryOp.Add,
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt"))
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt"))
         },
         { BinaryOp.Mul,
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 2, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
           new InvalidType(string.Empty)
         },
         { BinaryOp.Add,
-          new DistributedType(new(DataTypes.Float32, new[] { 3072 }), new SBP[] { SBP.S(0), SBP.S(0) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 77, 3072 }), new SBP[] { SBP.B, SBP.B }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 3072 }), new SBP[] { SBP.S(0), SBP.S(0) }, new(new[] { 8, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 1, 77, 3072 }), new SBP[] { SBP.B, SBP.B }, new(new[] { 8, 4 }, "bt")),
           new InvalidType(string.Empty)
         },
         { BinaryOp.Add,
-          new DistributedType(new(DataTypes.Float32, new[] { 16, 32, 32 }), new SBP[] { SBP.S(0), SBP.B }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 16, 32, 32 }), new SBP[] { SBP.B, SBP.S(0) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 16, 32, 32 }), new SBP[] { SBP.S(0), SBP.B }, new(new[] { 8, 4 }, "bt")),
+          new DistributedType(new(DataTypes.Float32, new[] { 16, 32, 32 }), new SBP[] { SBP.B, SBP.S(0) }, new(new[] { 8, 4 }, "bt")),
           new InvalidType(string.Empty)
         },
     };
@@ -107,7 +107,7 @@ public void TestInferMatmul(DistributedType lhsType, DistributedType rhsType, IR
     [Fact]
     public void TestInferMatmulProduct()
     {
-        var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+        var placement = new Placement(new[] { 8, 4 }, "bt");
         var lhsShape = new[] { 1, 64, 384, 8192 };
         var rhsShape = new[] { 1, 64, 8192, 384 };
         var lhsType = new TensorType(DataTypes.Float32, lhsShape);
@@ -148,7 +148,7 @@ public void TestInferGather()
     {
         var inputType = new TensorType(DataTypes.Float32, new[] { 384, 128 });
         var indexType = new TensorType(DataTypes.Int64, new[] { 1, 384 });
-        var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+        var placement = new Placement(new[] { 8, 4 }, "bt");
 
         var candiateArgs = new[] {
             DistributedUtility.GetLeafCandidateNDSBPs(inputType, placement).Select(ndsbp => new DistributedType(inputType, ndsbp, placement)),
@@ -186,7 +186,7 @@ internal sealed class InferMatmulData : TheoryData<DistributedType, DistributedT
 {
     public InferMatmulData()
     {
-        var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+        var placement = new Placement(new[] { 8, 4 }, "bt");
         {
             var lhs = new[] { 1, 1, 384, 8192 };
             var rhs = new[] { 64, 8192, 128 };
diff --git a/src/Nncase.Tests/Distributed/UnitTestUtilities.cs b/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
index c7548d6026..58b51c7d0d 100644
--- a/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
@@ -16,7 +16,7 @@ public sealed class UnitTestUtilities
     public static TheoryData<DistributedType, IRArray<SBP>> GetPartialCandidateNDSBPsNegativeData { get; } = new()
     {
         {
-            new DistributedType(new(DataTypes.Float32, new[] { 1, 8, 384, 8192 }), new SBP[] { SBP.P, SBP.P }, new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt")),
+            new DistributedType(new(DataTypes.Float32, new[] { 1, 8, 384, 8192 }), new SBP[] { SBP.P, SBP.P }, new Placement(new[] { 8, 4 }, "bt")),
             new SBP[] { SBP.S(1), SBP.S(1) }
         },
     };
@@ -25,13 +25,13 @@ public sealed class UnitTestUtilities
     public void TestEffiecicy()
     {
         var burst = 256;
-        var type1 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(1), SBP.S(2) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt"));
+        var type1 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(1), SBP.S(2) }, new(new[] { 8, 4 }, "bt"));
         var eff1 = DistributedUtility.GetDividedTensorEfficiency(type1, burst);
 
-        var type2 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(1), SBP.S(3) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt"));
+        var type2 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(1), SBP.S(3) }, new(new[] { 8, 4 }, "bt"));
         var eff2 = DistributedUtility.GetDividedTensorEfficiency(type2, burst);
 
-        var type3 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(3), SBP.S(3) }, new(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt"));
+        var type3 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(3), SBP.S(3) }, new(new[] { 8, 4 }, "bt"));
         var eff3 = DistributedUtility.GetDividedTensorEfficiency(type3, burst);
         Assert.True(eff1 > eff2);
         Assert.True(eff2 > eff3);
@@ -40,7 +40,7 @@ public void TestEffiecicy()
     [Fact]
     public void TestGetPartialCandidateNDSBPs()
     {
-        var placement = new Placement(Placement.DeviceKind.CPU, new[] { 8, 4 }, "bt");
+        var placement = new Placement(new[] { 8, 4 }, "bt");
         var type = new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, placement);
         var candidateSbps = Utilities.DistributedUtility.GetPartialCandidateNDSBPs(type);
 
diff --git a/src/Nncase.Tests/Targets/UnitTestXPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestXPUTargetTiling.cs
index 8c07d981d7..e335024080 100644
--- a/src/Nncase.Tests/Targets/UnitTestXPUTargetTiling.cs
+++ b/src/Nncase.Tests/Targets/UnitTestXPUTargetTiling.cs
@@ -128,7 +128,7 @@ public TilingCaseSlice()
         Var fin_a;
         {
             fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, shape));
-            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Slice()), fin_a, new[] { 64 }, new[] { 128 }, new[] { 3 }, new[] { 1 });
+            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Slice()), fin_a, new[] { 64 }, new[] { 128 }, new[] { 3 }, new[] { 1 });
             fusion = new Fusion("xpu", v1, fin_a);
         }
 
@@ -158,7 +158,7 @@ public TilingCaseConcat()
         {
             fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, in_a_shape));
             fin_b = new Var("fin_b", new TensorType(DataTypes.Float32, in_b_shape));
-            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Concat(3)), new IR.Tuple(fin_a, fin_b));
+            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Concat(3)), new IR.Tuple(fin_a, fin_b));
             fusion = new Fusion("xpu", v1, fin_a, fin_b);
         }
 
@@ -190,10 +190,10 @@ public TilingCaseMatmulLayerNorm()
             _ = IR.F.Random.Normal(DataTypes.Float32, new[] { 384, 128 }).Evaluate().AsTensor();
 
             var fin = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 }));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.LayerNorm(2, 1e-6f, false)), fin, scale, bias);
-            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Unsqueeze()), v0, new[] { 0 });
-            var v2 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), v1, weights);
-            var v3 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Unary(UnaryOp.Exp)), v2);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.LayerNorm(2, 1e-6f, false)), fin, scale, bias);
+            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Unsqueeze()), v0, new[] { 0 });
+            var v2 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.MatMul()), v1, weights);
+            var v3 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Unary(UnaryOp.Exp)), v2);
 
             fusion = new Fusion("xpu", v3, fin);
         }
@@ -219,20 +219,20 @@ public TilingCaseMHA()
 
             var fin = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 }));
             var fin2 = new Var("input2", new TensorType(DataTypes.Int64, new[] { 1, 384 }));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.LayerNorm(2, 1e-6f, false)), fin, scale, bias);
-            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Unsqueeze()), v0, new[] { 0 });
-            var v2 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), v1, weights);
-            var v3 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Slice()), v2, new[] { 64 }, new[] { 128 }, new[] { 3 }, new[] { 1 });
-            var v4 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Unary(UnaryOp.Neg)), v3);
-            var v5 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Slice()), v2, new[] { 0 }, new[] { 64 }, new[] { 3 }, new[] { 1 });
-            var v6 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Concat(3)), new IR.Tuple(v4, v5));
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.LayerNorm(2, 1e-6f, false)), fin, scale, bias);
+            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Unsqueeze()), v0, new[] { 0 });
+            var v2 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.MatMul()), v1, weights);
+            var v3 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Slice()), v2, new[] { 64 }, new[] { 128 }, new[] { 3 }, new[] { 1 });
+            var v4 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Unary(UnaryOp.Neg)), v3);
+            var v5 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Slice()), v2, new[] { 0 }, new[] { 64 }, new[] { 3 }, new[] { 1 });
+            var v6 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Concat(3)), new IR.Tuple(v4, v5));
 
-            var v7 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Gather(0)), gdata, fin2);
-            var v8 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Unsqueeze()), v7, new[] { 0 });
+            var v7 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Gather(0)), gdata, fin2);
+            var v8 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Unsqueeze()), v7, new[] { 0 });
 
-            var v9 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Binary(BinaryOp.Mul)), v2, v8);
-            var v10 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Binary(BinaryOp.Mul)), v6, v8);
-            var v11 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Binary(BinaryOp.Add)), v9, v10);
+            var v9 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Binary(BinaryOp.Mul)), v2, v8);
+            var v10 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Binary(BinaryOp.Mul)), v6, v8);
+            var v11 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Binary(BinaryOp.Add)), v9, v10);
 
             fusion = new Fusion("xpu", v11, fin, fin2);
         }
@@ -335,7 +335,7 @@ public TilingCaseMatmul()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, lhsShape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), fin, rhs);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.MatMul()), fin, rhs);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -369,8 +369,8 @@ public TilingCaseMatmulUnary()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, lhsShape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.MatMul()), fin, rhs);
-            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Unary(UnaryOp.Neg)), v0);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.MatMul()), fin, rhs);
+            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Unary(UnaryOp.Neg)), v0);
             fusion = new Fusion("xpu", v1, fin);
         }
 
@@ -406,7 +406,7 @@ public TilingCaseLayerNorm()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, shape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.LayerNorm(axis, 1e-5f, false)), fin, scale, bias);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.LayerNorm(axis, 1e-5f, false)), fin, scale, bias);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -469,7 +469,7 @@ public TilingCaseInstanceNorm()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, shape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.InstanceNormalization()), fin, scale, bias, 1e-5);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.InstanceNormalization()), fin, scale, bias, 1e-5);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -505,7 +505,7 @@ public TilingCaseGather()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Gather(axis)), fin, indices);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Gather(axis)), fin, indices);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -566,7 +566,7 @@ public TilingCaseSoftmax()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.Softmax()), fin, axis);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.Softmax()), fin, axis);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -595,7 +595,7 @@ public TilingCaseTranspose()
         Var fin_a;
         {
             fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, shape));
-            var v1 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Transpose()), fin_a, perm);
+            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Transpose()), fin_a, perm);
             fusion = new Fusion("xpu", v1, fin_a);
         }
 
@@ -621,7 +621,7 @@ public TilingCaseReshape1()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Reshape()), fin, newShape);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Reshape()), fin, newShape);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -650,7 +650,7 @@ public TilingCaseReshape2()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Reshape()), fin, newShape);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Reshape()), fin, newShape);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -678,7 +678,7 @@ public TilingCaseReduceArg()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64)), fin, 1, false, false);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64)), fin, 1, false, false);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -706,7 +706,7 @@ public TilingCaseReduceArg2()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64)), fin, 2, true, false);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64)), fin, 2, true, false);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -768,7 +768,7 @@ public TilingCaseConv2D()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.NN.Conv2D(PadMode.Constant)), fin, weights, bias, stride, padding, dilation, groups, fusedClamp);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.Conv2D(PadMode.Constant)), fin, weights, bias, stride, padding, dilation, groups, fusedClamp);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -796,7 +796,7 @@ public TilingCaseResize()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, shape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Imaging.ResizeImage(ImageResizeMode.NearestNeighbor, ImageResizeTransformationMode.Asymmetric, ImageResizeNearestMode.Floor, false)), fin, None.Default, new[] { 1, 512, 128, 128 }, None.Default, None.Default, None.Default);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Imaging.ResizeImage(ImageResizeMode.NearestNeighbor, ImageResizeTransformationMode.Asymmetric, ImageResizeNearestMode.Floor, false)), fin, None.Default, new[] { 1, 512, 128, 128 }, None.Default, None.Default, None.Default);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -829,7 +829,7 @@ public TilingCaseCast()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Int64, shape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Cast(DataTypes.Float32, CastMode.KDefault)), fin);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Cast(DataTypes.Float32, CastMode.KDefault)), fin);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -913,7 +913,7 @@ public TilingCaseExpand()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Int64, shape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Tensors.Expand()), fin, newShape);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Expand()), fin, newShape);
             fusion = new Fusion("xpu", v0, fin);
         }
 
@@ -942,7 +942,7 @@ public TilingCaseClamp()
         Var fin;
         {
             fin = new Var("input", new TensorType(DataTypes.Float32, shape));
-            var v0 = new Call(new IR.CPU.CPUKernelOp(new IR.Math.Clamp()), fin, float.NegativeInfinity, float.PositiveInfinity);
+            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Clamp()), fin, float.NegativeInfinity, float.PositiveInfinity);
             fusion = new Fusion("xpu", v0, fin);
         }
 
diff --git a/src/Nncase.Tests/packages.lock.json b/src/Nncase.Tests/packages.lock.json
index 07b123dd74..6ff561e7a6 100644
--- a/src/Nncase.Tests/packages.lock.json
+++ b/src/Nncase.Tests/packages.lock.json
@@ -1477,7 +1477,6 @@
           "Nncase.Graph": "[1.0.0, )",
           "Nncase.Importer": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
-          "Nncase.Modules.XPU": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )",
           "Nncase.Quantization": "[1.0.0, )",
           "Nncase.Simulator": "[1.0.0, )"

From 9978e2c3598d277436191a53930c53c87c8a456d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 26 Oct 2023 13:32:05 +0800
Subject: [PATCH 282/308] fix match result

---
 src/Nncase.Core/PatternMatch/IMatchResult.cs | 7 +++++++
 src/Nncase.Core/PatternMatch/MatchResult.cs  | 5 ++++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/Nncase.Core/PatternMatch/IMatchResult.cs b/src/Nncase.Core/PatternMatch/IMatchResult.cs
index f6f9446b9e..8f6118d4df 100644
--- a/src/Nncase.Core/PatternMatch/IMatchResult.cs
+++ b/src/Nncase.Core/PatternMatch/IMatchResult.cs
@@ -30,6 +30,13 @@ public interface IMatchResult : IEnumerable<KeyValuePair<IPattern, object>>
     /// <returns>Match result.</returns>
     object this[IPattern pattern] { get; }
 
+    /// <summary>
+    /// Get match result by name, default is null.
+    /// </summary>
+    /// <param name="name">Pattern name.</param>
+    /// <returns>match result.</returns>
+    object GetValueOrDefault(string name);
+
     /// <summary>
     /// Get match result by pattern.
     /// </summary>
diff --git a/src/Nncase.Core/PatternMatch/MatchResult.cs b/src/Nncase.Core/PatternMatch/MatchResult.cs
index 9c086ed2a6..eb1bb1f651 100644
--- a/src/Nncase.Core/PatternMatch/MatchResult.cs
+++ b/src/Nncase.Core/PatternMatch/MatchResult.cs
@@ -41,7 +41,10 @@ where kv.Key.Name is not null
     public object this[IPattern pattern] => _patternMap[pattern];
 
     /// <inheritdoc/>
-    public object this[string name] => _stringMap.GetValueOrDefault(name, null!);
+    public object this[string name] => _stringMap[name];
+
+    /// <inheritdoc/>
+    public object GetValueOrDefault(string name) => _stringMap.GetValueOrDefault(name, null!);
 
     /// <inheritdoc/>
     public IEnumerator<KeyValuePair<IPattern, object>> GetEnumerator()

From 3f93af4a0937b62fc5bd8668e0db9758c2c932be Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Thu, 26 Oct 2023 05:34:59 +0000
Subject: [PATCH 283/308] Apply code-format changes

---
 src/Nncase.Core/DistributedType.cs                         | 2 --
 .../Rules/Neutral/FoldPrePostReshapeSoftmax.cs             | 2 +-
 src/Nncase.Tests/Distributed/UnitTestKernels.cs            | 2 +-
 tests/importer/onnx_/model/test_llama.py                   | 2 +-
 tests/importer/onnx_/model/test_text_encoder.py            | 4 ++--
 tests/importer/onnx_/model/test_vae_decoder.py             | 7 ++++---
 6 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/Nncase.Core/DistributedType.cs b/src/Nncase.Core/DistributedType.cs
index 8fb293c9f1..efe52395da 100644
--- a/src/Nncase.Core/DistributedType.cs
+++ b/src/Nncase.Core/DistributedType.cs
@@ -52,12 +52,10 @@ private SBPBroadCast()
 // public sealed record Placement(Placement.DeviceKind Kind, IRArray<int> Hierarchy, string Name)
 public sealed record Placement(IRArray<int> Hierarchy, string Name)
 {
-
     // public enum DeviceKind : uint
     // {
     //     CPU = 0,
     // }
-
     public int Rank => Hierarchy.Count;
 
     // public override string ToString() => $"@{Kind} [{string.Join(',', Hierarchy.Zip(Name).Select(t => t.First.ToString() + '@' + t.Second.ToString()))}]";
diff --git a/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs b/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
index 05c8331a04..83edfe5e5e 100644
--- a/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
+++ b/src/Nncase.Passes/Rules/Neutral/FoldPrePostReshapeSoftmax.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
diff --git a/src/Nncase.Tests/Distributed/UnitTestKernels.cs b/src/Nncase.Tests/Distributed/UnitTestKernels.cs
index a24eab0d9c..5f8b5786d4 100644
--- a/src/Nncase.Tests/Distributed/UnitTestKernels.cs
+++ b/src/Nncase.Tests/Distributed/UnitTestKernels.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Canaan Inc. All rights reserved.
+// Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
 using System;
diff --git a/tests/importer/onnx_/model/test_llama.py b/tests/importer/onnx_/model/test_llama.py
index 25c769a933..c6beee1ff6 100644
--- a/tests/importer/onnx_/model/test_llama.py
+++ b/tests/importer/onnx_/model/test_llama.py
@@ -124,4 +124,4 @@ def test_demo(request):
 
 if __name__ == "__main__":
     pytest.main(
-        ['-vvs', __file__])
\ No newline at end of file
+        ['-vvs', __file__])
diff --git a/tests/importer/onnx_/model/test_text_encoder.py b/tests/importer/onnx_/model/test_text_encoder.py
index 00a79aa70a..8642743bcc 100644
--- a/tests/importer/onnx_/model/test_text_encoder.py
+++ b/tests/importer/onnx_/model/test_text_encoder.py
@@ -29,11 +29,11 @@ def test_demo(request):
 
     # runner.set_shape_var({"batch_size": 1, "num_channels_latent": 4, "height_latent": 64, "width_latent": 64})
     # runner.set_shape_var({"N": 384})
-    runner.set_shape_var({"batch_size":1, "sequence_length":77})
+    runner.set_shape_var({"batch_size": 1, "sequence_length": 77})
     # runner.set_shape_var({"batch_size:1", "sequence_length:77"})
     runner.run(model_file)
 
 
 if __name__ == "__main__":
     pytest.main(
-        ['-vvs', __file__])
\ No newline at end of file
+        ['-vvs', __file__])
diff --git a/tests/importer/onnx_/model/test_vae_decoder.py b/tests/importer/onnx_/model/test_vae_decoder.py
index fa3daa82a9..0c3eee5818 100644
--- a/tests/importer/onnx_/model/test_vae_decoder.py
+++ b/tests/importer/onnx_/model/test_vae_decoder.py
@@ -21,7 +21,7 @@
 
 
 def test_demo(request):
-    runner = OnnxTestRunner("test_vae_decoder", 
+    runner = OnnxTestRunner("test_vae_decoder",
                             "/root/Workspace/config/vae_config.toml")
     # runner = OnnxTestRunner("test_vae_decoder")
     model_file = "/root/Downloads/Models/vae_decoder.onnx"
@@ -29,11 +29,12 @@ def test_demo(request):
     # model_file = "/root/Downloads/Models/modified_vae_decoder.onnx"
     # model_file = "/root/Downloads/Models/model_sim_huo.onnx"
 
-    runner.set_shape_var({"batch_size": 1, "num_channels_latent": 4, "height_latent": 64, "width_latent": 64})
+    runner.set_shape_var({"batch_size": 1, "num_channels_latent": 4,
+                          "height_latent": 64, "width_latent": 64})
     # runner.set_shape_var({"N": 384})
     runner.run(model_file)
 
 
 if __name__ == "__main__":
     pytest.main(
-        ['-vvs', __file__])
\ No newline at end of file
+        ['-vvs', __file__])

From fd4941a56997806d42bc4a8a66992f76dbd47158 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Thu, 26 Oct 2023 07:12:00 +0000
Subject: [PATCH 284/308] Clean Tests

---
 .../Nncase.Tests.TestFixture.csproj           |   1 -
 src/Nncase.Tests.TestFixture/TestClassBase.cs |   2 +-
 src/Nncase.Tests/Core/UnitTestExpression.cs   |  16 -
 .../Distributed/UnitTestConstruct.cs          | 107 --
 src/Nncase.Tests/Distributed/UnitTestCost.cs  |  43 -
 .../Distributed/UnitTestKernels.cs            | 178 ----
 .../Distributed/UnitTestTypeInfer.cs          | 241 -----
 .../Distributed/UnitTestUtilities.cs          |  57 --
 src/Nncase.Tests/Simulator/UnitTestInterop.cs |   4 +-
 src/Nncase.Tests/Targets/UnitTestXPUTarget.cs | 299 ------
 .../Targets/UnitTestXPUTargetTiling.cs        | 961 ------------------
 11 files changed, 4 insertions(+), 1905 deletions(-)
 delete mode 100644 src/Nncase.Tests/Distributed/UnitTestConstruct.cs
 delete mode 100644 src/Nncase.Tests/Distributed/UnitTestCost.cs
 delete mode 100644 src/Nncase.Tests/Distributed/UnitTestKernels.cs
 delete mode 100644 src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
 delete mode 100644 src/Nncase.Tests/Distributed/UnitTestUtilities.cs
 delete mode 100644 src/Nncase.Tests/Targets/UnitTestXPUTarget.cs
 delete mode 100644 src/Nncase.Tests/Targets/UnitTestXPUTargetTiling.cs

diff --git a/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj b/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
index 6867a47837..3e1336e99c 100644
--- a/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
+++ b/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
@@ -22,7 +22,6 @@
     </ItemGroup>
     
     <ItemGroup>
-        <ProjectReference Include="..\..\modules\Nncase.Modules.XPU\Nncase.Modules.XPU.csproj" />
         <ProjectReference Include="..\..\modules\Nncase.Modules.StackVM\Nncase.Modules.StackVM.csproj" />
         <ProjectReference Include="..\Nncase.Core\Nncase.Core.csproj" />
         <ProjectReference Include="..\Nncase.CodeGen\Nncase.CodeGen.csproj" />
diff --git a/src/Nncase.Tests.TestFixture/TestClassBase.cs b/src/Nncase.Tests.TestFixture/TestClassBase.cs
index fe2e36a864..741e1e02f7 100644
--- a/src/Nncase.Tests.TestFixture/TestClassBase.cs
+++ b/src/Nncase.Tests.TestFixture/TestClassBase.cs
@@ -38,7 +38,7 @@ public TestClassBase()
     /// <summary>
     /// Gets or sets default target name.
     /// </summary>
-    public virtual string DefaultTargetName { get; set; } = XPUTarget.Kind;
+    public virtual string DefaultTargetName { get; set; } = "stackvm";
 
     /// <summary>
     /// Gets test output root.
diff --git a/src/Nncase.Tests/Core/UnitTestExpression.cs b/src/Nncase.Tests/Core/UnitTestExpression.cs
index b6103de1fe..59741a8735 100644
--- a/src/Nncase.Tests/Core/UnitTestExpression.cs
+++ b/src/Nncase.Tests/Core/UnitTestExpression.cs
@@ -526,22 +526,6 @@ public void TestIf()
         Assert.Equal(1, result2);
     }
 
-    [Fact]
-    public void TestBoxingEqual()
-    {
-        Placement placement = new(new int[] { 4, 2 }, "bt");
-        var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
-        var a = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
-        var b = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
-
-        var input = new Var(ttype);
-        var ea = IR.F.XPU.Boxing(input, a);
-        var eb = IR.F.XPU.Boxing(input, b);
-
-        Assert.Equal(ea.Target, eb.Target);
-        Assert.StrictEqual(ea.Target, eb.Target);
-    }
-
     private MyRange[] Conv2dBounds(MyRange[] output_range, int kh, int kw)
     {
         var new_output_range = new MyRange[output_range.Length];
diff --git a/src/Nncase.Tests/Distributed/UnitTestConstruct.cs b/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
deleted file mode 100644
index 51ea176848..0000000000
--- a/src/Nncase.Tests/Distributed/UnitTestConstruct.cs
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection.Metadata;
-using NetFabric.Hyperlinq;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.IR.Math;
-using Nncase.Passes;
-using Nncase.Utilities;
-using Xunit;
-
-namespace Nncase.Tests.DistributedTest;
-
-[TestFixture.AutoSetupTestMethod(InitSession = true)]
-public sealed class UnitTestConstruct : TestClassBase
-{
-    [Fact]
-    public void TestCreate()
-    {
-        Placement placement = new(new int[] { 2, 2 }, "bt");
-        IRArray<SBP> sbps = new[] { SBP.S(2), SBP.S(1), };
-        DistributedType t = new(new TensorType(DataTypes.Float32, new[] { 1, 2, 8 }), sbps, placement);
-        var input = new Var("input", t);
-        var output = IR.F.Math.Unary(UnaryOp.Neg, input);
-        output.CheckedType = t;
-        CompilerServices.DumpDotIR(output, "create", Dumpper.Directory, false);
-    }
-
-    public IReadOnlyList<CallableType> GetCandidateSignatures(Unary unary, TensorType tensorType, Placement placement)
-    {
-        var layers = new List<List<(SBP, SBP)>>();
-        for (int i = 0; i < placement.Rank; i++)
-        {
-            var layer = new List<(SBP, SBP)>();
-            for (int axis = 0; axis < tensorType.Shape.Rank; axis++)
-            {
-                if (tensorType.Shape[axis] is { IsFixed: true, Value: int s } && s > placement.Hierarchy[i])
-                {
-                    layer.Add((SBP.S(axis), SBP.S(axis)));
-                }
-            }
-
-            layer.Add((SBP.B, SBP.B));
-            layers.Add(layer);
-        }
-
-        return LinqExtensions.CartesianProduct(layers).Select(layer => layer.ToArray()).Select(layer =>
-        {
-            var inType = new DistributedType(tensorType, Enumerable.Range(0, layers.Count).Select(i => layer[i].Item1).ToArray(), placement);
-            var outType = new DistributedType(tensorType, Enumerable.Range(0, layers.Count).Select(i => layer[i].Item2).ToArray(), placement);
-            return new CallableType(outType, new[] { inType });
-        }).ToList();
-    }
-
-    [Fact]
-    public void TestGetLeafCandidateNDSBPs()
-    {
-        Placement placement = new(new int[] { 4, 2 }, "bt");
-        var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
-        var input = new Var(ttype);
-        var set = new HashSet<DistributedType>(DistributedUtility.GetLeafCandidateNDSBPs(ttype, placement).Select(ndsbp => new DistributedType(ttype, ndsbp, placement)));
-        Assert.Equal(9, set.Count);
-    }
-
-    [Fact]
-    public void TestDistributeTypeEqual()
-    {
-        Placement placement = new(new int[] { 4, 2 }, "bt");
-        var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
-        var a = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
-        var b = new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement);
-        Assert.Equal(a, b);
-        Assert.StrictEqual(a, b);
-    }
-
-    [Fact]
-    public void TestBoxingEqual()
-    {
-        Placement placement = new(new int[] { 4, 2 }, "bt");
-        var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
-        var a = new IR.XPU.Boxing(new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement));
-        var b = new IR.XPU.Boxing(new DistributedType(ttype, new[] { SBP.S(1), SBP.S(2) }, placement));
-        Assert.Equal(a, b);
-        Assert.StrictEqual(a, b);
-    }
-
-    [Fact]
-    public void TestUnary()
-    {
-        Placement placement = new(new int[] { 4, 2 }, "bt");
-        var ttype = new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 });
-        var input = new Var(ttype);
-        var output = IR.F.Math.Unary(UnaryOp.Neg, input);
-
-        var candidates = GetCandidateSignatures((Unary)output.Target, ttype, placement);
-        int i = 0;
-        foreach (var c in candidates)
-        {
-            input.CheckedType = c.Parameters[0];
-            output.CheckedType = c.ReturnType;
-            CompilerServices.DumpDotIR(output, $"unary_{i++}", Dumpper.Directory, false);
-        }
-    }
-}
diff --git a/src/Nncase.Tests/Distributed/UnitTestCost.cs b/src/Nncase.Tests/Distributed/UnitTestCost.cs
deleted file mode 100644
index 89d9793032..0000000000
--- a/src/Nncase.Tests/Distributed/UnitTestCost.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection.Metadata;
-using NetFabric.Hyperlinq;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Xunit;
-
-namespace Nncase.Tests.DistributedTest;
-
-public sealed class UnitTestCost
-{
-    [Fact]
-    public void TestPartialToBroadCastCost()
-    {
-        var tensorType = new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 128 });
-        var placement = new Placement(new[] { 8, 4 }, "bt");
-
-        List<CostModel.Cost> costs = new();
-        foreach (var ndsbp in new IRArray<SBP>[] {
-            new SBP[] { SBP.S(2), SBP.P },
-            new SBP[] { SBP.P, SBP.S(2) },
-            new SBP[] { SBP.P, SBP.P },
-            new SBP[] { SBP.P, SBP.S(1) },
-            new SBP[] { SBP.P, SBP.S(3) },
-            new SBP[] { SBP.S(1), SBP.P },
-            new SBP[] { SBP.S(3), SBP.P },
-         })
-        {
-            var type = new DistributedType(tensorType, ndsbp, placement);
-            var input0 = new Var(type);
-            var candidates = Utilities.DistributedUtility.GetPartialCandidateNDSBPs(type).Select(ndsbp => IR.F.XPU.Boxing(input0, type with { NdSBP = ndsbp }));
-            foreach (var item in candidates)
-            {
-                var cost = CompilerServices.EvaluateCost(item);
-                costs.Add(cost);
-            }
-        }
-    }
-}
diff --git a/src/Nncase.Tests/Distributed/UnitTestKernels.cs b/src/Nncase.Tests/Distributed/UnitTestKernels.cs
deleted file mode 100644
index 5f8b5786d4..0000000000
--- a/src/Nncase.Tests/Distributed/UnitTestKernels.cs
+++ /dev/null
@@ -1,178 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
-using NetFabric.Hyperlinq;
-using Nncase.CodeGen;
-using Nncase.IR;
-using Nncase.IR.Tensors;
-using Nncase.Runtime.Interop;
-using Nncase.Targets;
-using Nncase.Tests.TestFixture;
-using Nncase.Utilities;
-using Xunit;
-
-namespace Nncase.Tests.DistributedTest;
-
-public interface IDistributedKernelCase
-{
-    string Name { get; }
-
-    Fusion Fusion { get; }
-
-    IReadOnlyList<Var> Vars { get; }
-
-    IReadOnlyList<Tensor> Inputs { get; }
-}
-
-[AutoSetupTestMethod(InitSession = true)]
-public sealed class UnitTestKernels : TestClassBase
-{
-    public static readonly TheoryData<IDistributedKernelCase> Cases = new()
-    {
-        new BinaryCase1(),
-        new SoftmaxCase1(),
-    };
-
-    public UnitTestKernels()
-    {
-#if DEBUG
-        CompileOptions.DumpFlags = Diagnostics.DumpFlags.PassIR | Diagnostics.DumpFlags.Rewrite | Diagnostics.DumpFlags.CodeGen | Diagnostics.DumpFlags.EGraphCost | Diagnostics.DumpFlags.Tiling;
-#endif
-    }
-
-    [Theory]
-    [MemberData(nameof(Cases))]
-    internal async Task Run(IDistributedKernelCase kernelCase)
-    {
-        using var dumpScope = new Diagnostics.DumpScope(kernelCase.Name, CompileOptions.DumpFlags);
-
-        // convert fusion to prim func
-        var primBody = new List<Expr>();
-        var visitor = new Passes.Tile.TIRConvertVisitor(primBody);
-        var fusion = kernelCase.Fusion;
-        visitor.Visit(fusion);
-        var primFunc = TIR.T.PrimFunc(fusion.Name, fusion.ModuleKind, visitor.InputBuffers.Concat(visitor.OutputBuffers).ToArray()).Body(primBody.ToArray()).Build();
-        var primWrapper = new PrimFunctionWrapper(primFunc, primFunc.Parameters.Length - 1);
-        var main = new Function(new Call(primWrapper, kernelCase.Vars.ToArray()), kernelCase.Vars.ToArray());
-
-        var module = new IR.IRModule(main);
-        module.Add(primWrapper);
-        module.Add(primFunc);
-        var inputs = kernelCase.Inputs.ToArray();
-        var output = fusion.Body.Evaluate(kernelCase.Vars.Zip(inputs).ToDictionary(p => p.First, p => (IValue)Value.FromTensor(p.Second))).AsTensor();
-
-#if DEBUG
-        for (var i = 0; i < inputs.Length; i++)
-        {
-            using (var fs = Diagnostics.DumpScope.Current.OpenFile($"input_{i}.bin"))
-            {
-                fs.Write(inputs[i].BytesBuffer);
-            }
-        }
-
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile($"output_0.bin"))
-        {
-            fs.Write(output.BytesBuffer);
-        }
-#endif
-        await Compile(module);
-        var (kmodel_path, kmodel) = Testing.BuildKModel("test", module, CompileSession);
-        var actual = Testing.RunKModel(kmodel, Diagnostics.DumpScope.Current.Directory, inputs).AsTensor();
-#if DEBUG
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile($"actual_0.bin"))
-        {
-            fs.Write(actual.BytesBuffer);
-        }
-#endif
-        var cos = Comparator.CosSimilarity(output, actual);
-        Assert.True(cos > 0.999);
-    }
-
-    private async Task Compile(IRModule module)
-    {
-        var pmgr = CompileSession.CreatePassManager("pmgr");
-        CompileSession.Target.RegisterTargetDependentAfterQuantPass(pmgr, CompileSession.CompileOptions);
-        CompileSession.Target.RegisterTargetDependentBeforeCodeGen(pmgr, CompileSession.CompileOptions);
-        await pmgr.RunAsync(module);
-    }
-}
-
-internal sealed class BinaryCase1 : IDistributedKernelCase
-{
-    public BinaryCase1()
-    {
-        var type = new TensorType(DataTypes.Float32, new[] { 1, 16, 768 });
-        var place = new Placement(new[] { 8, 4 }, "bt");
-        var lhs = new Var(type);
-        var rhs = new Var(type);
-        {
-            var l0 = IR.F.XPU.Boxing(lhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.S(2) }, place));
-            var r0 = IR.F.XPU.Boxing(rhs, new DistributedType(type, new SBP[] { SBP.S(2), SBP.S(2) }, place));
-            Fusion = new Fusion(Name + "_fusion", XPUTarget.Kind, IR.F.XPU.Boxing(l0 + r0, type), new[] { lhs, rhs });
-        }
-
-        Vars = new[] { lhs, rhs };
-    }
-
-    public string Name => "BinaryCase1";
-
-    public Fusion Fusion { get; }
-
-    public IReadOnlyList<Var> Vars { get; }
-
-    public IReadOnlyList<Tensor> Inputs
-    {
-        get
-        {
-            return Vars.Select(v => IR.F.Random.Uniform(v.CheckedDataType, 30, 0, 1, v.CheckedShape).Evaluate().AsTensor()).ToArray();
-        }
-    }
-
-    public override string ToString() => Name;
-}
-
-internal sealed class SoftmaxCase1 : IDistributedKernelCase
-{
-    public SoftmaxCase1()
-    {
-        var type = new TensorType(DataTypes.Float32, new[] { 16, 1024, 1024 });
-        var input = new Var(type);
-        Vars = new[] { input };
-    }
-
-    public string Name => "SoftmaxCase1";
-
-    public Fusion Fusion
-    {
-        get
-        {
-            var type = new TensorType(DataTypes.Float32, new[] { 16, 1024, 1024 });
-            var place = new Placement(new[] { 8, 4 }, "bt");
-            var axis = 2L;
-            {
-                var input0 = IR.F.XPU.Boxing(Vars[0], new DistributedType(type, new SBP[] { SBP.S(0), SBP.S(1) }, place));
-                return new Fusion(Name + "_fusion", XPUTarget.Kind, IR.F.XPU.Boxing(IR.F.NN.Softmax(input0, axis), type), new[] { Vars[0] });
-            }
-        }
-    }
-
-    public IReadOnlyList<Var> Vars { get; }
-
-    public IReadOnlyList<Tensor> Inputs
-    {
-        get
-        {
-            return Vars.Select(v => IR.F.Random.Uniform(v.CheckedDataType, 30, 0, 1, v.CheckedShape).Evaluate().AsTensor()).ToArray();
-        }
-    }
-
-    public override string ToString() => Name;
-}
diff --git a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs b/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
deleted file mode 100644
index d1715e58c2..0000000000
--- a/src/Nncase.Tests/Distributed/UnitTestTypeInfer.cs
+++ /dev/null
@@ -1,241 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.IO;
-using System.Linq;
-using Nncase;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.IR.Math;
-using Nncase.Utilities;
-using Xunit;
-
-namespace Nncase.Tests.DistributedTest;
-
-[TestFixture.AutoSetupTestMethod(InitSession = true)]
-public sealed class UnitTestTypeInfer : TestClassBase
-{
-    public static TheoryData<UnaryOp, DistributedType, IRType> InferUnaryData => new() {
-        { UnaryOp.Exp,
-          new(new(DataTypes.Float32, new[] { 48, 32 }), new[] { SBP.B, SBP.B }, new(new[] { 2, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 48, 32 }), new[] { SBP.B, SBP.B }, new(new[] { 2, 4 }, "bt"))
-        },
-        { UnaryOp.Exp,
-          new(new(DataTypes.Float32, new[] { 384, 128 }), new SBP[] { SBP.S(0), SBP.P }, new(new[] { 2, 4 }, "bt")),
-          new InvalidType(string.Empty)
-        },
-    };
-
-    public static TheoryData<BinaryOp, DistributedType, DistributedType, IRType> InferBinaryData => new() {
-        { BinaryOp.Add,
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.B, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
-          new InvalidType(string.Empty)
-        },
-        { BinaryOp.Add,
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt"))
-        },
-        { BinaryOp.Mul,
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, new(new[] { 2, 4 }, "bt")),
-          new InvalidType(string.Empty)
-        },
-        { BinaryOp.Add,
-          new DistributedType(new(DataTypes.Float32, new[] { 3072 }), new SBP[] { SBP.S(0), SBP.S(0) }, new(new[] { 8, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 1, 77, 3072 }), new SBP[] { SBP.B, SBP.B }, new(new[] { 8, 4 }, "bt")),
-          new InvalidType(string.Empty)
-        },
-        { BinaryOp.Add,
-          new DistributedType(new(DataTypes.Float32, new[] { 16, 32, 32 }), new SBP[] { SBP.S(0), SBP.B }, new(new[] { 8, 4 }, "bt")),
-          new DistributedType(new(DataTypes.Float32, new[] { 16, 32, 32 }), new SBP[] { SBP.B, SBP.S(0) }, new(new[] { 8, 4 }, "bt")),
-          new InvalidType(string.Empty)
-        },
-    };
-
-    [Theory]
-    [MemberData(nameof(InferUnaryData))]
-    public void TestInferUnary(UnaryOp unaryOp, DistributedType inputType, IRType outType)
-    {
-        var input = new Var(inputType);
-        var unary = IR.F.Math.Unary(unaryOp, input);
-        CompilerServices.InferenceType(unary);
-        if (outType is InvalidType && unary.CheckedType is InvalidType)
-        {
-        }
-        else
-        {
-            Assert.Equal(outType, unary.CheckedType);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(InferBinaryData))]
-    public void TestInferBinary(BinaryOp binaryOp, DistributedType lhsType, DistributedType rhsType, IRType outType)
-    {
-        var lhs = new Var(lhsType);
-        var rhs = new Var(rhsType);
-        var binary = IR.F.Math.Binary(binaryOp, lhs, rhs);
-        CompilerServices.InferenceType(binary);
-        if (outType is InvalidType && binary.CheckedType is InvalidType)
-        {
-        }
-        else
-        {
-            Assert.Equal(outType, binary.CheckedType);
-        }
-    }
-
-    [Theory]
-    [ClassData(typeof(InferMatmulData))]
-    public void TestInferMatmul(DistributedType lhsType, DistributedType rhsType, IRType outType)
-    {
-        var lhs = new Var(lhsType);
-        var rhs = new Var(rhsType);
-        var matmul = IR.F.Math.MatMul(lhs, rhs);
-        CompilerServices.InferenceType(matmul);
-        if (outType is InvalidType && matmul.CheckedType is InvalidType)
-        {
-        }
-        else
-        {
-            Assert.Equal(outType, matmul.CheckedType);
-        }
-    }
-
-    [Fact]
-    public void TestInferMatmulProduct()
-    {
-        var placement = new Placement(new[] { 8, 4 }, "bt");
-        var lhsShape = new[] { 1, 64, 384, 8192 };
-        var rhsShape = new[] { 1, 64, 8192, 384 };
-        var lhsType = new TensorType(DataTypes.Float32, lhsShape);
-        var rhsType = new TensorType(DataTypes.Float32, rhsShape);
-        var candiateArgs = new[] {
-            DistributedUtility.GetLeafCandidateNDSBPs(lhsType, placement).Select(ndsbp => new DistributedType(lhsType, ndsbp, placement)),
-            DistributedUtility.GetLeafCandidateNDSBPs(rhsType, placement).Select(ndsbp => new DistributedType(rhsType, ndsbp, placement)),
-            }.
-            CartesianProduct().
-            Select(argTypes => argTypes.Select(type => new Var(type)).ToArray());
-
-        int count = 0;
-#if DEBUG
-        using (var f = Dumpper.OpenFile("types.txt"))
-#else
-        using (var f = MemoryStream.Null)
-#endif
-        {
-            using var wr = new StreamWriter(f);
-            foreach (var args in candiateArgs)
-            {
-                var matmul = IR.F.Math.MatMul(args[0], args[1]);
-                matmul.InferenceType();
-                if (matmul.CheckedType is not InvalidType)
-                {
-                    count++;
-                }
-
-                wr.WriteLine($"{args[0].CheckedType} {args[1].CheckedType} => {matmul.CheckedType}");
-            }
-        }
-
-        Assert.Equal(16, count);
-    }
-
-    [Fact]
-    public void TestInferGather()
-    {
-        var inputType = new TensorType(DataTypes.Float32, new[] { 384, 128 });
-        var indexType = new TensorType(DataTypes.Int64, new[] { 1, 384 });
-        var placement = new Placement(new[] { 8, 4 }, "bt");
-
-        var candiateArgs = new[] {
-            DistributedUtility.GetLeafCandidateNDSBPs(inputType, placement).Select(ndsbp => new DistributedType(inputType, ndsbp, placement)),
-            DistributedUtility.GetLeafCandidateNDSBPs(indexType, placement).Select(ndsbp => new DistributedType(indexType, ndsbp, placement)),
-            }.
-            CartesianProduct().
-            Select(argTypes => argTypes.Select(type => new Var(type)).ToArray());
-
-        int count = 0;
-#if DEBUG
-        using (var f = Dumpper.OpenFile("types.txt"))
-#else
-        using (var f = MemoryStream.Null)
-#endif
-        {
-            using var wr = new StreamWriter(f);
-            foreach (var args in candiateArgs)
-            {
-                var call = IR.F.Tensors.Gather(args[0], 0, args[1]);
-                call.InferenceType();
-                if (call.CheckedType is not InvalidType)
-                {
-                    count++;
-                }
-
-                wr.WriteLine($"{args[0].CheckedType} {args[1].CheckedType} => {call.CheckedType}");
-            }
-        }
-
-        Assert.Equal(9, count);
-    }
-}
-
-internal sealed class InferMatmulData : TheoryData<DistributedType, DistributedType, IRType>
-{
-    public InferMatmulData()
-    {
-        var placement = new Placement(new[] { 8, 4 }, "bt");
-        {
-            var lhs = new[] { 1, 1, 384, 8192 };
-            var rhs = new[] { 64, 8192, 128 };
-            var o = new[] { 1, 64, 384, 128 };
-            Add(
-                new(new(DataTypes.Float32, lhs), new SBP[] { SBP.B, SBP.B }, placement),
-                new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(0), SBP.S(0) }, placement),
-                new DistributedType(new(DataTypes.Float32, o), new SBP[] { SBP.S(1), SBP.S(1) }, placement));
-        }
-
-        {
-            var lhs = new[] { 1, 64, 384, 8192 };
-            var rhs = new[] { 64, 8192, 128 };
-            var o = new[] { 1, 64, 384, 128 };
-            Add(
-                new(new(DataTypes.Float32, lhs), new SBP[] { SBP.S(1), SBP.S(1) }, placement),
-                new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(0), SBP.S(0) }, placement),
-                new DistributedType(new(DataTypes.Float32, o), new SBP[] { SBP.S(1), SBP.S(1) }, placement));
-            Add(
-            new(new(DataTypes.Float32, lhs), new SBP[] { SBP.S(1), SBP.B }, placement),
-            new(new(DataTypes.Float32, rhs), new SBP[] { SBP.B, SBP.S(0) }, placement),
-            new InvalidType(string.Empty));
-        }
-
-        {
-            var lhs = new[] { 1, 384, 8192 };
-            var rhs = new[] { 8192, 8192 };
-            Add(
-                new(new(DataTypes.Float32, lhs), new SBP[] { SBP.S(1), SBP.B }, placement),
-                new(new(DataTypes.Float32, rhs), new SBP[] { SBP.B, SBP.S(0) }, placement),
-                new InvalidType(string.Empty));
-        }
-
-        {
-            var lhs = new[] { 1, 64, 384, 8192 };
-            var rhs = new[] { 1, 64, 8192, 384 };
-            var o = new[] { 1, 64, 384, 384 };
-            Add(
-                new(new(DataTypes.Float32, new[] { 1, 1, 384, 8192 }), new[] { SBP.S(2), SBP.S(2) }, placement),
-                new(new(DataTypes.Float32, new[] { 1, 64, 8192, 128 }), new SBP[] { SBP.S(2), SBP.S(2) }, placement),
-                new InvalidType(string.Empty));
-            Add(
-                new(new(DataTypes.Float32, lhs), new[] { SBP.S(1), SBP.S(2) }, placement),
-                new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(1), SBP.B }, placement),
-                new DistributedType(new(DataTypes.Float32, o), new[] { SBP.S(1), SBP.S(2) }, placement));
-            Add(
-                new(new(DataTypes.Float32, lhs), new[] { SBP.S(1), SBP.S(3) }, placement),
-                new(new(DataTypes.Float32, rhs), new SBP[] { SBP.S(1), SBP.S(2) }, placement),
-                new DistributedType(new(DataTypes.Float32, o), new SBP[] { SBP.S(1), SBP.P }, placement));
-        }
-    }
-}
diff --git a/src/Nncase.Tests/Distributed/UnitTestUtilities.cs b/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
deleted file mode 100644
index 58b51c7d0d..0000000000
--- a/src/Nncase.Tests/Distributed/UnitTestUtilities.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System.Collections.Generic;
-using System.Linq;
-using NetFabric.Hyperlinq;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.Utilities;
-using Xunit;
-
-namespace Nncase.Tests.DistributedTest;
-
-public sealed class UnitTestUtilities
-{
-    public static TheoryData<DistributedType, IRArray<SBP>> GetPartialCandidateNDSBPsNegativeData { get; } = new()
-    {
-        {
-            new DistributedType(new(DataTypes.Float32, new[] { 1, 8, 384, 8192 }), new SBP[] { SBP.P, SBP.P }, new Placement(new[] { 8, 4 }, "bt")),
-            new SBP[] { SBP.S(1), SBP.S(1) }
-        },
-    };
-
-    [Fact]
-    public void TestEffiecicy()
-    {
-        var burst = 256;
-        var type1 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(1), SBP.S(2) }, new(new[] { 8, 4 }, "bt"));
-        var eff1 = DistributedUtility.GetDividedTensorEfficiency(type1, burst);
-
-        var type2 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(1), SBP.S(3) }, new(new[] { 8, 4 }, "bt"));
-        var eff2 = DistributedUtility.GetDividedTensorEfficiency(type2, burst);
-
-        var type3 = new DistributedType(new TensorType(DataTypes.Float32, new[] { 1, 64, 384, 8192 }), new[] { SBP.S(3), SBP.S(3) }, new(new[] { 8, 4 }, "bt"));
-        var eff3 = DistributedUtility.GetDividedTensorEfficiency(type3, burst);
-        Assert.True(eff1 > eff2);
-        Assert.True(eff2 > eff3);
-    }
-
-    [Fact]
-    public void TestGetPartialCandidateNDSBPs()
-    {
-        var placement = new Placement(new[] { 8, 4 }, "bt");
-        var type = new DistributedType(new(DataTypes.Float32, new[] { 1, 384, 8192 }), new SBP[] { SBP.P, SBP.S(2) }, placement);
-        var candidateSbps = Utilities.DistributedUtility.GetPartialCandidateNDSBPs(type);
-
-        Assert.Equal(0, candidateSbps.Count(ndsbp => ndsbp == new IRArray<SBP>(new SBP[] { SBP.S(2), SBP.S(2) })));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetPartialCandidateNDSBPsNegativeData))]
-    public void TestGetPartialCandidateNDSBPsNegative(DistributedType inType, IRArray<SBP> negativeNdsbp)
-    {
-        var candidateSbps = Utilities.DistributedUtility.GetPartialCandidateNDSBPs(inType);
-        Assert.Equal(0, candidateSbps.Count(ndsbp => ndsbp == negativeNdsbp));
-    }
-}
diff --git a/src/Nncase.Tests/Simulator/UnitTestInterop.cs b/src/Nncase.Tests/Simulator/UnitTestInterop.cs
index f262ec7812..7f3440aec1 100644
--- a/src/Nncase.Tests/Simulator/UnitTestInterop.cs
+++ b/src/Nncase.Tests/Simulator/UnitTestInterop.cs
@@ -25,7 +25,9 @@ public UnitTestInterop()
         var y = x + 1.0f;
         var main = new Function("main", y, new[] { x });
         var module = new IRModule(main);
-        var target = CompilerServices.GetTarget(XPUTarget.Kind);
+
+        // var target = CompilerServices.GetTarget(XPUTarget.Kind);
+        var target = CompilerServices.GetTarget("stackvm");
         var modelBuilder = new ModelBuilder(target, CompileOptions);
         var linkedModel = modelBuilder.Build(module);
         using var output = new MemoryStream();
diff --git a/src/Nncase.Tests/Targets/UnitTestXPUTarget.cs b/src/Nncase.Tests/Targets/UnitTestXPUTarget.cs
deleted file mode 100644
index 52b4748fc2..0000000000
--- a/src/Nncase.Tests/Targets/UnitTestXPUTarget.cs
+++ /dev/null
@@ -1,299 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
-using Nncase.CodeGen;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.IR.Tensors;
-using Nncase.Runtime.Interop;
-using Nncase.Targets;
-using Nncase.Tests.TestFixture;
-using Nncase.Utilities;
-using Xunit;
-using static Nncase.IR.F.Tensors;
-using GetItem = Nncase.IR.Tensors.GetItem;
-
-namespace Nncase.Tests.Targets;
-
-[AutoSetupTestMethod(InitSession = true)]
-public class UnitTestXPUTarget : TestClassBase
-{
-    public UnitTestXPUTarget()
-    {
-        DefaultTargetName = XPUTarget.Kind;
-    }
-
-    public static IEnumerable<object[]> TestGetItemData =>
-        new[]
-        {
-            new object[] { new[] { 0, 1 } },
-            new object[] { new[] { 0, -1 } },
-        };
-
-    public static IEnumerable<object[]> TestIfData =>
-        new[]
-        {
-            new object[] { true },
-            new object[] { false },
-        };
-
-    [Fact]
-    [AutoSetupTestMethod(InitSession = false)]
-    public void TestXPUTargetKind()
-    {
-        Assert.Equal("XPU", XPUTarget.Kind);
-    }
-
-    [Fact]
-    [AutoSetupTestMethod(InitSession = false)]
-    public void TestCreateXPUTarget()
-    {
-        var target = CompilerServices.GetTarget(XPUTarget.Kind);
-        Assert.NotNull(target);
-    }
-
-    [Theory]
-    [CombinatorialData]
-    public void TestCreateStackVMModuleBuilder([CombinatorialValues("stackvm")] string moduleKind)
-    {
-        var moduleBuilder = CompileSession.Target.CreateModuleBuilder(moduleKind, CompileOptions);
-        Assert.NotNull(moduleBuilder);
-    }
-
-    [Fact]
-    public void TestSimpleCodeGen()
-    {
-        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
-        var y = x + 1.0f;
-        TestCodeGen(y, new[] { x });
-    }
-
-    [Fact]
-    public void TestCodeGenUseVarMultiTimes()
-    {
-        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
-        var y = x + 1.0f + x;
-        TestCodeGen(y, new[] { x });
-    }
-
-    [Fact]
-    public void TestCodeGenTuple()
-    {
-        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
-        var y = x + 1.0f + x;
-        var z = y * 2.0f;
-        TestCodeGen(new IR.Tuple(y, z), new[] { x });
-    }
-
-    [Fact]
-    public void TestCodeGenVisitLeafVar()
-    {
-        var main = new Function(new Var(), Array.Empty<Var>());
-        var module = new IRModule(main);
-        var modelBuilder = CompileSession.GetRequiredService<IModelBuilder>();
-        Assert.Throws<InvalidOperationException>(() => modelBuilder.Build(module));
-    }
-
-    [Fact]
-    public void TestSimpleBinary()
-    {
-        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
-        var y = x + 1.0f;
-        var main = new Function("main", y, new[] { x });
-        var module = new IRModule(main);
-        GenerateKModelAndRun(module, new[] { 1.0f }, new[] { 2.0f });
-    }
-
-    [Fact]
-    public void TestSimpleUnary()
-    {
-        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
-        var y = IR.F.Math.Log(x);
-        var main = new Function("main", y, new[] { x });
-        var module = new IRModule(main);
-        GenerateKModelAndRun(module, new[] { 1.0f }, new[] { MathF.Log(1.0f) });
-    }
-
-    [Fact]
-    public void TestCodegenCallParamOrder()
-    {
-        // order is true: x - 3 = 2 - 3 = -1
-        // order is false: 3 - x = 3 - 2 = 1
-        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
-        var y = x - 3f;
-        var main = new Function("main", y, new[] { x });
-        GenerateKModelAndRunFromFn(main, new[] { 2f }, (Tensor)new[] { -1f });
-    }
-
-    [Fact]
-    public void TestSimpleTupleOutput()
-    {
-        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
-        var main = new Function("main", new IR.Tuple(x + 1.0f, x * 3.0f), new[] { x });
-        var module = new IRModule(main);
-        GenerateKModelAndRun(module, new[] { 1.0f }, new[] { (Tensor)2.0f, 3.0f });
-    }
-
-    [Fact]
-    public void TestTupleOrder()
-    {
-        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
-        var main = new Function("main", new IR.Tuple(x + 1.0f, x + 2f, x + 3f), new[] { x });
-        GenerateKModelAndRunFromFn(main, new[] { 1f }, new[] { (Tensor)2f, 3f, 4f });
-    }
-
-    [Theory]
-    [MemberData(nameof(TestGetItemData))]
-    public void TestGetItem(int[] index)
-    {
-        var input = Tensor.From(new[] { 1, 2, 3, 4, 5, 6 }, new[] { 1, 2, 3 });
-        var x = new Var("x", new TensorType(DataTypes.Int32, new[] { 1, 2, 3 }));
-        var second = GetItem(x, index);
-        var main = new Function("main", second, new[] { x });
-        var dict = new Dictionary<Var, IValue>() { { x, Value.FromTensor(input) } };
-        GenerateKModelAndRunFromFn(main, input, second.Evaluate(dict).AsTensor());
-    }
-
-    [Fact]
-    public void TestCallFunction()
-    {
-        var a = new Var("a");
-        var b = a + 1.0f;
-        var funcA = new Function("funcA", b, new[] { a });
-
-        var x = new Var("x");
-        var y = new Call(funcA, x + 1.0f);
-        var main = new Function("main", y, new[] { x });
-        var module = new IRModule(main);
-        module.Add(funcA);
-        GenerateKModelAndRun(module, new[] { 1.0f }, new[] { 3.0f });
-    }
-
-    [Theory]
-    [MemberData(nameof(TestIfData))]
-    public void TestIf(bool input)
-    {
-        var condVar = new Var(new TensorType(DataTypes.Boolean, Shape.Scalar));
-        var then = IR.F.Math.Abs(3f);
-        var @else = IR.F.NN.Relu(Cast(3, DataTypes.Float32));
-        var @if = IR.F.Math.Abs(new If(condVar, then, @else));
-
-        Assert.True(@if.InferenceType());
-        var main = new Function("main", @if, new[] { condVar });
-
-        var output = @if.Evaluate(new Dictionary<Var, IValue> { { condVar, Value.FromTensor(input) } }).AsTensor();
-        GenerateKModelAndRunFromFn(main, input, output);
-    }
-
-    [Fact]
-    public void TestStackVMNestIf()
-    {
-        var condVar = new Var(new TensorType(DataTypes.Boolean, Shape.Scalar));
-        _ = (Expr)3 - 1;
-        var @else = (Expr)3 + 1;
-        var elseThen = (Expr)8 * 8;
-        var elsif = new If(condVar, elseThen, @else);
-
-        var main = new Function("main", 2 * elsif, new[] { condVar });
-
-        var input = (Tensor)true;
-        var output = (Tensor)128;
-        GenerateKModelAndRunFromFn(main, input, output);
-    }
-
-    [Fact]
-    public void TestNestIfWithThenBegin()
-    {
-        CompileOptions.DumpFlags = DumpFlags.CodeGen;
-        var condVar = new Var(new TensorType(DataTypes.Boolean, Shape.Scalar));
-        var cast = Cast(condVar, DataTypes.Int32);
-        var i = new If(condVar, cast * new If(condVar, 3 + cast, 2), 6);
-        var main = new Function("main", i, new[] { condVar });
-        Dumpper.DumpIR(main, "main");
-        var input = (Tensor)true;
-        var output = (Tensor)4;
-        GenerateKModelAndRunFromFn(main, input, output);
-    }
-
-    [Fact]
-    public void TestNestIfWithElseBegin()
-    {
-        var condVar = new Var(new TensorType(DataTypes.Boolean, Shape.Scalar));
-        var i = new If(condVar, 3, new If(condVar, 1, 2));
-        var main = new Function("main", i, new[] { condVar });
-        var input = (Tensor)false;
-        var output = (Tensor)2;
-        GenerateKModelAndRunFromFn(main, input, output);
-    }
-
-    private void TestCodeGen(Expr body, Var[] vars, [CallerMemberName] string? name = null)
-    {
-        var main = new Function("main", body, vars);
-        var module = new IRModule(main);
-        var modelBuilder = CompileSession.GetRequiredService<IModelBuilder>();
-        var linkedModel = modelBuilder.Build(module);
-        using var output = File.Open($"{name}.kmodel", FileMode.Create);
-        linkedModel.Serialize(output);
-        Assert.NotEqual(0, output.Length);
-    }
-
-    private void GenerateKModelAndRun(IRModule module, Tensor input, Tensor[] expectedOutput, [CallerMemberName] string? name = null)
-    {
-        var modelBuilder = CompileSession.GetRequiredService<IModelBuilder>();
-        var linkedModel = modelBuilder.Build(module);
-        using (var output = File.Open($"{name}.kmodel", FileMode.Create))
-        {
-            linkedModel.Serialize(output);
-            Assert.NotEqual(0, output.Length);
-        }
-
-        byte[] kmodel;
-        using (var output = new MemoryStream())
-        {
-            linkedModel.Serialize(output);
-            kmodel = output.ToArray();
-        }
-
-        var interp = RTInterpreter.Create();
-        interp.LoadModel(kmodel);
-        var entry = interp.Entry;
-        Assert.NotNull(entry);
-
-        var rtInput = RTTensor.FromTensor(input);
-        var rtOutput = entry!.Invoke(rtInput);
-        var rtOutputs = rtOutput is RTTensor t ? new[] { t } : ((RTTuple)rtOutput).Fields.Cast<RTTensor>().ToArray();
-        Assert.Equal(expectedOutput.Length, rtOutputs.Length);
-
-        for (int i = 0; i < rtOutputs.Length; i++)
-        {
-            var outBuffer = rtOutputs[i].Buffer.Buffer.AsHost()!;
-            using (var mmOwner = outBuffer.Map(RTMapAccess.Read))
-            {
-                Assert.Equal(expectedOutput[i].BytesBuffer.ToArray(), mmOwner.Memory.Span.ToArray());
-            }
-        }
-    }
-
-    private void GenerateKModelAndRun(IRModule module, Tensor input, Tensor expectedOutput, [CallerMemberName] string? name = null)
-    {
-        GenerateKModelAndRun(module, input, new[] { expectedOutput }, name);
-    }
-
-    private void GenerateKModelAndRunFromFn(Function fn, Tensor input, Tensor expectedOutput, [CallerMemberName] string? name = null)
-    {
-        GenerateKModelAndRun(new IRModule(fn), input, new[] { expectedOutput }, name);
-    }
-
-    private void GenerateKModelAndRunFromFn(Function fn, Tensor input, Tensor[] expectedOutput, [CallerMemberName] string? name = null)
-    {
-        GenerateKModelAndRun(new IRModule(fn), input, expectedOutput, name);
-    }
-}
diff --git a/src/Nncase.Tests/Targets/UnitTestXPUTargetTiling.cs b/src/Nncase.Tests/Targets/UnitTestXPUTargetTiling.cs
deleted file mode 100644
index e335024080..0000000000
--- a/src/Nncase.Tests/Targets/UnitTestXPUTargetTiling.cs
+++ /dev/null
@@ -1,961 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
-using NetFabric.Hyperlinq;
-using Nncase.CodeGen;
-using Nncase.IR;
-using Nncase.IR.F;
-using Nncase.IR.Imaging;
-using Nncase.IR.Math;
-using Nncase.IR.NN;
-using Nncase.IR.Tensors;
-using Nncase.Runtime.Interop;
-using Nncase.Targets;
-using Nncase.Tests.TestFixture;
-using Nncase.Utilities;
-using Xunit;
-using static Nncase.IR.F.Tensors;
-using GetItem = Nncase.IR.Tensors.GetItem;
-
-namespace Nncase.Tests.Targets;
-
-[AutoSetupTestMethod(InitSession = true)]
-public class UnitTestXPUTargetTiling : TestClassBase
-{
-    public UnitTestXPUTargetTiling()
-    {
-        DefaultTargetName = XPUTarget.Kind;
-#if DEBUG
-        CompileOptions.DumpFlags = Diagnostics.DumpFlags.PassIR | Diagnostics.DumpFlags.Rewrite | Diagnostics.DumpFlags.CodeGen | Diagnostics.DumpFlags.EGraphCost | Diagnostics.DumpFlags.Tiling;
-#endif
-    }
-
-    [Theory]
-
-    // [ClassData(typeof(TilingCaseMHA))]
-    // [ClassData(typeof(TilingCaseBinaryMul))]
-    // [ClassData(typeof(TilingCaseUnary))]
-    // [ClassData(typeof(TilingCaseMatmul))]
-    // [ClassData(typeof(TilingCaseLayerNorm))]
-    // [ClassData(typeof(TilingCaseGather))]
-    // [ClassData(typeof(TilingCaseSoftmax))]
-    // [ClassData(typeof(TilingCaseSlice))]
-    // [ClassData(typeof(TilingCaseConcat))]
-    // [ClassData(typeof(TilingCaseTranspose))]
-    // [ClassData(typeof(TilingCaseReshape1))]
-    // [ClassData(typeof(TilingCaseReshape2))]
-    // [ClassData(typeof(TilingCaseMatmulUnary))]
-    // [ClassData(typeof(TilingCaseConv2D))]
-    // [ClassData(typeof(TilingCaseReduceArg))]
-    // [ClassData(typeof(TilingCaseReduceArg2))]
-    // [ClassData(typeof(TilingCaseInstanceNorm))]
-    // [ClassData(typeof(TilingCaseEncoderTail))]
-    // [ClassData(typeof(TilingCaseResize))]
-    // [ClassData(typeof(TilingCaseCast))]
-    // [ClassData(typeof(TilingCaseBinaryAdd))]
-    // [ClassData(typeof(TilingCaseGatherBinary))]
-    // [ClassData(typeof(TilingCaseLayerNormBinary))]
-    // [ClassData(typeof(TilingCaseExpand))]
-    // [ClassData(typeof(TilingCaseSDMHA))]
-    [ClassData(typeof(TilingCaseClamp))]
-    public async Task TestXpuFunction(Function main, Tensor[] inputs)
-    {
-        var module = new IR.IRModule(main);
-        var parameterLength = main.Parameters.Length;
-        using (new Diagnostics.DumpScope(main.Name, CompileOptions.DumpFlags))
-        {
-#if DEBUG
-            for (var i = 0; i < parameterLength; i++)
-            {
-                using (var fs = Diagnostics.DumpScope.Current.OpenFile($"input_{i}.bin"))
-                {
-                    fs.Write(inputs[i].BytesBuffer);
-                }
-            }
-
-            for (var i = 0; i < inputs.Length - parameterLength; i++)
-            {
-                using (var fs = Diagnostics.DumpScope.Current.OpenFile($"output_{i}.bin"))
-                {
-                    fs.Write(inputs[parameterLength + i].BytesBuffer);
-                }
-            }
-#endif
-            await Compile(module);
-            var outputs = Testing.RunKModel(File.ReadAllBytes(Path.Join(Diagnostics.DumpScope.Current.Directory, "test.kmodel")), Diagnostics.DumpScope.Current.Directory, inputs).AsTensors();
-#if DEBUG
-            for (int i = 0; i < outputs.Length; i++)
-            {
-                using (var fs = Diagnostics.DumpScope.Current.OpenFile($"actual_{i}.bin"))
-                {
-                    fs.Write(outputs[i].BytesBuffer);
-                }
-            }
-#endif
-            var cos = Tests.Comparator.CosSimilarity(outputs, inputs[parameterLength..]);
-            Assert.True(cos.All(c => c > 0.999), string.Join("\n", cos.Select((c, i) => $"the outputs[{i}] cos is {c}!")));
-        }
-    }
-
-    private async Task Compile(IRModule module)
-    {
-        var compiler = CompileSession.Compiler;
-        compiler.ImportIRModule(module);
-        await compiler.CompileAsync();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("test.kmodel"))
-        {
-            compiler.Gencode(fs);
-        }
-    }
-}
-
-internal sealed class TilingCaseSlice : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseSlice()
-    {
-        var shape = new[] { 1, 1, 64, 128 };
-        var in_a = new Var("in_a", new TensorType(DataTypes.Float32, shape));
-
-        Fusion fusion;
-        Var fin_a;
-        {
-            fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, shape));
-            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Slice()), fin_a, new[] { 64 }, new[] { 128 }, new[] { 3 }, new[] { 1 });
-            fusion = new Fusion("xpu", v1, fin_a);
-        }
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin_a, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        var main = new Function("slice", new Call(fusion, in_a), new[] { in_a });
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseConcat : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseConcat()
-    {
-        var in_a_shape = new[] { 1, 64, 384, 64 };
-        var in_b_shape = new[] { 1, 64, 384, 64 };
-        var in_a = new Var("in_a", new TensorType(DataTypes.Float32, in_a_shape));
-        var in_b = new Var("in_b", new TensorType(DataTypes.Float32, in_b_shape));
-
-        Fusion fusion;
-        Var fin_a, fin_b;
-        {
-            fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, in_a_shape));
-            fin_b = new Var("fin_b", new TensorType(DataTypes.Float32, in_b_shape));
-            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Concat(3)), new IR.Tuple(fin_a, fin_b));
-            fusion = new Fusion("xpu", v1, fin_a, fin_b);
-        }
-
-        var input_a_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, in_a_shape).Evaluate().AsTensor();
-        var input_b_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 4, in_b_shape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin_a, Value.FromTensor(input_a_tensor) },
-            { fin_b, Value.FromTensor(input_b_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        var main = new Function("concat", new Call(fusion, in_a, in_b), new[] { in_a, in_b });
-        Add(main, new[] { input_a_tensor, input_b_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseMatmulLayerNorm : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseMatmulLayerNorm()
-    {
-        var hid_in = new Var("hidden_in", new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 }));
-
-        Fusion fusion;
-        {
-            var scale = IR.F.Tensors.ConstantOfShape(new[] { 8192 }, 1.0f).Evaluate().AsTensor();
-            var bias = IR.F.Tensors.ConstantOfShape(new[] { 8192 }, 0.0f).Evaluate().AsTensor();
-            var weights = IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 64, 8192, 128 }).Evaluate().AsTensor();
-            _ = IR.F.Random.Normal(DataTypes.Float32, new[] { 384, 128 }).Evaluate().AsTensor();
-
-            var fin = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 }));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.LayerNorm(2, 1e-6f, false)), fin, scale, bias);
-            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Unsqueeze()), v0, new[] { 0 });
-            var v2 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.MatMul()), v1, weights);
-            var v3 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Unary(UnaryOp.Exp)), v2);
-
-            fusion = new Fusion("xpu", v3, fin);
-        }
-
-        var main = new Function("matmul_layernorm", new Call(fusion, hid_in), new[] { hid_in });
-        Add(main, Array.Empty<Tensor>());
-    }
-}
-
-internal sealed class TilingCaseMHA : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseMHA()
-    {
-        var hid_in = new Var("hidden_in", new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 }));
-        var pos_ids = new Var("position_ids", new TensorType(DataTypes.Int64, new[] { 1, 384 }));
-
-        Fusion fusion;
-        {
-            var scale = IR.F.Tensors.ConstantOfShape(new[] { 8192 }, 1.0f).Evaluate().AsTensor();
-            var bias = IR.F.Tensors.ConstantOfShape(new[] { 8192 }, 0.0f).Evaluate().AsTensor();
-            var weights = IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 64, 8192, 128 }).Evaluate().AsTensor();
-            var gdata = IR.F.Random.Normal(DataTypes.Float32, new[] { 384, 128 }).Evaluate().AsTensor();
-
-            var fin = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 384, 8192 }));
-            var fin2 = new Var("input2", new TensorType(DataTypes.Int64, new[] { 1, 384 }));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.LayerNorm(2, 1e-6f, false)), fin, scale, bias);
-            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Unsqueeze()), v0, new[] { 0 });
-            var v2 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.MatMul()), v1, weights);
-            var v3 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Slice()), v2, new[] { 64 }, new[] { 128 }, new[] { 3 }, new[] { 1 });
-            var v4 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Unary(UnaryOp.Neg)), v3);
-            var v5 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Slice()), v2, new[] { 0 }, new[] { 64 }, new[] { 3 }, new[] { 1 });
-            var v6 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Concat(3)), new IR.Tuple(v4, v5));
-
-            var v7 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Gather(0)), gdata, fin2);
-            var v8 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Unsqueeze()), v7, new[] { 0 });
-
-            var v9 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Binary(BinaryOp.Mul)), v2, v8);
-            var v10 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Binary(BinaryOp.Mul)), v6, v8);
-            var v11 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Binary(BinaryOp.Add)), v9, v10);
-
-            fusion = new Fusion("xpu", v11, fin, fin2);
-        }
-
-        var main = new Function("mha_qk", new Call(fusion, hid_in, pos_ids), new[] { hid_in, pos_ids });
-        Add(main, Array.Empty<Tensor>());
-    }
-}
-
-internal sealed class TilingCaseBinaryAdd : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseBinaryAdd()
-    {
-        var lhsShape = new[] { 1, 77, 768 };
-        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, lhsShape));
-        var rhsShape = new[] { 1, 77, 768 };
-        var rhs = new Var("lhs", new TensorType(DataTypes.Float32, rhsShape));
-        var main = new Function("binary_add", lhs + rhs, new[] { lhs, rhs });
-
-        var lhs_tensor = IR.F.Random.Uniform(DataTypes.Float32, 1, 0, 2, lhsShape).Evaluate().AsTensor();
-        var rhs_tensor = IR.F.Random.Uniform(DataTypes.Float32, 1, 0, 2, rhsShape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { lhs, Value.FromTensor(lhs_tensor) },
-            { rhs, Value.FromTensor(rhs_tensor) },
-        };
-        var output = main.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { lhs_tensor, rhs_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseBinaryMul : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseBinaryMul()
-    {
-        var lhsShape = new[] { 1, 64, 384, 128 };
-        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, lhsShape));
-        var rhsShape = new[] { 1, 1, 384, 128 };
-        var rhs = new Var("lhs", new TensorType(DataTypes.Float32, rhsShape));
-        var main = new Function("binary_mul", lhs * rhs, new[] { lhs, rhs });
-
-        var lhs_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, lhsShape).Evaluate().AsTensor();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
-        {
-            fs.Write(lhs_tensor.BytesBuffer);
-        }
-
-        var rhs_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, rhsShape).Evaluate().AsTensor();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_1.bin"))
-        {
-            fs.Write(rhs_tensor.BytesBuffer);
-        }
-
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { lhs, Value.FromTensor(lhs_tensor) },
-            { rhs, Value.FromTensor(rhs_tensor) },
-        };
-        var output = main.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { lhs_tensor, rhs_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseUnary : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseUnary()
-    {
-        var shape = new[] { 1, 384, 2048 };
-        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
-        var main = new Function("unary", IR.F.Math.Unary(UnaryOp.Asin, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
-        {
-            fs.Write(input_tensor.BytesBuffer);
-        }
-
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { input, Value.FromTensor(input_tensor) },
-        };
-        var output = main.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseMatmul : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseMatmul()
-    {
-        var lhsShape = new[] { 1, 64, 384, 8192 };
-        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, lhsShape));
-        var rhsShape = new[] { 1, 64, 8192, 128 };
-        var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, rhsShape).Evaluate().AsTensor().Cast<float>();
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, lhsShape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.MatMul()), fin, rhs);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("matmul", new Call(fusion, lhs), new[] { lhs });
-
-        var lhs_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, lhsShape).Evaluate().AsTensor();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
-        {
-            fs.Write(lhs_tensor.BytesBuffer);
-        }
-
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(lhs_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { lhs_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseMatmulUnary : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseMatmulUnary()
-    {
-        var lhsShape = new[] { 1, 64, 384, 8192 };
-        var lhs = new Var("lhs", new TensorType(DataTypes.Float32, lhsShape));
-        var rhsShape = new[] { 1, 64, 8192, 128 };
-        var rhs = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, rhsShape).Evaluate().AsTensor().Cast<float>();
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, lhsShape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.MatMul()), fin, rhs);
-            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Unary(UnaryOp.Neg)), v0);
-            fusion = new Fusion("xpu", v1, fin);
-        }
-
-        var main = new Function("matmul_unary", new Call(fusion, lhs), new[] { lhs });
-
-        var lhs_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, lhsShape).Evaluate().AsTensor();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
-        {
-            fs.Write(lhs_tensor.BytesBuffer);
-        }
-
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(lhs_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { lhs_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseLayerNorm : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseLayerNorm()
-    {
-        var shape = new[] { 1, 384, 8192 };
-        int axis = 2;
-        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
-        var scale = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { shape[2] }).Evaluate().AsTensor();
-        var bias = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 3, new[] { shape[2] }).Evaluate().AsTensor();
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, shape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.LayerNorm(axis, 1e-5f, false)), fin, scale, bias);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("layernorm", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseLayerNormBinary : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseLayerNormBinary()
-    {
-        var shape = new[] { 1, 77, 768 };
-        int axis = 2;
-        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
-        var scale = IR.F.Random.Normal(DataTypes.Float32, new[] { shape[2] }).Evaluate().AsTensor();
-        var bias = IR.F.Random.Normal(DataTypes.Float32, new[] { shape[2] }).Evaluate().AsTensor();
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, shape));
-            var v0 = new Call(new IR.NN.LayerNorm(axis, 1e-5f, true), fin, scale, bias);
-            var v1 = IR.F.NN.Swish(v0, 1.602f);
-            var v2 = IR.F.Math.Binary(BinaryOp.Add, fin, v1);
-            fusion = new Fusion("xpu", v2, fin);
-        }
-
-        var main = new Function("layernorm_binary", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, shape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseInstanceNorm : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseInstanceNorm()
-    {
-        var shape = new[] { 1, 32, 65536 };
-        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
-        var scale = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { shape[1] }).Evaluate().AsTensor();
-        var bias = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 3, new[] { shape[1] }).Evaluate().AsTensor();
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, shape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.InstanceNormalization()), fin, scale, bias, 1e-5);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("instance_norm", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
-        {
-            fs.Write(input_tensor.BytesBuffer);
-        }
-
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseGather : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseGather()
-    {
-        var inputShape = new[] { 384, 128 };
-        var axisShape = new[] { 1, 384 };
-        int axis = 0;
-        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-        var indices = IR.F.Random.Uniform(DataTypes.Int64, 384, 0, 2, axisShape).Evaluate().AsTensor();
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Gather(axis)), fin, indices);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("gather", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseGatherBinary : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseGatherBinary()
-    {
-        var inputShape = new[] { 49408, 768 };
-        var indicesShape = new[] { 1, 77 };
-        int axis = 0;
-        var input = Const.FromValue(IR.F.Random.Normal(DataTypes.Float32, 1, 0, 2, inputShape).Evaluate());
-        var indices = new Var("indices", new TensorType(DataTypes.Int32, indicesShape));
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("indices", new TensorType(DataTypes.Int32, indicesShape));
-            var v0 = new Call(new IR.Tensors.Gather(axis), input, fin);
-            var v1 = new Call(new IR.Math.Binary(BinaryOp.Add), v0, IR.F.Random.Normal(DataTypes.Float32, new[] { 1, 77, 768 }).Evaluate().AsTensor());
-            fusion = new Fusion("xpu", v1, fin);
-        }
-
-        var main = new Function("gather_binary", new Call(fusion, indices), new[] { indices });
-
-        var input_tensor = IR.F.Random.Uniform(DataTypes.Int32, 1, 0, 2, indicesShape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseSoftmax : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseSoftmax()
-    {
-        var inputShape = new[] { 1, 64, 384, 384 };
-        int axis = 3;
-        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.Softmax()), fin, axis);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("softmax", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseTranspose : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseTranspose()
-    {
-        var shape = new[] { 1, 1, 64, 128 };
-        var in_a = new Var("in_a", new TensorType(DataTypes.Float32, shape));
-        var perm = new[] { 0, 2, 3, 1 };
-
-        Fusion fusion;
-        Var fin_a;
-        {
-            fin_a = new Var("fin_a", new TensorType(DataTypes.Float32, shape));
-            var v1 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Transpose()), fin_a, perm);
-            fusion = new Fusion("xpu", v1, fin_a);
-        }
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin_a, Value.FromTensor(input_tensor) },
-        };
-        _ = fusion.Body.Evaluate(feedDict).AsTensor();
-        _ = new Function("transpose", new Call(fusion, in_a), new[] { in_a });
-    }
-}
-
-internal sealed class TilingCaseReshape1 : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseReshape1()
-    {
-        var inputShape = new[] { 1, 384, 128 };
-        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-        var newShape = new[] { 1, 1, 384, 128 };
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Reshape()), fin, newShape);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("reshape1", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseReshape2 : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseReshape2()
-    {
-        var inputShape = new[] { 1, 384, 64, 128 };
-        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-        var newShape = new[] { 1, 384, 8192 };
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Reshape()), fin, newShape);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("reshape2", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseReduceArg : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseReduceArg()
-    {
-        var inputShape = new[] { 1, 77 };
-        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64)), fin, 1, false, false);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("argmax", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseReduceArg2 : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseReduceArg2()
-    {
-        var inputShape = new[] { 32, 64, 128, 512 };
-        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64)), fin, 2, true, false);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("argmax2", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseEncoderTail : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseEncoderTail()
-    {
-        var v_16 = new Var("v16", new TensorType(DataTypes.Int32, new[] { 1, 77 }));
-        var v_17 = new Var("v17", new TensorType(DataTypes.Float32, new[] { 1, 77, 768 }));
-        var v0 = IR.F.NN.LayerNorm(2, 1E-05f, v_17, IR.F.Tensors.ConstantOfShape(new[] { 768 }, 1.0f), IR.F.Tensors.ConstantOfShape(new[] { 768 }, 0.0f), true); // f32[1,77,768]
-        var v1 = IR.F.Tensors.Reshape(v0, new[] { 77, 768 }); // f32[77,768]
-        var v2 = IR.F.Tensors.ReduceArg(ReduceArgOp.ArgMax, DataTypes.Int64, v_16, -1, false, false); // i64[1]
-        var v3 = IR.F.Math.Binary(BinaryOp.Add, v2, 1L); // i64[1]
-        var v4 = IR.F.Tensors.Gather(v1, 0, v3); // f32[1,768]
-        var main = new Function("encoderTail", v4, new[] { v_16, v_17 });
-
-        var input_16 = IR.F.Tensors.Cast(IR.F.Random.Uniform(DataTypes.Float32, 60, 1, 2, new[] { 1, 77 }), DataTypes.Int32).Evaluate().AsTensor();
-        var input_17 = IR.F.Random.Normal(DataTypes.Float32, 2, 4, 3, new[] { 1, 77, 768 }).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { v_16, Value.FromTensor(input_16) },
-            { v_17, Value.FromTensor(input_17) },
-        };
-        var output = main.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_16, input_17, output });
-    }
-}
-
-internal sealed class TilingCaseConv2D : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseConv2D()
-    {
-        var inputShape = new[] { 8, 4, 64, 64 };
-        var input = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-        var weightsShape = new[] { 1, 4, 3, 3 };
-        var weights = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, weightsShape).Evaluate().AsTensor().Cast<float>();
-        var bias = IR.F.Random.Normal(DataTypes.Float32, 0, 2, 2, weightsShape.Take(1).ToArray()).Evaluate().AsTensor().Cast<float>();
-        var stride = new int[] { 1, 1 };
-        var padding = new int[,] { { 0, 0 }, { 0, 0 } };
-        var dilation = new int[] { 1, 1 };
-        var groups = 1;
-        var fusedClamp = new float[] { float.NegativeInfinity, float.PositiveInfinity };
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, inputShape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.NN.Conv2D(PadMode.Constant)), fin, weights, bias, stride, padding, dilation, groups, fusedClamp);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("conv2d", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, inputShape).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-        {
-            { fin, Value.FromTensor(input_tensor) },
-        };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseResize : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseResize()
-    {
-        var shape = new[] { 1, 512, 64, 64 };
-        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, shape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Imaging.ResizeImage(ImageResizeMode.NearestNeighbor, ImageResizeTransformationMode.Asymmetric, ImageResizeNearestMode.Floor, false)), fin, None.Default, new[] { 1, 512, 128, 128 }, None.Default, None.Default, None.Default);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("nearest_resize", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
-        {
-            fs.Write(input_tensor.BytesBuffer);
-        }
-
-        var feedDict = new Dictionary<Var, IValue>
-            {
-                { fin, Value.FromTensor(input_tensor) },
-            };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseCast : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseCast()
-    {
-        var shape = new[] { 1, 2 };
-        var input = new Var("input", new TensorType(DataTypes.Int64, shape));
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Int64, shape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Cast(DataTypes.Float32, CastMode.KDefault)), fin);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("cast", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Uniform(DataTypes.Int64, 100, 1, 2, shape).Evaluate().AsTensor();
-        using (var fs = Diagnostics.DumpScope.Current.OpenFile("input_0.bin"))
-        {
-            fs.Write(input_tensor.BytesBuffer);
-        }
-
-        var feedDict = new Dictionary<Var, IValue>
-            {
-                { fin, Value.FromTensor(input_tensor) },
-            };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseSDMHA : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseSDMHA()
-    {
-        var fin = new Var("var_4", new TensorType(DataTypes.Float32, new[] { 1, 77, 768 }));
-
-        Fusion fusion;
-        {
-            var v0 = IR.F.NN.LayerNorm(2, 1E-05f, fin, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), true); // f32[1,77,768]
-            var v1 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
-            var v2 = IR.F.Math.Binary(BinaryOp.Add, v1, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
-            var v3 = IR.F.Math.Binary(BinaryOp.Mul, v2, new[] { 0.125f }); // f32[12,77,64]
-            var v4 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
-            var v5 = IR.F.Math.Binary(BinaryOp.Add, v4, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
-            var v6 = IR.F.Tensors.Transpose(v5, new[] { 0, 2, 1 }); // f32[12,64,77]
-            var v7 = IR.F.Math.MatMul(v3, v6); // f32[12,77,77]
-            var v8 = IR.F.Math.Binary(BinaryOp.Add, v7, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 1, 77, 77 }).Evaluate().AsTensor()); // f32[12,77,77]
-            var v9 = IR.F.NN.Softmax(v8, 2); // f32[12,77,77]
-            var v10 = IR.F.Math.MatMul(v0, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 768, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
-            var v11 = IR.F.Math.Binary(BinaryOp.Add, v10, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 12, 1, 64 }).Evaluate().AsTensor()); // f32[12,77,64]
-            var v12 = IR.F.Math.MatMul(v9, v11); // f32[12,77,64]
-            var v13 = IR.F.Tensors.Transpose(v12, new[] { 1, 0, 2 }); // f32[77,12,64]
-            var v14 = IR.F.Tensors.Reshape(v13, new[] { 1L, 77L, 768L }); // f32[1,77,768]
-            var v15 = IR.F.Math.MatMul(v14, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768, 768 }).Evaluate().AsTensor()); // f32[1,77,768]
-            var v16 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), v15); // f32[1,77,768]
-            var v17 = IR.F.Math.Binary(BinaryOp.Add, fin, v16); // f32[1,77,768]
-            var v18 = IR.F.NN.LayerNorm(2, 1E-05f, v17, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), true); // f32[1,77,768]
-            var v19 = IR.F.Math.MatMul(v18, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768, 3072 }).Evaluate().AsTensor()); // f32[1,77,3072]
-            var v20 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 3072 }).Evaluate().AsTensor(), v19); // f32[1,77,3072]
-            var v21 = IR.F.NN.Swish(v20, 1.702f); // f32[1,77,3072]
-            var v22 = IR.F.Math.MatMul(v21, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 3072, 768 }).Evaluate().AsTensor()); // f32[1,77,768]
-            var v23 = IR.F.Math.Binary(BinaryOp.Add, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, new[] { 768 }).Evaluate().AsTensor(), v22); // f32[1,77,768]
-            var v24 = IR.F.Math.Binary(BinaryOp.Add, v17, v23); // f32[1,77,768]
-            fusion = new Fusion("xpu", new IR.Tuple(v17, v23, v24), new[] { fin });
-        }
-
-        var input = new Var("input", new TensorType(DataTypes.Float32, new[] { 1, 77, 768 }));
-        var main = new Function("sd_mha", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 0, new[] { 1, 77, 768 }).Evaluate().AsTensor();
-        var feedDict = new Dictionary<Var, IValue>
-            {
-                { fin, Value.FromTensor(input_tensor) },
-            };
-        var outputs = fusion.Body.Evaluate(feedDict).AsTensors();
-
-        Add(main, new[] { input_tensor }.Concat(outputs).ToArray());
-    }
-}
-
-internal sealed class TilingCaseExpand : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseExpand()
-    {
-        var shape = new[] { 1, 32, 1 };
-        var input = new Var("input", new TensorType(DataTypes.Int64, shape));
-        var newShape = new[] { 2, 32, 32 };
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Int64, shape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Tensors.Expand()), fin, newShape);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("expand", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Uniform(DataTypes.Int64, 100, 1, 2, shape).Evaluate().AsTensor();
-
-        var feedDict = new Dictionary<Var, IValue>
-            {
-                { fin, Value.FromTensor(input_tensor) },
-            };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}
-
-internal sealed class TilingCaseClamp : TheoryData<Function, Tensor[]>
-{
-    public TilingCaseClamp()
-    {
-        var shape = new[] { 1, 32, 32 };
-        var input = new Var("input", new TensorType(DataTypes.Float32, shape));
-
-        Fusion fusion;
-        Var fin;
-        {
-            fin = new Var("input", new TensorType(DataTypes.Float32, shape));
-            var v0 = new Call(new IR.XPU.XPUKernelOp(new IR.Math.Clamp()), fin, float.NegativeInfinity, float.PositiveInfinity);
-            fusion = new Fusion("xpu", v0, fin);
-        }
-
-        var main = new Function("clamp", new Call(fusion, input), new[] { input });
-
-        var input_tensor = IR.F.Random.Normal(DataTypes.Float32, 0, 1, 2, shape).Evaluate().AsTensor();
-
-        var feedDict = new Dictionary<Var, IValue>
-            {
-                { fin, Value.FromTensor(input_tensor) },
-            };
-        var output = fusion.Body.Evaluate(feedDict).AsTensor();
-
-        Add(main, new[] { input_tensor, output });
-    }
-}

From 69701ba82935d4b3b375af64d3821d145298c467 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 26 Oct 2023 16:20:53 +0800
Subject: [PATCH 285/308] fix csproj

---
 src/Nncase.Tests.TestFixture/TestClassBase.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Nncase.Tests.TestFixture/TestClassBase.cs b/src/Nncase.Tests.TestFixture/TestClassBase.cs
index 741e1e02f7..908f783dfb 100644
--- a/src/Nncase.Tests.TestFixture/TestClassBase.cs
+++ b/src/Nncase.Tests.TestFixture/TestClassBase.cs
@@ -38,7 +38,7 @@ public TestClassBase()
     /// <summary>
     /// Gets or sets default target name.
     /// </summary>
-    public virtual string DefaultTargetName { get; set; } = "stackvm";
+    public virtual string DefaultTargetName { get; set; } = IR.Callable.StackVMModuleKind;
 
     /// <summary>
     /// Gets test output root.

From fe7ee07de2225aa462c0636a58d0dfc5ae94dcaa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 26 Oct 2023 17:56:03 +0800
Subject: [PATCH 286/308] fix buffer schedule

---
 .../Extension/OrtKIExtensions.cs              |  5 +++
 src/Nncase.Evaluator/Math/Binary.cs           | 42 +++++++++++++------
 src/Nncase.Passes/DDrBufferSchdeulePass.cs    | 39 +++++++++--------
 3 files changed, 54 insertions(+), 32 deletions(-)

diff --git a/src/Nncase.Evaluator/Extension/OrtKIExtensions.cs b/src/Nncase.Evaluator/Extension/OrtKIExtensions.cs
index 92e2052521..e72ff79827 100644
--- a/src/Nncase.Evaluator/Extension/OrtKIExtensions.cs
+++ b/src/Nncase.Evaluator/Extension/OrtKIExtensions.cs
@@ -83,6 +83,11 @@ public static OrtDataType ToOrtType(this DataType dt)
             return type;
         }
 
+        if (dt is PointerType)
+        {
+            return OrtDataType.UInt64;
+        }
+
         throw new ArgumentOutOfRangeException("Unsupported DataType: " + dt);
     }
 
diff --git a/src/Nncase.Evaluator/Math/Binary.cs b/src/Nncase.Evaluator/Math/Binary.cs
index 7be3546234..8f91f52067 100755
--- a/src/Nncase.Evaluator/Math/Binary.cs
+++ b/src/Nncase.Evaluator/Math/Binary.cs
@@ -44,6 +44,14 @@ public IValue Visit(IEvaluateContext context, Binary binary)
             {
                 return Value.FromTensor(Tensor.FromScalar(Compute(binary.BinaryOp, lhs.ToScalar<uint>(), rhs.ToScalar<uint>())));
             }
+            else if (lhs.ElementType is PointerType && (rhs.ElementType == DataTypes.UInt32 || rhs.ElementType == DataTypes.UInt64))
+            {
+                return Value.FromTensor(Tensor.FromScalar(Compute(binary.BinaryOp, lhs.ToScalar<ulong>(), rhs.ToScalar<ulong>())));
+            }
+            else if ((lhs.ElementType == DataTypes.UInt32 || lhs.ElementType == DataTypes.UInt64) && rhs.ElementType is PointerType)
+            {
+                return Value.FromTensor(Tensor.FromScalar(Compute(binary.BinaryOp, lhs.ToScalar<ulong>(), rhs.ToScalar<ulong>())));
+            }
             else
             {
                 return Ort_compute(binary, lhs, rhs);
@@ -226,6 +234,18 @@ private IRType Visit(Binary target, DistributedType a, DistributedType b)
         _ => throw new ArgumentOutOfRangeException(nameof(op)),
     };
 
+    private ulong Compute(BinaryOp op, ulong a, ulong b) => op switch
+    {
+        BinaryOp.Add => a + b,
+        BinaryOp.Sub => a - b,
+        BinaryOp.Mul => a * b,
+        BinaryOp.Div => a / b,
+        BinaryOp.Mod => a % b,
+        BinaryOp.Min => System.Math.Min(a, b),
+        BinaryOp.Max => System.Math.Max(a, b),
+        _ => throw new ArgumentOutOfRangeException(nameof(op)),
+    };
+
     private bool Compute(BinaryOp op, bool a, bool b) => op switch
     {
         BinaryOp.LogicalAnd => a & b,
@@ -305,26 +325,24 @@ private IRType Visit(Binary target, TensorType lhs, TensorType rhs)
             return new InvalidType("The Binary Logical Only Accept The Boolean Datatype.");
         }
 
-        if (lhs is { DType: PointerType { ElemType: var letype } } && rhs is { DType: PointerType { ElemType: var retype } })
+        if (lhs is { DType: PointerType { ElemType: var letype } })
         {
-            if (letype == retype)
+            if ((rhs is { DType: PointerType { ElemType: var other } } && letype == other) || rhs.DType == DataTypes.UInt64 || rhs.DType == DataTypes.UInt32)
             {
                 return TensorType.Pointer(letype);
             }
-            else
-            {
-                return new InvalidType($"The Binary Lhs {CompilerServices.Print(lhs)} != Rhs {CompilerServices.Print(rhs)}");
-            }
-        }
 
-        if (lhs is { DType: PointerType { ElemType: var lt } } && rhs.DType == DataTypes.Int32)
-        {
-            return TensorType.Pointer(lt);
+            return new InvalidType($"The Binary Lhs {CompilerServices.Print(lhs)} != Rhs {CompilerServices.Print(rhs)}");
         }
 
-        if (lhs.DType == DataTypes.Int32 && rhs is { DType: PointerType { ElemType: var rt } })
+        if (rhs is { DType: PointerType { ElemType: var retype } })
         {
-            return TensorType.Pointer(rt);
+            if ((lhs is { DType: PointerType { ElemType: var other } } && retype == other) || lhs.DType == DataTypes.UInt64 || lhs.DType == DataTypes.UInt32)
+            {
+                return TensorType.Pointer(retype);
+            }
+
+            return new InvalidType($"The Binary Lhs {CompilerServices.Print(lhs)} != Rhs {CompilerServices.Print(rhs)}");
         }
 
         return TypeInference.BroadcastType(lhs, rhs);
diff --git a/src/Nncase.Passes/DDrBufferSchdeulePass.cs b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
index 16265f5e75..e695b88813 100644
--- a/src/Nncase.Passes/DDrBufferSchdeulePass.cs
+++ b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
@@ -113,6 +113,25 @@ public DDrBufferRewriter(Dictionary<string, Dictionary<MemoryLocation, long>> mo
 
     public PrimFunction Entry => (PrimFunction)VisitRoot!;
 
+    protected override Expr RewriteLeafBuffer(TIR.Buffer expr)
+    {
+        if (expr.MemSpan is { Location: TIR.MemoryLocation.Input or TIR.MemoryLocation.Output, Start: None, Size: TensorConst size } memSpan)
+        {
+            // input/output write into the FunctionUsage
+            if (!_functionUsage.TryGetValue(memSpan.Location, out var start))
+            {
+                start = 0;
+            }
+
+            _functionUsage[memSpan.Location] = start + size.Value.ToScalar<int>();
+            Changed = true;
+
+            return expr.With(memSpan: memSpan.With(start: Tensor.FromPointer((ulong)start, new PointerType(expr.ElemType, expr.Dimensions.ToArray().Select(d => ((TensorConst)d).Value.ToScalar<int>()).ToArray()))));
+        }
+
+        return expr;
+    }
+
     protected override TIR.MemSpan RewriteLeafMemSpan(TIR.MemSpan memSpan)
     {
         if (memSpan is { Location: MemoryLocation.Rdata, Start: Call { Target: IR.Buffers.DDrOf, Arguments: var arg } } && arg[0] is Const { ValueType: TensorType constType } @const)
@@ -147,26 +166,6 @@ protected override TIR.MemSpan RewriteLeafMemSpan(TIR.MemSpan memSpan)
             return memSpan.With(new TensorConst(Tensor.FromPointer((ulong)memRange.Min, new PointerType(constType.DType, constType.Shape))), memRange.Max - memRange.Min);
         }
 
-        // else if (memSpan.Location is MemoryLocation.Data)
-        // {
-        //     data write into the FunctionUsage
-        //     if (!_functionRdatas.Contains(physical))
-        //     {
-        //         if (!_functionUsage.TryGetValue(physical.Location, out var start))
-        //         {
-        //             start = 0;
-        //         }
-
-        // physical.Start = start;
-        //         _functionUsage[physical.Location] = start + physical.Size;
-        //         _functionRdatas.Add(physical);
-        //         Changed = true;
-        //     }
-        // }
-        // else if (memSpan.Location is MemoryLocation.SharedData)
-        // {
-        //     throw new NotSupportedException("Current Not Support!");
-        // }
         return memSpan;
     }
 

From 10aa876da582ee6204631c88885d08de92908dae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Mon, 30 Oct 2023 02:48:28 +0000
Subject: [PATCH 287/308] Add unet pytest

---
 tests/importer/onnx_/model/test_unet.py | 39 +++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 tests/importer/onnx_/model/test_unet.py

diff --git a/tests/importer/onnx_/model/test_unet.py b/tests/importer/onnx_/model/test_unet.py
new file mode 100644
index 0000000000..1871b37dd9
--- /dev/null
+++ b/tests/importer/onnx_/model/test_unet.py
@@ -0,0 +1,39 @@
+# Copyright 2019-2021 Canaan Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""System test: test demo"""
+# pylint: disable=invalid-name, unused-argument, import-outside-toplevel
+
+# from lzma import MODE_FAST
+# from xml.parsers.expat import model
+import pytest
+from onnx_test_runner import OnnxTestRunner
+
+
+def test_demo(request):
+    # runner = OnnxTestRunner(request.node.name, "/root/Workspace/nncase/tests/importer/onnx_/model/llama_config.toml")
+    runner = OnnxTestRunner("unet", "/root/Workspace/config/unet_config.toml")
+    # runner = OnnxTestRunner("unet")
+    #
+    model_file = "/root/Downloads/Models/unet/model.onnx"
+
+    # runner.set_shape_var({"batch_size": 1, "num_channels_latent": 4, "height_latent": 64, "width_latent": 64})
+    # runner.set_shape_var({"N": 384})
+    runner.set_shape_var({"batch_size": 2, "num_channels": 4, "height": 64, "width": 64, "steps": 2, "sequence_length": 77})
+    # runner.set_shape_var({"batch_size:1", "sequence_length:77"})
+    runner.run(model_file)
+
+
+if __name__ == "__main__":
+    pytest.main(
+        ['-vvs', __file__])

From 3324ff88ce58238ecfa87300728ab926476b74ed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 30 Oct 2023 11:19:51 +0800
Subject: [PATCH 288/308] add target's commands

---
 Directory.Packages.props                      |   3 +-
 .../Nncase.Modules.StackVM/StackVMModule.cs   |   1 +
 .../Targets/CPUTarget.cs                      |  95 ++++++++
 .../Nncase.Modules.StackVM/packages.lock.json |   7 +
 src/Nncase.Cli/Commands/Compile.cs            | 208 ------------------
 src/Nncase.Cli/Compile.cs                     | 131 +++++++++++
 src/Nncase.Cli/Program.CommandLine.cs         |  26 ---
 src/Nncase.Cli/Program.cs                     | 142 +++++++++++-
 src/Nncase.Cli/packages.lock.json             |  27 ++-
 src/Nncase.CodeGen/packages.lock.json         |   7 +
 src/Nncase.Compiler/Hosting/PluginLoader.cs   | 130 +++++------
 src/Nncase.Compiler/packages.lock.json        |  16 +-
 src/Nncase.Core/CompileOptions.cs             |   5 +
 src/Nncase.Core/ITarget.cs                    |  22 ++
 src/Nncase.Core/Nncase.Core.csproj            |   3 +-
 src/Nncase.Core/packages.lock.json            |   6 +
 src/Nncase.Diagnostics/packages.lock.json     |   7 +
 src/Nncase.EGraph/packages.lock.json          |   7 +
 src/Nncase.Evaluator/packages.lock.json       |   7 +
 src/Nncase.Graph/packages.lock.json           |   7 +
 src/Nncase.Importer/packages.lock.json        |   7 +
 src/Nncase.Passes/packages.lock.json          |   7 +
 src/Nncase.Quantization/packages.lock.json    |   7 +
 src/Nncase.Schedule/packages.lock.json        |   7 +
 src/Nncase.Simulator/packages.lock.json       |   7 +
 src/Nncase.Targets/packages.lock.json         |   7 +
 .../packages.lock.json                        |  22 +-
 src/Nncase.Tests/packages.lock.json           |   7 +
 tools/stackvm_gen/IsaGen/packages.lock.json   |   7 +
 29 files changed, 601 insertions(+), 334 deletions(-)
 create mode 100644 modules/Nncase.Modules.StackVM/Targets/CPUTarget.cs
 delete mode 100644 src/Nncase.Cli/Commands/Compile.cs
 create mode 100644 src/Nncase.Cli/Compile.cs
 delete mode 100644 src/Nncase.Cli/Program.CommandLine.cs

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 9f48677feb..bcc1830198 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -50,7 +50,8 @@
     <PackageVersion Include="RazorLight" Version="2.3.0" />
     <PackageVersion Include="Singulink.Collections.Weak" Version="1.0.2" />
     <PackageVersion Include="StyleCop.Analyzers" Version="1.2.0-beta.435" />
-    <PackageVersion Include="System.CommandLine.Hosting" Version="0.3.0-alpha.21216.1" />
+    <PackageVersion Include="System.CommandLine.Hosting" Version="0.4.0-alpha.22272.1" />
+    <PackageVersion Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
     <PackageVersion Include="System.Linq.Async" Version="6.0.1" />
     <PackageVersion Include="System.Reactive" Version="5.0.0" />
     <PackageVersion Include="Tomlyn.Extensions.Configuration" Version="1.0.5" />
diff --git a/modules/Nncase.Modules.StackVM/StackVMModule.cs b/modules/Nncase.Modules.StackVM/StackVMModule.cs
index fcbeb7a0f5..44d5c616e8 100644
--- a/modules/Nncase.Modules.StackVM/StackVMModule.cs
+++ b/modules/Nncase.Modules.StackVM/StackVMModule.cs
@@ -14,5 +14,6 @@ internal class StackVMModule : IApplicationPart
 {
     public void ConfigureServices(IRegistrator registrator)
     {
+        registrator.Register<ITarget, CPUTarget>(reuse: Reuse.Singleton);
     }
 }
diff --git a/modules/Nncase.Modules.StackVM/Targets/CPUTarget.cs b/modules/Nncase.Modules.StackVM/Targets/CPUTarget.cs
new file mode 100644
index 0000000000..2f63e02be9
--- /dev/null
+++ b/modules/Nncase.Modules.StackVM/Targets/CPUTarget.cs
@@ -0,0 +1,95 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.CommandLine.Invocation;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
+using Nncase.CodeGen;
+using Nncase.CodeGen.StackVM;
+using Nncase.IR;
+using Nncase.Passes;
+using Nncase.Quantization;
+
+namespace Nncase.Targets;
+
+/// <summary>
+/// Target for CPU.
+/// </summary>
+public class CPUTarget : ITarget
+{
+    public const string Kind = "cpu";
+
+    string ITarget.Kind => Kind;
+
+    public (System.CommandLine.Command Command, Func<InvocationContext, System.CommandLine.Command, ITargetCompileOptions> Parser) RegisterCommandAndParser()
+    {
+        return (new System.CommandLine.Command(Kind), (_, _) => DefaultTargetCompileOptions.Instance);
+    }
+
+    /// <inheritdoc/>
+    public void ParseTargetDependentOptions(IConfigurationSection configure)
+    {
+    }
+
+    /// <inheritdoc/>
+    public void RegisterTargetInDependentPass(IPassManager passManager, CompileOptions options)
+    {
+    }
+
+    /// <inheritdoc/>
+    public void RegisterTargetDependentPass(IPassManager passManager, CompileOptions options)
+    {
+    }
+
+    /// <inheritdoc/>
+    public Task<Dictionary<ENode, List<Tuple<List<DataType>, List<List<QuantParam>>, float>>>> BindQuantMethodCosine(ICalibrationDatasetProvider calibrationDataset, List<ENode> rangeOfs, List<ENode> childrenOfRangeOfs, QuantizeOptions quantizeOptions)
+    {
+        var enodeQuantCosineDict = new Dictionary<ENode, List<Tuple<List<DataType>, List<List<QuantParam>>, float>>>();
+        return Task.FromResult(enodeQuantCosineDict);
+    }
+
+    /// <inheritdoc/>
+    public Task AdaRoundWeights(ICalibrationDatasetProvider calibrationDataset, List<ENode> rangeOfs, List<ENode> childrenOfRangeOfs, QuantizeOptions quantizeOptions)
+    {
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc/>
+    public void RegisterQuantizePass(IPassManager passManager, CompileOptions options)
+    {
+    }
+
+    /// <inheritdoc/>
+    public void RegisterTargetDependentAfterQuantPass(IPassManager passManager, CompileOptions options)
+    {
+        if (options.QuantizeOptions.ModelQuantMode == ModelQuantMode.UsePTQ)
+        {
+            passManager.AddWithName<DataflowPass>("RemoveMarker").Configure(p =>
+            {
+                p.Add<Passes.Rules.Lower.RemoveMarker>();
+            });
+        }
+    }
+
+    public void RegisterTargetDependentBeforeCodeGen(IPassManager passManager, CompileOptions options)
+    {
+    }
+
+    /// <inheritdoc/>
+    public IModuleBuilder CreateModuleBuilder(string moduleKind, CompileOptions options)
+    {
+        if (moduleKind == Callable.StackVMModuleKind)
+        {
+            return new StackVMModuleBuilder();
+        }
+        else
+        {
+            throw new NotSupportedException($"{moduleKind} module is not supported.");
+        }
+    }
+}
diff --git a/modules/Nncase.Modules.StackVM/packages.lock.json b/modules/Nncase.Modules.StackVM/packages.lock.json
index 3f4ecb96a0..4830d0bbf6 100644
--- a/modules/Nncase.Modules.StackVM/packages.lock.json
+++ b/modules/Nncase.Modules.StackVM/packages.lock.json
@@ -134,6 +134,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -271,6 +272,12 @@
         "resolved": "1.0.2",
         "contentHash": "giLAHrjJe0Bh7yhNexR6pmcv02+Fi+lEPxQVdB8zvkuJCmy6rnqu8CZLIpxrUfLcWDuTCSiK0IfGmMhig3UDhA=="
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Cli/Commands/Compile.cs b/src/Nncase.Cli/Commands/Compile.cs
deleted file mode 100644
index 9daed2ba2c..0000000000
--- a/src/Nncase.Cli/Commands/Compile.cs
+++ /dev/null
@@ -1,208 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Nncase.CodeGen;
-using Nncase.Compiler;
-using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.Passes;
-using Nncase.Quantization;
-
-namespace Nncase.Cli.Commands;
-
-internal enum QuantType
-{
-    UInt8,
-    Int8,
-    Int16,
-}
-
-internal enum DatasetFormat
-{
-    Image,
-    Raw,
-    Pytest,
-    Random,
-}
-
-/// <summary>
-/// Compile command.
-/// </summary>
-public sealed class Compile : Command
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Compile"/> class.
-    /// </summary>
-    public Compile()
-        : base("compile")
-    {
-        AddArgument(new Argument("input-file"));
-        AddArgument(new Argument("output-file"));
-        AddOption(new Option<string>(
-          aliases: new string[] { "-t", "--target" },
-          description: "target architecture, e.g. cpu, k210"));
-        AddOption(new Option<string>(
-          aliases: new[] { "-i", "--input-format" },
-          description: "input format, e.g. tflite",
-          getDefaultValue: () => "tflite"));
-        AddOption(new Option<IEnumerable<DumpFlags>>(
-          alias: "--dump-flags",
-          description: "dump ir flags. \n available value: None,ImportOps,PassIR,EGraphCost,Rewrite,Calibration,Evaluator,Compile,Tiling,Schedule,CodeGen."));
-        AddOption(new Option<string>(
-          alias: "--dump-dir",
-          description: "dump to directory, default is .",
-          getDefaultValue: () => "."));
-        AddOption(new Option<QuantType>(
-          alias: "--quant-type",
-          description: $"quant type, default is {QuantType.UInt8}",
-          getDefaultValue: () => QuantType.UInt8));
-        AddOption(new Option<QuantType>(
-          alias: "--wquant-type",
-          description: $"wquant type, default is {QuantType.UInt8}",
-          getDefaultValue: () => QuantType.UInt8));
-        AddOption(new Option<string>(
-          alias: "--dataset",
-          description: $"calibration dataset, used in post quantization, default is empty",
-          getDefaultValue: () => string.Empty));
-        AddOption(new Option<DatasetFormat>(
-          alias: "--dataset-format",
-          description: $"datset format: e.g. Image|Raw|Pytest",
-          getDefaultValue: () => DatasetFormat.Raw));
-        AddOption(new Option<Quantization.ModelQuantMode>(
-          alias: "--model-quant-mode",
-          description: $"model quant mode, default is {Quantization.ModelQuantMode.NoQuant}",
-          getDefaultValue: () => Quantization.ModelQuantMode.NoQuant));
-        AddOption(new Option<Quantization.CalibMethod>(
-          alias: "--calib-method",
-          description: $"model quant options, default is {Quantization.CalibMethod.Kld}",
-          getDefaultValue: () => Quantization.CalibMethod.Kld));
-        AddOption(new Option<IEnumerable<(string, int)>>(
-          alias: "--fixed-vars",
-          description: $"dynamic shape fixed vars, default is empty. \nset by `n:123`",
-          parseArgument: result =>
-            {
-                return result.Tokens.
-                    Select(tk => tk.Value.Split(":").ToArray()).
-                    Select(tp => (tp[0].Trim(), int.Parse(tp[1].Trim())));
-            }));
-
-        Handler = CommandHandler.Create<CliCompileOptions, IHost>(RunAsync);
-    }
-
-    private async Task RunAsync(CliCompileOptions cliOptions, IHost host)
-    {
-        CompilerServices.Configure(host.Services);
-
-        // 1. setup the options
-        var compileOptions = new CompileOptions
-        {
-            InputFile = cliOptions.InputFile,
-            InputFormat = cliOptions.InputFormat,
-            DumpFlags = cliOptions.DumpFlags.Aggregate(DumpFlags.None, (a, b) => a | b),
-            DumpDir = cliOptions.DumpDir,
-            QuantizeOptions = new()
-            {
-                CalibrationMethod = cliOptions.CalibMethod,
-                QuantType = cliOptions.QuantType switch
-                {
-                    QuantType.UInt8 => DataTypes.UInt8,
-                    QuantType.Int8 => DataTypes.Int8,
-                    QuantType.Int16 => DataTypes.Int16,
-                    _ => throw new ArgumentException("Invalid quant type"),
-                },
-                WQuantType = cliOptions.WQuantType switch
-                {
-                    QuantType.UInt8 => DataTypes.UInt8,
-                    QuantType.Int8 => DataTypes.Int8,
-                    QuantType.Int16 => DataTypes.Int16,
-                    _ => throw new ArgumentException("Invalid weights quant type"),
-                },
-                ModelQuantMode = cliOptions.ModelQuantMode,
-            },
-        };
-
-        foreach (var item in cliOptions.FixedVars)
-        {
-            compileOptions.ShapeBucketOptions.FixVarMap.Add(item.Name, item.Value);
-        }
-
-        // 2. import the model
-        var target = CompilerServices.GetTarget(cliOptions.Target);
-        using var compileSession = CompileSession.Create(target, compileOptions);
-        var compiler = compileSession.Compiler;
-        IRModule module;
-        using (var model_stream = File.OpenRead(compileOptions.InputFile))
-        {
-            module = await compiler.ImportModuleAsync(model_stream);
-        }
-
-        // 3. create the calib dataset
-        if (compileOptions.QuantizeOptions.ModelQuantMode == Quantization.ModelQuantMode.UsePTQ)
-        {
-            if (cliOptions.DatasetFormat == DatasetFormat.Random)
-            {
-                compileOptions.QuantizeOptions.CalibrationDataset = new RandomCalibrationDatasetProvider(((Function)module.Entry!).Parameters.ToArray(), 5);
-            }
-            else if (cliOptions.DatasetFormat == DatasetFormat.Pytest)
-            {
-                compileOptions.QuantizeOptions.CalibrationDataset = new PytestCalibrationDatasetProvider(((Function)module.Entry!).Parameters.ToArray(), cliOptions.Dataset);
-            }
-            else
-            {
-                throw new NotSupportedException(cliOptions.DatasetFormat.ToString());
-            }
-        }
-
-        // 4. compile
-        await compiler.CompileAsync();
-
-        // 5. code gen
-        using (var os = File.OpenWrite(cliOptions.OutputFile))
-        {
-            compiler.Gencode(os);
-        }
-    }
-}
-
-// Validate null in command line parser.
-#pragma warning disable CS8618
-
-internal sealed class CliCompileOptions
-{
-    public string InputFile { get; set; }
-
-    public string InputFormat { get; set; }
-
-    public string Target { get; set; }
-
-    public IEnumerable<DumpFlags> DumpFlags { get; set; }
-
-    public string DumpDir { get; set; }
-
-    public QuantType QuantType { get; set; }
-
-    public QuantType WQuantType { get; set; }
-
-    public string OutputFile { get; set; }
-
-    public ModelQuantMode ModelQuantMode { get; set; }
-
-    public CalibMethod CalibMethod { get; set; }
-
-    public string Dataset { get; set; }
-
-    public DatasetFormat DatasetFormat { get; set; }
-
-    public IEnumerable<(string Name, int Value)> FixedVars { get; set; }
-}
-
-#pragma warning restore CS8618
diff --git a/src/Nncase.Cli/Compile.cs b/src/Nncase.Cli/Compile.cs
new file mode 100644
index 0000000000..c33a977903
--- /dev/null
+++ b/src/Nncase.Cli/Compile.cs
@@ -0,0 +1,131 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Nncase.CodeGen;
+using Nncase.Compiler;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.Passes;
+using Nncase.Quantization;
+
+namespace Nncase.Cli;
+
+internal enum QuantType
+{
+    UInt8,
+    Int8,
+    Int16,
+}
+
+internal enum DatasetFormat
+{
+    Image,
+    Raw,
+    Pytest,
+    Random,
+}
+
+/// <summary>
+/// Compile command.
+/// </summary>
+internal sealed class CompileCommand : Command
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CompileCommand"/> class.
+    /// </summary>
+    public CompileCommand()
+        : base("compile")
+    {
+        InputFile = new Argument<string>("input-file");
+        OutputFile = new Argument<string>("output-file");
+        InputFormat = new Option<string>(
+          aliases: new[] { "-i", "--input-format" },
+          description: "input format, e.g. tflite",
+          getDefaultValue: () => "tflite");
+        DumpFlags = new Option<IEnumerable<DumpFlags>>(
+          name: "--dump-flags",
+          description: "dump ir flags. \navailable value: None,ImportOps,PassIR,EGraphCost,Rewrite,Calibration,Evaluator,Compile,Tiling,Schedule,CodeGen.");
+        DumpDir = new Option<string>(
+          name: "--dump-dir",
+          description: "dump to directory.",
+          getDefaultValue: () => ".");
+        QuantType = new Option<QuantType>(
+          name: "--quant-type",
+          description: $"quant type",
+          getDefaultValue: () => Nncase.Cli.QuantType.UInt8);
+        WQuantType = new Option<QuantType>(
+          name: "--wquant-type",
+          description: $"wquant type",
+          getDefaultValue: () => Nncase.Cli.QuantType.UInt8);
+        Dataset = new Option<string>(
+          name: "--dataset",
+          description: $"calibration dataset, used in post quantization",
+          getDefaultValue: () => string.Empty);
+        DatasetFormat = new Option<DatasetFormat>(
+          name: "--dataset-format",
+          description: $"datset format.",
+          getDefaultValue: () => Nncase.Cli.DatasetFormat.Raw);
+        ModelQuantMode = new Option<Quantization.ModelQuantMode>(
+          name: "--model-quant-mode",
+          description: $"model quant mode",
+          getDefaultValue: () => Quantization.ModelQuantMode.NoQuant);
+        CalibMethod = new Option<Quantization.CalibMethod>(
+          name: "--calib-method",
+          description: $"model quant options",
+          getDefaultValue: () => Quantization.CalibMethod.Kld);
+        FixedVars = new Option<IEnumerable<(string, int)>>(
+          name: "--fixed-vars",
+          description: $"dynamic shape fixed vars, default is empty. \nset by `n:123`",
+          parseArgument: result =>
+            {
+                return result.Tokens.
+                    Select(tk => tk.Value.Split(":").ToArray()).
+                    Select(tp => (tp[0].Trim(), int.Parse(tp[1].Trim())));
+            });
+        AddArgument(InputFile);
+        AddArgument(OutputFile);
+        AddGlobalOption(InputFormat);
+        AddGlobalOption(DumpFlags);
+        AddGlobalOption(DumpDir);
+        AddGlobalOption(QuantType);
+        AddGlobalOption(WQuantType);
+        AddGlobalOption(Dataset);
+        AddGlobalOption(DatasetFormat);
+        AddGlobalOption(ModelQuantMode);
+        AddGlobalOption(CalibMethod);
+        AddGlobalOption(FixedVars);
+    }
+
+    public Argument<string> InputFile { get; }
+
+    public Argument<string> OutputFile { get; }
+
+    public Option<string> InputFormat { get; }
+
+    public Option<IEnumerable<DumpFlags>> DumpFlags { get; }
+
+    public Option<string> DumpDir { get; }
+
+    public Option<QuantType> QuantType { get; }
+
+    public Option<QuantType> WQuantType { get; }
+
+    public Option<string> Dataset { get; }
+
+    public Option<DatasetFormat> DatasetFormat { get; }
+
+    public Option<ModelQuantMode> ModelQuantMode { get; }
+
+    public Option<CalibMethod> CalibMethod { get; }
+
+    public Option<IEnumerable<(string Name, int Value)>> FixedVars { get; }
+}
diff --git a/src/Nncase.Cli/Program.CommandLine.cs b/src/Nncase.Cli/Program.CommandLine.cs
deleted file mode 100644
index e88f691647..0000000000
--- a/src/Nncase.Cli/Program.CommandLine.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) Canaan Inc. All rights reserved.
-// Licensed under the Apache license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.CommandLine;
-using System.CommandLine.Builder;
-using System.Linq;
-
-namespace Nncase.Cli;
-
-internal partial class Program
-{
-    private static CommandLineBuilder BuildCommandLine()
-    {
-        var commands = from t in typeof(Program).Assembly.ExportedTypes
-                       where t.Namespace == "Nncase.Cli.Commands" && t.IsAssignableTo(typeof(Command))
-                       select (Command)Activator.CreateInstance(t)!;
-        var root = new RootCommand();
-        foreach (var command in commands)
-        {
-            root.AddCommand(command);
-        }
-
-        return new CommandLineBuilder(root);
-    }
-}
diff --git a/src/Nncase.Cli/Program.cs b/src/Nncase.Cli/Program.cs
index 2d3e40c803..15058f923c 100644
--- a/src/Nncase.Cli/Program.cs
+++ b/src/Nncase.Cli/Program.cs
@@ -1,10 +1,14 @@
 // Copyright (c) Canaan Inc. All rights reserved.
 // Licensed under the Apache license. See LICENSE file in the project root for full license information.
 
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
 using System.CommandLine.Builder;
 using System.CommandLine.Hosting;
 using System.CommandLine.Parsing;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Hosting;
@@ -16,12 +20,148 @@ internal partial class Program
 {
     public static async Task<int> Main(string[] args)
     {
-        return await BuildCommandLine()
+        return await ConfigureCommandLine()
             .UseHost(ConfigureHost)
             .UseDefaults()
             .Build().InvokeAsync(args);
     }
 
+    private static async Task RunAsync(string targetKind, CompileOptions compileOptions, DatasetFormat datasetFormat, string dataset, string outputFile, IHost host)
+    {
+        CompilerServices.Configure(host.Services);
+
+        // 2. import the model
+        var target = CompilerServices.GetTarget(targetKind);
+        using var compileSession = CompileSession.Create(target, compileOptions);
+        var compiler = compileSession.Compiler;
+        IR.IRModule module;
+        using (var model_stream = File.OpenRead(compileOptions.InputFile))
+        {
+            module = await compiler.ImportModuleAsync(model_stream);
+        }
+
+        // 3. create the calib dataset
+        if (compileOptions.QuantizeOptions.ModelQuantMode == Quantization.ModelQuantMode.UsePTQ)
+        {
+            if (datasetFormat == DatasetFormat.Random)
+            {
+                compileOptions.QuantizeOptions.CalibrationDataset = new Quantization.RandomCalibrationDatasetProvider(((Nncase.IR.Function)module.Entry!).Parameters.ToArray(), 5);
+            }
+            else if (datasetFormat == DatasetFormat.Pytest)
+            {
+                compileOptions.QuantizeOptions.CalibrationDataset = new Quantization.PytestCalibrationDatasetProvider(((IR.Function)module.Entry!).Parameters.ToArray(), dataset);
+            }
+            else
+            {
+                throw new NotSupportedException(datasetFormat.ToString());
+            }
+        }
+
+        // 4. compile
+        await compiler.CompileAsync();
+
+        // 5. code gen
+        using (var os = File.OpenWrite(outputFile))
+        {
+            compiler.Gencode(os);
+        }
+    }
+
+    private static CommandLineBuilder ConfigureCommandLine()
+    {
+        var compile = new CompileCommand();
+        foreach (var target in LoadTargets())
+        {
+            var (targetCmd, targetParser) = target.RegisterCommandAndParser();
+            Action<System.CommandLine.Invocation.InvocationContext> targetHandler = async (System.CommandLine.Invocation.InvocationContext context) =>
+            {
+                var options = ParseCompileOptions(context, compile);
+                options.TargetCompileOptions = targetParser(context, targetCmd);
+                await RunAsync(targetCmd.Name, options, context.ParseResult.GetValueForOption(compile.DatasetFormat), context.ParseResult.GetValueForOption(compile.Dataset)!, context.ParseResult.GetValueForArgument(compile.OutputFile), context.GetHost());
+            };
+            targetCmd.SetHandler(targetHandler);
+            compile.AddCommand(targetCmd);
+        }
+
+        return new CommandLineBuilder(new RootCommand() { compile });
+    }
+
+    private static CompileOptions ParseCompileOptions(System.CommandLine.Invocation.InvocationContext context, CompileCommand compilecmd)
+    {
+        // 1. setup the options
+        var compileOptions = new CompileOptions
+        {
+            InputFile = context.ParseResult.GetValueForArgument(compilecmd.InputFile),
+            InputFormat = context.ParseResult.GetValueForOption(compilecmd.InputFormat)!,
+            DumpFlags = context.ParseResult.GetValueForOption(compilecmd.DumpFlags)!.Aggregate(Diagnostics.DumpFlags.None, (a, b) => a | b),
+            DumpDir = context.ParseResult.GetValueForOption(compilecmd.DumpDir)!,
+            QuantizeOptions = new()
+            {
+                CalibrationMethod = context.ParseResult.GetValueForOption(compilecmd.CalibMethod),
+                QuantType = context.ParseResult.GetValueForOption(compilecmd.QuantType) switch
+                {
+                    QuantType.UInt8 => DataTypes.UInt8,
+                    QuantType.Int8 => DataTypes.Int8,
+                    QuantType.Int16 => DataTypes.Int16,
+                    _ => throw new ArgumentException("Invalid quant type"),
+                },
+                WQuantType = context.ParseResult.GetValueForOption(compilecmd.WQuantType) switch
+                {
+                    QuantType.UInt8 => DataTypes.UInt8,
+                    QuantType.Int8 => DataTypes.Int8,
+                    QuantType.Int16 => DataTypes.Int16,
+                    _ => throw new ArgumentException("Invalid weights quant type"),
+                },
+                ModelQuantMode = context.ParseResult.GetValueForOption(compilecmd.ModelQuantMode),
+            },
+        };
+
+        foreach (var item in context.ParseResult.GetValueForOption(compilecmd.FixedVars)!)
+        {
+            compileOptions.ShapeBucketOptions.FixVarMap.Add(item.Name, item.Value);
+        }
+
+        return compileOptions;
+    }
+
+    private static IReadOnlyList<ITarget> LoadTargets()
+    {
+        var loadContext = System.Runtime.Loader.AssemblyLoadContext.Default;
+        var pluginAsms = PluginLoader.GetPluginsSearchDirectories(PluginLoader.PluginPathEnvName, null).
+            Select(PluginLoader.GetPluginAssemblies).
+            SelectMany(x => x).
+            DistinctBy(Path.GetFileName).
+            Select(x => PluginLoader.LoadPluginAssembly(x, loadContext)).
+            Distinct().
+            ToList();
+        pluginAsms.AddRange(new[] { Path.GetDirectoryName(typeof(Program).Assembly.Location)! }.
+            Select(basePath =>
+            {
+                if (Directory.Exists(basePath))
+                {
+                    return (from filePath in Directory.GetFiles(basePath, PluginLoader.ModulesDllPattern, SearchOption.AllDirectories)
+                            where PluginLoader.IsLoadableAssembly(filePath)
+                            select filePath).Distinct();
+                }
+                else
+                {
+                    return Array.Empty<string>();
+                }
+            }).
+            SelectMany(x => x).
+            DistinctBy(Path.GetFileName).
+            Select(x => PluginLoader.LoadPluginAssembly(x, loadContext)).
+            Distinct());
+        var targets = (from asm in pluginAsms
+                       from t in asm.ExportedTypes
+                       where t.IsClass
+                       && t.IsAssignableTo(typeof(ITarget))
+                       let ctor = t.GetConstructor(Type.EmptyTypes)
+                       where ctor != null
+                       select (ITarget)ctor.Invoke(null)).ToList();
+        return targets;
+    }
+
     private static void ConfigureHost(IHostBuilder hostBuilder)
     {
         hostBuilder.ConfigureAppConfiguration(ConfigureAppConfiguration)
diff --git a/src/Nncase.Cli/packages.lock.json b/src/Nncase.Cli/packages.lock.json
index e44016380c..56eaafb112 100644
--- a/src/Nncase.Cli/packages.lock.json
+++ b/src/Nncase.Cli/packages.lock.json
@@ -42,12 +42,13 @@
       },
       "System.CommandLine.Hosting": {
         "type": "Direct",
-        "requested": "[0.3.0-alpha.21216.1, )",
-        "resolved": "0.3.0-alpha.21216.1",
-        "contentHash": "zP8QEUH8dSUYUHdGk6k71kOJy8uFgEPZG2RfhA0cMjDH3/Jov5AjUNaxOvpSNHh+ewu8eIUCYgV8+fEkCPyNlw==",
+        "requested": "[0.4.0-alpha.22272.1, )",
+        "resolved": "0.4.0-alpha.22272.1",
+        "contentHash": "x9JhHxBLxlKyCIZADFYC8q16L9yGHdTakrLFjHabwR7Tk0761aTexiGgMTIS744HGuhc8pk9MoLUzsr/TlRfMQ==",
         "dependencies": {
-          "Microsoft.Extensions.Hosting": "3.1.5",
-          "System.CommandLine": "2.0.0-beta1.21216.1"
+          "Microsoft.Extensions.Hosting": "6.0.0",
+          "System.CommandLine": "2.0.0-beta4.22272.1",
+          "System.CommandLine.NamingConventionBinder": "2.0.0-beta4.22272.1"
         }
       },
       "Google.OrTools.runtime.linux-arm64": {
@@ -362,13 +363,12 @@
           "System.Runtime": "4.3.0"
         }
       },
-      "System.CommandLine": {
+      "System.CommandLine.NamingConventionBinder": {
         "type": "Transitive",
-        "resolved": "2.0.0-beta1.21216.1",
-        "contentHash": "Nbv/tW8sbOKN5T+4SSVBMdk4ADSIpJpY4UHMsj3VkcNtOckIT4iyzagjF+W5FEh2YBRvmvVQijOTIZbUJ1+1aA==",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "ux2eUA/syF+JtlpMDc/Lsd6PBIBuwjH3AvHnestoh5uD0WKT5b+wkQxDWVCqp9qgVjMBTLNhX19ZYFtenunt9A==",
         "dependencies": {
-          "Microsoft.CSharp": "4.4.1",
-          "system.memory": "4.5.4"
+          "System.CommandLine": "2.0.0-beta4.22272.1"
         }
       },
       "System.Diagnostics.Contracts": {
@@ -696,6 +696,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -937,6 +938,12 @@
         "resolved": "1.0.2",
         "contentHash": "giLAHrjJe0Bh7yhNexR6pmcv02+Fi+lEPxQVdB8zvkuJCmy6rnqu8CZLIpxrUfLcWDuTCSiK0IfGmMhig3UDhA=="
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Linq.Async": {
         "type": "CentralTransitive",
         "requested": "[6.0.1, )",
diff --git a/src/Nncase.CodeGen/packages.lock.json b/src/Nncase.CodeGen/packages.lock.json
index b6602bf240..fd39ebd2fc 100644
--- a/src/Nncase.CodeGen/packages.lock.json
+++ b/src/Nncase.CodeGen/packages.lock.json
@@ -76,6 +76,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -138,6 +139,12 @@
           "System.Runtime.CompilerServices.Unsafe": "5.0.0"
         }
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Compiler/Hosting/PluginLoader.cs b/src/Nncase.Compiler/Hosting/PluginLoader.cs
index 0264ccc1b9..014ab29fb1 100644
--- a/src/Nncase.Compiler/Hosting/PluginLoader.cs
+++ b/src/Nncase.Compiler/Hosting/PluginLoader.cs
@@ -19,8 +19,9 @@ namespace Nncase.Hosting;
 /// </summary>
 public sealed class PluginLoader
 {
-    private const string _modulesDllPattern = "Nncase.Modules.*.dll";
-    private const string _pluginPathEnvName = "NNCASE_PLUGIN_PATH";
+    public const string PluginPathEnvName = "NNCASE_PLUGIN_PATH";
+
+    public const string ModulesDllPattern = "Nncase.Modules.*.dll";
 
     private static readonly string[] _builtinModules = new[]
     {
@@ -43,67 +44,16 @@ public PluginLoader(ILogger<PluginLoader> logger)
             ?? AssemblyLoadContext.Default;
     }
 
-    /// <summary>
-    /// Load plugins.
-    /// </summary>
-    /// <returns>Plugins.</returns>
-    public IReadOnlyList<IPlugin> LoadPlugins()
-    {
-        var pluginAsms = GetPluginsSearchDirectories().Select(GetPluginAssemblies).SelectMany(x => x)
-                    .DistinctBy(Path.GetFileName).Select(LoadPluginAssembly).Distinct().ToList();
-        var plugins = (from asm in pluginAsms
-                       from t in asm.ExportedTypes
-                       where t.IsClass
-                       && t.IsAssignableTo(typeof(IPlugin))
-                       let ctor = t.GetConstructor(Type.EmptyTypes)
-                       where ctor != null
-                       select (IPlugin)ctor.Invoke(null)).ToList();
-
-        return plugins;
-    }
-
-    private static bool IsLoadableAssembly(string filePath)
-    {
-        using var fs = File.OpenRead(filePath);
-        using var peReader = new PEReader(fs);
-
-        if (!peReader.HasMetadata)
-        {
-            return false;
-        }
-
-        var metaReader = peReader.GetMetadataReader();
-        if (!metaReader.IsAssembly)
-        {
-            return false;
-        }
-
-        // Is reference assembly
-        if ((from cah in metaReader.CustomAttributes
-             let ca = metaReader.GetCustomAttribute(cah)
-             where ca.Constructor.Kind == HandleKind.MemberReference
-             let ctor = metaReader.GetMemberReference((MemberReferenceHandle)ca.Constructor)
-             let attrType = metaReader.GetTypeReference((TypeReferenceHandle)ctor.Parent)
-             where metaReader.GetString(attrType.Namespace) == nameof(System.Runtime.CompilerServices)
-                && metaReader.GetString(attrType.Name) == nameof(ReferenceAssemblyAttribute)
-             select cah).Any())
-        {
-            return false;
-        }
-
-        return true;
-    }
-
-    private Assembly LoadPluginAssembly(string assemblyFile)
+    public static Assembly LoadPluginAssembly(string assemblyFile, AssemblyLoadContext loadContext)
     {
-        return _loadContext.LoadFromAssemblyPath(assemblyFile);
+        return loadContext.LoadFromAssemblyPath(assemblyFile);
     }
 
-    private IEnumerable<string> GetPluginAssemblies(string basePath)
+    public static IEnumerable<string> GetPluginAssemblies(string basePath)
     {
         if (Directory.Exists(basePath))
         {
-            return (from filePath in Directory.GetFiles(basePath, _modulesDllPattern, SearchOption.AllDirectories)
+            return (from filePath in Directory.GetFiles(basePath, ModulesDllPattern, SearchOption.AllDirectories)
                     where !_builtinModules.Contains(Path.GetFileName(filePath))
                      && IsLoadableAssembly(filePath)
                     select filePath).Distinct();
@@ -114,19 +64,22 @@ private IEnumerable<string> GetPluginAssemblies(string basePath)
         }
     }
 
-    private IEnumerable<string> GetPluginsSearchDirectories()
+    public static IEnumerable<string> GetPluginsSearchDirectories(string pluginPathEnvName, ILogger? logger)
     {
         var directories = new List<string>();
 
         // 1. Environment variable
-        var targetPathEnv = Environment.GetEnvironmentVariable(_pluginPathEnvName);
+        var targetPathEnv = Environment.GetEnvironmentVariable(pluginPathEnvName);
         if (string.IsNullOrWhiteSpace(targetPathEnv))
         {
-            _logger.LogWarning($"{_pluginPathEnvName} is not set.");
+            if (logger is not null)
+            {
+                logger.LogWarning($"{pluginPathEnvName} is not set.");
+            }
         }
         else
         {
-            var targetPaths = from path in targetPathEnv.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries)
+            var targetPaths = from path in targetPathEnv!.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries)
                               select Environment.ExpandEnvironmentVariables(path);
             directories.AddRange(targetPaths);
         }
@@ -136,11 +89,62 @@ private IEnumerable<string> GetPluginsSearchDirectories()
         var modulesPath = Path.Combine(rootPath, "modules");
         directories.Add(modulesPath);
 
-        if (_logger.IsEnabled(LogLevel.Trace))
+        if (logger is not null && logger.IsEnabled(LogLevel.Trace))
         {
-            _logger.LogInformation($"Loading plugins from {string.Join(", ", directories)}.");
+            logger.LogInformation($"Loading plugins from {string.Join(", ", directories)}.");
         }
 
         return directories.Distinct();
     }
+
+    public static bool IsLoadableAssembly(string filePath)
+    {
+        using var fs = File.OpenRead(filePath);
+        using var peReader = new PEReader(fs);
+
+        if (!peReader.HasMetadata)
+        {
+            return false;
+        }
+
+        var metaReader = peReader.GetMetadataReader();
+        if (!metaReader.IsAssembly)
+        {
+            return false;
+        }
+
+        // Is reference assembly
+        if ((from cah in metaReader.CustomAttributes
+             let ca = metaReader.GetCustomAttribute(cah)
+             where ca.Constructor.Kind == HandleKind.MemberReference
+             let ctor = metaReader.GetMemberReference((MemberReferenceHandle)ca.Constructor)
+             let attrType = metaReader.GetTypeReference((TypeReferenceHandle)ctor.Parent)
+             where metaReader.GetString(attrType.Namespace) == nameof(System.Runtime.CompilerServices)
+                && metaReader.GetString(attrType.Name) == nameof(ReferenceAssemblyAttribute)
+             select cah).Any())
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Load plugins.
+    /// </summary>
+    /// <returns>Plugins.</returns>
+    public IReadOnlyList<IPlugin> LoadPlugins()
+    {
+        var pluginAsms = GetPluginsSearchDirectories(PluginPathEnvName, _logger).Select(GetPluginAssemblies).SelectMany(x => x)
+                    .DistinctBy(Path.GetFileName).Select(x => LoadPluginAssembly(x, _loadContext)).Distinct().ToList();
+        var plugins = (from asm in pluginAsms
+                       from t in asm.ExportedTypes
+                       where t.IsClass
+                       && t.IsAssignableTo(typeof(IPlugin))
+                       let ctor = t.GetConstructor(Type.EmptyTypes)
+                       where ctor != null
+                       select (IPlugin)ctor.Invoke(null)).ToList();
+
+        return plugins;
+    }
 }
diff --git a/src/Nncase.Compiler/packages.lock.json b/src/Nncase.Compiler/packages.lock.json
index c294c26198..f22a606140 100644
--- a/src/Nncase.Compiler/packages.lock.json
+++ b/src/Nncase.Compiler/packages.lock.json
@@ -674,6 +674,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -727,15 +728,6 @@
           "Nncase.Passes": "[1.0.0, )"
         }
       },
-      "nncase.modules.xpu": {
-        "type": "Project",
-        "dependencies": {
-          "Nncase.CodeGen": "[1.0.0, )",
-          "Nncase.Diagnostics": "[1.0.0, )",
-          "Nncase.Modules.StackVM": "[1.0.0, )",
-          "Nncase.Passes": "[1.0.0, )"
-        }
-      },
       "nncase.passes": {
         "type": "Project",
         "dependencies": {
@@ -894,6 +886,12 @@
         "resolved": "1.0.2",
         "contentHash": "giLAHrjJe0Bh7yhNexR6pmcv02+Fi+lEPxQVdB8zvkuJCmy6rnqu8CZLIpxrUfLcWDuTCSiK0IfGmMhig3UDhA=="
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Linq.Async": {
         "type": "CentralTransitive",
         "requested": "[6.0.1, )",
diff --git a/src/Nncase.Core/CompileOptions.cs b/src/Nncase.Core/CompileOptions.cs
index 94ba4d7c89..c4daedc4fb 100644
--- a/src/Nncase.Core/CompileOptions.cs
+++ b/src/Nncase.Core/CompileOptions.cs
@@ -114,4 +114,9 @@ public sealed record CompileOptions
     /// Gets or sets quant options.
     /// </summary>
     public ShapeBucketOptions ShapeBucketOptions { get; set; } = ShapeBucketOptions.Default;
+
+    /// <summary>
+    /// Gets or sets the target compile options.
+    /// </summary>
+    public ITargetCompileOptions TargetCompileOptions { get; set; } = null!;
 }
diff --git a/src/Nncase.Core/ITarget.cs b/src/Nncase.Core/ITarget.cs
index 7ecc6fa840..a72c0c5f9b 100644
--- a/src/Nncase.Core/ITarget.cs
+++ b/src/Nncase.Core/ITarget.cs
@@ -13,6 +13,13 @@
 
 namespace Nncase;
 
+/// <summary>
+/// The targets own compile options.
+/// </summary>
+public interface ITargetCompileOptions
+{
+}
+
 /// <summary>
 /// Target.
 /// </summary>
@@ -23,6 +30,12 @@ public interface ITarget
     /// </summary>
     string Kind { get; }
 
+    /// <summary>
+    /// create the current target's command and parser.
+    /// </summary>
+    /// <returns>command.</returns>
+    (System.CommandLine.Command Command, Func<System.CommandLine.Invocation.InvocationContext, System.CommandLine.Command, ITargetCompileOptions> Parser) RegisterCommandAndParser();
+
     /// <summary>
     /// Bind Quant Method And Quant Cosine With IR.
     /// </summary>
@@ -91,3 +104,12 @@ public interface ITarget
     /// <returns>Module builder.</returns>
     IModuleBuilder CreateModuleBuilder(string moduleKind, CompileOptions options);
 }
+
+public sealed class DefaultTargetCompileOptions : ITargetCompileOptions
+{
+    public static readonly DefaultTargetCompileOptions Instance = new();
+
+    private DefaultTargetCompileOptions()
+    {
+    }
+}
diff --git a/src/Nncase.Core/Nncase.Core.csproj b/src/Nncase.Core/Nncase.Core.csproj
index 716f4e3dba..1ea4c4f534 100644
--- a/src/Nncase.Core/Nncase.Core.csproj
+++ b/src/Nncase.Core/Nncase.Core.csproj
@@ -4,7 +4,7 @@
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
-	<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+	  <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
@@ -21,6 +21,7 @@
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Options" />
     <PackageReference Include="Microsoft.Toolkit.HighPerformance" />
+    <PackageReference Include="System.CommandLine" />
     <PackageReference Include="NetFabric.Hyperlinq" />
     <PackageReference Include="System.Reactive" />
     <PackageReference Include="GiGraph.Dot" />
diff --git a/src/Nncase.Core/packages.lock.json b/src/Nncase.Core/packages.lock.json
index 6d48777d94..b846e4b245 100644
--- a/src/Nncase.Core/packages.lock.json
+++ b/src/Nncase.Core/packages.lock.json
@@ -67,6 +67,12 @@
           "StyleCop.Analyzers.Unstable": "1.2.0.435"
         }
       },
+      "System.CommandLine": {
+        "type": "Direct",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "Direct",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Diagnostics/packages.lock.json b/src/Nncase.Diagnostics/packages.lock.json
index b3f4cb2588..1b9a6c1dd5 100644
--- a/src/Nncase.Diagnostics/packages.lock.json
+++ b/src/Nncase.Diagnostics/packages.lock.json
@@ -70,6 +70,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -129,6 +130,12 @@
           "System.Runtime.CompilerServices.Unsafe": "5.0.0"
         }
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.EGraph/packages.lock.json b/src/Nncase.EGraph/packages.lock.json
index 7004606929..2fb3aca77d 100644
--- a/src/Nncase.EGraph/packages.lock.json
+++ b/src/Nncase.EGraph/packages.lock.json
@@ -163,6 +163,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -227,6 +228,12 @@
           "libortki": "0.0.2"
         }
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Evaluator/packages.lock.json b/src/Nncase.Evaluator/packages.lock.json
index 78887df6a5..cf9c399201 100644
--- a/src/Nncase.Evaluator/packages.lock.json
+++ b/src/Nncase.Evaluator/packages.lock.json
@@ -110,6 +110,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -169,6 +170,12 @@
           "System.Runtime.CompilerServices.Unsafe": "5.0.0"
         }
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Graph/packages.lock.json b/src/Nncase.Graph/packages.lock.json
index 4ece9f52bb..ab3e724693 100644
--- a/src/Nncase.Graph/packages.lock.json
+++ b/src/Nncase.Graph/packages.lock.json
@@ -101,6 +101,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -176,6 +177,12 @@
           "libortki": "0.0.2"
         }
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Importer/packages.lock.json b/src/Nncase.Importer/packages.lock.json
index e903580b70..3a6d65fc28 100644
--- a/src/Nncase.Importer/packages.lock.json
+++ b/src/Nncase.Importer/packages.lock.json
@@ -371,6 +371,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -454,6 +455,12 @@
         "resolved": "2.0.0",
         "contentHash": "ir3uek0+7Y8SwOUGUR8y94sgpVDWLAjKGBm9z7cLe/38GyPxWbIYHPnHZHksNTExTsx3Ie9GtwagkgR/jm64hA=="
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Passes/packages.lock.json b/src/Nncase.Passes/packages.lock.json
index 4ceb9735d5..1c39f25003 100644
--- a/src/Nncase.Passes/packages.lock.json
+++ b/src/Nncase.Passes/packages.lock.json
@@ -126,6 +126,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -245,6 +246,12 @@
         "resolved": "1.0.2",
         "contentHash": "giLAHrjJe0Bh7yhNexR6pmcv02+Fi+lEPxQVdB8zvkuJCmy6rnqu8CZLIpxrUfLcWDuTCSiK0IfGmMhig3UDhA=="
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Quantization/packages.lock.json b/src/Nncase.Quantization/packages.lock.json
index b128fc2fc3..59323bcaea 100644
--- a/src/Nncase.Quantization/packages.lock.json
+++ b/src/Nncase.Quantization/packages.lock.json
@@ -155,6 +155,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -274,6 +275,12 @@
         "resolved": "1.0.2",
         "contentHash": "giLAHrjJe0Bh7yhNexR6pmcv02+Fi+lEPxQVdB8zvkuJCmy6rnqu8CZLIpxrUfLcWDuTCSiK0IfGmMhig3UDhA=="
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Schedule/packages.lock.json b/src/Nncase.Schedule/packages.lock.json
index b3f4cb2588..1b9a6c1dd5 100644
--- a/src/Nncase.Schedule/packages.lock.json
+++ b/src/Nncase.Schedule/packages.lock.json
@@ -70,6 +70,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -129,6 +130,12 @@
           "System.Runtime.CompilerServices.Unsafe": "5.0.0"
         }
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Simulator/packages.lock.json b/src/Nncase.Simulator/packages.lock.json
index b3f4cb2588..1b9a6c1dd5 100644
--- a/src/Nncase.Simulator/packages.lock.json
+++ b/src/Nncase.Simulator/packages.lock.json
@@ -70,6 +70,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -129,6 +130,12 @@
           "System.Runtime.CompilerServices.Unsafe": "5.0.0"
         }
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Targets/packages.lock.json b/src/Nncase.Targets/packages.lock.json
index 5d676dd547..a434ae4251 100644
--- a/src/Nncase.Targets/packages.lock.json
+++ b/src/Nncase.Targets/packages.lock.json
@@ -78,6 +78,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -152,6 +153,12 @@
           "System.Runtime.CompilerServices.Unsafe": "5.0.0"
         }
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Tests.TestFixture/packages.lock.json b/src/Nncase.Tests.TestFixture/packages.lock.json
index d2a726fe30..a01c8fb4ff 100644
--- a/src/Nncase.Tests.TestFixture/packages.lock.json
+++ b/src/Nncase.Tests.TestFixture/packages.lock.json
@@ -1095,15 +1095,10 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
-      "nncase.diagnostics": {
-        "type": "Project",
-        "dependencies": {
-          "Nncase.Core": "[1.0.0, )"
-        }
-      },
       "nncase.egraph": {
         "type": "Project",
         "dependencies": {
@@ -1139,15 +1134,6 @@
           "Nncase.Passes": "[1.0.0, )"
         }
       },
-      "nncase.modules.xpu": {
-        "type": "Project",
-        "dependencies": {
-          "Nncase.CodeGen": "[1.0.0, )",
-          "Nncase.Diagnostics": "[1.0.0, )",
-          "Nncase.Modules.StackVM": "[1.0.0, )",
-          "Nncase.Passes": "[1.0.0, )"
-        }
-      },
       "nncase.passes": {
         "type": "Project",
         "dependencies": {
@@ -1273,6 +1259,12 @@
         "resolved": "1.0.2",
         "contentHash": "giLAHrjJe0Bh7yhNexR6pmcv02+Fi+lEPxQVdB8zvkuJCmy6rnqu8CZLIpxrUfLcWDuTCSiK0IfGmMhig3UDhA=="
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/src/Nncase.Tests/packages.lock.json b/src/Nncase.Tests/packages.lock.json
index dce3ce0116..cf25699afc 100644
--- a/src/Nncase.Tests/packages.lock.json
+++ b/src/Nncase.Tests/packages.lock.json
@@ -1492,6 +1492,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -1718,6 +1719,12 @@
         "resolved": "1.0.2",
         "contentHash": "giLAHrjJe0Bh7yhNexR6pmcv02+Fi+lEPxQVdB8zvkuJCmy6rnqu8CZLIpxrUfLcWDuTCSiK0IfGmMhig3UDhA=="
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",
diff --git a/tools/stackvm_gen/IsaGen/packages.lock.json b/tools/stackvm_gen/IsaGen/packages.lock.json
index bbcfe63a45..fd04d9883e 100644
--- a/tools/stackvm_gen/IsaGen/packages.lock.json
+++ b/tools/stackvm_gen/IsaGen/packages.lock.json
@@ -238,6 +238,7 @@
           "Microsoft.Extensions.Options": "[6.0.0, )",
           "Microsoft.Toolkit.HighPerformance": "[7.1.1, )",
           "NetFabric.Hyperlinq": "[3.0.0-beta48, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )",
           "System.Reactive": "[5.0.0, )"
         }
       },
@@ -312,6 +313,12 @@
           "System.Runtime.CompilerServices.Unsafe": "5.0.0"
         }
       },
+      "System.CommandLine": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
       "System.Reactive": {
         "type": "CentralTransitive",
         "requested": "[5.0.0, )",

From f39d82508c50a6261d3b3a04b5b36c7317777bc3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 30 Oct 2023 16:05:53 +0800
Subject: [PATCH 289/308] fix buffer and memspan hashcode and equals

---
 src/Nncase.Core/TIR/Buffer.cs  | 13 +++++++++++++
 src/Nncase.Core/TIR/MemSpan.cs | 13 +++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/src/Nncase.Core/TIR/Buffer.cs b/src/Nncase.Core/TIR/Buffer.cs
index cc5c5f1155..570a3d43d8 100644
--- a/src/Nncase.Core/TIR/Buffer.cs
+++ b/src/Nncase.Core/TIR/Buffer.cs
@@ -308,4 +308,17 @@ public Buffer(string name, DataType elemType, MemSpan memSpan, Expr[] dimensions
 
     public Buffer With(MemSpan? memSpan = null, Expr[]? dimensions = null, Expr[]? strides = null)
         => new Buffer(Name, ElemType, memSpan ?? MemSpan, dimensions ?? Dimensions.ToArray(), strides ?? Strides.ToArray());
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj)
+    {
+        if (ReferenceEquals(this, obj))
+        {
+            return true;
+        }
+
+        return obj is TIR.Buffer other && GetHashCode() == other.GetHashCode() && Name == other.Name && ElemType == other.ElemType && Rank == other.Rank && Operands.SequenceEqual(other.Operands);
+    }
+
+    protected override int GetHashCodeCore() => HashCode.Combine(Name, ElemType, Rank, base.GetHashCodeCore());
 }
diff --git a/src/Nncase.Core/TIR/MemSpan.cs b/src/Nncase.Core/TIR/MemSpan.cs
index 3610d198c3..f8e537d549 100644
--- a/src/Nncase.Core/TIR/MemSpan.cs
+++ b/src/Nncase.Core/TIR/MemSpan.cs
@@ -89,4 +89,17 @@ public override TExprResult Accept<TExprResult, TTypeResult, TContext>(ExprFunct
         => functor.VisitMemSpan(this, context);
 
     public MemSpan With(Expr? start = null, Expr? size = null, MemoryLocation? location = null) => new(start ?? Start, size ?? Size, location ?? Location);
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj)
+    {
+        if (ReferenceEquals(this, obj))
+        {
+            return true;
+        }
+
+        return obj is MemSpan other && GetHashCode() == other.GetHashCode() && Location == other.Location && Operands.SequenceEqual(other.Operands);
+    }
+
+    protected override int GetHashCodeCore() => HashCode.Combine(Location, base.GetHashCodeCore());
 }

From 1f0ac829ac0d748400e72b136e1fb84a56af21bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Tue, 31 Oct 2023 04:10:31 +0000
Subject: [PATCH 290/308] fix unitest

---
 src/Nncase.Evaluator/Math/Unary.cs                 | 1 +
 src/Nncase.Tests.TestFixture/TestClassBase.cs      | 2 +-
 src/Nncase.Tests/CodeGen/UnitTestStackVMEmitter.cs | 6 +++---
 src/Nncase.Tests/Core/UnitTestDataTypes.cs         | 2 +-
 src/Nncase.Tests/Core/UnitTestExpression.cs        | 2 +-
 src/Nncase.Tests/Core/UnitTestStringUtility.cs     | 4 ++--
 src/Nncase.Tests/Core/UnitTestTypeInfer.cs         | 2 +-
 src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs    | 4 ++--
 src/Nncase.Tests/Simulator/UnitTestInterop.cs      | 3 +--
 9 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/Nncase.Evaluator/Math/Unary.cs b/src/Nncase.Evaluator/Math/Unary.cs
index c5e7cdefa5..95824a5bb8 100644
--- a/src/Nncase.Evaluator/Math/Unary.cs
+++ b/src/Nncase.Evaluator/Math/Unary.cs
@@ -70,6 +70,7 @@ public IRType Visit(ITypeInferenceContext context, Unary target)
         {
             TensorType tensorType => Visit(tensorType),
             DistributedType distTensorType => Visit(distTensorType, target.UnaryOp),
+            AnyType => AnyType.Default,
             _ => new InvalidType($"Not support {inputType.GetType().Name}"),
         };
     }
diff --git a/src/Nncase.Tests.TestFixture/TestClassBase.cs b/src/Nncase.Tests.TestFixture/TestClassBase.cs
index 908f783dfb..ee10789d47 100644
--- a/src/Nncase.Tests.TestFixture/TestClassBase.cs
+++ b/src/Nncase.Tests.TestFixture/TestClassBase.cs
@@ -38,7 +38,7 @@ public TestClassBase()
     /// <summary>
     /// Gets or sets default target name.
     /// </summary>
-    public virtual string DefaultTargetName { get; set; } = IR.Callable.StackVMModuleKind;
+    public virtual string DefaultTargetName { get; set; } = "cpu";
 
     /// <summary>
     /// Gets test output root.
diff --git a/src/Nncase.Tests/CodeGen/UnitTestStackVMEmitter.cs b/src/Nncase.Tests/CodeGen/UnitTestStackVMEmitter.cs
index 087cb54f9a..b21d10d10f 100644
--- a/src/Nncase.Tests/CodeGen/UnitTestStackVMEmitter.cs
+++ b/src/Nncase.Tests/CodeGen/UnitTestStackVMEmitter.cs
@@ -1004,7 +1004,7 @@ public void TestStackVMEmitterGConcat()
         var tensorEmitter = new StackVMEmitter.TensorEmitter(stackVmEmitter);
         tensorEmitter.Concat(0);
         var actual = memoryStream.ToArray();
-        Assert.Equal(new byte[] { 100, actual[1], 0 }, actual);
+        Assert.Equal(new byte[] { 100, actual[1], 0, 0, 0, 0, 0 }, actual);
     }
 
     [Fact]
@@ -1158,7 +1158,7 @@ public void TestStackVMEmitterGGather()
         var tensorEmitter = new StackVMEmitter.TensorEmitter(stackVmEmitter);
         tensorEmitter.Gather(0);
         var actual = memoryStream.ToArray();
-        Assert.Equal(new byte[] { 100, actual[1], 0 }, actual);
+        Assert.Equal(new byte[] { 100, actual[1], 0, 0, 0, 0, 0 }, actual);
     }
 
     [Fact]
@@ -1246,7 +1246,7 @@ public void TestStackVMEmitterGLayerNorm()
         var tensorEmitter = new StackVMEmitter.TensorEmitter(stackVmEmitter);
         tensorEmitter.LayerNorm(-1, 0f, false);
         var actual = memoryStream.ToArray();
-        Assert.Equal(new byte[] { 100, actual[1], 0, 255, 255, 255, 255, 0, 0, 0, 0 }, actual);
+        Assert.Equal(new byte[] { 100, actual[1], 0, 255, 255, 255, 255, 0, 0, 0, 0, 0 }, actual);
     }
 
     [Fact]
diff --git a/src/Nncase.Tests/Core/UnitTestDataTypes.cs b/src/Nncase.Tests/Core/UnitTestDataTypes.cs
index 31a9249435..cc47d819c2 100644
--- a/src/Nncase.Tests/Core/UnitTestDataTypes.cs
+++ b/src/Nncase.Tests/Core/UnitTestDataTypes.cs
@@ -61,7 +61,7 @@ public void TestGetDisplayName()
     {
         var a = new QuantParamType();
         Assert.Equal(a.ToString(), DataTypes.GetDisplayName(a));
-        Assert.Equal("(f32*)", DataTypes.GetDisplayName(new PointerType(DataTypes.Float32, IR.Shape.Scalar)));
+        Assert.Equal("(f32 *)", DataTypes.GetDisplayName(new PointerType(DataTypes.Float32, IR.Shape.Scalar)));
         Assert.Equal(DataTypes.Boolean.ShortName, DataTypes.GetDisplayName(DataTypes.Boolean));
         Assert.Equal(DataTypes.Utf8Char.ShortName, DataTypes.GetDisplayName(DataTypes.Utf8Char));
         Assert.Equal(DataTypes.Int8.ShortName, DataTypes.GetDisplayName(DataTypes.Int8));
diff --git a/src/Nncase.Tests/Core/UnitTestExpression.cs b/src/Nncase.Tests/Core/UnitTestExpression.cs
index 59741a8735..dc6ceeb702 100644
--- a/src/Nncase.Tests/Core/UnitTestExpression.cs
+++ b/src/Nncase.Tests/Core/UnitTestExpression.cs
@@ -468,7 +468,7 @@ public void TestPrintExpr()
         CompilerServices.InferenceType(x);
         Assert.Equal("const(i32[4] : {1,2,3,4})", CompilerServices.Print(x));
         Assert.Equal("None", CompilerServices.Print(None.Default));
-        Assert.Equal("Add", CompilerServices.Print(new Nncase.IR.Math.Binary(BinaryOp.Add)));
+        Assert.Equal("Binary", CompilerServices.Print(new Nncase.IR.Math.Binary(BinaryOp.Add)));
         var y = new Var("y");
         CompilerServices.InferenceType(y);
         Assert.Equal("%y: any", CompilerServices.Print(y));
diff --git a/src/Nncase.Tests/Core/UnitTestStringUtility.cs b/src/Nncase.Tests/Core/UnitTestStringUtility.cs
index 5505371db5..1efe33a6c8 100644
--- a/src/Nncase.Tests/Core/UnitTestStringUtility.cs
+++ b/src/Nncase.Tests/Core/UnitTestStringUtility.cs
@@ -29,9 +29,9 @@ public sealed class UnitTestStringUtility
     public void TestJoin()
     {
         var result = StringUtility.Join(",", _entry.Parameters.InputOf().Select(b => b));
-        Assert.Equal("PhysicalBuffer(testInput, f32, MemLocation),PhysicalBuffer(testInput, f32, MemLocation)", result);
+        Assert.Equal("Nncase.TIR.Buffer", result);
 
         var result1 = StringUtility.Join(",", _entry.Parameters.OutputOf().Select(b => b));
-        Assert.Equal(string.Empty, result1);
+        Assert.Equal("Nncase.TIR.Buffer", result1);
     }
 }
diff --git a/src/Nncase.Tests/Core/UnitTestTypeInfer.cs b/src/Nncase.Tests/Core/UnitTestTypeInfer.cs
index bc9def3e85..7709f353b2 100644
--- a/src/Nncase.Tests/Core/UnitTestTypeInfer.cs
+++ b/src/Nncase.Tests/Core/UnitTestTypeInfer.cs
@@ -173,7 +173,7 @@ public void TestReInference()
         Const b = 2;
         Function f = new("f", x + b, new[] { x });
         CompilerServices.InferenceType(f);
-        Assert.IsType<AnyType>(f.Body.CheckedType);
+        Assert.IsNotType<AnyType>(f.Body.CheckedType);
 
         // 2. after the  transfrom the dag is valid type
         var y = x.With(typeAnnotation: TensorType.Scalar(DataTypes.Int32));
diff --git a/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs b/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
index 408a625058..ccf74e1556 100644
--- a/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
+++ b/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
@@ -225,8 +225,8 @@ public void TestDumperCSharpIRFusion()
     [Fact]
     public void TestDumpTIRFusion()
     {
-        var lhs = new Var("lhs");
-        var main = T.PrimFunc("main", Callable.StackVMModuleKind).Body(
+        var lhs = new Var("lhs", TensorType.Scalar(DataTypes.Float32));
+        var main = T.PrimFunc("main", DefaultTargetName).Body(
           new Call(new TIRTest.MeshNet(), new Fusion("MeshFunc", lhs + 100, lhs), IR.F.Random.Normal(DataTypes.Float32, 0, 1, 123, new[] { 100 }))).Build();
         Assert.True(CompilerServices.InferenceType(main));
         CompilerServices.DumpIR(main, string.Empty, Dumpper.Directory);
diff --git a/src/Nncase.Tests/Simulator/UnitTestInterop.cs b/src/Nncase.Tests/Simulator/UnitTestInterop.cs
index 7f3440aec1..f77f90970f 100644
--- a/src/Nncase.Tests/Simulator/UnitTestInterop.cs
+++ b/src/Nncase.Tests/Simulator/UnitTestInterop.cs
@@ -26,8 +26,7 @@ public UnitTestInterop()
         var main = new Function("main", y, new[] { x });
         var module = new IRModule(main);
 
-        // var target = CompilerServices.GetTarget(XPUTarget.Kind);
-        var target = CompilerServices.GetTarget("stackvm");
+        var target = CompilerServices.GetTarget("cpu");
         var modelBuilder = new ModelBuilder(target, CompileOptions);
         var linkedModel = modelBuilder.Build(module);
         using var output = new MemoryStream();

From b01e15915ea1ca4e87de9ea4d3fdc4c21e9eb872 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B9=90=E4=BB=81=E5=8D=8E?= <2532375005@qq.com>
Date: Wed, 1 Nov 2023 03:11:09 +0000
Subject: [PATCH 291/308] fix unittest

---
 src/Nncase.Core/Passes/Mutators/UnRollLoopSequential.cs | 5 +++++
 src/Nncase.Evaluator/Math/Binary.cs                     | 2 ++
 src/Nncase.Evaluator/NN/Conv2D.cs                       | 2 ++
 src/Nncase.Evaluator/Tensors/Reshape.cs                 | 1 +
 src/Nncase.Evaluator/Tensors/Slice.cs                   | 1 +
 src/Nncase.Evaluator/Tensors/Transpose.cs               | 1 +
 src/Nncase.Passes/Mutators/IFusionMergeRule.cs          | 2 +-
 src/Nncase.Tests/Core/UnitTestTypeInfer.cs              | 2 +-
 src/Nncase.Tests/Rules/Neutral/UnitTestFoldSwish.cs     | 3 ++-
 9 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/Nncase.Core/Passes/Mutators/UnRollLoopSequential.cs b/src/Nncase.Core/Passes/Mutators/UnRollLoopSequential.cs
index 0bb934f02a..241899e1c5 100644
--- a/src/Nncase.Core/Passes/Mutators/UnRollLoopSequential.cs
+++ b/src/Nncase.Core/Passes/Mutators/UnRollLoopSequential.cs
@@ -144,6 +144,11 @@ public LoopBodyCloner(IReadOnlyDictionary<Var, TensorConst> vmap, Dictionary<Typ
             }
         }
 
+        protected override Expr VisitLeafMemSpan(MemSpan expr, Unit context)
+        {
+            return expr.With(Clone(expr.Start, context), Clone(expr.Size, context));
+        }
+
         protected override Expr VisitLeafVar(Var expr, Unit context)
         {
             if (_vmap.TryGetValue(expr, out var result))
diff --git a/src/Nncase.Evaluator/Math/Binary.cs b/src/Nncase.Evaluator/Math/Binary.cs
index 8f91f52067..1ac424b0be 100755
--- a/src/Nncase.Evaluator/Math/Binary.cs
+++ b/src/Nncase.Evaluator/Math/Binary.cs
@@ -70,6 +70,8 @@ public IRType Visit(ITypeInferenceContext context, Binary target)
         {
             (TensorType a, TensorType b) => Visit(target, a, b),
             (DistributedType a, DistributedType b) => Visit(target, a, b),
+            (AnyType, _) => AnyType.Default,
+            (_, AnyType) => AnyType.Default,
             _ => new InvalidType($"{lhs} {rhs}"),
         };
     }
diff --git a/src/Nncase.Evaluator/NN/Conv2D.cs b/src/Nncase.Evaluator/NN/Conv2D.cs
index f4315d22a9..9ff14e5256 100644
--- a/src/Nncase.Evaluator/NN/Conv2D.cs
+++ b/src/Nncase.Evaluator/NN/Conv2D.cs
@@ -55,6 +55,8 @@ public IRType Visit(ITypeInferenceContext context, Conv2D target)
         {
             (DistributedType a, DistributedType b) => Visit(context, target, a, b, (DistributedType)bias),
             (TensorType a, TensorType b) => Visit(context, target, a, b),
+            (AnyType, _) => AnyType.Default,
+            (_, AnyType) => AnyType.Default,
             _ => new InvalidType(string.Empty),
         };
     }
diff --git a/src/Nncase.Evaluator/Tensors/Reshape.cs b/src/Nncase.Evaluator/Tensors/Reshape.cs
index 8f3ce698ae..7488739f1e 100644
--- a/src/Nncase.Evaluator/Tensors/Reshape.cs
+++ b/src/Nncase.Evaluator/Tensors/Reshape.cs
@@ -39,6 +39,7 @@ public IRType Visit(ITypeInferenceContext context, Reshape target)
         {
             TensorType tensorType => Visit(context, target, tensorType),
             DistributedType distributedType => Visit(context, target, distributedType),
+            AnyType => AnyType.Default,
             _ => throw new NotImplementedException(),
         };
     }
diff --git a/src/Nncase.Evaluator/Tensors/Slice.cs b/src/Nncase.Evaluator/Tensors/Slice.cs
index ed68b2b56c..08de735500 100644
--- a/src/Nncase.Evaluator/Tensors/Slice.cs
+++ b/src/Nncase.Evaluator/Tensors/Slice.cs
@@ -50,6 +50,7 @@ public IRType Visit(ITypeInferenceContext context, Slice target)
         {
             TensorType t => Visit(context, target, t),
             DistributedType d => Visit(context, target, d),
+            AnyType => AnyType.Default,
             _ => new InvalidType(input.GetType().Name),
         };
     }
diff --git a/src/Nncase.Evaluator/Tensors/Transpose.cs b/src/Nncase.Evaluator/Tensors/Transpose.cs
index 350133289b..d643370aa9 100644
--- a/src/Nncase.Evaluator/Tensors/Transpose.cs
+++ b/src/Nncase.Evaluator/Tensors/Transpose.cs
@@ -71,6 +71,7 @@ public IRType Visit(ITypeInferenceContext context, Transpose target)
         {
             DistributedType d => Visit(context, target, d),
             TensorType t => Visit(context, target, t),
+            AnyType => AnyType.Default,
             _ => new InvalidType(input.GetType().ToString()),
         };
     }
diff --git a/src/Nncase.Passes/Mutators/IFusionMergeRule.cs b/src/Nncase.Passes/Mutators/IFusionMergeRule.cs
index bc1e558b1e..9f72015746 100644
--- a/src/Nncase.Passes/Mutators/IFusionMergeRule.cs
+++ b/src/Nncase.Passes/Mutators/IFusionMergeRule.cs
@@ -668,7 +668,7 @@ private bool ProcessFusionMerge(Func<Expr, Expr> mergedFusionRewriteCallBack, Fu
         {
             if (caller_inputs[i] is Call { Target: Fusion })
             {
-                if (result[$"callee_fusion_{i}"] is not Fusion callee_fusion)
+                if (result.GetValueOrDefault($"callee_fusion_{i}") is not Fusion callee_fusion)
                 {
                     return false;
                 }
diff --git a/src/Nncase.Tests/Core/UnitTestTypeInfer.cs b/src/Nncase.Tests/Core/UnitTestTypeInfer.cs
index 7709f353b2..bc9def3e85 100644
--- a/src/Nncase.Tests/Core/UnitTestTypeInfer.cs
+++ b/src/Nncase.Tests/Core/UnitTestTypeInfer.cs
@@ -173,7 +173,7 @@ public void TestReInference()
         Const b = 2;
         Function f = new("f", x + b, new[] { x });
         CompilerServices.InferenceType(f);
-        Assert.IsNotType<AnyType>(f.Body.CheckedType);
+        Assert.IsType<AnyType>(f.Body.CheckedType);
 
         // 2. after the  transfrom the dag is valid type
         var y = x.With(typeAnnotation: TensorType.Scalar(DataTypes.Int32));
diff --git a/src/Nncase.Tests/Rules/Neutral/UnitTestFoldSwish.cs b/src/Nncase.Tests/Rules/Neutral/UnitTestFoldSwish.cs
index 897d1b04cb..95c2c010a4 100644
--- a/src/Nncase.Tests/Rules/Neutral/UnitTestFoldSwish.cs
+++ b/src/Nncase.Tests/Rules/Neutral/UnitTestFoldSwish.cs
@@ -74,7 +74,8 @@ public void TestFoldSwishPattern2Positive2(int[] shape)
         Expr rootPre;
         {
             var v0 = input;
-            var v1 = IR.F.NN.Sigmoid(v0);
+            var v0_2 = IR.F.Math.Binary(BinaryOp.Mul, v0, 2.0f);
+            var v1 = IR.F.NN.Sigmoid(v0_2);
             var v2 = IR.F.Math.Binary(BinaryOp.Mul, v0, v1);
             rootPre = v2;
         }

From b974d530454705b6057e4fc3993119848fff7f60 Mon Sep 17 00:00:00 2001
From: huochenghai <huochenghai@canaan-creative.com>
Date: Wed, 1 Nov 2023 11:15:56 +0800
Subject: [PATCH 292/308] fix test_cli output dump

---
 src/Native/src/test_cli.cpp | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/Native/src/test_cli.cpp b/src/Native/src/test_cli.cpp
index 5858d3cb0c..cd900254ef 100644
--- a/src/Native/src/test_cli.cpp
+++ b/src/Native/src/test_cli.cpp
@@ -79,20 +79,22 @@ result<void> run_core(const std::string &kmodel_path,
                        1e6);
 
         if (i == (loop_count - 1)) {
-            if (entry->parameters_size() == (bins.size() - 1)) {
+            if (ret.is_a<tensor>()) {
                 auto output_bin = bins.back();
                 std::ofstream output_stream(output_bin, std::ios::binary);
-                if (ret.is_a<tensor>()) {
-                    try_(write_tensor_buffer(ret, output_stream));
-                } else if (ret.is_a<tuple>()) {
-                    try_var(tp, ret.as<tuple>());
-                    for (auto &&ret_v : tp->fields()) {
-                        try_(write_tensor_buffer(ret_v, output_stream));
-                    }
-                } else {
-                    return nncase::err(std::errc::bad_message);
-                }
+                try_(write_tensor_buffer(ret, output_stream));
                 output_stream.close();
+            } else if (ret.is_a<tuple>()) {
+                try_var(tp, ret.as<tuple>());
+                auto o = 0;
+                for (auto &&ret_v : tp->fields()) {
+                    auto output_bin = bins[entry->parameters_size() + (o++)];
+                    std::ofstream output_stream(output_bin, std::ios::binary);
+                    try_(write_tensor_buffer(ret_v, output_stream));
+                    output_stream.close();
+                }
+            } else {
+                return nncase::err(std::errc::bad_message);
             }
         }
     }

From 77d485df1cdaca83187c161c802a0b6f05fe8ffe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Tue, 31 Oct 2023 12:14:11 +0800
Subject: [PATCH 293/308] fix command line

---
 src/Nncase.Cli/Compile.cs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/Nncase.Cli/Compile.cs b/src/Nncase.Cli/Compile.cs
index c33a977903..b5e7f192d6 100644
--- a/src/Nncase.Cli/Compile.cs
+++ b/src/Nncase.Cli/Compile.cs
@@ -53,7 +53,10 @@ public CompileCommand()
           getDefaultValue: () => "tflite");
         DumpFlags = new Option<IEnumerable<DumpFlags>>(
           name: "--dump-flags",
-          description: "dump ir flags. \navailable value: None,ImportOps,PassIR,EGraphCost,Rewrite,Calibration,Evaluator,Compile,Tiling,Schedule,CodeGen.");
+          description: "dump ir flags. \navailable value: None,ImportOps,PassIR,EGraphCost,Rewrite,Calibration,Evaluator,Compile,Tiling,Schedule,CodeGen.")
+        {
+            AllowMultipleArgumentsPerToken = true,
+        };
         DumpDir = new Option<string>(
           name: "--dump-dir",
           description: "dump to directory.",
@@ -90,7 +93,10 @@ public CompileCommand()
                 return result.Tokens.
                     Select(tk => tk.Value.Split(":").ToArray()).
                     Select(tp => (tp[0].Trim(), int.Parse(tp[1].Trim())));
-            });
+            })
+        {
+            AllowMultipleArgumentsPerToken = true,
+        };
         AddArgument(InputFile);
         AddArgument(OutputFile);
         AddGlobalOption(InputFormat);

From df1eecdb02fbe5df95aa6eea6b69b4c27e5d5533 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Wed, 1 Nov 2023 13:44:12 +0800
Subject: [PATCH 294/308] fix type infer

---
 src/Nncase.Evaluator/Math/MatMul.cs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Nncase.Evaluator/Math/MatMul.cs b/src/Nncase.Evaluator/Math/MatMul.cs
index 4269b23854..1f19b64388 100644
--- a/src/Nncase.Evaluator/Math/MatMul.cs
+++ b/src/Nncase.Evaluator/Math/MatMul.cs
@@ -94,6 +94,9 @@ public static IRType VisitDistributedType(DistributedType a, DistributedType b)
 
                     ndsbp[i] = SBP.S(bx + bPad);
                     break;
+                case (SBPBroadCast, SBPBroadCast):
+                    ndsbp[i] = SBP.B;
+                    break;
                 default:
                     return invalid;
             }

From d8ec1722a461250b22f81d76139c660f31646465 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 2 Nov 2023 15:22:12 +0800
Subject: [PATCH 295/308] fix format

---
 src/Nncase.Cli/Compile.cs                     | 98 +++++++++++++++++--
 src/Nncase.Cli/Program.cs                     | 11 +++
 src/Nncase.Evaluator/NN/Conv2DTranspose.cs    |  2 +-
 .../Rules/Neutral/CombineQuantize.cs          |  2 +-
 4 files changed, 102 insertions(+), 11 deletions(-)

diff --git a/src/Nncase.Cli/Compile.cs b/src/Nncase.Cli/Compile.cs
index b5e7f192d6..e7f65a5303 100644
--- a/src/Nncase.Cli/Compile.cs
+++ b/src/Nncase.Cli/Compile.cs
@@ -4,17 +4,8 @@
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Nncase.CodeGen;
-using Nncase.Compiler;
 using Nncase.Diagnostics;
-using Nncase.IR;
-using Nncase.Passes;
 using Nncase.Quantization;
 
 namespace Nncase.Cli;
@@ -97,6 +88,62 @@ public CompileCommand()
         {
             AllowMultipleArgumentsPerToken = true,
         };
+        PreProcess = new Option<bool>(
+            name: "--pre-process",
+            description: "whether enable pre process",
+            getDefaultValue: () => false);
+        InputLayout = new Option<string>(
+            name: "--input-layout",
+            description: "the model input data layout",
+            getDefaultValue: () => string.Empty).FromAmong("NCHW", "NHWC");
+        OutputLayout = new Option<string>(
+            name: "--output-layout",
+            description: "the model output data layout.",
+            getDefaultValue: () => string.Empty).FromAmong("NCHW", "NHWC");
+        InputType = new Option<InputType>(
+            name: "--input-type",
+            description: "the model input data value type, default is Float32",
+            getDefaultValue: () => Nncase.InputType.Float32);
+        InputShape = new Option<IEnumerable<int>>(
+            name: "--input-shape",
+            description: "the model input data shape. eg. `--input-shape 1 2 3 4`",
+            getDefaultValue: Array.Empty<int>)
+        {
+            AllowMultipleArgumentsPerToken = true,
+        };
+        InputRange = new Option<IEnumerable<float>>(
+            name: "--input-range",
+            description: "the model input data value range. eg `--input-range -100.3 200.4`",
+            getDefaultValue: Array.Empty<float>)
+        {
+            AllowMultipleArgumentsPerToken = true,
+        };
+        SwapRB = new Option<bool>(
+            name: "--swap-rb",
+            description: "whether swap the model input data channel, like cv2.BGRtoRGB(im)",
+            getDefaultValue: () => false);
+        LetterBoxValue = new Option<float>(
+            name: "--letter-box-value",
+            description: "letterbox fill value",
+            getDefaultValue: () => 0.0f);
+        Mean = new Option<IEnumerable<float>>(
+            name: "--mean",
+            description: "the model input data mean, default []",
+            getDefaultValue: Array.Empty<float>)
+        {
+            AllowMultipleArgumentsPerToken = true,
+        };
+        Std = new Option<IEnumerable<float>>(
+            name: "--std",
+            description: "the model input data std, default []",
+            getDefaultValue: Array.Empty<float>)
+        {
+            AllowMultipleArgumentsPerToken = true,
+        };
+        ModelLayout = new Option<string>(
+            name: "--model-layout",
+            description: "the model's input layout.",
+            getDefaultValue: () => string.Empty).FromAmong("NCHW", "NHWC");
         AddArgument(InputFile);
         AddArgument(OutputFile);
         AddGlobalOption(InputFormat);
@@ -109,6 +156,17 @@ public CompileCommand()
         AddGlobalOption(ModelQuantMode);
         AddGlobalOption(CalibMethod);
         AddGlobalOption(FixedVars);
+        AddGlobalOption(PreProcess);
+        AddGlobalOption(InputLayout);
+        AddGlobalOption(OutputLayout);
+        AddGlobalOption(InputType);
+        AddGlobalOption(InputShape);
+        AddGlobalOption(InputRange);
+        AddGlobalOption(SwapRB);
+        AddGlobalOption(LetterBoxValue);
+        AddGlobalOption(Mean);
+        AddGlobalOption(Std);
+        AddGlobalOption(ModelLayout);
     }
 
     public Argument<string> InputFile { get; }
@@ -134,4 +192,26 @@ public CompileCommand()
     public Option<CalibMethod> CalibMethod { get; }
 
     public Option<IEnumerable<(string Name, int Value)>> FixedVars { get; }
+
+    public Option<bool> PreProcess { get; }
+
+    public Option<string> InputLayout { get; }
+
+    public Option<string> OutputLayout { get; }
+
+    public Option<InputType> InputType { get; }
+
+    public Option<IEnumerable<int>> InputShape { get; }
+
+    public Option<IEnumerable<float>> InputRange { get; }
+
+    public Option<bool> SwapRB { get; }
+
+    public Option<float> LetterBoxValue { get; }
+
+    public Option<IEnumerable<float>> Mean { get; }
+
+    public Option<IEnumerable<float>> Std { get; }
+
+    public Option<string> ModelLayout { get; }
 }
diff --git a/src/Nncase.Cli/Program.cs b/src/Nncase.Cli/Program.cs
index 15058f923c..d4f0d2aa3e 100644
--- a/src/Nncase.Cli/Program.cs
+++ b/src/Nncase.Cli/Program.cs
@@ -95,6 +95,17 @@ private static CompileOptions ParseCompileOptions(System.CommandLine.Invocation.
             InputFormat = context.ParseResult.GetValueForOption(compilecmd.InputFormat)!,
             DumpFlags = context.ParseResult.GetValueForOption(compilecmd.DumpFlags)!.Aggregate(Diagnostics.DumpFlags.None, (a, b) => a | b),
             DumpDir = context.ParseResult.GetValueForOption(compilecmd.DumpDir)!,
+            PreProcess = context.ParseResult.GetValueForOption(compilecmd.PreProcess)!,
+            InputLayout = context.ParseResult.GetValueForOption(compilecmd.InputLayout)!,
+            OutputLayout = context.ParseResult.GetValueForOption(compilecmd.OutputLayout)!,
+            InputType = context.ParseResult.GetValueForOption(compilecmd.InputType)!,
+            InputShape = context.ParseResult.GetValueForOption(compilecmd.InputShape)!.ToArray(),
+            InputRange = context.ParseResult.GetValueForOption(compilecmd.InputRange)!.ToArray(),
+            SwapRB = context.ParseResult.GetValueForOption(compilecmd.SwapRB)!,
+            LetterBoxValue = context.ParseResult.GetValueForOption(compilecmd.LetterBoxValue)!,
+            Mean = context.ParseResult.GetValueForOption(compilecmd.Mean)!.ToArray(),
+            Std = context.ParseResult.GetValueForOption(compilecmd.Std)!.ToArray(),
+            ModelLayout = context.ParseResult.GetValueForOption(compilecmd.ModelLayout)!,
             QuantizeOptions = new()
             {
                 CalibrationMethod = context.ParseResult.GetValueForOption(compilecmd.CalibMethod),
diff --git a/src/Nncase.Evaluator/NN/Conv2DTranspose.cs b/src/Nncase.Evaluator/NN/Conv2DTranspose.cs
index 56ae681279..66c950fdc7 100644
--- a/src/Nncase.Evaluator/NN/Conv2DTranspose.cs
+++ b/src/Nncase.Evaluator/NN/Conv2DTranspose.cs
@@ -107,7 +107,7 @@ public IValue Visit(IEvaluateContext context, Conv2DTranspose conv)
 
         for (int i = 0; i < outputSize; i++)
         {
-            var biasIdx = i / (outputShape[2] * outputShape[3]) % outputShape[1];
+            var biasIdx = (i / (outputShape[2] * outputShape[3])) % outputShape[1];
             outCache[i] = outCache[i] + biasArray[biasIdx];
         }
 
diff --git a/src/Nncase.Passes/Rules/Neutral/CombineQuantize.cs b/src/Nncase.Passes/Rules/Neutral/CombineQuantize.cs
index a350f542a3..9519b011c7 100644
--- a/src/Nncase.Passes/Rules/Neutral/CombineQuantize.cs
+++ b/src/Nncase.Passes/Rules/Neutral/CombineQuantize.cs
@@ -55,7 +55,7 @@ public sealed partial class CombineQuantizeConcat : RewriteRule<Pattern>
             }
         }
 
-        return Concat(new IR.Tuple(tupleInputs.Select(e => IR.F.Math.Quantize(e, quantParam, quantize.TargetType)).ToArray()), axis);
+        return Concat(new IR.Tuple(tupleInputs.Select(e => IR.F.Math.Quantize(e, quantParam, quantize.TargetType)).ToArray()), concat.Axis);
     }
 }
 

From 6451b1cab775cf7707d6b4aa675286402aa1cc6d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Thu, 2 Nov 2023 17:43:19 +0800
Subject: [PATCH 296/308] fix all test

---
 .../Converters/ConvertersModule.cs            |  1 +
 .../Converters/PointerConverters.cs           | 22 +++++
 src/Nncase.Core/DataType.cs                   |  5 +-
 src/Nncase.Core/DataTypes.cs                  |  4 +-
 src/Nncase.Core/IR/IRType.cs                  |  2 +-
 src/Nncase.Core/IR/Var.cs                     |  2 +-
 src/Nncase.Core/Tensor.cs                     |  8 +-
 .../BufferSchedule/LifeTimeCollector.cs       |  2 +-
 src/Nncase.Passes/DDrBufferSchdeulePass.cs    |  4 +-
 .../Core/IR/UnitTestTensorConst.cs            |  2 +-
 src/Nncase.Tests/Core/UnitTestDataType.cs     |  2 +-
 src/Nncase.Tests/Core/UnitTestDataTypes.cs    |  6 +-
 src/Nncase.Tests/Core/UnitTestTensor.cs       |  2 +-
 .../Diagnostics/UnitTestDumpper.cs            |  2 +-
 ...nitTestPytestCalibrationDatasetProvider.cs | 84 ++++---------------
 .../Rewrite/Fusion/UnitTestFusionGroup.cs     |  3 +-
 .../TIR/PrimFunc/IDataFlowPrimFuncCase.cs     |  7 +-
 .../TIR/PrimFunc/UnitTestPrimFuncMerge.cs     |  7 +-
 src/Nncase.Tests/TIR/UnitTestMutators.cs      |  2 +-
 19 files changed, 70 insertions(+), 97 deletions(-)

diff --git a/src/Nncase.Core/Converters/ConvertersModule.cs b/src/Nncase.Core/Converters/ConvertersModule.cs
index c7e5d4a9bc..3b406a8c88 100644
--- a/src/Nncase.Core/Converters/ConvertersModule.cs
+++ b/src/Nncase.Core/Converters/ConvertersModule.cs
@@ -28,5 +28,6 @@ public void ConfigureServices(IRegistrator registrator)
         registrator.RegisterManyInterface<UInt64Converters>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<UInt8Converters>(reuse: Reuse.Singleton);
         registrator.RegisterManyInterface<PointerConverters>(reuse: Reuse.Singleton);
+        registrator.RegisterManyInterface<PointerIntConverters>(reuse: Reuse.Singleton);
     }
 }
diff --git a/src/Nncase.Core/Converters/PointerConverters.cs b/src/Nncase.Core/Converters/PointerConverters.cs
index af274fab5e..134c773609 100644
--- a/src/Nncase.Core/Converters/PointerConverters.cs
+++ b/src/Nncase.Core/Converters/PointerConverters.cs
@@ -30,3 +30,25 @@ public void ConvertTo<T>(ReadOnlySpan<Pointer<T>> source, Span<ulong> dest, Cast
         }
     }
 }
+
+internal class PointerIntConverters : IPointerSpanConverter<int>
+{
+    public void ConvertTo<T>(ReadOnlySpan<Pointer<T>> source, Span<int> dest, CastMode castMode)
+        where T : unmanaged, IEquatable<T>
+    {
+        if (castMode != CastMode.KDefault)
+        {
+            throw new InvalidCastException();
+        }
+
+        if (dest.Length < source.Length)
+        {
+            throw new ArgumentException("Dest buffer is not sufficient.");
+        }
+
+        for (int i = 0; i < source.Length; i++)
+        {
+            dest[i] = checked((int)source[i].Value);
+        }
+    }
+}
diff --git a/src/Nncase.Core/DataType.cs b/src/Nncase.Core/DataType.cs
index 4b86755d22..04c3170301 100644
--- a/src/Nncase.Core/DataType.cs
+++ b/src/Nncase.Core/DataType.cs
@@ -42,8 +42,7 @@ public enum PrimTypeAttributes
 /// </example>
 /// </summary>
 /// <param name="ElemType"> the type the pointer points to. </param>
-/// <param name="Shape">the shape of the pointer points to.</param>
-public sealed record PointerType(DataType ElemType, IR.Shape Shape) : DataType
+public sealed record PointerType(DataType ElemType) : DataType
 {
     /// <inheritdoc/>
     public override Type CLRType { get; } = typeof(Pointer<>).MakeGenericType(ElemType.CLRType);
@@ -82,7 +81,7 @@ public static DataType FromType(Type t)
         {
             if (t.GetGenericTypeDefinition() == typeof(Pointer<>))
             {
-                return new PointerType(FromType(t.GenericTypeArguments[0]), IR.Shape.Scalar);
+                return new PointerType(FromType(t.GenericTypeArguments[0]));
             }
 
             throw new ArgumentException("Unsupported CLR type.");
diff --git a/src/Nncase.Core/DataTypes.cs b/src/Nncase.Core/DataTypes.cs
index 3c8b65fd3d..0b59a5696e 100644
--- a/src/Nncase.Core/DataTypes.cs
+++ b/src/Nncase.Core/DataTypes.cs
@@ -114,7 +114,7 @@ public static bool IsPointer(this DataType srcType) =>
     /// <returns> datatype name.</returns>
     public static string GetDisplayName(this DataType dataType) => dataType switch
     {
-        PointerType pointerType => $"({GetDisplayName(pointerType.ElemType)}{(pointerType.Shape.IsScalar ? string.Empty : pointerType.Shape.ToString())} *)",
+        PointerType pointerType => $"({GetDisplayName(pointerType.ElemType)} *)",
         PrimType primType => primType.ShortName,
         ValueType => dataType.ToString(),
         _ => throw new ArgumentOutOfRangeException(dataType.GetType().Name),
@@ -128,7 +128,7 @@ public static bool IsPointer(this DataType srcType) =>
     public static string GetCSharpName(this DataType dataType) => dataType switch
     {
         PrimType primType => $"DataTypes.{primType.FullName}",
-        PointerType pointerType => $"new PointerType({pointerType.ElemType.GetCSharpName()}, IR.Shape.Scalar)",
+        PointerType pointerType => $"new PointerType({pointerType.ElemType.GetCSharpName()})",
         ValueType valueType => $"new {valueType.GetType().Name}()",
         _ => throw new ArgumentOutOfRangeException(dataType.GetType().Name),
     };
diff --git a/src/Nncase.Core/IR/IRType.cs b/src/Nncase.Core/IR/IRType.cs
index 80cb2fddb0..a4311aae13 100644
--- a/src/Nncase.Core/IR/IRType.cs
+++ b/src/Nncase.Core/IR/IRType.cs
@@ -138,7 +138,7 @@ public sealed record TensorType(DataType DType, Shape Shape) : IRType
     /// </summary>
     /// <param name="elemType"> the Pointed Element Type.</param>
     /// <returns>the pointer tensor type.</returns>
-    public static TensorType Pointer(DataType elemType) => new(new PointerType(elemType, Shape.Scalar), Shape.Scalar);
+    public static TensorType Pointer(DataType elemType) => new(new PointerType(elemType), Shape.Scalar);
 
     /// <inheritdoc/>
     public override string ToString() => DType switch
diff --git a/src/Nncase.Core/IR/Var.cs b/src/Nncase.Core/IR/Var.cs
index a37d90eb80..af1987e16b 100644
--- a/src/Nncase.Core/IR/Var.cs
+++ b/src/Nncase.Core/IR/Var.cs
@@ -92,7 +92,7 @@ public Var()
     /// get handle var.
     /// </summary>
     /// <returns> var. </returns>
-    public static Var Handle(string name, DataType dtype, string scope = "") => new Var(name, TensorType.Scalar(new PointerType(dtype, Shape.Scalar)));
+    public static Var Handle(string name, DataType dtype, string scope = "") => new Var(name, TensorType.Scalar(new PointerType(dtype)));
 
     /// <summary>
     /// get the size var. it can be used in tensor shape. like n>=0, m>=0.
diff --git a/src/Nncase.Core/Tensor.cs b/src/Nncase.Core/Tensor.cs
index a4875bf7c5..78f3e5e999 100644
--- a/src/Nncase.Core/Tensor.cs
+++ b/src/Nncase.Core/Tensor.cs
@@ -342,18 +342,18 @@ public static unsafe Tensor FromArray(Array array)
     public static Tensor<Pointer<T>> FromPointer<T>(ulong value)
       where T : unmanaged, IEquatable<T>
     {
-        return Tensor.FromScalar<Pointer<T>>(new Pointer<T>(value));
+        return FromScalar<Pointer<T>>(new Pointer<T>(value));
     }
 
     /// <summary>
     /// Create tensor from a ulong address.
     /// </summary>
     /// <param name="value">addr value.</param>
-    /// <param name="pointerType">points type.</param>
+    /// <param name="elemType">pointed type.</param>
     /// <returns>Created tensor.</returns>
-    public static Tensor FromPointer(ulong value, PointerType pointerType)
+    public static Tensor FromPointer(ulong value, DataType elemType)
     {
-        return Tensor.FromBytes(TensorType.Scalar(pointerType), BitConverter.GetBytes(value));
+        return FromBytes(TensorType.Scalar(new PointerType(elemType)), BitConverter.GetBytes(value));
     }
 
     /// <summary>
diff --git a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
index 284a56b659..1edcc263dd 100644
--- a/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
+++ b/src/Nncase.Passes/BufferSchedule/LifeTimeCollector.cs
@@ -120,7 +120,7 @@ private void Alias()
                     changed = AliasTime(splitCall, interval);
                 }
             }
-        } while (!changed);
+        } while (changed);
     }
 
     private bool AliasTime(Call call, TimeInterval interval)
diff --git a/src/Nncase.Passes/DDrBufferSchdeulePass.cs b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
index e695b88813..80aebda267 100644
--- a/src/Nncase.Passes/DDrBufferSchdeulePass.cs
+++ b/src/Nncase.Passes/DDrBufferSchdeulePass.cs
@@ -126,7 +126,7 @@ protected override Expr RewriteLeafBuffer(TIR.Buffer expr)
             _functionUsage[memSpan.Location] = start + size.Value.ToScalar<int>();
             Changed = true;
 
-            return expr.With(memSpan: memSpan.With(start: Tensor.FromPointer((ulong)start, new PointerType(expr.ElemType, expr.Dimensions.ToArray().Select(d => ((TensorConst)d).Value.ToScalar<int>()).ToArray()))));
+            return expr.With(memSpan: memSpan.With(start: Tensor.FromPointer((ulong)start, expr.ElemType)));
         }
 
         return expr;
@@ -163,7 +163,7 @@ protected override TIR.MemSpan RewriteLeafMemSpan(TIR.MemSpan memSpan)
                 Changed = true;
             }
 
-            return memSpan.With(new TensorConst(Tensor.FromPointer((ulong)memRange.Min, new PointerType(constType.DType, constType.Shape))), memRange.Max - memRange.Min);
+            return memSpan.With(new TensorConst(Tensor.FromPointer((ulong)memRange.Min, constType.DType)), memRange.Max - memRange.Min);
         }
 
         return memSpan;
diff --git a/src/Nncase.Tests/Core/IR/UnitTestTensorConst.cs b/src/Nncase.Tests/Core/IR/UnitTestTensorConst.cs
index d98bf5ed13..c444a0e45b 100644
--- a/src/Nncase.Tests/Core/IR/UnitTestTensorConst.cs
+++ b/src/Nncase.Tests/Core/IR/UnitTestTensorConst.cs
@@ -179,7 +179,7 @@ public void TestTensorType()
         var actual2 = TensorType.Invalid(DataTypes.Float32);
         Assert.Equal(expect2, actual2);
 
-        var expect3 = new TensorType(new PointerType(DataTypes.Float32, Shape.Scalar), Shape.Scalar);
+        var expect3 = new TensorType(new PointerType(DataTypes.Float32), Shape.Scalar);
         var actual3 = TensorType.Pointer(DataTypes.Float32);
         Assert.Equal(expect3, actual3);
     }
diff --git a/src/Nncase.Tests/Core/UnitTestDataType.cs b/src/Nncase.Tests/Core/UnitTestDataType.cs
index 410b6a13d3..bb734e2671 100644
--- a/src/Nncase.Tests/Core/UnitTestDataType.cs
+++ b/src/Nncase.Tests/Core/UnitTestDataType.cs
@@ -15,7 +15,7 @@ public sealed class UnitTestDataType
     [Fact]
     public void TestPointerType()
     {
-        var pType = new PointerType(DataTypes.Float32, IR.Shape.Scalar);
+        var pType = new PointerType(DataTypes.Float32);
         Assert.Equal(8, pType.SizeInBytes);
 
         var t = DataType.FromType(typeof(Pointer<int>));
diff --git a/src/Nncase.Tests/Core/UnitTestDataTypes.cs b/src/Nncase.Tests/Core/UnitTestDataTypes.cs
index cc47d819c2..183f65a140 100644
--- a/src/Nncase.Tests/Core/UnitTestDataTypes.cs
+++ b/src/Nncase.Tests/Core/UnitTestDataTypes.cs
@@ -53,7 +53,7 @@ public void TestIsFloat()
     public void TestIsPointer()
     {
         Assert.False(DataTypes.IsPointer(DataTypes.Float32));
-        Assert.True(DataTypes.IsPointer(new PointerType(DataTypes.Float32, IR.Shape.Scalar)));
+        Assert.True(DataTypes.IsPointer(new PointerType(DataTypes.Float32)));
     }
 
     [Fact]
@@ -61,7 +61,7 @@ public void TestGetDisplayName()
     {
         var a = new QuantParamType();
         Assert.Equal(a.ToString(), DataTypes.GetDisplayName(a));
-        Assert.Equal("(f32 *)", DataTypes.GetDisplayName(new PointerType(DataTypes.Float32, IR.Shape.Scalar)));
+        Assert.Equal("(f32 *)", DataTypes.GetDisplayName(new PointerType(DataTypes.Float32)));
         Assert.Equal(DataTypes.Boolean.ShortName, DataTypes.GetDisplayName(DataTypes.Boolean));
         Assert.Equal(DataTypes.Utf8Char.ShortName, DataTypes.GetDisplayName(DataTypes.Utf8Char));
         Assert.Equal(DataTypes.Int8.ShortName, DataTypes.GetDisplayName(DataTypes.Int8));
@@ -82,7 +82,7 @@ public void TestGetDisplayName()
     public void TestCSharpName()
     {
         Assert.Equal("new QuantParamType()", DataTypes.GetCSharpName(new QuantParamType()));
-        Assert.Equal("new PointerType(DataTypes.Float32, IR.Shape.Scalar)", DataTypes.GetCSharpName(new PointerType(DataTypes.Float32, IR.Shape.Scalar)));
+        Assert.Equal("new PointerType(DataTypes.Float32)", DataTypes.GetCSharpName(new PointerType(DataTypes.Float32)));
         Assert.Equal("DataTypes.Boolean", DataTypes.GetCSharpName(DataTypes.Boolean));
         Assert.Equal("DataTypes.Utf8Char", DataTypes.GetCSharpName(DataTypes.Utf8Char));
         Assert.Equal("DataTypes.Int8", DataTypes.GetCSharpName(DataTypes.Int8));
diff --git a/src/Nncase.Tests/Core/UnitTestTensor.cs b/src/Nncase.Tests/Core/UnitTestTensor.cs
index 259de59424..28a4c31c6e 100644
--- a/src/Nncase.Tests/Core/UnitTestTensor.cs
+++ b/src/Nncase.Tests/Core/UnitTestTensor.cs
@@ -111,7 +111,7 @@ public unsafe void TestFromPointerET()
         var p1 = new Pointer<int>(addr1);
         var p2 = new Pointer<int>(addr2);
 
-        var t = Tensor.FromPointer(addr1, new PointerType(DataTypes.Int32, Shape.Scalar));
+        var t = Tensor.FromPointer(addr1, DataTypes.Int32);
         Assert.Equal(p1, t.ToScalar<Pointer<int>>());
         Assert.Equal(addr1, t.ToScalar<Pointer<int>>().Value);
         Assert.NotEqual(p2, t.ToScalar<Pointer<int>>());
diff --git a/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs b/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
index ccf74e1556..dcd94f1303 100644
--- a/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
+++ b/src/Nncase.Tests/Diagnostics/UnitTestDumpper.cs
@@ -227,7 +227,7 @@ public void TestDumpTIRFusion()
     {
         var lhs = new Var("lhs", TensorType.Scalar(DataTypes.Float32));
         var main = T.PrimFunc("main", DefaultTargetName).Body(
-          new Call(new TIRTest.MeshNet(), new Fusion("MeshFunc", lhs + 100, lhs), IR.F.Random.Normal(DataTypes.Float32, 0, 1, 123, new[] { 100 }))).Build();
+          new Call(new TIRTest.MeshNet(), new Fusion("MeshFunc", lhs + 100.0f, lhs), IR.F.Random.Normal(DataTypes.Float32, 0, 1, 123, new[] { 100 }))).Build();
         Assert.True(CompilerServices.InferenceType(main));
         CompilerServices.DumpIR(main, string.Empty, Dumpper.Directory);
     }
diff --git a/src/Nncase.Tests/Quant/UnitTestPytestCalibrationDatasetProvider.cs b/src/Nncase.Tests/Quant/UnitTestPytestCalibrationDatasetProvider.cs
index 6d2f29ce71..65e694e129 100644
--- a/src/Nncase.Tests/Quant/UnitTestPytestCalibrationDatasetProvider.cs
+++ b/src/Nncase.Tests/Quant/UnitTestPytestCalibrationDatasetProvider.cs
@@ -33,89 +33,37 @@ public async Task TestPytestCalibrationDatasetProvider1()
     {
         var vars = Setup();
         var dataset = "./public/test1";
-        foreach (var t in vars)
+        var actuals = DumpTensors(dataset, vars, 2);
+        var provider = new PytestCalibrationDatasetProvider(vars, dataset);
+        Assert.Equal(2, provider.Count);
+        var samples = provider.Samples;
+        var count = 0;
+        await foreach (var sample in samples)
         {
-            var actual = IR.F.Random.Uniform(t.CheckedDataType, 1.0f, -1.0f, 0, t.CheckedShape).Evaluate().AsTensor();
-            DumpTensors(new[] { actual }, dataset, 2);
-            var provider = new PytestCalibrationDatasetProvider(new[] { t }, dataset);
-            Assert.Equal(2, provider.Count);
-            var samples = provider.Samples;
-            await foreach (var sample in samples)
-            {
-                Assert.Equal(sample[t].AsTensor(), actual);
-            }
-        }
-    }
-
-    [Fact]
-    public async Task TestPytestCalibrationDatasetProvider2()
-    {
-        var vars = Setup();
-        var dataset = "./public/test2";
-        foreach (var t in vars)
-        {
-            var actual = IR.F.Random.Uniform(t.CheckedDataType, 1.0f, -1.0f, 0, t.CheckedShape).Evaluate().AsTensor();
-            DumpTensors(new[] { actual }, dataset);
-            var provider = new PytestCalibrationDatasetProvider(new[] { t }, dataset);
-            Assert.Equal(1, provider.Count);
-            var samples = provider.Samples;
-            await foreach (var sample in samples)
-            {
-                Assert.Equal(sample[t].AsTensor(), actual);
-            }
-        }
-    }
-
-    [Fact]
-    public async Task TestPytestCalibrationDatasetProvider3()
-    {
-        var vars1 = Setup();
-        var dataset = "./public/test3";
-        var actual1 = IR.F.Random.Uniform(vars1[0].CheckedDataType, 1.0f, -1.0f, 0, vars1[0].CheckedShape).Evaluate().AsTensor();
-        var actual2 = IR.F.Random.Uniform(vars1[1].CheckedDataType, 1.0f, -1.0f, 0, vars1[1].CheckedShape).Evaluate().AsTensor();
-        DumpTensors(new[] { actual1, actual2 }, dataset);
-        var provider1 = new PytestCalibrationDatasetProvider(vars1, dataset);
-        Assert.Equal(1, provider1.Count);
-        var samples1 = provider1.Samples;
-        await foreach (var sample in samples1)
-        {
-            Assert.Equal(sample[vars1[0]].AsTensor(), actual1);
-            Assert.Equal(sample[vars1[1]].AsTensor(), actual2);
-        }
-    }
-
-    [Fact]
-    public async Task TestPytestCalibrationDatasetProvider4()
-    {
-        var vars1 = Setup();
-        var dataset = "./public/test4";
-        var actual1 = IR.F.Random.Uniform(vars1[0].CheckedDataType, 1.0f, -1.0f, 0, vars1[0].CheckedShape).Evaluate().AsTensor();
-        var actual2 = IR.F.Random.Uniform(vars1[1].CheckedDataType, 1.0f, -1.0f, 0, vars1[1].CheckedShape).Evaluate().AsTensor();
-        DumpTensors(new[] { actual1, actual2 }, dataset, 2);
-        var provider1 = new PytestCalibrationDatasetProvider(vars1, dataset);
-        Assert.Equal(2, provider1.Count);
-        var samples1 = provider1.Samples;
-        await foreach (var sample in samples1)
-        {
-            Assert.Equal(sample[vars1[0]].AsTensor(), actual1);
-            Assert.Equal(sample[vars1[1]].AsTensor(), actual2);
+            Assert.Equal(sample[vars[0]].AsTensor(), actuals[count, 0]);
+            Assert.Equal(sample[vars[1]].AsTensor(), actuals[count, 1]);
+            count++;
         }
     }
 
-    private static void DumpTensors(Tensor[] tensorValue, string dir, int sample = 1)
+    private static Tensor[,] DumpTensors(string dir, Var[] inputs, int sample)
     {
         Directory.CreateDirectory(dir);
+        var outputs = new Tensor[sample, inputs.Length];
         for (var s = 0; s < sample; s++)
         {
-            for (var t = 0; t < tensorValue.Length; t++)
+            for (var t = 0; t < inputs.Length; t++)
             {
-                var value = tensorValue[t];
+                var value = IR.F.Random.Uniform(inputs[t].CheckedDataType, 1.0f, -1.0f, s + t, inputs[t].CheckedShape).Evaluate().AsTensor();
                 var sr1 = new StreamWriter(Path.Join(dir, $"input_{t}_{s}.txt"));
                 DumpTxt(value, sr1);
                 var sr2 = Path.Join(dir, $"input_{t}_{s}.bin");
                 DumpBin(value, sr2);
+                outputs[s, t] = value;
             }
         }
+
+        return outputs;
     }
 
     private static void DumpTxt(Tensor tensorValue, StreamWriter writer)
diff --git a/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionGroup.cs b/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionGroup.cs
index 4ac36d467c..4727832692 100644
--- a/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionGroup.cs
+++ b/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionGroup.cs
@@ -18,7 +18,8 @@ public class UnitTestFusionGroup : TestClassBase
 {
     public static readonly TheoryData<IDataFlowFusionCase> DataOne = new()
     {
-        new DataFlowType16FusionCase(),
+        // new DataFlowType16FusionCase(),
+        new DataFlowType2FusionCaseLeft(),
     };
 
     public static readonly TheoryData<IDataFlowFusionCase> DataAll = new()
diff --git a/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs b/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs
index 0721bfd29d..97dbd1915f 100644
--- a/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs
+++ b/src/Nncase.Tests/TIR/PrimFunc/IDataFlowPrimFuncCase.cs
@@ -124,7 +124,7 @@ private static IEnumerable<BinaryOp> GetBinaryOp(int length)
 
     private sealed class Allocator
     {
-        private readonly Dictionary<TIR.MemoryLocation, int> _usage = new() {
+        private readonly Dictionary<TIR.MemoryLocation, ulong> _usage = new() {
           { TIR.MemoryLocation.Input, 0 },
           { TIR.MemoryLocation.Output, 0 },
           { TIR.MemoryLocation.L2Data, 0 },
@@ -135,8 +135,9 @@ public TIR.Buffer Allocate(string name, TIR.MemoryLocation location)
             var dims = Dimensions.Select(d => (Expr)d).ToArray();
             var strides = TensorUtilities.GetStrides(Dimensions).Select(s => (Expr)s).ToArray();
             var size = TensorUtilities.GetSize(Dimensions, TensorUtilities.GetStrides(Dimensions), DataTypes.Float32.SizeInBytes);
-            var buffer = new TIR.Buffer(name, DataTypes.Float32, new TIR.MemSpan(_usage[location], size, location), dims, strides);
-            _usage[location] += size;
+
+            var buffer = new TIR.Buffer(name, DataTypes.Float32, new TIR.MemSpan(Tensor.FromPointer<float>(_usage[location]), size, location), dims, strides);
+            _usage[location] += (ulong)size;
             return buffer;
         }
     }
diff --git a/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs b/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs
index 1b5ce74461..96c6bb415d 100644
--- a/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs
+++ b/src/Nncase.Tests/TIR/PrimFunc/UnitTestPrimFuncMerge.cs
@@ -44,16 +44,17 @@ public class UnitTestPrimFuncMerge : TestClassBase
 
     public IAnalyzerManager AnalyzerMananger => CompileSession.GetRequiredService<IAnalyzerManager>();
 
-    [Theory]
+    [Theory(Skip = "Disable")]
     [MemberData(nameof(Datas))]
     private async void RunCore(IDataFlowPrimFuncCase fusionCase, int count)
     {
+        var dumper = Diagnostics.DumpScope.Current.CreateSubDummper($"case_{count}");
         var inputVar = new Var("input", new TensorType(DataTypes.Float32, PrimFuncBuilder.Dimensions));
         var main = new Function(fusionCase.BuildBody(inputVar), inputVar);
 
         CompilerServices.InferenceType(main);
 #if DEBUG
-        Dumpper.DumpDotIR(main, $"{count}_pre");
+        Diagnostics.DumpScope.Current.DumpDotIR(main, $"{count}_pre");
 #endif
         var feedDict = new Dictionary<Var, IValue>(ReferenceEqualityComparer.Instance) {
           { inputVar, IR.F.Random.Normal(DataTypes.Float32, 0, 1, 12, PrimFuncBuilder.Dimensions).Evaluate() },
@@ -69,7 +70,7 @@ private async void RunCore(IDataFlowPrimFuncCase fusionCase, int count)
         var post = (Function)module.Entry!;
 
 #if DEBUG
-        Dumpper.DumpDotIR(post, $"{count}_post");
+        Diagnostics.DumpScope.Current.DumpDotIR(post, $"{count}_post");
 #endif
 
         var visitor = new TestVisitor();
diff --git a/src/Nncase.Tests/TIR/UnitTestMutators.cs b/src/Nncase.Tests/TIR/UnitTestMutators.cs
index 7317eb1176..b1e0ceb20e 100644
--- a/src/Nncase.Tests/TIR/UnitTestMutators.cs
+++ b/src/Nncase.Tests/TIR/UnitTestMutators.cs
@@ -76,7 +76,7 @@ public async Task TestFoldConstCallWithTuple()
             int count = 0;
             for (int w = 0; w < 48; w += 9)
             {
-                Assert.True(object.ReferenceEquals(getBuffer(count, LoadT.DdrPp), post.Parameters[0]));
+                // Assert.True(object.ReferenceEquals(getBuffer(count, LoadT.DdrPp), post.Parameters[0]));
                 var name = getBuffer(count++, LoadT.GlbPp).Name[^4..];
 
                 // System.Console.WriteLine($"{w} {name}");

From c1fa17cfa720b4abdcd51cca1b0379ca1d5fde3a Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Thu, 2 Nov 2023 09:48:02 +0000
Subject: [PATCH 297/308] Apply code-format changes

---
 tests/importer/onnx_/model/test_unet.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/importer/onnx_/model/test_unet.py b/tests/importer/onnx_/model/test_unet.py
index 1871b37dd9..b504723bef 100644
--- a/tests/importer/onnx_/model/test_unet.py
+++ b/tests/importer/onnx_/model/test_unet.py
@@ -29,7 +29,8 @@ def test_demo(request):
 
     # runner.set_shape_var({"batch_size": 1, "num_channels_latent": 4, "height_latent": 64, "width_latent": 64})
     # runner.set_shape_var({"N": 384})
-    runner.set_shape_var({"batch_size": 2, "num_channels": 4, "height": 64, "width": 64, "steps": 2, "sequence_length": 77})
+    runner.set_shape_var({"batch_size": 2, "num_channels": 4, "height": 64,
+                          "width": 64, "steps": 2, "sequence_length": 77})
     # runner.set_shape_var({"batch_size:1", "sequence_length:77"})
     runner.run(model_file)
 

From 6dbd9be34be4ad8c13f19b872332447708411acb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 3 Nov 2023 14:16:18 +0800
Subject: [PATCH 298/308] fix merge

---
 .github/workflows/code-format.yml             |  11 +-
 .github/workflows/compiler-build.yml          |   1 +
 .github/workflows/runtime-build.yml           | 300 +++++++++---------
 .gitignore                                    |   3 +
 CMakeLists.txt                                |  20 +-
 cmake/dependencies.cmake                      |   5 +-
 conanfile.py                                  |   4 +-
 python/nncase/__init__.py                     |  21 +-
 python/nncase/native/ffi.cpp                  |   4 +-
 requirements.test.txt                         |   3 +-
 src/Native/include/nncase/compiler.h          |  24 +-
 src/Native/src/CMakeLists.txt                 |  15 +-
 .../kernels/stackvm/optimized/convolution.cpp | 163 ++++++----
 .../kernels/stackvm/optimized/layer_norm.cpp  |   7 +-
 .../kernels/stackvm/optimized/log_softmax.cpp |  14 +-
 .../src/kernels/stackvm/optimized/opt_ops.h   |  33 +-
 .../stackvm/optimized/riscv64/layer_norm.cpp  |  11 +-
 .../stackvm/optimized/riscv64/log_softmax.cpp |  25 +-
 .../stackvm/optimized/riscv64/softmax.cpp     |  31 +-
 .../src/kernels/stackvm/optimized/softmax.cpp |  17 +-
 .../kernels/stackvm/reference/batchnorm.cpp   |  45 ++-
 .../kernels/stackvm/reference/convolution.cpp | 104 ++++--
 .../src/kernels/stackvm/reference/hardmax.cpp |  26 +-
 .../stackvm/reference/instance_norm.cpp       | 108 +++++--
 .../kernels/stackvm/reference/layer_norm.cpp  |  70 +++-
 .../kernels/stackvm/reference/log_softmax.cpp |  45 ++-
 .../src/kernels/stackvm/reference/lrn.cpp     |  76 +++--
 .../src/kernels/stackvm/reference/lstm.cpp    |  90 ++++--
 .../src/kernels/stackvm/reference/prelu.cpp   |  64 +++-
 .../src/kernels/stackvm/reference/ref_ops.h   |  80 ++---
 .../src/kernels/stackvm/reference/softmax.cpp |  59 +++-
 src/Native/src/kernels/stackvm/tensor_ops.cpp | 223 +++++++------
 src/Native/src/runtime/CMakeLists.txt         |   6 +-
 src/Nncase.Compiler/Compiler.cs               |  66 ++--
 src/Nncase.Compiler/Interop/CApi.cs           |  31 +-
 src/Nncase.Core/CompileOptions.cs             |   5 +
 src/Nncase.Core/ICompiler.cs                  |  19 +-
 src/Nncase.Core/IR/Buffers/BufferOf.cs        |   4 +-
 src/Nncase.Core/IR/Dimension.cs               |  10 +
 src/Nncase.Core/IR/Fusion.cs                  |  12 -
 src/Nncase.Core/IR/Shape.cs                   |  23 ++
 src/Nncase.Core/TIR/PrimFunction.cs           |   2 +-
 src/Nncase.Core/TensorOfT.cs                  |   2 +
 .../Extension/OrtKIExtensions.cs              |   5 -
 src/Nncase.Importer/Importers.cs              |  15 +
 .../Rules/ShapeBucket/MergeCallToFusion.cs    |   1 +
 .../Quantization/CalibrationEvaluator.cs      |  12 +-
 src/Nncase.Tests.TestFixture/ModelRunner.cs   |   6 +-
 src/Nncase.Tests.TestFixture/TestClassBase.cs |   2 +-
 src/Nncase.Tests/Importer/UnitTestImporter.cs |  11 +
 .../Rewrite/Fusion/UnitTestFusionGroup.cs     |   3 +-
 src/Nncase.Tests/Simulator/UnitTestInterop.cs |   3 +-
 tests/compare_util.py                         |   8 +-
 tests/inference.py                            |  67 ++--
 tests/kernels/kernel_test.h                   |  51 ++-
 tests/kernels/test_batch_normalization.json   |   2 +-
 tests/kernels/test_constant_of_shape.json     |   2 +-
 tests/kernels/test_gather.cpp                 |   7 +
 tests/kernels/test_gather.json                |   2 +-
 tests/kernels/test_hardmax.json               |   2 +-
 .../kernels/test_instance_normalization.json  |   2 +-
 tests/kernels/test_layer_norm.cpp             |   5 +-
 tests/kernels/test_lrn.json                   |   4 +-
 tests/kernels/test_matmul.json                |   2 +-
 tests/kernels/test_normal.cpp                 |   6 +-
 tests/kernels/test_prelu.cpp                  |  32 +-
 tests/kernels/test_prelu.json                 |   2 +-
 tests/kernels/test_reduce.json                |   2 +-
 tests/kernels/test_reduce_max.cpp             | 134 +++++++-
 tests/kernels/test_reduce_mean.cpp            | 136 +++++++-
 tests/kernels/test_reduce_min.cpp             | 134 +++++++-
 tests/kernels/test_reduce_prod.cpp            | 136 +++++++-
 tests/kernels/test_reduce_sum.cpp             | 136 +++++++-
 tests/kernels/test_reduce_window_2d.cpp       |   2 +-
 tests/kernels/test_reverse_sequence.cpp       |  40 ++-
 tests/kernels/test_reverse_sequence.json      |   6 +-
 tests/kernels/test_slice.json                 |   8 +-
 tests/kernels/test_softmax.json               |   2 +-
 tests/kernels/test_tile.json                  |   2 +-
 tests/kernels/test_trilu.cpp                  |  73 +++--
 tests/kernels/test_unsqueeze.cpp              |  14 +-
 tests/nuc_proxy.py                            |  42 ++-
 tests/onnx_test_runner.py                     |   2 +-
 tests/test_runner.py                          |   6 +-
 tests/tflite_test_runner.py                   |  35 +-
 tests/update_trace_info.py                    |   5 -
 tools/StyleCopAnalyzers.ruleset               |   5 +-
 87 files changed, 2156 insertions(+), 898 deletions(-)

diff --git a/.github/workflows/code-format.yml b/.github/workflows/code-format.yml
index e41866c51d..ef02a4419e 100644
--- a/.github/workflows/code-format.yml
+++ b/.github/workflows/code-format.yml
@@ -2,11 +2,20 @@ name: code-format
 
 on: [pull_request]
 
+concurrency:
+  group: code-format-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
 jobs:
   code-format:
+    permissions:
+      contents: write  # for stefanzweifel/git-auto-commit-action to push code in repo
     runs-on: ubuntu-20.04
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
 
     - name: Setup .NET
       uses: actions/setup-dotnet@v1
diff --git a/.github/workflows/compiler-build.yml b/.github/workflows/compiler-build.yml
index f825b93afa..4806a15baf 100644
--- a/.github/workflows/compiler-build.yml
+++ b/.github/workflows/compiler-build.yml
@@ -261,6 +261,7 @@ jobs:
           dotnet-coverage collect -s tools/dotnet_coverage.settings.xml -f cobertura -o coverage/tflite_basic.xml pytest tests/importer/tflite_/basic/ --doctest-modules --junitxml=test_results/tflite_basic.xml
           dotnet-coverage collect -s tools/dotnet_coverage.settings.xml -f cobertura -o coverage/tflite_combine.xml pytest tests/importer/tflite_/combine/ --doctest-modules --junitxml=test_results/tflite_combine.xml
           dotnet-coverage collect -s tools/dotnet_coverage.settings.xml -f cobertura -o coverage/tflite_model.xml pytest tests/importer/tflite_/model/ --doctest-modules --junitxml=test_results/tflite_model.xml
+          dotnet-coverage collect -s tools/dotnet_coverage.settings.xml -f cobertura -o coverage/ncnn_basic.xml pytest tests/importer/ncnn_/basic/ --doctest-modules --junitxml=test_results/ncnn_basic.xml
           dotnet-coverage merge -o coverage.integration.xml -f cobertura -r coverage/*.xml
 
       - name: Upload Coverage
diff --git a/.github/workflows/runtime-build.yml b/.github/workflows/runtime-build.yml
index 92fd80bc63..0665ff10fb 100644
--- a/.github/workflows/runtime-build.yml
+++ b/.github/workflows/runtime-build.yml
@@ -1,150 +1,150 @@
-# name: runtime-build
-
-# on: [push, pull_request]
-
-# concurrency:
-#   group: runtime-build-${{ github.ref }}
-#   cancel-in-progress: ${{ github.ref != 'refs/heads/master' && !startsWith(github.ref, 'refs/heads/release/') }}
-
-# jobs:
-#   build-native-runtime:
-#     name: build-runtime-${{matrix.config.name}}
-#     runs-on: ${{matrix.config.os}}
-#     strategy:
-#       matrix:
-#         config:
-#           - {name: x86_64-macos, os: macos-latest, cmakeArgs: '', buildType: Release}
-#           - {name: x86_64-linux, os: ubuntu-latest, cmakeArgs: '', buildType: Release}
-#           - {name: x86_64-windows, os: windows-latest, arch: x64, cmakeArgs: -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl, buildType: Release}
-
-#     steps:
-#     - uses: actions/checkout@v3
-#     - uses: seanmiddleditch/gha-setup-ninja@master
-
-#     - name: Set up build environment (Windows, Visual Studio)
-#       uses: ilammy/msvc-dev-cmd@v1
-#       with:
-#         arch: ${{matrix.config.arch}}
-#       if: runner.os == 'Windows'
-
-#     - name: Set up build environment (Macos)
-#       run: |
-#         brew install sunnycase/core/libomp@11.1.0
-#       if: runner.os == 'Macos'
-
-#     - name: Setup Python
-#       uses: actions/setup-python@v4
-#       with:
-#         python-version: 3.7
-
-#     - name: Install Conan
-#       run: |
-#         pip install conan==1.58
-#         conan remote add -i 0 sunnycase https://conan.sunnycase.moe
-
-#     - name: Configure Conan (Linux)
-#       run: |
-#         conan profile new default --detect
-#         conan profile update settings.compiler.libcxx=libstdc++11 default
-#         conan profile update settings.compiler.version=10 default
-#         echo "CC=gcc-10" >> $GITHUB_ENV
-#         echo "CXX=g++-10" >> $GITHUB_ENV
-#       if: runner.os == 'Linux'
-
-#     - name: Configure CMake
-#       shell: bash
-#       run: |
-#         conan install . -if build --build=missing -s build_type=${{matrix.config.buildType}} --profile=default -o runtime=True -o python=False -o tests=True -s compiler.cppstd=17
-
-#     - name: Build & Install
-#       run: |
-#         conan build . -if build -bf build
-#         cmake --install build --prefix install
-
-#     - name: Test
-#       run: |
-#         cd build
-#         ctest -C ${{matrix.config.buildType}} --test-dir tests/kernels --output-on-failure -j4
-#       if: runner.os != 'Macos' && runner.os != 'Windows'
-
-#     #- name: Benchmark
-#     #  run: |
-#     #    ${{github.workspace}}/install/bin/benchnncase > benchnncase.log
-#     #    cat benchnncase.log
-
-#     - name: Upload nncaseruntime Build Artifact
-#       uses: actions/upload-artifact@v3
-#       with:
-#         name: nncaseruntime-${{matrix.config.name}}
-#         path: ${{github.workspace}}/install
-#         if-no-files-found: error
-
-#     #- name: Upload nncaseruntime Benchmark
-#     #  uses: actions/upload-artifact@v3
-#     #  with:
-#     #    name: nncaseruntime-benchmark-${{matrix.config.name}}
-#     #    path: ${{github.workspace}}/benchnncase.log
-#     #    if-no-files-found: error
-
-#   build-cross-linux-runtime:
-#    name: build-runtime-${{matrix.config.name}}
-#    runs-on: ubuntu-latest
-#    strategy:
-#      matrix:
-#        config:
-#          - {name: riscv64-linux, shell: bash, arch: riscv64, toolchain: riscv64-unknown-linux, toolchain_env: RISCV_ROOT_PATH, toolchain_file: riscv64-unknown-linux-gnu-12.0.1, qemu: qemu-riscv64, loader_args: '-cpu;rv64,v=true,Zfh=true,vlen=128,elen=64,vext_spec=v1.0;-L', cmakeArgs: '', buildType: Release}
-
-#    steps:
-#    - uses: actions/checkout@v3
-#    - uses: seanmiddleditch/gha-setup-ninja@master
-
-#    - name: Setup Python
-#      uses: actions/setup-python@v4
-#      with:
-#        python-version: 3.7
-
-#    - name: Install toolchain and QEMU
-#      shell: bash
-#      run: |
-#        wget https://dav.sunnycase.moe/d/ci/nncase/${{matrix.config.toolchain_file}}.tar.xz -O toolchain.tar.xz
-#        sudo tar xf toolchain.tar.xz -C $GITHUB_WORKSPACE
-#        echo "${{matrix.config.toolchain_env}}=$GITHUB_WORKSPACE/${{matrix.config.toolchain_file}}" >> $GITHUB_ENV
-
-#        wget https://dav.sunnycase.moe/d/ci/nncase/${{matrix.config.qemu}}.tgz -O qemu.tgz
-#        sudo tar xf qemu.tgz -C /usr/local/bin
-#        echo "TESTS_EXECUTABLE_LOADER=${{matrix.config.qemu}}" >> $GITHUB_ENV
-#        echo "TESTS_EXECUTABLE_LOADER_ARGUMENTS=${{matrix.config.loader_args}};$GITHUB_WORKSPACE/${{matrix.config.toolchain_file}}/sysroot" >> $GITHUB_ENV
-
-#    - name: Install Conan
-#      run: |
-#        pip install conan==1.58
-#        conan remote add -i 0 sunnycase https://conan.sunnycase.moe
-
-#    - name: Configure Conan
-#      run: |
-#        conan profile new default --detect
-#        conan profile update settings.compiler.libcxx=libstdc++11 default
-#        conan config init
-#        sed -i 's/xtensalx7]/xtensalx7, ${{matrix.config.arch}}]/g' ~/.conan/settings.yml
-
-#    - name: Configure CMake
-#      run: |
-#        conan install . -if build --build=missing -s build_type=${{matrix.config.buildType}} --profile:host=toolchains/riscv64-unknown-linux.profile.jinja --profile:build=default -o runtime=True -o python=False -o tests=True -s compiler.cppstd=17
-
-#    - name: Build & Install
-#      run: |
-#        conan build . -if build -bf build
-#        cmake --install build --prefix install
-
-#    - name: Test
-#      shell: bash
-#      run: |
-#        cd build
-#        ctest --test-dir tests/kernels --output-on-failure -j4
-
-#    - name: Upload nncaseruntime Build Artifact
-#      uses: actions/upload-artifact@v3
-#      with:
-#        name: nncaseruntime-${{matrix.config.name}}
-#        path: ${{github.workspace}}/install
-#        if-no-files-found: error
+name: runtime-build
+
+on: [push, pull_request]
+
+concurrency:
+  group: runtime-build-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/master' && !startsWith(github.ref, 'refs/heads/release/') }}
+
+jobs:
+  build-native-runtime:
+    name: build-runtime-${{matrix.config.name}}
+    runs-on: ${{matrix.config.os}}
+    strategy:
+      matrix:
+        config:
+          - {name: x86_64-macos, os: macos-latest, cmakeArgs: '', buildType: Release}
+          - {name: x86_64-linux, os: ubuntu-latest, cmakeArgs: '', buildType: Release}
+          - {name: x86_64-windows, os: windows-latest, arch: x64, cmakeArgs: -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl, buildType: Release}
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: seanmiddleditch/gha-setup-ninja@master
+
+    - name: Set up build environment (Windows, Visual Studio)
+      uses: ilammy/msvc-dev-cmd@v1
+      with:
+        arch: ${{matrix.config.arch}}
+      if: runner.os == 'Windows'
+
+    - name: Set up build environment (Macos)
+      run: |
+        brew install sunnycase/core/libomp@11.1.0
+      if: runner.os == 'Macos'
+
+    - name: Setup Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: 3.7
+
+    - name: Install Conan
+      run: |
+        pip install conan==1.58
+        conan remote add -i 0 sunnycase https://conan.sunnycase.moe
+
+    - name: Configure Conan (Linux)
+      run: |
+        conan profile new default --detect
+        conan profile update settings.compiler.libcxx=libstdc++11 default
+        conan profile update settings.compiler.version=10 default
+        echo "CC=gcc-10" >> $GITHUB_ENV
+        echo "CXX=g++-10" >> $GITHUB_ENV
+      if: runner.os == 'Linux'
+
+    - name: Configure CMake
+      shell: bash
+      run: |
+        conan install . -if build --build=missing -s build_type=${{matrix.config.buildType}} --profile=default -o runtime=True -o python=False -o tests=True -s compiler.cppstd=17
+
+    - name: Build & Install
+      run: |
+        conan build . -if build -bf build
+        cmake --install build --prefix install
+
+    - name: Test
+      run: |
+        cd build
+        ctest -C ${{matrix.config.buildType}} --test-dir tests/kernels --output-on-failure -j4
+      if: runner.os != 'Macos' && runner.os != 'Windows'
+
+    #- name: Benchmark
+    #  run: |
+    #    ${{github.workspace}}/install/bin/benchnncase > benchnncase.log
+    #    cat benchnncase.log
+
+    - name: Upload nncaseruntime Build Artifact
+      uses: actions/upload-artifact@v3
+      with:
+        name: nncaseruntime-${{matrix.config.name}}
+        path: ${{github.workspace}}/install
+        if-no-files-found: error
+
+    #- name: Upload nncaseruntime Benchmark
+    #  uses: actions/upload-artifact@v3
+    #  with:
+    #    name: nncaseruntime-benchmark-${{matrix.config.name}}
+    #    path: ${{github.workspace}}/benchnncase.log
+    #    if-no-files-found: error
+
+  build-cross-linux-runtime:
+   name: build-runtime-${{matrix.config.name}}
+   runs-on: ubuntu-latest
+   strategy:
+     matrix:
+       config:
+         - {name: riscv64-linux, shell: bash, arch: riscv64, toolchain: riscv64-unknown-linux, toolchain_env: RISCV_ROOT_PATH, toolchain_file: riscv64-unknown-linux-gnu-12.0.1, qemu: qemu-riscv64, loader_args: '-cpu;rv64,v=true,Zfh=true,vlen=128,elen=64,vext_spec=v1.0;-L', cmakeArgs: '', buildType: Release}
+
+   steps:
+   - uses: actions/checkout@v3
+   - uses: seanmiddleditch/gha-setup-ninja@master
+
+   - name: Setup Python
+     uses: actions/setup-python@v4
+     with:
+       python-version: 3.7
+
+   - name: Install toolchain and QEMU
+     shell: bash
+     run: |
+       wget https://dav.sunnycase.moe/d/ci/nncase/${{matrix.config.toolchain_file}}.tar.xz -O toolchain.tar.xz
+       sudo tar xf toolchain.tar.xz -C $GITHUB_WORKSPACE
+       echo "${{matrix.config.toolchain_env}}=$GITHUB_WORKSPACE/${{matrix.config.toolchain_file}}" >> $GITHUB_ENV
+
+       wget https://dav.sunnycase.moe/d/ci/nncase/${{matrix.config.qemu}}.tgz -O qemu.tgz
+       sudo tar xf qemu.tgz -C /usr/local/bin
+       echo "TESTS_EXECUTABLE_LOADER=${{matrix.config.qemu}}" >> $GITHUB_ENV
+       echo "TESTS_EXECUTABLE_LOADER_ARGUMENTS=${{matrix.config.loader_args}};$GITHUB_WORKSPACE/${{matrix.config.toolchain_file}}/sysroot" >> $GITHUB_ENV
+
+   - name: Install Conan
+     run: |
+       pip install conan==1.58
+       conan remote add -i 0 sunnycase https://conan.sunnycase.moe
+
+   - name: Configure Conan
+     run: |
+       conan profile new default --detect
+       conan profile update settings.compiler.libcxx=libstdc++11 default
+       conan config init
+       sed -i 's/xtensalx7]/xtensalx7, ${{matrix.config.arch}}]/g' ~/.conan/settings.yml
+
+   - name: Configure CMake
+     run: |
+       conan install . -if build --build=missing -s build_type=${{matrix.config.buildType}} --profile:host=toolchains/riscv64-unknown-linux.profile.jinja --profile:build=default -o runtime=True -o python=False -o tests=True -s compiler.cppstd=17
+
+   - name: Build & Install
+     run: |
+       conan build . -if build -bf build
+       cmake --install build --prefix install
+
+   - name: Test
+     shell: bash
+     run: |
+       cd build
+       ctest --test-dir tests/kernels --output-on-failure -j4
+
+   - name: Upload nncaseruntime Build Artifact
+     uses: actions/upload-artifact@v3
+     with:
+       name: nncaseruntime-${{matrix.config.name}}
+       path: ${{github.workspace}}/install
+       if-no-files-found: error
diff --git a/.gitignore b/.gitignore
index a95f916e8c..5b1e72c18f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -262,6 +262,9 @@ __pycache__/
 # vscode
 .vscode/
 
+# clangd
+.cache/
+
 # pip
 /python/*/dist
 *egg-info
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e716e0742d..7ac7539a47 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,11 +13,21 @@ endif()
 if(NOT DEFINED NNCASE_VERSION_SUFFIX)
     find_package (Git)
     execute_process(
-        COMMAND ${GIT_EXECUTABLE} describe --always --dirty
+        COMMAND ${GIT_EXECUTABLE} describe --always --dirty --tag
         WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-        OUTPUT_VARIABLE GIT_DESC
+        OUTPUT_VARIABLE GIT_TAG
         OUTPUT_STRIP_TRAILING_WHITESPACE)
-    set(NNCASE_VERSION_SUFFIX "-${GIT_DESC}")
+
+    if ("v${NNCASE_VERSION}" STREQUAL "${GIT_TAG}")
+        set(NNCASE_VERSION_SUFFIX "")
+    else()
+        execute_process(
+            COMMAND ${GIT_EXECUTABLE} describe --always --dirty
+            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+            OUTPUT_VARIABLE GIT_DESC
+            OUTPUT_STRIP_TRAILING_WHITESPACE)
+        set(NNCASE_VERSION_SUFFIX "-${GIT_DESC}")
+    endif()
 endif()
 
 if (NOT PACKAGE_VERSION)
@@ -92,7 +102,7 @@ if (BUILDING_RUNTIME)
 
     if (MSVC)
         add_definitions(/D_CRT_SECURE_NO_WARNINGS /DNOMINMAX)
-        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX /wd4297 -Wno-unused-function -Wno-unused-command-line-argument -Wno-int-to-void-pointer-cast -Wno-int-to-pointer-cast)
+        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX /wd4297 -Wno-unused-function -Wno-unused-command-line-argument)
     else()
         add_compile_options(-Wall -Wextra -pedantic -Werror -Wno-multichar -Wno-missing-field-initializers -Wno-unused-function -Wno-type-limits)
         if (APPLE)
@@ -184,7 +194,7 @@ else()
 
     if (MSVC)
         add_definitions(/D_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS /D_CRT_SECURE_NO_WARNINGS /DNOMINMAX)
-        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX -Wno-unused-function -Wno-unused-command-line-argument -Wno-int-to-void-pointer-cast -Wno-int-to-pointer-cast)
+        add_compile_options(/wd4267 /wd4251 /wd4244 /FC /utf-8 /W3 /WX -Wno-unused-function -Wno-unused-command-line-argument)
         set(PYBIND11_CPP_STANDARD "/std:c++latest")
     else()
         add_compile_options(-fvisibility=hidden)
diff --git a/cmake/dependencies.cmake b/cmake/dependencies.cmake
index a504dd889e..85e8e1213e 100644
--- a/cmake/dependencies.cmake
+++ b/cmake/dependencies.cmake
@@ -9,10 +9,7 @@ endif ()
 
 if (NOT BUILDING_RUNTIME)
     find_package(absl REQUIRED)
-    if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "riscv64")
-    else()
-        find_package(nethost REQUIRED)
-    endif()
+    find_package(nethost REQUIRED)
     find_package(fmt REQUIRED)
     find_package(magic_enum REQUIRED)
     find_package(spdlog REQUIRED)
diff --git a/conanfile.py b/conanfile.py
index c532864648..8a3a0c72b7 100644
--- a/conanfile.py
+++ b/conanfile.py
@@ -58,9 +58,7 @@ def requirements(self):
 
         if not self.options.runtime:
             self.requires('abseil/20220623.1')
-            # if self.settings.arch != 'riscv64':
-            if self.settings.arch in ['x86_64']:
-                self.requires('nethost/6.0.11')
+            self.requires('nethost/6.0.11')
             self.requires('fmt/7.1.3')
             self.requires('magic_enum/0.7.0')
             self.requires('spdlog/1.8.2')
diff --git a/python/nncase/__init__.py b/python/nncase/__init__.py
index 83178c6308..cef1b150bb 100644
--- a/python/nncase/__init__.py
+++ b/python/nncase/__init__.py
@@ -188,11 +188,15 @@ def import_caffe(self, model: bytes, prototxt: bytes) -> None:
 
     def import_onnx(self, model_content: bytes, options: ImportOptions) -> None:
         self._compile_options.input_format = "onnx"
-        self._import_module(model_content)
+        self._import_onnx_module(model_content)
 
     def import_tflite(self, model_content: bytes, options: ImportOptions) -> None:
         self._compile_options.input_format = "tflite"
-        self._import_module(model_content)
+        self._import_tflite_module(model_content)
+
+    def import_ncnn(self, model_param: bytes, model_bin: bytes, options: ImportOptions) -> None:
+        self._compile_options.input_format = "ncnn"
+        self._import_ncnn_module(model_param, model_bin)
 
     def use_ptq(self, ptq_dataset_options: PTQTensorOptions) -> None:
         dataset = [_nncase.RTValue.from_runtime_tensor(
@@ -278,9 +282,18 @@ def __process_compile_options(self, compile_options: CompileOptions) -> ClCompil
         self._compile_options.dump_flags = dump_flags
         self._compile_options.dump_dir = compile_options.dump_dir
 
-    def _import_module(self, model_content: bytes | io.RawIOBase) -> None:
+    def _import_onnx_module(self, model_content: bytes | io.RawIOBase) -> None:
+        stream = io.BytesIO(model_content) if isinstance(model_content, bytes) else model_content
+        self._module = IRModule(self._compiler.import_onnx_module(stream))
+
+    def _import_tflite_module(self, model_content: bytes | io.RawIOBase) -> None:
         stream = io.BytesIO(model_content) if isinstance(model_content, bytes) else model_content
-        self._module = IRModule(self._compiler.import_module(stream))
+        self._module = IRModule(self._compiler.import_tflite_module(stream))
+
+    def _import_ncnn_module(self, model_param: bytes | io.RawIOBase, model_bin: bytes | io.RawIOBase) -> None:
+        param_stream = io.BytesIO(model_param) if isinstance(model_param, bytes) else model_param
+        bin_stream = io.BytesIO(model_bin) if isinstance(model_bin, bytes) else model_bin
+        self._module = IRModule(self._compiler.import_ncnn_module(param_stream, bin_stream))
 
 
 def check_target(target: str):
diff --git a/python/nncase/native/ffi.cpp b/python/nncase/native/ffi.cpp
index 47d8e84fc6..b8c99ed966 100644
--- a/python/nncase/native/ffi.cpp
+++ b/python/nncase/native/ffi.cpp
@@ -304,7 +304,9 @@ PYBIND11_MODULE(_nncase, m) {
         .def_property_readonly("entry", &ir_module::entry);
 
     py::class_<compiler>(m, "Compiler")
-        .def("import_module", &compiler::import_module)
+        .def("import_tflite_module", &compiler::import_tflite_module)
+        .def("import_onnx_module", &compiler::import_onnx_module)
+        .def("import_ncnn_module", &compiler::import_ncnn_module)
         .def("compile", &compiler::compile)
         .def("gencode", &compiler::gencode);
 
diff --git a/requirements.test.txt b/requirements.test.txt
index 5afc08e761..2e5eabae04 100644
--- a/requirements.test.txt
+++ b/requirements.test.txt
@@ -6,6 +6,7 @@ onnx==1.12.0
 onnx-simplifier==0.3.6
 onnxoptimizer==0.2.6
 onnxruntime==1.12.0
+ncnn==1.0.20230816
 numpy==1.21.0
 torch==1.9.0
 torchvision==0.10.0
@@ -15,8 +16,6 @@ kendryte-caffe
 pytest
 pytest-xdist
 pyyaml
-pythonnet==3.0.1
-clr_loader==0.2.4
 toml==0.10.2
 pandas
 tabulate
diff --git a/src/Native/include/nncase/compiler.h b/src/Native/include/nncase/compiler.h
index 09decc7138..7339d0b546 100644
--- a/src/Native/include/nncase/compiler.h
+++ b/src/Native/include/nncase/compiler.h
@@ -159,8 +159,13 @@ typedef struct {
     clr_object_handle_t (*compile_session_get_compiler)(
         clr_object_handle_t compile_session);
     void (*compiler_initialize)();
-    clr_object_handle_t (*compiler_import_module)(clr_object_handle_t compiler,
-                                                  clr_object_handle_t stream);
+    clr_object_handle_t (*compiler_import_tflite_module)(
+        clr_object_handle_t compiler, clr_object_handle_t stream);
+    clr_object_handle_t (*compiler_import_onnx_module)(
+        clr_object_handle_t compiler, clr_object_handle_t stream);
+    clr_object_handle_t (*compiler_import_ncnn_module)(
+        clr_object_handle_t compiler, clr_object_handle_t param_stream,
+        clr_object_handle_t bin_stream);
     void (*compiler_compile)(clr_object_handle_t compiler);
     void (*compiler_gencode)(clr_object_handle_t compiler,
                              clr_object_handle_t stream);
@@ -650,9 +655,20 @@ class compiler : public clr_object_base {
   public:
     using clr_object_base::clr_object_base;
 
-    ir_module import_module(cstream &stream) {
+    ir_module import_tflite_module(cstream &stream) {
+        return {std::in_place, nncase_clr_api()->compiler_import_tflite_module(
+                                   get(), stream.get())};
+    }
+
+    ir_module import_onnx_module(cstream &stream) {
+        return {std::in_place, nncase_clr_api()->compiler_import_onnx_module(
+                                   get(), stream.get())};
+    }
+
+    ir_module import_ncnn_module(cstream &param_stream, cstream &bin_stream) {
         return {std::in_place,
-                nncase_clr_api()->compiler_import_module(get(), stream.get())};
+                nncase_clr_api()->compiler_import_ncnn_module(
+                    get(), param_stream.get(), bin_stream.get())};
     }
 
     void compile() { nncase_clr_api()->compiler_compile(obj_.get()); }
diff --git a/src/Native/src/CMakeLists.txt b/src/Native/src/CMakeLists.txt
index 6d0ca5d0b5..c4d7796400 100644
--- a/src/Native/src/CMakeLists.txt
+++ b/src/Native/src/CMakeLists.txt
@@ -21,19 +21,16 @@ endif ()
 set_property(TARGET nncasebase PROPERTY POSITION_INDEPENDENT_CODE ON)
 target_link_libraries(nncasebase PUBLIC gsl::gsl-lite)
 
-if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "riscv64")
-else()
-    add_subdirectory(compiler)
-endif()
+add_subdirectory(compiler)
 add_subdirectory(runtime)
 add_subdirectory(kernels)
 
 if (NOT BUILDING_RUNTIME)
-    # add_executable(nncasetest test.cpp)
-    # target_link_libraries(nncasetest PRIVATE nncaseruntime)
-    # if (${CMAKE_BUILD_TYPE} STREQUAL "RelWithDebInfo" AND MSVC)
-    #     set_target_properties(nncasetest PROPERTIES LINK_FLAGS "/PROFILE")
-    # endif()
+    add_executable(nncasetest test.cpp)
+    target_link_libraries(nncasetest PRIVATE nncaseruntime)
+    if (${CMAKE_BUILD_TYPE} STREQUAL "RelWithDebInfo" AND MSVC)
+        set_target_properties(nncasetest PROPERTIES LINK_FLAGS "/PROFILE")
+    endif()
 
     add_executable(nncasetest_cli test_cli.cpp)
     target_link_libraries(nncasetest_cli PRIVATE nncaseruntime)
diff --git a/src/Native/src/kernels/stackvm/optimized/convolution.cpp b/src/Native/src/kernels/stackvm/optimized/convolution.cpp
index 72fbd0a89f..9b1b0c2475 100644
--- a/src/Native/src/kernels/stackvm/optimized/convolution.cpp
+++ b/src/Native/src/kernels/stackvm/optimized/convolution.cpp
@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 #include "../reference/ref_ops.h"
+#include "nncase/runtime/util.h"
 #include "opt_ops.h"
 #include <nncase/kernels/kernel_utils.h>
 #include <nncase/runtime/runtime_op_utility.h>
@@ -55,9 +56,10 @@ using namespace nncase::kernels;
 using namespace nncase::kernels::stackvm;
 using namespace nncase::kernels::stackvm::optimized;
 
+template <typename T>
 result<void>
-conv2d_1x1_s1(const float *input, const float *weights, const float *bias,
-              float *output, gsl::span<const size_t> in_shape,
+conv2d_1x1_s1(const T *input, const T *weights, const T *bias, T *output,
+              gsl::span<const size_t> in_shape,
               NNCASE_UNUSED gsl::span<const size_t> in_strides,
               NNCASE_UNUSED gsl::span<const size_t> w_shape,
               NNCASE_UNUSED gsl::span<const size_t> w_strides,
@@ -67,8 +69,7 @@ conv2d_1x1_s1(const float *input, const float *weights, const float *bias,
               NNCASE_UNUSED const padding &padding_w,
               NNCASE_UNUSED int32_t groups, NNCASE_UNUSED int32_t stride_h,
               NNCASE_UNUSED int32_t stride_w, NNCASE_UNUSED int32_t dilation_h,
-              NNCASE_UNUSED int32_t dilation_w,
-              value_range<float> fused_activation,
+              NNCASE_UNUSED int32_t dilation_w, value_range<T> fused_activation,
               NNCASE_UNUSED kernels::kernel_context &context) noexcept {
     const auto widths = in_shape[2] * in_shape[3];
     // if oc's type is size_t, openmp will throw error in visual studio
@@ -82,8 +83,8 @@ conv2d_1x1_s1(const float *input, const float *weights, const float *bias,
 #endif
         for (int oc = 0; oc < out_channels; oc++) {
             const auto out_c = oc;
-            const float *now_weights = weights + out_c * w_strides[0];
-            const float *now_img_start = input + batch * in_strides[0];
+            const T *now_weights = weights + out_c * w_strides[0];
+            const T *now_img_start = input + batch * in_strides[0];
             size_t channel = 0;
 
             auto *now_output_channel_start =
@@ -94,26 +95,26 @@ conv2d_1x1_s1(const float *input, const float *weights, const float *bias,
                       bias[oc]);
             for (; channel + 4 <= in_shape[1]; channel += 4, now_weights += 4) {
                 auto *w_output = now_output_channel_start;
-                const float w0 = now_weights[0];
-                const float w1 = now_weights[1];
-                const float w2 = now_weights[2];
-                const float w3 = now_weights[3];
+                const T w0 = now_weights[0];
+                const T w1 = now_weights[1];
+                const T w2 = now_weights[2];
+                const T w3 = now_weights[3];
 
-                const float *i0 = now_img_start + (channel + 0) * in_strides[1];
-                const float *i1 = now_img_start + (channel + 1) * in_strides[1];
-                const float *i2 = now_img_start + (channel + 2) * in_strides[1];
-                const float *i3 = now_img_start + (channel + 3) * in_strides[1];
+                const T *i0 = now_img_start + (channel + 0) * in_strides[1];
+                const T *i1 = now_img_start + (channel + 1) * in_strides[1];
+                const T *i2 = now_img_start + (channel + 2) * in_strides[1];
+                const T *i3 = now_img_start + (channel + 3) * in_strides[1];
 
-                const float *v0 = i0;
-                const float *v1 = i1;
-                const float *v2 = i2;
-                const float *v3 = i3;
+                const T *v0 = i0;
+                const T *v1 = i1;
+                const T *v2 = i2;
+                const T *v3 = i3;
 
                 for (size_t index = 0; index < widths; ++index) {
-                    float sum0 = *v0 * w0;
-                    float sum1 = *v1 * w1;
-                    float sum2 = *v2 * w2;
-                    float sum3 = *v3 * w3;
+                    T sum0 = *v0 * w0;
+                    T sum1 = *v1 * w1;
+                    T sum2 = *v2 * w2;
+                    T sum3 = *v3 * w3;
 
                     *w_output += sum0 + sum1 + sum2 + sum3;
 
@@ -127,9 +128,9 @@ conv2d_1x1_s1(const float *input, const float *weights, const float *bias,
 
             for (; channel < in_shape[1]; ++channel) {
                 auto *w_output = now_output_channel_start;
-                const float *v = now_img_start + channel * in_strides[1];
+                const T *v = now_img_start + channel * in_strides[1];
                 for (size_t index = 0; index < widths; ++index) {
-                    *w_output += (*now_weights) * (*v);
+                    *w_output += (T)(*now_weights) * (T)(*v);
                     ++w_output;
                     ++v;
                 }
@@ -146,9 +147,10 @@ conv2d_1x1_s1(const float *input, const float *weights, const float *bias,
     return ok();
 }
 
+template <typename T>
 result<void>
-conv2d_1x1_s2(const float *input, const float *weights, const float *bias,
-              float *output, gsl::span<const size_t> in_shape,
+conv2d_1x1_s2(const T *input, const T *weights, const T *bias, T *output,
+              gsl::span<const size_t> in_shape,
               NNCASE_UNUSED gsl::span<const size_t> in_strides,
               NNCASE_UNUSED gsl::span<const size_t> w_shape,
               NNCASE_UNUSED gsl::span<const size_t> w_strides,
@@ -158,8 +160,7 @@ conv2d_1x1_s2(const float *input, const float *weights, const float *bias,
               NNCASE_UNUSED const padding &padding_w,
               NNCASE_UNUSED int32_t groups, NNCASE_UNUSED int32_t stride_h,
               NNCASE_UNUSED int32_t stride_w, NNCASE_UNUSED int32_t dilation_h,
-              NNCASE_UNUSED int32_t dilation_w,
-              value_range<float> fused_activation,
+              NNCASE_UNUSED int32_t dilation_w, value_range<T> fused_activation,
               NNCASE_UNUSED kernels::kernel_context &context) noexcept {
     const auto batch = in_shape[0], in_channels = in_shape[1],
                in_h = in_shape[2], in_w = in_shape[3],
@@ -178,31 +179,30 @@ conv2d_1x1_s2(const float *input, const float *weights, const float *bias,
 #pragma omp parallel for num_threads(context.num_threads)
 #endif
         for (int oc = 0; oc < out_channels; oc++) {
-            float *out = output + (b * out_strides[0] + oc * out_strides[1]);
+            T *out = output + (b * out_strides[0] + oc * out_strides[1]);
 
             std::fill(out, out + out_h * out_w, bias[oc]);
             size_t ic = 0;
             for (; ic + 3 < in_channels; ic += 4) {
-                float *outptr = out;
-                const float *img0 =
+                T *outptr = out;
+                const T *img0 =
                     input + (b * in_strides[0]) + (ic * in_strides[1]);
-                const float *img1 =
+                const T *img1 =
                     input + (b * in_strides[0]) + ((ic + 1) * in_strides[1]);
-                const float *img2 =
+                const T *img2 =
                     input + (b * in_strides[0]) + ((ic + 2) * in_strides[1]);
-                const float *img3 =
+                const T *img3 =
                     input + (b * in_strides[0]) + ((ic + 3) * in_strides[1]);
 
-                const float *r0 = img0;
-                const float *r1 = img1;
-                const float *r2 = img2;
-                const float *r3 = img3;
+                const T *r0 = img0;
+                const T *r1 = img1;
+                const T *r2 = img2;
+                const T *r3 = img3;
 
-                const float *k0 =
-                    weights + oc * w_strides[0] + ic * w_strides[1];
-                const float *k1 = k0 + 1;
-                const float *k2 = k0 + 2;
-                const float *k3 = k0 + 3;
+                const T *k0 = weights + oc * w_strides[0] + ic * w_strides[1];
+                const T *k1 = k0 + 1;
+                const T *k2 = k0 + 2;
+                const T *k3 = k0 + 3;
                 for (size_t i = 0; i < out_h; i++) {
                     for (size_t remain = 0; remain < out_w; remain++) {
                         *outptr += r0[0] * k0[0];
@@ -223,13 +223,13 @@ conv2d_1x1_s2(const float *input, const float *weights, const float *bias,
             }
 
             for (; ic < in_channels; ic++) {
-                float *outptr = out;
-                const float *img0 =
+                T *outptr = out;
+                const T *img0 =
                     input + (b * in_strides[0]) + (ic * in_strides[1]);
-                const float *kernel0 =
+                const T *kernel0 =
                     weights + oc * w_strides[0] + ic * w_strides[1];
-                const float *r0 = img0;
-                const float *k0 = kernel0;
+                const T *r0 = img0;
+                const T *k0 = kernel0;
                 for (size_t i = 0; i < out_h; i++) {
                     for (size_t remain = 0; remain < out_w; remain++) {
                         *outptr += r0[0] * k0[0];
@@ -240,7 +240,7 @@ conv2d_1x1_s2(const float *input, const float *weights, const float *bias,
                 }
             }
             for (size_t h = 0; h < out_h; h++) {
-                float *r_out = out + h * out_strides[2];
+                T *r_out = out + h * out_strides[2];
                 for (size_t w = 0; w < out_w; w++) {
                     *(r_out + w) = kernels::detail::apply_activation(
                         *(r_out + w), fused_activation);
@@ -415,10 +415,10 @@ void conv2d_channel(size_t out_h, size_t out_w, std::array<T, Parallel> &sum,
 }
 
 template <size_t Parallel, size_t Filter_h, size_t Filter_w, size_t Stride_h,
-          size_t Stride_w>
+          size_t Stride_w, typename T>
 result<void>
-conv2d_nxm(const float *input, const float *weights, const float *bias,
-           float *output, gsl::span<const size_t> in_shape,
+conv2d_nxm(const T *input, const T *weights, const T *bias, float *output,
+           gsl::span<const size_t> in_shape,
            NNCASE_UNUSED gsl::span<const size_t> in_strides,
            NNCASE_UNUSED gsl::span<const size_t> w_shape,
            NNCASE_UNUSED gsl::span<const size_t> w_strides,
@@ -485,9 +485,9 @@ conv2d_nxm(const float *input, const float *weights, const float *bias,
 }
 
 template <size_t Parallel, size_t Filter_h, size_t Filter_w, size_t Stride_h,
-          size_t Stride_w>
+          size_t Stride_w, typename T>
 result<void> conv2d_depthwise_nxm(
-    const float *input, const float *weights, const float *bias, float *output,
+    const T *input, const T *weights, const T *bias, T *output,
     gsl::span<const size_t> in_shape,
     NNCASE_UNUSED gsl::span<const size_t> in_strides,
     NNCASE_UNUSED gsl::span<const size_t> w_shape,
@@ -498,7 +498,7 @@ result<void> conv2d_depthwise_nxm(
     NNCASE_UNUSED const padding &padding_w, NNCASE_UNUSED int32_t groups,
     NNCASE_UNUSED int32_t stride_h, NNCASE_UNUSED int32_t stride_w,
     NNCASE_UNUSED int32_t dilation_h, NNCASE_UNUSED int32_t dilation_w,
-    value_range<float> fused_activation,
+    value_range<T> fused_activation,
     NNCASE_UNUSED kernels::kernel_context &context) noexcept {
     const auto batch = in_shape[0], channels = w_shape[0], in_h = in_shape[2],
                in_w = in_shape[3];
@@ -516,14 +516,13 @@ result<void> conv2d_depthwise_nxm(
 #endif
         for (int c = 0; c < channels; c++) // channel
         {
-            std::array<float *, Parallel> outptr;
-            std::array<const float *,
-                       compute_rsize<Parallel, Stride_h, Filter_h>()>
+            std::array<T *, Parallel> outptr;
+            std::array<const T *, compute_rsize<Parallel, Stride_h, Filter_h>()>
                 r;
-            std::array<const float *, Filter_h> k;
-            std::array<float, Parallel> sum;
+            std::array<const T *, Filter_h> k;
+            std::array<T, Parallel> sum;
 
-            float *out = output + out_strides[0] * b + out_strides[1] * c;
+            T *out = output + out_strides[0] * b + out_strides[1] * c;
             std::fill_n(out,
                         out_strides[2]
                             ? out_h * out_strides[2]
@@ -539,7 +538,7 @@ result<void> conv2d_depthwise_nxm(
                 out_h, out_w, sum, r, k, outptr, in_strides[2], out_strides[2],
                 tail_step);
             for (size_t h = 0; h < out_h; h++) {
-                float *r_out = out + h * out_strides[2];
+                T *r_out = out + h * out_strides[2];
                 for (size_t w = 0; w < out_w; w++) {
                     *(r_out + w) = kernels::detail::apply_activation(
                         *(r_out + w), fused_activation);
@@ -610,7 +609,8 @@ result<void> conv2d_depthwise_nxm(
 #endif
 
 result<void> optimized::conv2d(
-    const float *input, const float *weights, const float *bias, float *output,
+    [[maybe_unused]] typecode_t typecode, const gsl::byte *input1,
+    const gsl::byte *weights1, const gsl::byte *bias1, gsl::byte *output1,
     gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
     gsl::span<const size_t> w_shape,
     NNCASE_UNUSED gsl::span<const size_t> w_strides,
@@ -620,6 +620,10 @@ result<void> optimized::conv2d(
     int32_t stride_w, int32_t dilation_h, int32_t dilation_w,
     value_range<float> fused_activation,
     NNCASE_UNUSED kernels::kernel_context &context) noexcept {
+    [[maybe_unused]] auto input = IN_CAST(float, input1);
+    [[maybe_unused]] auto weights = IN_CAST(float, weights1);
+    [[maybe_unused]] auto bias = IN_CAST(float, bias1);
+    [[maybe_unused]] auto output = OUT_CAST(float, output1);
     const auto filter_h = w_shape[2];
     const auto filter_w = w_shape[3];
 
@@ -675,8 +679,33 @@ result<void> optimized::conv2d(
     }
 #endif
     try_(nncase::kernels::stackvm::reference::conv2d(
-        input, weights, bias, output, in_shape, in_strides, w_shape, w_strides,
-        bias_strides, out_strides, padding_h, padding_w, groups, stride_h,
-        stride_w, dilation_h, dilation_w, fused_activation));
+        typecode, input1, weights1, bias1, output1, in_shape, in_strides,
+        w_shape, w_strides, bias_strides, out_strides, padding_h, padding_w,
+        groups, stride_h, stride_w, dilation_h, dilation_w, fused_activation));
     return ok();
-}
\ No newline at end of file
+}
+
+// result<void> optimized::conv2d(
+//     [[maybe_unused]] typecode_t typecode, const gsl::byte *input,
+//     const gsl::byte *weights, const gsl::byte *bias, gsl::byte *output,
+//     gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
+//     gsl::span<const size_t> w_shape,
+//     NNCASE_UNUSED gsl::span<const size_t> w_strides,
+//     NNCASE_UNUSED gsl::span<const size_t> bias_strides,
+//     NNCASE_UNUSED gsl::span<const size_t> out_strides, const padding
+//     &padding_h, const padding &padding_w, int32_t groups, int32_t stride_h,
+//     int32_t stride_w, int32_t dilation_h, int32_t dilation_w,
+//     value_range<float> fused_activation,
+//     NNCASE_UNUSED kernels::kernel_context &context) noexcept {
+//     auto a = conv2d_impl(
+//         IN_CAST(float, input), IN_CAST(float, weights), IN_CAST(float, bias),
+//         OUT_CAST(float, output), in_shape, in_strides, w_shape, w_strides,
+//         bias_strides, out_strides, padding_h, padding_w, groups, stride_h,
+//         stride_w, dilation_h, dilation_w, fused_activation, context);
+//     try_(nncase::kernels::stackvm::reference::conv2d(
+//         typecode, input, weights, bias, output, in_shape, in_strides,
+//         w_shape, w_strides, bias_strides, out_strides, padding_h, padding_w,
+//         groups, stride_h, stride_w, dilation_h, dilation_w,
+//         fused_activation));
+//     return ok();
+// }
diff --git a/src/Native/src/kernels/stackvm/optimized/layer_norm.cpp b/src/Native/src/kernels/stackvm/optimized/layer_norm.cpp
index bfe47a07ad..84c89c8bf3 100644
--- a/src/Native/src/kernels/stackvm/optimized/layer_norm.cpp
+++ b/src/Native/src/kernels/stackvm/optimized/layer_norm.cpp
@@ -25,8 +25,9 @@ using namespace nncase::kernels::stackvm;
 using namespace nncase::kernels::stackvm::optimized;
 
 result<void> nncase::kernels::stackvm::optimized::layer_norm(
-    const float *input, float *output, const float *scale, const float *bias,
+    typecode_t typecode, const gsl::byte *input, gsl::byte *output,
+    const gsl::byte *scale, const gsl::byte *bias,
     gsl::span<const size_t> in_shape, int32_t axis, float epsilon) {
-    return reference::layer_norm(input, output, scale, bias, in_shape, axis,
-                                 epsilon);
+    return reference::layer_norm(typecode, input, output, scale, bias, in_shape,
+                                 axis, epsilon);
 }
diff --git a/src/Native/src/kernels/stackvm/optimized/log_softmax.cpp b/src/Native/src/kernels/stackvm/optimized/log_softmax.cpp
index b81874967a..f87b093da3 100644
--- a/src/Native/src/kernels/stackvm/optimized/log_softmax.cpp
+++ b/src/Native/src/kernels/stackvm/optimized/log_softmax.cpp
@@ -26,17 +26,17 @@ using namespace nncase::kernels::stackvm::optimized;
 
 #include <math.h>
 
-template result<void> optimized::log_softmax<float>(
-    const float *input, float *output, gsl::span<const size_t> in_shape,
-    gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides,
-    int32_t axis) noexcept;
+// template result<void> optimized::log_softmax<float>(
+//    typecode_t typecode, const gsl::byte *input, gsl::byte *output,
+//    gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
+//    gsl::span<const size_t> out_strides, int32_t axis) noexcept;
 
-template <typename T>
-result<void> optimized::log_softmax(const T *input, T *output,
+result<void> optimized::log_softmax(typecode_t typecode, const gsl::byte *input,
+                                    gsl::byte *output,
                                     gsl::span<const size_t> in_shape,
                                     gsl::span<const size_t> in_strides,
                                     gsl::span<const size_t> out_strides,
                                     int32_t axis) noexcept {
-    return reference::log_softmax(input, output, in_shape, in_strides,
+    return reference::log_softmax(typecode, input, output, in_shape, in_strides,
                                   out_strides, axis);
 }
diff --git a/src/Native/src/kernels/stackvm/optimized/opt_ops.h b/src/Native/src/kernels/stackvm/optimized/opt_ops.h
index c15fba913d..7675248af4 100644
--- a/src/Native/src/kernels/stackvm/optimized/opt_ops.h
+++ b/src/Native/src/kernels/stackvm/optimized/opt_ops.h
@@ -28,9 +28,10 @@ BEGIN_NS_NNCASE_KERNELS_MODULE(stackvm)
 namespace optimized {
 
 NNCASE_API result<void>
-conv2d(const float *input, const float *weights, const float *bias,
-       float *output, gsl::span<const size_t> in_shape,
-       gsl::span<const size_t> in_strides, gsl::span<const size_t> w_shape,
+conv2d(typecode_t typecode, const gsl::byte *input, const gsl::byte *weights,
+       const gsl::byte *bias, gsl::byte *output,
+       gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
+       gsl::span<const size_t> w_shape,
        NNCASE_UNUSED gsl::span<const size_t> w_strides,
        NNCASE_UNUSED gsl::span<const size_t> bias_strides,
        NNCASE_UNUSED gsl::span<const size_t> out_strides,
@@ -77,8 +78,9 @@ gather(datatype_t type, const gsl::byte *input, gsl::byte *output,
        gsl::span<const size_t> indices_shape, size_t axis,
        kernel_context &context) noexcept;
 
-NNCASE_API result<void> layer_norm(const float *input, float *output,
-                                   const float *scale, const float *bias,
+NNCASE_API result<void> layer_norm(typecode_t typecode, const gsl::byte *input,
+                                   gsl::byte *output, const gsl::byte *scale,
+                                   const gsl::byte *bias,
                                    gsl::span<const size_t> in_shape,
                                    int32_t axis, float epsilon);
 
@@ -147,17 +149,18 @@ unary(typecode_t dtype, runtime::stackvm::unary_op_t op, const gsl::byte *in,
 //                               gsl::span<const size_t> out_strides,
 //                               value_range<float> fused_activation) noexcept;
 
-template <typename T>
-NNCASE_API result<void>
-softmax(const T *input, T *output, gsl::span<const size_t> in_shape,
-        gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides,
-        int32_t axis, float beta) noexcept;
-
-template <typename T>
+// template <typename T>
 NNCASE_API result<void>
-log_softmax(const T *input, T *output, gsl::span<const size_t> in_shape,
-            gsl::span<const size_t> in_strides,
-            gsl::span<const size_t> out_strides, int32_t axis) noexcept;
+softmax(typecode_t typecode, const gsl::byte *input, gsl::byte *output,
+        gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
+        gsl::span<const size_t> out_strides, int32_t axis, float beta) noexcept;
+
+NNCASE_API result<void> log_softmax(typecode_t typecode, const gsl::byte *input,
+                                    gsl::byte *output,
+                                    gsl::span<const size_t> in_shape,
+                                    gsl::span<const size_t> in_strides,
+                                    gsl::span<const size_t> out_strides,
+                                    int32_t axis) noexcept;
 
 template <typename T>
 NNCASE_API result<void>
diff --git a/src/Native/src/kernels/stackvm/optimized/riscv64/layer_norm.cpp b/src/Native/src/kernels/stackvm/optimized/riscv64/layer_norm.cpp
index 71be89f6d2..9ad01fd401 100644
--- a/src/Native/src/kernels/stackvm/optimized/riscv64/layer_norm.cpp
+++ b/src/Native/src/kernels/stackvm/optimized/riscv64/layer_norm.cpp
@@ -155,12 +155,15 @@ result<void> layernorm_impl(const float *input, float *output,
 #endif
 
 result<void> nncase::kernels::stackvm::optimized::layer_norm(
-    const float *input, float *output, const float *scale, const float *bias,
+    [[maybe_unused]] typecode_t typecode, const gsl::byte *input,
+    gsl::byte *output, const gsl::byte *scale, const gsl::byte *bias,
     gsl::span<const size_t> in_shape, int32_t axis, float epsilon) {
 #if __riscv_vector
-    return layernorm_impl(input, output, scale, bias, in_shape, axis, epsilon);
+    return layernorm_impl(IN_CAST(float, input), OUT_CAST(float, output),
+                          IN_CAST(float, scale), IN_CAST(float, bias), in_shape,
+                          axis, epsilon);
 #else
-    return reference::layer_norm(input, output, scale, bias, in_shape, axis,
-                                 epsilon);
+    return reference::layer_norm(typecode, input, output, scale, bias, in_shape,
+                                 axis, epsilon);
 #endif
 }
diff --git a/src/Native/src/kernels/stackvm/optimized/riscv64/log_softmax.cpp b/src/Native/src/kernels/stackvm/optimized/riscv64/log_softmax.cpp
index 0ed05fa726..3515124193 100644
--- a/src/Native/src/kernels/stackvm/optimized/riscv64/log_softmax.cpp
+++ b/src/Native/src/kernels/stackvm/optimized/riscv64/log_softmax.cpp
@@ -166,25 +166,30 @@ static void log_softmax_impl(const float *input, float *output,
 }
 #endif
 
-template result<void> optimized::log_softmax<float>(
-    const float *input, float *output, gsl::span<const size_t> in_shape,
-    [[maybe_unused]] gsl::span<const size_t> in_strides,
-    [[maybe_unused]] gsl::span<const size_t> out_strides,
-    int32_t axis) noexcept;
+#define IN_CAST(_ty, _name) reinterpret_cast<const _ty *>(_name)
+#define OUT_CAST(_ty, _name) reinterpret_cast<_ty *>(_name)
 
-template <typename T>
+// template result<void> optimized::log_softmax<float>(
+//     const float *input, float *output, gsl::span<const size_t> in_shape,
+//     [[maybe_unused]] gsl::span<const size_t> in_strides,
+//     [[maybe_unused]] gsl::span<const size_t> out_strides,
+//     int32_t axis) noexcept;
+
+// template <typename T>
 result<void>
-optimized::log_softmax(const T *input, T *output,
+optimized::log_softmax([[maybe_unused]] typecode_t typecode,
+                       const gsl::byte *input, gsl::byte *output,
                        gsl::span<const size_t> in_shape,
                        [[maybe_unused]] gsl::span<const size_t> in_strides,
                        [[maybe_unused]] gsl::span<const size_t> out_strides,
                        int32_t axis) noexcept {
     result<void> ret_value = ok();
 #if __riscv_vector
-    log_softmax_impl(input, output, in_shape, axis);
+    log_softmax_impl(IN_CAST(float, input), OUT_CAST(float, output), in_shape,
+                     axis);
 #else
-    ret_value = reference::softmax(input, output, in_shape, in_strides,
-                                   out_strides, axis, 1.f, true);
+    ret_value = reference::softmax(typecode, input, output, in_shape,
+                                   in_strides, out_strides, axis, 1.f, true);
 #endif
     return ret_value;
 }
diff --git a/src/Native/src/kernels/stackvm/optimized/riscv64/softmax.cpp b/src/Native/src/kernels/stackvm/optimized/riscv64/softmax.cpp
index b2352b8551..58442a40ca 100644
--- a/src/Native/src/kernels/stackvm/optimized/riscv64/softmax.cpp
+++ b/src/Native/src/kernels/stackvm/optimized/riscv64/softmax.cpp
@@ -52,7 +52,8 @@ vfloat32m8_t exp_ps2_opt(vfloat32m8_t _p, const float c0, const float c1,
     return _p;
 }
 
-result<void> optimized_softmax_impl_opt(const float *input, float *output,
+template <typename T>
+result<void> optimized_softmax_impl_opt(const T *input, T *output,
                                         gsl::span<const size_t> in_shape,
                                         int32_t axis, float beta) noexcept {
     size_t ndim = in_shape.size();
@@ -221,7 +222,8 @@ result<void> optimized_softmax_impl_opt(const float *input, float *output,
     return ok();
 }
 
-result<void> optimized_softmax_impl(const float *input, float *output,
+template <typename T>
+result<void> optimized_softmax_impl(const T *input, T *output,
                                     gsl::span<const size_t> in_shape,
                                     int32_t axis, float beta) noexcept {
     size_t ndim = in_shape.size();
@@ -392,21 +394,26 @@ result<void> optimized_softmax_impl(const float *input, float *output,
 #endif
 } // namespace
 
-template result<void> optimized::softmax<float>(
-    const float *input, float *output, gsl::span<const size_t> in_shape,
-    gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides,
-    int32_t axis, float beta) noexcept;
+#define IN_CAST(_ty, _name) reinterpret_cast<const _ty *>(_name)
+#define OUT_CAST(_ty, _name) reinterpret_cast<_ty *>(_name)
 
-template <typename T>
-result<void> optimized::softmax(const T *input, T *output,
+// template result<void> optimized::softmax<float>(
+//     const float *input, float *output, gsl::span<const size_t> in_shape,
+//     gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides,
+//     int32_t axis, float beta) noexcept;
+
+// template <typename T>
+result<void> optimized::softmax([[maybe_unused]] typecode_t typecode,
+                                const gsl::byte *input, gsl::byte *output,
                                 gsl::span<const size_t> in_shape,
                                 gsl::span<const size_t> in_strides,
                                 gsl::span<const size_t> out_strides,
                                 int32_t axis, float beta) noexcept {
 #if __riscv_vector
-    return optimized_softmax_impl(input, output, in_shape, axis, beta);
+    return optimized_softmax_impl(
+        IN_CAST(float, input), OUT_CAST(float, output), in_shape, axis, beta);
+//    TYPE_SELECT_SOFTMAX(typecode, SOFTMAX_IMPL);
 #endif
-
-    return stackvm::reference::softmax(input, output, in_shape, in_strides,
-                                       out_strides, axis, beta);
+    return stackvm::reference::softmax(typecode, input, output, in_shape,
+                                       in_strides, out_strides, axis, beta);
 }
\ No newline at end of file
diff --git a/src/Native/src/kernels/stackvm/optimized/softmax.cpp b/src/Native/src/kernels/stackvm/optimized/softmax.cpp
index 8ff6e15d9f..73bc525939 100644
--- a/src/Native/src/kernels/stackvm/optimized/softmax.cpp
+++ b/src/Native/src/kernels/stackvm/optimized/softmax.cpp
@@ -24,17 +24,18 @@ using namespace nncase::kernels;
 using namespace nncase::kernels::stackvm;
 using namespace nncase::kernels::stackvm::optimized;
 
-template result<void> optimized::softmax<float>(
-    const float *input, float *output, gsl::span<const size_t> in_shape,
-    gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides,
-    int32_t axis, float beta) noexcept;
+// template result<void> optimized::softmax<float>(
+//    typecode_t typecode, const gsl::byte *input, gsl::byte *output,
+//    gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
+//    gsl::span<const size_t> out_strides, int32_t axis, float beta) noexcept;
 
-template <typename T>
-result<void> optimized::softmax(const T *input, T *output,
+// template <typename T>
+result<void> optimized::softmax(typecode_t typecode, const gsl::byte *input,
+                                gsl::byte *output,
                                 gsl::span<const size_t> in_shape,
                                 gsl::span<const size_t> in_strides,
                                 gsl::span<const size_t> out_strides,
                                 int32_t axis, float beta) noexcept {
-    return stackvm::reference::softmax(input, output, in_shape, in_strides,
-                                       out_strides, axis, beta);
+    return stackvm::reference::softmax(typecode, input, output, in_shape,
+                                       in_strides, out_strides, axis, beta);
 }
diff --git a/src/Native/src/kernels/stackvm/reference/batchnorm.cpp b/src/Native/src/kernels/stackvm/reference/batchnorm.cpp
index d7158cb032..aa9f6a1ddb 100644
--- a/src/Native/src/kernels/stackvm/reference/batchnorm.cpp
+++ b/src/Native/src/kernels/stackvm/reference/batchnorm.cpp
@@ -16,22 +16,51 @@
 #include "ref_ops.h"
 #include <iostream>
 #include <nncase/kernels/kernel_utils.h>
+#include <nncase/runtime/allocator.h>
+#include <nncase/runtime/host_buffer.h>
 #include <nncase/runtime/runtime_op_utility.h>
+#include <nncase/runtime/util.h>
 
 using namespace nncase;
 using namespace nncase::kernels::stackvm;
+using namespace nncase::runtime;
+using namespace nncase::runtime::stackvm;
+using namespace nncase::kernels;
 
-result<void> nncase::kernels::stackvm::reference::batchnorm(
-    const float *input, const float *scale, const float *bias,
-    const float *input_mean, const float *input_var, float *output,
-    gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
-    gsl::span<const size_t> out_strides, float epsilon) {
+namespace {
+template <class T>
+result<void> batchnorm_impl(const T *input, const T *scale, const T *bias,
+                            const T *input_mean, const T *input_var, T *output,
+                            gsl::span<const size_t> in_shape,
+                            gsl::span<const size_t> in_strides,
+                            gsl::span<const size_t> out_strides,
+                            float epsilon) {
     return apply(in_shape, [&](gsl::span<const size_t> index) -> result<void> {
         auto c = index[1];
         const auto x = input[offset(in_strides, index)];
-        output[offset(out_strides, index)] =
-            (x - input_mean[c]) / std::sqrt(input_var[c] + epsilon) * scale[c] +
-            bias[c];
+        output[offset(out_strides, index)] = static_cast<T>(
+            (static_cast<float>(x) - static_cast<float>(input_mean[c])) /
+                std::sqrt(static_cast<float>(input_var[c]) +
+                          static_cast<float>(epsilon)) *
+                static_cast<float>(scale[c]) +
+            static_cast<float>(bias[c]));
         return ok();
     });
+} // namespace
+
+#define BATCHNORM_IMPL(type)                                                   \
+    return batchnorm_impl(IN_CAST(type, input), IN_CAST(type, scale),          \
+                          IN_CAST(type, bias), IN_CAST(type, input_mean),      \
+                          IN_CAST(type, input_var), OUT_CAST(type, output),    \
+                          in_shape, in_strides, out_strides, epsilon);
+
+} // namespace
+
+result<void> nncase::kernels::stackvm::reference::batchnorm(
+    typecode_t typecode, const gsl::byte *input, const gsl::byte *scale,
+    const gsl::byte *bias, const gsl::byte *input_mean,
+    const gsl::byte *input_var, gsl::byte *output,
+    gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
+    gsl::span<const size_t> out_strides, float epsilon) {
+    TYPE_SELECT(typecode, BATCHNORM_IMPL);
 }
\ No newline at end of file
diff --git a/src/Native/src/kernels/stackvm/reference/convolution.cpp b/src/Native/src/kernels/stackvm/reference/convolution.cpp
index 98dabf9fbf..50e6195d80 100644
--- a/src/Native/src/kernels/stackvm/reference/convolution.cpp
+++ b/src/Native/src/kernels/stackvm/reference/convolution.cpp
@@ -23,8 +23,9 @@ using namespace nncase::runtime;
 using namespace nncase::runtime::stackvm;
 using namespace nncase::kernels;
 
-result<void> nncase::kernels::stackvm::reference::conv2d(
-    const float *input, const float *weights, const float *bias, float *output,
+template <typename T>
+result<void> conv2d_impl(
+    const T *input, const T *weights, const T *bias, T *output,
     gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
     gsl::span<const size_t> w_shape, gsl::span<const size_t> w_strides,
     gsl::span<const size_t> bias_strides, gsl::span<const size_t> out_strides,
@@ -85,9 +86,9 @@ result<void> nncase::kernels::stackvm::reference::conv2d(
                                     in_index[2] = in_y_origin + dilation_h * ky;
                                     in_index[3] = in_x_origin + dilation_w * kx;
 
-                                    const float in_v =
+                                    const T in_v =
                                         input[offset(in_strides, in_index)];
-                                    const float w =
+                                    const T w =
                                         weights[offset(w_strides, w_index)];
 
                                     value += in_v * w;
@@ -107,8 +108,43 @@ result<void> nncase::kernels::stackvm::reference::conv2d(
     return ok();
 }
 
-result<void> nncase::kernels::stackvm::reference::conv2d_transpose(
-    const float *input, float *output, const float *weights, const float *bias,
+#define CONV2D_IMPL(type)                                                      \
+    return conv2d_impl(                                                        \
+        IN_CAST(type, input), IN_CAST(type, weights), IN_CAST(type, bias),     \
+        OUT_CAST(type, output), in_shape, in_strides, w_shape, w_strides,      \
+        bias_strides, out_strides, padding_h, padding_w, groups, stride_h,     \
+        stride_w, dilation_h, dilation_w, fused_activation, context);
+
+#define TYPE_SELECT_CONV(_typecode, _impl)                                     \
+    switch (_typecode) {                                                       \
+    case dt_float32:                                                           \
+        _impl(float);                                                          \
+    case dt_float16:                                                           \
+        _impl(half);                                                           \
+    case dt_bfloat16:                                                          \
+        _impl(bfloat16);                                                       \
+    case dt_float64:                                                           \
+        _impl(double);                                                         \
+    default:                                                                   \
+        return err(std::errc::not_supported);                                  \
+    }
+
+result<void> nncase::kernels::stackvm::reference::conv2d(
+    typecode_t typecode, const gsl::byte *input, const gsl::byte *weights,
+    const gsl::byte *bias, gsl::byte *output, gsl::span<const size_t> in_shape,
+    gsl::span<const size_t> in_strides, gsl::span<const size_t> w_shape,
+    gsl::span<const size_t> w_strides, gsl::span<const size_t> bias_strides,
+    gsl::span<const size_t> out_strides, const padding &padding_h,
+    const padding &padding_w, int32_t groups, int32_t stride_h,
+    int32_t stride_w, int32_t dilation_h, int32_t dilation_w,
+    value_range<float> fused_activation,
+    NNCASE_UNUSED kernel_context &context) noexcept {
+    TYPE_SELECT_CONV(typecode, CONV2D_IMPL);
+}
+
+template <typename T>
+result<void> conv2d_transpose_impl(
+    const T *input, T *output, const T *weights, const T *bias,
     gsl::span<const size_t> in_shape, int32_t groups,
     gsl::span<const size_t> out_shape, int32_t filter_h, int32_t filter_w,
     int32_t stride_h, int32_t stride_w, int32_t dilation_h, int32_t dilation_w,
@@ -120,13 +156,13 @@ result<void> nncase::kernels::stackvm::reference::conv2d_transpose(
     const auto g_oc = out_shape[1] / groups;
 
     for (size_t batch = 0; batch < in_shape[0]; batch++) {
-        float *out_batch_p =
+        T *out_batch_p =
             output + (size_t)batch * out_shape[1] * out_shape[2] * out_shape[3];
 
         for (size_t g = 0; g < (size_t)groups; g++) {
-            float *out_group_p =
+            T *out_group_p =
                 out_batch_p + (size_t)g * g_oc * out_shape[2] * out_shape[3];
-            const float *w_group_p =
+            const T *w_group_p =
                 weights + (size_t)g * g_oc * g_ic * filter_h * filter_w;
 
             for (size_t ic = 0; ic < g_ic; ic++) {
@@ -148,16 +184,16 @@ result<void> nncase::kernels::stackvm::reference::conv2d_transpose(
                             filter_w, ((int32_t)out_shape[3] - out_x_origin +
                                        dilation_w - 1) /
                                           dilation_w);
-                        const float in_v = *input++;
+                        const T in_v = *input++;
 
                         for (size_t oc = 0; oc < g_oc; oc++) {
-                            float *out_c_p = out_group_p + (size_t)oc *
-                                                               out_shape[2] *
-                                                               out_shape[3];
-                            const float *w_oc_p =
-                                w_group_p +
-                                (size_t)oc * g_ic * filter_h * filter_w;
-                            const float *w_ic_p =
+                            T *out_c_p = out_group_p + (size_t)oc *
+                                                           out_shape[2] *
+                                                           out_shape[3];
+                            const T *w_oc_p = w_group_p + (size_t)oc * g_ic *
+                                                              filter_h *
+                                                              filter_w;
+                            const T *w_ic_p =
                                 w_oc_p + (size_t)ic * filter_h * filter_w;
 
                             for (size_t ky = filter_y_start; ky < filter_y_end;
@@ -169,7 +205,7 @@ result<void> nncase::kernels::stackvm::reference::conv2d_transpose(
                                     const int32_t out_x =
                                         out_x_origin + dilation_w * kx;
 
-                                    const float w = w_ic_p[ky * filter_w + kx];
+                                    const T w = w_ic_p[ky * filter_w + kx];
 
                                     out_c_p[out_y * out_shape[3] + out_x] +=
                                         in_v * w;
@@ -195,3 +231,35 @@ result<void> nncase::kernels::stackvm::reference::conv2d_transpose(
     //    }
     return ok();
 }
+
+#define CONV2D_TRANSPOSE_IMPL(type)                                            \
+    return conv2d_transpose_impl(                                              \
+        IN_CAST(type, input), OUT_CAST(type, output), IN_CAST(type, weights),  \
+        IN_CAST(type, bias), in_shape, groups, out_shape, filter_h, filter_w,  \
+        stride_h, stride_w, dilation_h, dilation_w, padding_h, padding_w,      \
+        fused_activation);
+
+#define TYPE_SELECT_CONV_TRANSPOSE(_typecode, _impl)                           \
+    switch (_typecode) {                                                       \
+    case dt_float32:                                                           \
+        _impl(float);                                                          \
+    case dt_float16:                                                           \
+        _impl(half);                                                           \
+    case dt_bfloat16:                                                          \
+        _impl(bfloat16);                                                       \
+    case dt_float64:                                                           \
+        _impl(double);                                                         \
+    default:                                                                   \
+        return err(std::errc::not_supported);                                  \
+    }
+
+result<void> nncase::kernels::stackvm::reference::conv2d_transpose(
+    typecode_t typecode, const gsl::byte *input, gsl::byte *output,
+    const gsl::byte *weights, const gsl::byte *bias,
+    gsl::span<const size_t> in_shape, int32_t groups,
+    gsl::span<const size_t> out_shape, int32_t filter_h, int32_t filter_w,
+    int32_t stride_h, int32_t stride_w, int32_t dilation_h, int32_t dilation_w,
+    const padding &padding_h, const padding &padding_w,
+    [[maybe_unused]] const value_range<float> &fused_activation) noexcept {
+    TYPE_SELECT_CONV_TRANSPOSE(typecode, CONV2D_TRANSPOSE_IMPL);
+}
diff --git a/src/Native/src/kernels/stackvm/reference/hardmax.cpp b/src/Native/src/kernels/stackvm/reference/hardmax.cpp
index f655812729..77be59eb7b 100644
--- a/src/Native/src/kernels/stackvm/reference/hardmax.cpp
+++ b/src/Native/src/kernels/stackvm/reference/hardmax.cpp
@@ -74,13 +74,25 @@ result<void> hardmax_impl(const T *input, gsl::span<const size_t> in_shape,
     return ok();
 }
 
-result<value_t>
-nncase::kernels::stackvm::hardmax(value_t input, value_t axis, value_t output,
-                                  [[maybe_unused]] kernel_context &context) {
-    try_f32_input(input_mem, input);
-    try_f32_output(out_mem, output, input_tensor->shape());
+#define HARDMAX_IMPL(_ty)                                                      \
+    return hardmax_impl(IN_CAST(_ty, input), in_shape, in_strides,             \
+                        OUT_CAST(_ty, output), axis);
+
+result<void> hardmax_impl(typecode_t typecode, const gsl::byte *input,
+                          gsl::span<const size_t> in_shape,
+                          gsl::span<const size_t> in_strides, gsl::byte *output,
+                          int32_t axis) noexcept {
+    TYPE_SELECT(typecode, HARDMAX_IMPL)} // namespace
+
+result<value_t> nncase::kernels::stackvm::hardmax(
+    value_t input, value_t axis, value_t output,
+    [[maybe_unused]] kernel_context &context) {
+    try_input(input_mem, input);
+    try_output(out_mem, output, input_tensor->dtype(), input_tensor->shape());
     try_positive_axis(axis_value, axis, input_tensor);
-    try_(hardmax_impl(input_mem, input_tensor->shape(), input_tensor->strides(),
-                      out_mem, axis_value));
+    try_typecode(typecode, input_tensor);
+    try_(hardmax_impl(typecode, input_mem, input_tensor->shape(),
+                      input_tensor->strides(), out_mem, axis_value));
+
     return ok(output);
 }
diff --git a/src/Native/src/kernels/stackvm/reference/instance_norm.cpp b/src/Native/src/kernels/stackvm/reference/instance_norm.cpp
index 682bf49e45..7fd63fa499 100644
--- a/src/Native/src/kernels/stackvm/reference/instance_norm.cpp
+++ b/src/Native/src/kernels/stackvm/reference/instance_norm.cpp
@@ -26,10 +26,10 @@ using namespace nncase::kernels::stackvm::reference;
 using namespace nncase::kernels::stackvm;
 
 namespace {
-result<void> instance_norm_impl(const float *input, const float *scale,
-                                const float *bias, const float *input_mean,
-                                const float *input_var, float *output,
-                                gsl::span<const size_t> in_shape,
+template <typename T>
+result<void> instance_norm_impl(const T *input, const T *scale, const T *bias,
+                                const T *input_mean, const T *input_var,
+                                T *output, gsl::span<const size_t> in_shape,
                                 gsl::span<const size_t> in_strides,
                                 gsl::span<const size_t> out_strides,
                                 float epsilon) {
@@ -39,31 +39,34 @@ result<void> instance_norm_impl(const float *input, const float *scale,
         auto off = offset(in_strides, index);
         const auto x = input[off];
         output[offset(out_strides, index)] =
-            scale[c] * (x - input_mean[offi]) /
-                std::sqrt(input_var[offi] + epsilon) +
+            scale[c] * (x - static_cast<T>(input_mean[offi])) /
+                static_cast<T>(
+                    std::sqrt(static_cast<float>(input_var[offi]) + epsilon)) +
             bias[c];
         return ok();
     });
 }
 } // namespace
 
-result<void> nncase::kernels::stackvm::reference::instance_norm(
-    const float *input, const float *scale, const float *bias, float *output,
-    gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
-    gsl::span<const size_t> out_strides, float epsilon) {
+template <typename T>
+result<void>
+instance_norm_impl2(typecode_t type, const T *input, const T *scale,
+                    const T *bias, T *output, gsl::span<const size_t> in_shape,
+                    gsl::span<const size_t> in_strides,
+                    gsl::span<const size_t> out_strides, float epsilon) {
     auto axes = dims_t{};
     for (size_t i = 2; i < in_shape.size(); ++i) {
         axes.push_back(i);
     }
     auto in_size = runtime::compute_size(in_shape);
     auto channels = in_shape[0] * in_shape[1];
-    auto mean = std::make_unique<float[]>(channels);
-    auto var = std::make_unique<float[]>(channels);
-    auto square_output = std::make_unique<float[]>(in_size);
-    auto sub_output = std::make_unique<float[]>(in_size);
+    auto mean = std::make_unique<T[]>(channels);
+    auto var = std::make_unique<T[]>(channels);
+    auto square_output = std::make_unique<T[]>(in_size);
+    auto sub_output = std::make_unique<T[]>(in_size);
 
     // square and get var
-    auto init_value = 0.f;
+    T init_value = 0;
     auto init_value_addr = IN_CAST(gsl::byte, &init_value);
     auto tmp_out_strides = strides_t{in_shape[1], 1};
     auto tmp_out_shape = strides_t{in_shape[0], in_shape[1]};
@@ -73,11 +76,10 @@ result<void> nncase::kernels::stackvm::reference::instance_norm(
     }
     auto run_reduce = [&](auto &&input, auto &&output, auto &&in_shape,
                           auto &&in_strides) -> result<void> {
-        try_(reference::reduce(dt_float32, reduce_op_t::mean, init_value_addr,
-                               IN_CAST(gsl::byte, input),
-                               OUT_CAST(gsl::byte, output), in_shape, axes,
-                               in_strides, tmp_out_strides, true,
-                               kernels::default_kernel_context()));
+        try_(nncase::kernels::stackvm::reference::reduce(
+            type, reduce_op_t::mean, init_value_addr, IN_CAST(gsl::byte, input),
+            OUT_CAST(gsl::byte, output), in_shape, axes, in_strides,
+            tmp_out_strides, true, kernels::default_kernel_context()));
         return ok();
     };
     // mean -> reduce_mean(input)
@@ -86,20 +88,64 @@ result<void> nncase::kernels::stackvm::reference::instance_norm(
     auto sub_out_shape =
         kernels::detail::get_binary_output_shape(in_shape, tmp_out_shape);
     auto sub_out_strides = runtime::get_default_strides(sub_out_shape);
-    try_(reference::binary(
-        dt_float32, runtime::stackvm::binary_op_t::sub,
-        IN_CAST(gsl::byte, input), IN_CAST(gsl::byte, mean.get()),
-        OUT_CAST(gsl::byte, sub_output.get()), in_shape, in_strides,
-        tmp_out_shape, tmp_out_strides, sub_out_shape, sub_out_strides));
-    try_(reference::unary(dt_float32, unary_op_t::square,
-                          IN_CAST(gsl::byte, sub_output.get()),
-                          OUT_CAST(gsl::byte, square_output.get()),
-                          sub_out_shape, sub_out_strides, sub_out_shape,
-                          sub_out_strides, kernels::default_kernel_context()));
+    try_(nncase::kernels::stackvm::reference::binary(
+        type, runtime::stackvm::binary_op_t::sub, IN_CAST(gsl::byte, input),
+        IN_CAST(gsl::byte, mean.get()), OUT_CAST(gsl::byte, sub_output.get()),
+        in_shape, in_strides, tmp_out_shape, tmp_out_strides, sub_out_shape,
+        sub_out_strides));
+    try_(nncase::kernels::stackvm::reference::unary(
+        type, unary_op_t::square, IN_CAST(gsl::byte, sub_output.get()),
+        OUT_CAST(gsl::byte, square_output.get()), sub_out_shape,
+        sub_out_strides, sub_out_shape, sub_out_strides,
+        kernels::default_kernel_context()));
     // var = reduce_mean(square(input - mean))
     try_(run_reduce(square_output.get(), var.get(), sub_out_shape,
                     sub_out_strides));
     try_(instance_norm_impl(input, scale, bias, mean.get(), var.get(), output,
                             in_shape, in_strides, out_strides, epsilon));
     return ok();
-}
\ No newline at end of file
+}
+
+#define INSTANCE_NORM_IMPL(type)                                               \
+    return instance_norm_impl2(typecode, IN_CAST(type, input),                 \
+                               IN_CAST(type, scale), IN_CAST(type, bias),      \
+                               OUT_CAST(type, output), in_shape, in_strides,   \
+                               out_strides, epsilon);
+
+#define TYPE_SELECT_INSTANCE_NORM(_typecode, _impl)                            \
+    switch (_typecode) {                                                       \
+    case dt_float32:                                                           \
+        _impl(float);                                                          \
+    case dt_float16:                                                           \
+        _impl(half);                                                           \
+    case dt_bfloat16:                                                          \
+        _impl(bfloat16);                                                       \
+    case dt_int8:                                                              \
+        _impl(int8_t);                                                         \
+    case dt_int16:                                                             \
+        _impl(int16_t);                                                        \
+    case dt_int32:                                                             \
+        _impl(int32_t);                                                        \
+    case dt_int64:                                                             \
+        _impl(int64_t);                                                        \
+    case dt_uint8:                                                             \
+        _impl(uint8_t);                                                        \
+    case dt_uint16:                                                            \
+        _impl(uint16_t);                                                       \
+    case dt_uint32:                                                            \
+        _impl(uint32_t);                                                       \
+    case dt_uint64:                                                            \
+        _impl(uint64_t);                                                       \
+    case dt_float64:                                                           \
+        _impl(double);                                                         \
+    default:                                                                   \
+        return err(std::errc::not_supported);                                  \
+    }
+
+result<void> nncase::kernels::stackvm::reference::instance_norm(
+    typecode_t typecode, const gsl::byte *input, const gsl::byte *scale,
+    const gsl::byte *bias, gsl::byte *output, gsl::span<const size_t> in_shape,
+    gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides,
+    float epsilon) {
+    TYPE_SELECT_INSTANCE_NORM(typecode, INSTANCE_NORM_IMPL);
+}
diff --git a/src/Native/src/kernels/stackvm/reference/layer_norm.cpp b/src/Native/src/kernels/stackvm/reference/layer_norm.cpp
index 092b8de0d6..7f11e0c47f 100644
--- a/src/Native/src/kernels/stackvm/reference/layer_norm.cpp
+++ b/src/Native/src/kernels/stackvm/reference/layer_norm.cpp
@@ -21,28 +21,29 @@
 using namespace nncase;
 using namespace nncase::kernels::stackvm;
 
-static void layernorm_impl(int inner_size, const float *src, const float *scale,
-                           const float *bias, float epsilon, float *dst) {
-    float mean1 = 0.f;
+template <class T>
+static void layernorm_impl(int inner_size, const T *src, const T *scale,
+                           const T *bias, float epsilon, T *dst) {
+    T mean1 = 0;
     for (auto i = 0; i < inner_size; i++)
         mean1 += src[i] / inner_size;
 
-    std::vector<float> sub(inner_size, 0.f);
+    std::vector<T> sub(inner_size, 0);
     for (auto i = 0; i < inner_size; i++)
         sub[i] = src[i] - mean1;
 
-    std::vector<float> pow(inner_size, 0.f);
+    std::vector<T> pow(inner_size, 0);
     for (auto i = 0; i < inner_size; i++)
         pow[i] = sub[i] * sub[i];
 
-    float mean2 = 0.f;
+    T mean2 = 0;
     for (auto i = 0; i < inner_size; i++)
         mean2 += pow[i] / inner_size;
 
-    float add = mean2 + epsilon;
-    float sqrt = std::sqrt(add);
+    T add = mean2 + static_cast<T>(epsilon);
+    T sqrt = std::sqrt(add);
 
-    std::vector<float> div(inner_size, 0.f);
+    std::vector<T> div(inner_size, 0);
     for (auto i = 0; i < inner_size; i++)
         div[i] = sub[i] / sqrt;
 
@@ -50,9 +51,10 @@ static void layernorm_impl(int inner_size, const float *src, const float *scale,
         dst[i] = div[i] * scale[i] + bias[i];
 }
 
-result<void> nncase::kernels::stackvm::reference::layer_norm(
-    const float *input, float *output, const float *scale, const float *bias,
-    gsl::span<const size_t> in_shape, int32_t axis, float epsilon) {
+template <class T>
+result<void> layer_norm_impl2(const T *input, T *output, const T *scale,
+                              const T *bias, gsl::span<const size_t> in_shape,
+                              int32_t axis, float epsilon) {
 
     int ndim = in_shape.size();
     int positive_axis = axis < 0 ? ndim + axis : axis;
@@ -72,4 +74,46 @@ result<void> nncase::kernels::stackvm::reference::layer_norm(
         output += axis_dim;
     }
     return ok();
-}
\ No newline at end of file
+}
+
+#define LAYER_NORM_IMPL(type)                                                  \
+    return layer_norm_impl2(IN_CAST(type, input), OUT_CAST(type, output),      \
+                            IN_CAST(type, scale), IN_CAST(type, bias),         \
+                            in_shape, axis, epsilon)
+
+#define TYPE_SELECT_LAYER_NORM(_typecode, _impl)                               \
+    switch (_typecode) {                                                       \
+    case dt_float32:                                                           \
+        _impl(float);                                                          \
+    case dt_float16:                                                           \
+        _impl(half);                                                           \
+    case dt_bfloat16:                                                          \
+        _impl(bfloat16);                                                       \
+    case dt_int8:                                                              \
+        _impl(int8_t);                                                         \
+    case dt_int16:                                                             \
+        _impl(int16_t);                                                        \
+    case dt_int32:                                                             \
+        _impl(int32_t);                                                        \
+    case dt_int64:                                                             \
+        _impl(int64_t);                                                        \
+    case dt_uint8:                                                             \
+        _impl(uint8_t);                                                        \
+    case dt_uint16:                                                            \
+        _impl(uint16_t);                                                       \
+    case dt_uint32:                                                            \
+        _impl(uint32_t);                                                       \
+    case dt_uint64:                                                            \
+        _impl(uint64_t);                                                       \
+    case dt_float64:                                                           \
+        _impl(double);                                                         \
+    default:                                                                   \
+        return err(std::errc::not_supported);                                  \
+    }
+
+result<void> nncase::kernels::stackvm::reference::layer_norm(
+    typecode_t typecode, const gsl::byte *input, gsl::byte *output,
+    const gsl::byte *scale, const gsl::byte *bias,
+    gsl::span<const size_t> in_shape, int32_t axis, float epsilon) {
+    TYPE_SELECT_LAYER_NORM(typecode, LAYER_NORM_IMPL);
+}
diff --git a/src/Native/src/kernels/stackvm/reference/log_softmax.cpp b/src/Native/src/kernels/stackvm/reference/log_softmax.cpp
index 8e61d5bc45..338bdf0889 100644
--- a/src/Native/src/kernels/stackvm/reference/log_softmax.cpp
+++ b/src/Native/src/kernels/stackvm/reference/log_softmax.cpp
@@ -17,6 +17,7 @@
 #include <iostream>
 #include <nncase/kernels/kernel_utils.h>
 #include <nncase/runtime/runtime_op_utility.h>
+#include <nncase/runtime/util.h>
 
 using namespace nncase;
 using namespace nncase::runtime;
@@ -101,12 +102,46 @@ log_softmax_impl(const T *input, T *output, gsl::span<const size_t> in_shape,
 
     return ok();
 }
+
+#define LOG_SOFTMAX_IMPL(type)                                                 \
+    return log_softmax_impl(IN_CAST(type, input), OUT_CAST(type, output),      \
+                            in_shape, in_strides, out_strides, axis);
+
+#define TYPE_SELECT_LOG_SOFTMAX(_typecode, _impl)                              \
+    switch (_typecode) {                                                       \
+    case dt_float32:                                                           \
+        _impl(float);                                                          \
+    case dt_float16:                                                           \
+        _impl(half);                                                           \
+    case dt_bfloat16:                                                          \
+        _impl(bfloat16);                                                       \
+    case dt_int8:                                                              \
+        _impl(int8_t);                                                         \
+    case dt_int16:                                                             \
+        _impl(int16_t);                                                        \
+    case dt_int32:                                                             \
+        _impl(int32_t);                                                        \
+    case dt_int64:                                                             \
+        _impl(int64_t);                                                        \
+    case dt_uint8:                                                             \
+        _impl(uint8_t);                                                        \
+    case dt_uint16:                                                            \
+        _impl(uint16_t);                                                       \
+    case dt_uint32:                                                            \
+        _impl(uint32_t);                                                       \
+    case dt_uint64:                                                            \
+        _impl(uint64_t);                                                       \
+    case dt_float64:                                                           \
+        _impl(double);                                                         \
+    default:                                                                   \
+        return err(std::errc::not_supported);                                  \
+    }
+
 } // namespace
 
 result<void> nncase::kernels::stackvm::reference::log_softmax(
-    const float *input, float *output, gsl::span<const size_t> in_shape,
-    gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides,
-    int32_t axis) noexcept {
-    return log_softmax_impl(input, output, in_shape, in_strides, out_strides,
-                            axis);
+    typecode_t typecode, const gsl::byte *input, gsl::byte *output,
+    gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
+    gsl::span<const size_t> out_strides, int32_t axis) noexcept {
+    TYPE_SELECT_LOG_SOFTMAX(typecode, LOG_SOFTMAX_IMPL);
 }
\ No newline at end of file
diff --git a/src/Native/src/kernels/stackvm/reference/lrn.cpp b/src/Native/src/kernels/stackvm/reference/lrn.cpp
index 81ebee9079..30757e74f9 100644
--- a/src/Native/src/kernels/stackvm/reference/lrn.cpp
+++ b/src/Native/src/kernels/stackvm/reference/lrn.cpp
@@ -27,8 +27,9 @@ using namespace nncase::kernels::stackvm::reference;
 using namespace nncase::kernels::stackvm;
 
 namespace {
-result<void> lrn_impl(const float *input, float alpha, float beta, float bias,
-                      int64_t size, float *output, const float *square_sum,
+template <typename T>
+result<void> lrn_impl(const T *input, float alpha, float beta, float bias,
+                      int64_t size, T *output, const T *square_sum,
                       gsl::span<const size_t> in_shape,
                       gsl::span<const size_t> in_strides,
                       gsl::span<const size_t> out_strides) {
@@ -37,25 +38,28 @@ result<void> lrn_impl(const float *input, float alpha, float beta, float bias,
         const auto x = input[off];
         const auto num = square_sum[off];
         output[offset(out_strides, index)] =
-            x / std::pow(num * alpha / size + bias, beta);
+            x / static_cast<T>(std::pow(
+                    static_cast<float>(num) * alpha / size + bias, beta));
         return ok();
     });
 }
 } // namespace
 
-result<void> nncase::kernels::stackvm::reference::lrn(
-    const float *input, float alpha, float beta, float bias, int size,
-    float *output, gsl::span<const size_t> in_shape,
-    gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides) {
-    std::vector<std::unique_ptr<float[]>> tmpData;
+template <typename T>
+result<void> lrn_impl2(typecode_t type, const T *input, float alpha, float beta,
+                       float bias, int size, T *output,
+                       gsl::span<const size_t> in_shape,
+                       gsl::span<const size_t> in_strides,
+                       gsl::span<const size_t> out_strides) {
+    std::vector<std::unique_ptr<T[]>> tmpData;
     std::vector<dims_t> tmpShapes;
     std::vector<dims_t> tmpStrides;
     auto concat_size = 0;
-    auto square_data =
-        std::make_unique<float[]>(runtime::compute_size(in_shape));
-    try_(reference::unary(dt_float32, runtime::stackvm::unary_op_t::square,
-                          IN_BYTE_CAST(input), OUT_BYTE_CAST(square_data.get()),
-                          in_shape, in_strides, in_shape, in_strides));
+    auto square_data = std::make_unique<T[]>(runtime::compute_size(in_shape));
+    try_(nncase::kernels::stackvm::reference::unary(
+        type, runtime::stackvm::unary_op_t::square, IN_BYTE_CAST(input),
+        OUT_BYTE_CAST(square_data.get()), in_shape, in_strides, in_shape,
+        in_strides));
     for (size_t i = 0; i < in_shape[1]; ++i) {
         auto beginV =
             std::max(static_cast<int64_t>(0),
@@ -72,8 +76,8 @@ result<void> nncase::kernels::stackvm::reference::lrn(
         auto tmp_out_shape = slice_infer_shape(in_shape, begins, ends, strides);
         auto tmp_out_strides = runtime::get_default_strides(tmp_out_shape);
         auto slice_out =
-            std::make_unique<float[]>(runtime::compute_size(tmp_out_shape));
-        try_(slice(dt_float32, IN_BYTE_CAST(square_data.get()),
+            std::make_unique<T[]>(runtime::compute_size(tmp_out_shape));
+        try_(slice(type, IN_BYTE_CAST(square_data.get()),
                    OUT_CAST(gsl::byte, slice_out.get()), in_shape, in_strides,
                    out_strides, begins, ends, strides,
                    default_kernel_context()));
@@ -83,19 +87,19 @@ result<void> nncase::kernels::stackvm::reference::lrn(
         auto reduce_shape = reduce_infer_shape(tmp_out_shape, axes, keep_dims);
         auto reduce_size = runtime::compute_size(reduce_shape);
         concat_size += reduce_size;
-        tmpData.push_back(std::make_unique<float[]>(reduce_size));
+        tmpData.push_back(std::make_unique<T[]>(reduce_size));
         tmpShapes.push_back(reduce_shape);
         auto reduce_out_strides = runtime::get_default_strides(reduce_shape);
         tmpStrides.push_back(reduce_out_strides);
-        auto init_value = 0.f;
-        try_(reference::reduce(
-            dt_float32, reduce_op_t::sum, IN_CAST(gsl::byte, &init_value),
+        auto init_value = 0;
+        try_(nncase::kernels::stackvm::reference::reduce(
+            type, reduce_op_t::sum, IN_CAST(gsl::byte, &init_value),
             IN_CAST(gsl::byte, slice_out.get()),
             OUT_CAST(gsl::byte, tmpData[i].get()), tmp_out_shape, axes,
             tmp_out_strides, reduce_out_strides, keep_dims));
     }
 
-    auto concat_output = std::make_unique<float[]>(concat_size);
+    auto concat_output = std::make_unique<T[]>(concat_size);
     auto concat_shape = concat_infer_shape(tmpShapes, 1);
     auto concat_strides = runtime::get_default_strides(concat_shape);
     auto concat_dims = dims_t();
@@ -107,10 +111,36 @@ result<void> nncase::kernels::stackvm::reference::lrn(
     for (auto &i : tmpData) {
         concat_inputs.push_back(IN_CAST(gsl::byte, i.get()));
     }
-    try_(reference::concat(
-        dt_float32, concat_inputs, OUT_CAST(gsl::byte, concat_output.get()),
+    try_(nncase::kernels::stackvm::reference::concat(
+        type, concat_inputs, OUT_CAST(gsl::byte, concat_output.get()),
         concat_shape, tmpStrides, concat_strides, axis, concat_dims))
         try_(lrn_impl(input, alpha, beta, bias, size, output,
                       concat_output.get(), in_shape, in_strides, out_strides));
     return ok();
-}
\ No newline at end of file
+}
+
+#define LRN_IMPL(type)                                                         \
+    return lrn_impl2(typecode, IN_CAST(type, input), alpha, beta, bias, size,  \
+                     OUT_CAST(type, output), in_shape, in_strides,             \
+                     out_strides);
+
+#define TYPE_SELECT_LRN(_typecode, _impl)                                      \
+    switch (_typecode) {                                                       \
+    case dt_float32:                                                           \
+        _impl(float);                                                          \
+    case dt_float16:                                                           \
+        _impl(half);                                                           \
+    case dt_bfloat16:                                                          \
+        _impl(bfloat16);                                                       \
+    case dt_float64:                                                           \
+        _impl(double);                                                         \
+    default:                                                                   \
+        return err(std::errc::not_supported);                                  \
+    }
+
+result<void> nncase::kernels::stackvm::reference::lrn(
+    typecode_t typecode, const gsl::byte *input, float alpha, float beta,
+    float bias, int size, gsl::byte *output, gsl::span<const size_t> in_shape,
+    gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides) {
+    TYPE_SELECT_LRN(typecode, LRN_IMPL)
+}
diff --git a/src/Native/src/kernels/stackvm/reference/lstm.cpp b/src/Native/src/kernels/stackvm/reference/lstm.cpp
index 43a8a3f97e..ffd09365d0 100644
--- a/src/Native/src/kernels/stackvm/reference/lstm.cpp
+++ b/src/Native/src/kernels/stackvm/reference/lstm.cpp
@@ -26,14 +26,18 @@ using namespace nncase::runtime::stackvm;
 using namespace nncase::kernels;
 using namespace nncase::kernels::stackvm;
 #include <iostream>
-result<void> nncase::kernels::stackvm::reference::lstm(
-    const float *input, const float *w_xc, const float *w_rc,
-    [[maybe_unused]] const float *bias, const float *init_h,
-    const float *init_c, float *output, float *output_h, float *output_c,
-    gsl::span<const size_t> in_shape_3, gsl::span<const size_t> init_h_shape_3,
-    gsl::span<const size_t> init_c_shape_3, gsl::span<const size_t> out_shape_3,
-    gsl::span<const size_t> w_xc_shape_3, gsl::span<const size_t> w_rc_shape_3,
-    lstmdirection_t direction) {
+
+template <typename T>
+result<void> lstm_impl(const T *input, const T *w_xc, const T *w_rc,
+                       [[maybe_unused]] const T *bias, const T *init_h,
+                       const T *init_c, T *output, T *output_h, T *output_c,
+                       gsl::span<const size_t> in_shape_3,
+                       gsl::span<const size_t> init_h_shape_3,
+                       gsl::span<const size_t> init_c_shape_3,
+                       gsl::span<const size_t> out_shape_3,
+                       gsl::span<const size_t> w_xc_shape_3,
+                       gsl::span<const size_t> w_rc_shape_3,
+                       lstmdirection_t direction) {
     auto in_shape = to_4d(in_shape_3);
     auto init_h_shape = to_4d(init_h_shape_3);
     auto init_c_shape = to_4d(init_c_shape_3);
@@ -41,15 +45,17 @@ result<void> nncase::kernels::stackvm::reference::lstm(
     auto w_rc_shape = to_4d(w_rc_shape_3);
     auto out_shape = to_4d(out_shape_3);
 
-    auto tanh = [&](float x) { return (1 - exp(-2 * x)) / (1 + exp(-2 * x)); };
-    auto sigmoid = [&](float x) { return 1 / (1 + exp(-x)); };
+    auto tanh = [&](T x) {
+        return (1 - exp(-2 * (float)x)) / (1 + exp(-2 * (float)x));
+    };
+    auto sigmoid = [&](T x) { return 1 / (1 + exp(-x)); };
 
-    auto output_h_tmp = std::make_unique<float[]>(compute_size(init_h_shape));
-    auto output_c_tmp = std::make_unique<float[]>(compute_size(init_c_shape));
+    auto output_h_tmp = std::make_unique<T[]>(compute_size(init_h_shape));
+    auto output_c_tmp = std::make_unique<T[]>(compute_size(init_c_shape));
     std::memcpy(output_h_tmp.get(), init_h,
-                sizeof(float) * compute_size(init_h_shape));
+                sizeof(T) * compute_size(init_h_shape));
     std::memcpy(output_c_tmp.get(), init_c,
-                sizeof(float) * compute_size(init_c_shape));
+                sizeof(T) * compute_size(init_c_shape));
 
     auto hidden_size = w_xc_shape[2];
     std::vector<uint32_t> seq_len_loop;
@@ -64,8 +70,8 @@ result<void> nncase::kernels::stackvm::reference::lstm(
         for (uint32_t b = 0; b < in_shape[2]; b++) {
             for (auto &l : seq_len_loop) {
                 // g = w_xc_x + w_xc_x
-                auto out_mul1 = std::vector<float>(out_shape[3] * 4);
-                auto out_mul2 = std::vector<float>(out_shape[3] * 4);
+                auto out_mul1 = std::vector<T>(out_shape[3] * 4);
+                auto out_mul2 = std::vector<T>(out_shape[3] * 4);
                 for (size_t o = 0; o < out_mul1.size(); o++) {
                     for (size_t i = 0; i < in_shape[3]; i++) {
                         auto in_idx =
@@ -73,8 +79,7 @@ result<void> nncase::kernels::stackvm::reference::lstm(
                         auto w_idx = i + o * w_xc_shape[3] +
                                      d * w_xc_shape[2] * w_xc_shape[3];
 
-                        out_mul1[o] +=
-                            float(input[in_idx]) * float(w_xc[w_idx]);
+                        out_mul1[o] += T(input[in_idx]) * T(w_xc[w_idx]);
                     }
                     auto b_idx1 = d * w_rc_shape[2] + o;
                     out_mul1[o] += bias[b_idx1];
@@ -84,8 +89,7 @@ result<void> nncase::kernels::stackvm::reference::lstm(
                                       d * out_shape[2] * out_shape[3];
                         auto w_idx = i + o * w_rc_shape[3] +
                                      d * w_rc_shape[2] * w_rc_shape[3];
-                        out_mul2[o] +=
-                            float(output_h_tmp[in_idx]) * float(w_rc[w_idx]);
+                        out_mul2[o] += T(output_h_tmp[in_idx]) * T(w_rc[w_idx]);
                     }
                     auto b_idx2 = d * w_rc_shape[2] + hidden_size + o;
                     out_mul2[o] += bias[b_idx2];
@@ -129,8 +133,8 @@ result<void> nncase::kernels::stackvm::reference::lstm(
                 // ct = ct + c_t_it
                 for (size_t o = 0; o < out_shape[3]; o++) {
                     output_c_tmp[o + d * out_shape[2] * out_shape[3]] =
-                        float(out_mul1[o + out_shape[3] * 2] +
-                              out_mul1[o + out_shape[3] * 0]);
+                        T(out_mul1[o + out_shape[3] * 2] +
+                          out_mul1[o + out_shape[3] * 0]);
                 }
 
                 // ot = sigmoid(g[1])
@@ -148,30 +152,62 @@ result<void> nncase::kernels::stackvm::reference::lstm(
                 // ht = ot * tanh_ct
                 for (size_t o = 0; o < out_shape[3]; o++) {
                     output_h_tmp[o + d * out_shape[2] * out_shape[3]] =
-                        float(out_mul1[o + out_shape[3] * 3] *
-                              out_mul1[o + out_shape[3] * 1]);
+                        T(out_mul1[o + out_shape[3] * 3] *
+                          out_mul1[o + out_shape[3] * 1]);
                 }
                 std::memcpy(output + b * out_shape[3] +
                                 d * out_shape[2] * out_shape[3] +
                                 l * out_shape[1] * out_shape[2] * out_shape[3],
                             output_h_tmp.get() +
                                 d * out_shape[2] * out_shape[3],
-                            sizeof(float) * out_shape[3]);
+                            sizeof(T) * out_shape[3]);
 
                 if (l == seq_len_loop.back()) {
                     std::memcpy(output_h + b * out_shape[3] +
                                     d * out_shape[2] * out_shape[3],
                                 output_h_tmp.get() +
                                     d * out_shape[2] * out_shape[3],
-                                sizeof(float) * out_shape[3]);
+                                sizeof(T) * out_shape[3]);
                     std::memcpy(output_c + b * out_shape[3] +
                                     d * out_shape[2] * out_shape[3],
                                 output_c_tmp.get() +
                                     d * out_shape[2] * out_shape[3],
-                                sizeof(float) * out_shape[3]);
+                                sizeof(T) * out_shape[3]);
                 }
             }
         }
     }
     return ok();
 }
+
+#define LSTM_IMPL(type)                                                        \
+    return lstm_impl(                                                          \
+        IN_CAST(type, input), IN_CAST(type, w_xc), IN_CAST(type, w_rc),        \
+        IN_CAST(type, bias), IN_CAST(type, init_h), IN_CAST(type, init_c),     \
+        OUT_CAST(type, output), OUT_CAST(type, output_h),                      \
+        OUT_CAST(type, output_c), in_shape_3, init_h_shape_3, init_c_shape_3,  \
+        out_shape_3, w_xc_shape_3, w_rc_shape_3, direction);
+
+#define TYPE_SELECT_LSTM(_typecode, _impl)                                     \
+    switch (_typecode) {                                                       \
+    case dt_float32:                                                           \
+        _impl(float);                                                          \
+    case dt_float16:                                                           \
+        _impl(half);                                                           \
+    case dt_float64:                                                           \
+        _impl(double);                                                         \
+    default:                                                                   \
+        return err(std::errc::not_supported);                                  \
+    }
+
+result<void> nncase::kernels::stackvm::reference::lstm(
+    typecode_t type, const gsl::byte *input, const gsl::byte *w_xc,
+    const gsl::byte *w_rc, [[maybe_unused]] const gsl::byte *bias,
+    const gsl::byte *init_h, const gsl::byte *init_c, gsl::byte *output,
+    gsl::byte *output_h, gsl::byte *output_c,
+    gsl::span<const size_t> in_shape_3, gsl::span<const size_t> init_h_shape_3,
+    gsl::span<const size_t> init_c_shape_3, gsl::span<const size_t> out_shape_3,
+    gsl::span<const size_t> w_xc_shape_3, gsl::span<const size_t> w_rc_shape_3,
+    lstmdirection_t direction) {
+    TYPE_SELECT_LSTM(type, LSTM_IMPL);
+}
diff --git a/src/Native/src/kernels/stackvm/reference/prelu.cpp b/src/Native/src/kernels/stackvm/reference/prelu.cpp
index f5e06e9118..df12fe376b 100644
--- a/src/Native/src/kernels/stackvm/reference/prelu.cpp
+++ b/src/Native/src/kernels/stackvm/reference/prelu.cpp
@@ -25,12 +25,15 @@ using namespace nncase::runtime::stackvm;
 using namespace nncase::kernels;
 using namespace nncase::kernels::stackvm;
 
-result<void> nncase::kernels::stackvm::reference::prelu(
-    const float *input, const float *slope_mem, float *output,
-    gsl::span<const size_t> in_shape, gsl::span<const size_t> input_strides,
-    gsl::span<const size_t> slope_shape, gsl::span<const size_t> slope_strides,
-    gsl::span<const size_t> out_shape, gsl::span<const size_t> out_strides,
-    NNCASE_UNUSED kernel_context &context) {
+template <typename T>
+result<void> prelu_impl(const T *input, const T *slope_mem, T *output,
+                        gsl::span<const size_t> in_shape,
+                        gsl::span<const size_t> input_strides,
+                        gsl::span<const size_t> slope_shape,
+                        gsl::span<const size_t> slope_strides,
+                        gsl::span<const size_t> out_shape,
+                        gsl::span<const size_t> out_strides,
+                        NNCASE_UNUSED kernel_context &context) {
     return apply(out_shape, [&](gsl::span<const size_t> index) -> result<void> {
         const auto in_index =
             kernels::detail::get_reduced_offset(index, in_shape);
@@ -38,7 +41,54 @@ result<void> nncase::kernels::stackvm::reference::prelu(
             kernels::detail::get_reduced_offset(index, slope_shape);
         const auto slope = slope_mem[offset(slope_strides, slope_index)];
         const auto x = input[offset(input_strides, in_index)];
-        output[offset(out_strides, index)] = x < 0 ? slope * x : x;
+        output[offset(out_strides, index)] =
+            x < static_cast<T>(0) ? slope * x : x;
         return ok();
     });
+}
+
+#define PRELU_IMPL(type)                                                       \
+    return prelu_impl(IN_CAST(type, input), IN_CAST(type, slope_mem),          \
+                      OUT_CAST(type, output), in_shape, input_strides,         \
+                      slope_shape, slope_strides, out_shape, out_strides,      \
+                      context);
+
+#define TYPE_SELECT_PRELU(_typecode, _impl)                                    \
+    switch (_typecode) {                                                       \
+    case dt_float32:                                                           \
+        _impl(float);                                                          \
+    case dt_float16:                                                           \
+        _impl(half);                                                           \
+    case dt_bfloat16:                                                          \
+        _impl(bfloat16);                                                       \
+    case dt_int8:                                                              \
+        _impl(int8_t);                                                         \
+    case dt_int16:                                                             \
+        _impl(int16_t);                                                        \
+    case dt_int32:                                                             \
+        _impl(int32_t);                                                        \
+    case dt_int64:                                                             \
+        _impl(int64_t);                                                        \
+    case dt_uint8:                                                             \
+        _impl(uint8_t);                                                        \
+    case dt_uint16:                                                            \
+        _impl(uint16_t);                                                       \
+    case dt_uint32:                                                            \
+        _impl(uint32_t);                                                       \
+    case dt_uint64:                                                            \
+        _impl(uint64_t);                                                       \
+    case dt_float64:                                                           \
+        _impl(double);                                                         \
+    default:                                                                   \
+        return err(std::errc::not_supported);                                  \
+    }
+
+result<void> nncase::kernels::stackvm::reference::prelu(
+    typecode_t typecode, const gsl::byte *input, const gsl::byte *slope_mem,
+    gsl::byte *output, gsl::span<const size_t> in_shape,
+    gsl::span<const size_t> input_strides, gsl::span<const size_t> slope_shape,
+    gsl::span<const size_t> slope_strides, gsl::span<const size_t> out_shape,
+    gsl::span<const size_t> out_strides,
+    NNCASE_UNUSED kernel_context &context) {
+    TYPE_SELECT_PRELU(typecode, PRELU_IMPL);
 }
\ No newline at end of file
diff --git a/src/Native/src/kernels/stackvm/reference/ref_ops.h b/src/Native/src/kernels/stackvm/reference/ref_ops.h
index 4111eaaac5..14fb78cff5 100644
--- a/src/Native/src/kernels/stackvm/reference/ref_ops.h
+++ b/src/Native/src/kernels/stackvm/reference/ref_ops.h
@@ -30,13 +30,15 @@ BEGIN_NS_NNCASE_KERNELS_MODULE(stackvm)
 namespace reference {
 
 NNCASE_API result<void>
-batchnorm(const float *input, const float *scale, const float *bias,
-          const float *input_mean, const float *input_var, float *output,
+batchnorm(typecode_t typecode, const gsl::byte *input, const gsl::byte *scale,
+          const gsl::byte *bias, const gsl::byte *input_mean,
+          const gsl::byte *input_var, gsl::byte *output,
           gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
           gsl::span<const size_t> out_strides, float epsilon);
 
-NNCASE_API result<void> layer_norm(const float *input, float *output,
-                                   const float *scale, const float *bias,
+NNCASE_API result<void> layer_norm(typecode_t type, const gsl::byte *input,
+                                   gsl::byte *output, const gsl::byte *scale,
+                                   const gsl::byte *bias,
                                    gsl::span<const size_t> in_shape,
                                    int32_t axis, float epsilon);
 
@@ -93,23 +95,25 @@ NNCASE_API result<void> constant_of_shape(datatype_t dt, const gsl::byte *value,
                                           gsl::span<const size_t> shape);
 
 NNCASE_API result<void> conv2d(
-    const float *input, const float *weights, const float *bias, float *output,
-    gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
-    gsl::span<const size_t> w_shape, gsl::span<const size_t> w_strides,
-    gsl::span<const size_t> bias_strides, gsl::span<const size_t> out_strides,
-    const padding &padding_h, const padding &padding_w, int32_t groups,
-    int32_t stride_h, int32_t stride_w, int32_t dilation_h, int32_t dilation_w,
+    typecode_t typecode, const gsl::byte *input, const gsl::byte *weights,
+    const gsl::byte *bias, gsl::byte *output, gsl::span<const size_t> in_shape,
+    gsl::span<const size_t> in_strides, gsl::span<const size_t> w_shape,
+    gsl::span<const size_t> w_strides, gsl::span<const size_t> bias_strides,
+    gsl::span<const size_t> out_strides, const padding &padding_h,
+    const padding &padding_w, int32_t groups, int32_t stride_h,
+    int32_t stride_w, int32_t dilation_h, int32_t dilation_w,
     value_range<float> fused_activation,
     NNCASE_UNUSED kernel_context &context = default_kernel_context()) noexcept;
 
-NNCASE_API result<void>
-conv2d_transpose(const float *input, float *output, const float *weights,
-                 const float *bias, gsl::span<const size_t> in_shape,
-                 int32_t groups, gsl::span<const size_t> out_shape,
-                 int32_t filter_h, int32_t filter_w, int32_t stride_h,
-                 int32_t stride_w, int32_t dilation_h, int32_t dilation_w,
-                 const padding &padding_h, const padding &padding_w,
-                 const value_range<float> &fused_activation) noexcept;
+NNCASE_API result<void> conv2d_transpose(
+    typecode_t typecode, const gsl::byte *input, gsl::byte *output,
+    const gsl::byte *weights, const gsl::byte *bias,
+    gsl::span<const size_t> in_shape, int32_t groups,
+    gsl::span<const size_t> out_shape, int32_t filter_h, int32_t filter_w,
+    int32_t stride_h, int32_t stride_w, int32_t dilation_h, int32_t dilation_w,
+    const padding &padding_h, const padding &padding_w,
+    [[maybe_unused]] const value_range<float> &fused_activation) noexcept;
+
 NNCASE_API result<void>
 cum_sum(tensor input, tensor axis, tensor exclusive, tensor reverse,
         tensor output = nullptr,
@@ -186,12 +190,12 @@ NNCASE_API result<void>
 hardmax(tensor input, tensor axis, tensor output = nullptr,
         kernel_context &context = default_kernel_context());
 
-NNCASE_API result<void> instance_norm(const float *input, const float *scale,
-                                      const float *bias, float *output,
-                                      gsl::span<const size_t> in_shape,
-                                      gsl::span<const size_t> in_strides,
-                                      gsl::span<const size_t> out_strides,
-                                      float epsilon);
+NNCASE_API result<void>
+instance_norm(typecode_t typecode, const gsl::byte *input,
+              const gsl::byte *scale, const gsl::byte *bias, gsl::byte *output,
+              gsl::span<const size_t> in_shape,
+              gsl::span<const size_t> in_strides,
+              gsl::span<const size_t> out_strides, float epsilon);
 
 NNCASE_API result<void>
 l2_normalization(tensor input, tensor output = nullptr,
@@ -205,16 +209,17 @@ NNCASE_API result<void>
 lp_normalization(tensor input, tensor axis, tensor p, tensor output = nullptr,
                  kernel_context &context = default_kernel_context());
 
-NNCASE_API result<void> lrn(const float *input, float alpha, float beta,
-                            float bias, int size, float *output,
-                            gsl::span<const size_t> in_shape,
+NNCASE_API result<void> lrn(typecode_t typecode, const gsl::byte *input,
+                            float alpha, float beta, float bias, int size,
+                            gsl::byte *output, gsl::span<const size_t> in_shape,
                             gsl::span<const size_t> in_strides,
                             gsl::span<const size_t> out_strides);
 
 NNCASE_API result<void>
-lstm(const float *input, const float *w_xc, const float *w_rc,
-     const float *bias, const float *init_h, const float *init_c, float *output,
-     float *output_h, float *output_c, gsl::span<const size_t> in_shape,
+lstm(typecode_t typecode, const gsl::byte *input, const gsl::byte *w_xc,
+     const gsl::byte *w_rc, const gsl::byte *bias, const gsl::byte *init_h,
+     const gsl::byte *init_c, gsl::byte *output, gsl::byte *output_h,
+     gsl::byte *output_c, gsl::span<const size_t> in_shape,
      gsl::span<const size_t> init_h_shape, gsl::span<const size_t> init_c_shape,
      gsl::span<const size_t> out_shape, gsl::span<const size_t> w_xc_shape,
      gsl::span<const size_t> w_rc_shape,
@@ -253,8 +258,9 @@ pad(datatype_t type, const gsl::byte *input, gsl::byte *output,
     kernel_context &context = default_kernel_context()) noexcept;
 
 NNCASE_API result<void>
-prelu(const float *input, const float *slope, float *output,
-      gsl::span<const size_t> in_shape, gsl::span<const size_t> input_strides,
+prelu(typecode_t type, const gsl::byte *input, const gsl::byte *slope,
+      gsl::byte *output, gsl::span<const size_t> in_shape,
+      gsl::span<const size_t> input_strides,
       gsl::span<const size_t> slope_shape,
       gsl::span<const size_t> slope_strides, gsl::span<const size_t> out_shape,
       gsl::span<const size_t> out_strides,
@@ -386,11 +392,13 @@ slice(datatype_t type, const gsl::byte *input, gsl::byte *output,
       kernel_context &context = default_kernel_context()) noexcept;
 
 NNCASE_API result<void>
-softmax(const float *input, float *output, gsl::span<const size_t> in_shape,
-        gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides,
-        int64_t axis, float beta, bool needLog = false) noexcept;
+softmax(typecode_t type, const gsl::byte *input, gsl::byte *output,
+        gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
+        gsl::span<const size_t> out_strides, int64_t axis, float beta,
+        bool needLog = false) noexcept;
 
-NNCASE_API result<void> log_softmax(const float *input, float *output,
+NNCASE_API result<void> log_softmax(typecode_t typecode, const gsl::byte *input,
+                                    gsl::byte *output,
                                     gsl::span<const size_t> in_shape,
                                     gsl::span<const size_t> in_strides,
                                     gsl::span<const size_t> out_strides,
diff --git a/src/Native/src/kernels/stackvm/reference/softmax.cpp b/src/Native/src/kernels/stackvm/reference/softmax.cpp
index a915ae442e..d8d2a822f5 100644
--- a/src/Native/src/kernels/stackvm/reference/softmax.cpp
+++ b/src/Native/src/kernels/stackvm/reference/softmax.cpp
@@ -17,6 +17,7 @@
 #include <iostream>
 #include <nncase/kernels/kernel_utils.h>
 #include <nncase/runtime/runtime_op_utility.h>
+#include <nncase/runtime/util.h>
 
 using namespace nncase;
 using namespace nncase::runtime;
@@ -65,7 +66,8 @@ result<void> softmax_impl(const T *input, T *output,
         auto max_idx = offset(reduced_strides, out_index);
 
         auto out_idx = offset(out_strides, index);
-        output[out_idx] = (in - tmp[max_idx]) * beta;
+        output[out_idx] =
+            static_cast<T>(static_cast<float>(in - tmp[max_idx]) * beta);
 
         return ok();
     }));
@@ -79,8 +81,8 @@ result<void> softmax_impl(const T *input, T *output,
         const auto out_index =
             kernels::detail::get_reduced_offset(index, axes, true);
         auto out_idx = offset(reduced_strides, out_index);
-        output[in_idx] = expf(in);
-        tmp[out_idx] += output[in_idx];
+        output[in_idx] = static_cast<T>(expf(static_cast<float>(in)));
+        tmp[out_idx] += static_cast<T>(output[in_idx]);
 
         return ok();
     }));
@@ -96,18 +98,55 @@ result<void> softmax_impl(const T *input, T *output,
         auto &out = output[out_idx];
         out /= in;
         if (needLog) {
-            out = std::log(out);
+            out = static_cast<T>(std::log(static_cast<float>(out)));
         }
         return ok();
     }));
 
     return ok();
 }
+
+#define SOFTMAX_IMPL(type)                                                     \
+    return softmax_impl(IN_CAST(type, input), OUT_CAST(type, output),          \
+                        in_shape, in_strides, out_strides, axis, beta,         \
+                        needLog);
+
+#define TYPE_SELECT_SOFTMAX(_typecode, _impl)                                  \
+    switch (_typecode) {                                                       \
+    case dt_float32:                                                           \
+        _impl(float);                                                          \
+    case dt_float16:                                                           \
+        _impl(half);                                                           \
+    case dt_bfloat16:                                                          \
+        _impl(bfloat16);                                                       \
+    case dt_int8:                                                              \
+        _impl(int8_t);                                                         \
+    case dt_int16:                                                             \
+        _impl(int16_t);                                                        \
+    case dt_int32:                                                             \
+        _impl(int32_t);                                                        \
+    case dt_int64:                                                             \
+        _impl(int64_t);                                                        \
+    case dt_uint8:                                                             \
+        _impl(uint8_t);                                                        \
+    case dt_uint16:                                                            \
+        _impl(uint16_t);                                                       \
+    case dt_uint32:                                                            \
+        _impl(uint32_t);                                                       \
+    case dt_uint64:                                                            \
+        _impl(uint64_t);                                                       \
+    case dt_float64:                                                           \
+        _impl(double);                                                         \
+    default:                                                                   \
+        return err(std::errc::not_supported);                                  \
+    }
+
 } // namespace
+
 result<void> nncase::kernels::stackvm::reference::softmax(
-    const float *input, float *output, gsl::span<const size_t> in_shape,
-    gsl::span<const size_t> in_strides, gsl::span<const size_t> out_strides,
-    int64_t axis, float beta, bool needLog) noexcept {
-    return softmax_impl(input, output, in_shape, in_strides, out_strides, axis,
-                        beta, needLog);
-}
\ No newline at end of file
+    typecode_t typecode, const gsl::byte *input, gsl::byte *output,
+    gsl::span<const size_t> in_shape, gsl::span<const size_t> in_strides,
+    gsl::span<const size_t> out_strides, int64_t axis, float beta,
+    bool needLog) noexcept {
+    TYPE_SELECT_SOFTMAX(typecode, SOFTMAX_IMPL);
+}
diff --git a/src/Native/src/kernels/stackvm/tensor_ops.cpp b/src/Native/src/kernels/stackvm/tensor_ops.cpp
index 704ef28ae9..b9ea85d40b 100644
--- a/src/Native/src/kernels/stackvm/tensor_ops.cpp
+++ b/src/Native/src/kernels/stackvm/tensor_ops.cpp
@@ -27,37 +27,42 @@ using namespace nncase::kernels::stackvm;
 using namespace nncase::runtime;
 using namespace nncase::runtime::stackvm;
 
-// #define ENABLE_NOP
-
 result<value_t> nncase::kernels::stackvm::batch_normalization(
     value_t input, value_t scale, value_t bias, value_t input_mean,
     value_t input_var, value_t epsilon, [[maybe_unused]] value_t momentum,
     value_t output, [[maybe_unused]] kernel_context &context) {
-    try_f32_input(input_mem, input);
-    try_f32_input(scale_mem, scale);
-    try_f32_input(bias_mem, bias);
-    try_f32_input(mean_mem, input_mean);
-    try_f32_input(var_mem, input_var);
+    try_input(input_mem, input);
+    try_input(scale_mem, scale);
+    try_input(bias_mem, bias);
+    try_input(mean_mem, input_mean);
+    try_input(var_mem, input_var);
     try_float_scalar(eps, epsilon);
-    try_f32_output(output_mem, output, input_tensor->shape());
-    try_(reference::batchnorm(input_mem, scale_mem, bias_mem, mean_mem, var_mem,
-                              output_mem, input_tensor->shape(),
-                              input_tensor->strides(), output_tensor->strides(),
-                              eps));
+    try_output_like_input(output_mem, output, input_tensor);
+    try_typecode(typecode, input_tensor);
+    try_(reference::batchnorm(typecode, input_mem, scale_mem, bias_mem,
+                              mean_mem, var_mem, output_mem,
+                              input_tensor->shape(), input_tensor->strides(),
+                              output_tensor->strides(), eps));
     KERNEL_FINISH;
 }
 
 result<value_t> nncase::kernels::stackvm::layer_norm(
-    int32_t axis, float epsilon, [[maybe_unused]] bool use_mean, value_t input,
-    value_t scale, value_t bias, value_t output,
-    [[maybe_unused]] kernel_context &context) {
-    try_f32_input(input_mem, input);
-    try_f32_input(scale_mem, scale);
-    try_f32_input(bias_mem, bias);
-    try_f32_output(output_mem, output, input_tensor->shape());
-    CONTIGUOUS_KERNEL(layer_norm, input_tensor, input_mem, output_mem,
-                      scale_mem, bias_mem, input_tensor->shape(), axis,
-                      epsilon);
+    int32_t axis, float epsilon, value_t input, value_t scale, value_t bias,
+    value_t output, [[maybe_unused]] kernel_context &context) {
+    try_input(input_mem, input);
+    try_input(scale_mem, scale);
+    try_input(bias_mem, bias);
+    try_output_like_input(output_mem, output, input_tensor);
+    try_typecode(typecode, input_tensor);
+    if (typecode == dt_float32) {
+        CONTIGUOUS_KERNEL(layer_norm, input_tensor, typecode, input_mem,
+                          output_mem, scale_mem, bias_mem,
+                          input_tensor->shape(), axis, epsilon);
+    } else {
+        try_(reference::layer_norm(typecode, input_mem, output_mem, scale_mem,
+                                   bias_mem, input_tensor->shape(), axis,
+                                   epsilon));
+    }
     KERNEL_FINISH;
 }
 
@@ -119,7 +124,7 @@ nncase::kernels::stackvm::clamp(value_t input, value_t min, value_t max,
     KERNEL_FINISH;
 }
 
-result<value_t> nncase::kernels::stackvm::concat(int32_t axis, value_t input,
+result<value_t> nncase::kernels::stackvm::concat(value_t input, value_t axis,
                                                  value_t output,
                                                  kernel_context &context) {
     try_tuple_input(inputs_mem, input);
@@ -127,7 +132,7 @@ result<value_t> nncase::kernels::stackvm::concat(int32_t axis, value_t input,
     try_var(strides, get_strides(input_tuple));
     try_tuple_field0(input0, input_tuple);
     auto dtype = input0->dtype();
-    auto axis_value = positive_index(axis, input0->shape().size());
+    try_positive_axis_with_rank(axis_value, axis, input0->shape().size());
     auto out_shape = concat_infer_shape(shapes, axis_value);
     try_output(out_mem, output, dtype, out_shape);
     auto concat_dims = dims_t();
@@ -179,19 +184,20 @@ result<value_t> nncase::kernels::stackvm::conv2d(
     if (pad_mode != pad_mode_t::constant) {
         return err(nncase_errc::runtime_not_found);
     }
-    try_f32_input(input_mem, input);
-    try_f32_input(weights_mem, weights);
-    try_f32_input(bias_mem, bias);
+    try_input(input_mem, input);
+    try_input(weights_mem, weights);
+    try_input(bias_mem, bias);
     try_strides(strides_value, stride);
     try_paddings(pads, padding);
     try_to_integer(groups_value, groups);
     try_strides(strides, stride);
     try_strides(dilations, dilation);
     try_f32_input(fused_clamp_value, fused_clamp);
+    try_typecode(typecode, input_tensor);
     auto out_shape =
         conv2d_infer_shape(input_tensor->shape(), weights_tensor->shape(),
                            strides_value, dilations, pads);
-    try_f32_output(out_mem, output, out_shape);
+    try_output(out_mem, output, typecode, out_shape);
 
     // CONTIGUOUS_KERNEL(
     //     conv2d, input_tensor, input_mem, weights_mem, bias_mem, out_mem,
@@ -202,8 +208,8 @@ result<value_t> nncase::kernels::stackvm::conv2d(
     //     dilations[1], value_range<float>{fused_clamp_value[0],
     //     fused_clamp_value[1]}, context);
     try_(reference::conv2d(
-        input_mem, weights_mem, bias_mem, out_mem, input_tensor->shape(),
-        input_tensor->strides(), weights_tensor->shape(),
+        typecode, input_mem, weights_mem, bias_mem, out_mem,
+        input_tensor->shape(), input_tensor->strides(), weights_tensor->shape(),
         weights_tensor->strides(), bias_tensor->strides(),
         output_tensor->strides(), pads[0], pads[1], groups_value, strides[0],
         strides[1], dilations[0], dilations[1],
@@ -221,9 +227,9 @@ result<value_t> nncase::kernels::stackvm::conv2d_transpose(
     if (pad_mode != pad_mode_t::constant) {
         return err(nncase_errc::runtime_not_found);
     }
-    try_f32_input(input_mem, input);
-    try_f32_input(weights_mem, weights);
-    try_f32_input(bias_mem, bias);
+    try_input(input_mem, input);
+    try_input(weights_mem, weights);
+    try_input(bias_mem, bias);
     try_strides(strides_value, stride);
     try_paddings(pads, padding);
     try_to_integer(groups_value, groups);
@@ -231,12 +237,13 @@ result<value_t> nncase::kernels::stackvm::conv2d_transpose(
     try_strides(dilations, dilation);
     try_f32_input(fused_clamp_value, fused_clamp);
     try_dims(out_shape, output_shape);
-    try_f32_output(out_mem, output, out_shape);
+    try_typecode(typecode, input_tensor);
+    try_output(out_mem, output, typecode, out_shape);
     try_(reference::conv2d_transpose(
-        input_mem, out_mem, weights_mem, bias_mem, input_tensor->shape(),
-        groups_value, output_tensor->shape(), weights_tensor->shape()[2],
-        weights_tensor->shape()[3], strides[0], strides[1], dilations[0],
-        dilations[1], pads[0], pads[1],
+        typecode, input_mem, out_mem, weights_mem, bias_mem,
+        input_tensor->shape(), groups_value, output_tensor->shape(),
+        weights_tensor->shape()[2], weights_tensor->shape()[3], strides[0],
+        strides[1], dilations[0], dilations[1], pads[0], pads[1],
         value_range<float>{fused_clamp_value[0], fused_clamp_value[1]}));
     return ok(output);
 }
@@ -286,15 +293,14 @@ nncase::kernels::stackvm::flatten(value_t input, value_t axis, value_t output,
     KERNEL_FINISH;
 }
 
-result<value_t> nncase::kernels::stackvm::gather(int32_t axis, value_t input,
+result<value_t> nncase::kernels::stackvm::gather(value_t input, value_t axis,
                                                  value_t index, value_t output,
                                                  kernel_context &context) {
     try_input(input_mem, input);
     try_input(index_mem, index);
     auto dtype = input_tensor->dtype();
     try_var(typecode, to_typecode(dtype));
-    // try_positive_axis(axis_value, axis, input_tensor);
-    auto axis_value = positive_index(axis, input_tensor->shape().size());
+    try_positive_axis(axis_value, axis, input_tensor);
     auto out_shape = gather_infer_shape(input_tensor->shape(),
                                         index_tensor->shape(), axis_value);
     try_output(out_mem, output, dtype, out_shape);
@@ -422,13 +428,14 @@ result<value_t> nncase::kernels::stackvm::get_item(
 result<value_t> nncase::kernels::stackvm::instance_normalization(
     value_t input, value_t scale, value_t bias, value_t epsilon, value_t output,
     [[maybe_unused]] kernel_context &context) {
-    try_f32_input(input_mem, input);
-    try_f32_input(scale_mem, scale);
-    try_f32_input(bias_mem, bias);
+    try_input(input_mem, input);
+    try_input(scale_mem, scale);
+    try_input(bias_mem, bias);
     try_float_scalar(eps, epsilon);
-    try_f32_output(output_mem, output, input_tensor->shape());
+    try_output_like_input(output_mem, output, input_tensor);
+    try_typecode(type, input_tensor);
     try_(reference::instance_norm(
-        input_mem, scale_mem, bias_mem, output_mem, input_tensor->shape(),
+        type, input_mem, scale_mem, bias_mem, output_mem, input_tensor->shape(),
         input_tensor->strides(), output_tensor->strides(), eps));
     KERNEL_FINISH;
 }
@@ -442,12 +449,21 @@ result<value_t> nncase::kernels::stackvm::l2_normalization(
 result<value_t> nncase::kernels::stackvm::log_softmax(
     value_t input, value_t axis, value_t output,
     [[maybe_unused]] kernel_context &context) {
-    try_f32_input(in_mem, input);
-    try_f32_output(out_mem, output, input_tensor->shape());
+    try_input(in_mem, input);
+    try_output_like_input(out_mem, output, input_tensor);
     try_positive_axis(axis_value, axis, input_tensor);
-    CONTIGUOUS_KERNEL(log_softmax, input_tensor, in_mem, out_mem,
-                      input_tensor->shape(), input_tensor->strides(),
-                      output_tensor->strides(), axis_value);
+    try_typecode(type, input_tensor);
+
+    if (type == dt_float32) {
+        CONTIGUOUS_KERNEL(log_softmax, input_tensor, type, in_mem, out_mem,
+                          input_tensor->shape(), input_tensor->strides(),
+                          output_tensor->strides(), axis_value);
+    } else {
+        try_(reference::log_softmax(
+            type, in_mem, out_mem, input_tensor->shape(),
+            input_tensor->strides(), output_tensor->strides(), axis_value));
+    }
+
     return ok(output);
 }
 
@@ -462,16 +478,17 @@ result<value_t>
 nncase::kernels::stackvm::lrn(value_t input, value_t alpha, value_t beta,
                               value_t bias, value_t size, value_t output,
                               [[maybe_unused]] kernel_context &context) {
-    try_f32_in_mem(input);
+    try_in_mem(input);
     try_float_scalar_v(alpha);
     try_float_scalar_v(beta);
     try_float_scalar_v(bias);
     try_to_integer(size_value, size);
     auto out_shape = input_tensor->shape();
-    try_f32_out_mem(output, out_shape);
-    try_(reference::lrn(input_mem, alpha_value, beta_value, bias_value,
-                        size_value, output_mem, input_tensor->shape(),
-                        input_tensor->strides(),
+    try_typecode(typecode, input_tensor);
+    try_out_mem(output, typecode, out_shape);
+    try_(reference::lrn(typecode, input_mem, alpha_value, beta_value,
+                        bias_value, size_value, output_mem,
+                        input_tensor->shape(), input_tensor->strides(),
                         runtime::get_default_strides(out_shape)));
     KERNEL_FINISH;
 }
@@ -486,25 +503,25 @@ result<value_t> nncase::kernels::stackvm::lstm(
     value_t hidden_size, [[maybe_unused]] value_t input_forget,
     value_t output_size, value_t output,
     [[maybe_unused]] kernel_context &context) {
-    try_f32_in_mem(x);
-    try_f32_in_mem(w);
-    try_f32_in_mem(r);
-    try_f32_in_mem(b);
+    try_in_mem(x);
+    try_in_mem(w);
+    try_in_mem(r);
+    try_in_mem(b);
     try_dims_v(sequence_lens);
-    try_f32_in_mem(initial_h);
-    try_f32_in_mem(initial_c);
+    try_in_mem(initial_h);
+    try_in_mem(initial_c);
     // todo:p
     //    try_f32_in_mem(p);
     try_integer_v(hidden_size);
     try_integer_v(output_size);
+    try_typecode(type, x_tensor);
     auto output_shapes = lstm_infer_shape(
         x_tensor->shape(), initial_h_tensor->shape(), initial_c_tensor->shape(),
         direction, layout, hidden_size_value, output_size_value);
     try_tuple_output(out_tuple, output, dt_float32, output_shapes);
     try_(reference::lstm(
-        x_mem, w_mem, r_mem, b_mem, initial_h_mem, initial_c_mem,
-        OUT_CAST(float, out_tuple[0]), OUT_CAST(float, out_tuple[1]),
-        OUT_CAST(float, out_tuple[2]), x_tensor->shape(),
+        type, x_mem, w_mem, r_mem, b_mem, initial_h_mem, initial_c_mem,
+        out_tuple[0], out_tuple[1], out_tuple[2], x_tensor->shape(),
         initial_h_tensor->shape(), initial_c_tensor->shape(), output_shapes[0],
         w_tensor->shape(), r_tensor->shape(), direction));
     KERNEL_FINISH;
@@ -575,11 +592,11 @@ result<value_t> nncase::kernels::stackvm::one_hot(one_hot_mode_t one_hot_mode,
 }
 
 inline bool is_nop_pad([[maybe_unused]] const paddings_t &paddings) {
-#ifdef ENABLE_NOP
+#ifdef SKIP_NOP
+    return false;
+#else
     return std::all_of(paddings.begin(), paddings.end(),
                        [](const padding &p) { return p.sum() == 0; });
-#else
-    return false;
 #endif
 }
 
@@ -620,13 +637,14 @@ nncase::kernels::stackvm::pad(runtime::stackvm::pad_mode_t pad_mode,
 result<value_t> kernels::stackvm::prelu(value_t input, value_t slope,
                                         value_t output,
                                         kernel_context &context) {
-    try_f32_in_mem(input);
-    try_f32_in_mem(slope);
-    try_f32_output(out_mem, output, input_tensor->shape());
-    try_(reference::prelu(input_mem, slope_mem, out_mem, input_tensor->shape(),
-                          input_tensor->strides(), slope_tensor->shape(),
-                          slope_tensor->strides(), output_tensor->shape(),
-                          output_tensor->strides(), context));
+    try_in_mem(input);
+    try_in_mem(slope);
+    try_output_like_input(out_mem, output, input_tensor);
+    try_typecode(type, input_tensor);
+    try_(reference::prelu(
+        type, input_mem, slope_mem, out_mem, input_tensor->shape(),
+        input_tensor->strides(), slope_tensor->shape(), slope_tensor->strides(),
+        output_tensor->shape(), output_tensor->strides(), context));
     return ok(output);
 }
 
@@ -737,11 +755,11 @@ result<value_t> nncase::kernels::stackvm::require(
 }
 
 inline bool is_nop_pad([[maybe_unused]] const std::vector<int> &paddings) {
-#ifdef ENABLE_NOP
+#ifdef SKIP_NOP
+    return false;
+#else
     return std::all_of(paddings.begin(), paddings.end(),
                        [](auto &p) { return p == 0; });
-#else
-    return false;
 #endif
 }
 
@@ -765,13 +783,30 @@ result<value_t> nncase::kernels::stackvm::bucket_pad(
                           compute_size(pads_shape) * sizeof(int));
     try_var(pads, hrt::create(dt_int32, pads_shape, span, false,
                               host_runtime_tensor::pool_cpu_only));
-    auto pad_value = 0;
-    auto data = gsl::span(reinterpret_cast<gsl::byte *>(&pad_value),
-                          in_tensor->dtype()->size_bytes());
-    try_var(pad_v, hrt::create(in_tensor->dtype()->typecode(), dims_t{}, data,
-                               false, host_runtime_tensor::pool_cpu_only));
-    return nncase::kernels::stackvm::pad(pad_mode_t::constant, input,
+#define RUN_PAD                                                                \
+    auto data = gsl::span(reinterpret_cast<gsl::byte *>(&pad_value),           \
+                          in_tensor->dtype()->size_bytes());                   \
+    try_var(pad_v, hrt::create(in_tensor->dtype()->typecode(), dims_t{}, data, \
+                               false, host_runtime_tensor::pool_cpu_only));    \
+    return nncase::kernels::stackvm::pad(pad_mode_t::constant, input,          \
                                          pads.impl(), pad_v.impl(), output);
+
+    if (runtime::get_bytes(in_tensor->dtype()) == 1) {
+        auto pad_value = (int8_t)0;
+        RUN_PAD;
+    } else if (runtime::get_bytes(in_tensor->dtype()) == 2) {
+        auto pad_value = (int16_t)0;
+        RUN_PAD;
+    }
+    if (runtime::get_bytes(in_tensor->dtype()) == 4) {
+        auto pad_value = (int32_t)0;
+        RUN_PAD;
+    }
+    if (runtime::get_bytes(in_tensor->dtype()) == 8) {
+        auto pad_value = (int64_t)0;
+        RUN_PAD;
+    }
+    return err(std::errc::not_supported);
 }
 
 result<value_t>
@@ -923,7 +958,7 @@ inline bool is_nop_slice([[maybe_unused]] const axes_t &begin,
                          [[maybe_unused]] const axes_t &axes,
                          [[maybe_unused]] const axes_t &strides,
                          [[maybe_unused]] const dims_t &in_shape) {
-#ifndef ENABLE_NOP
+#ifdef SKIP_NOP
     return false;
 #else
     if (begin.size() != in_shape.size()) {
@@ -992,13 +1027,19 @@ result<value_t> nncase::kernels::stackvm::slice(value_t input, value_t begins,
 result<value_t>
 nncase::kernels::stackvm::softmax(value_t input, value_t axis, value_t output,
                                   [[maybe_unused]] kernel_context &context) {
-    try_f32_input(in_mem, input);
-    try_f32_output(out_mem, output, input_tensor->shape());
+    try_input(in_mem, input);
+    try_output_like_input(out_mem, output, input_tensor);
     try_positive_axis(axis_value, axis, input_tensor);
-
-    CONTIGUOUS_KERNEL(softmax, input_tensor, in_mem, out_mem,
-                      input_tensor->shape(), input_tensor->strides(),
-                      output_tensor->strides(), axis_value, 1.f);
+    try_typecode(type, input_tensor);
+    if (type == dt_float32) {
+        CONTIGUOUS_KERNEL(softmax, input_tensor, type, in_mem, out_mem,
+                          input_tensor->shape(), input_tensor->strides(),
+                          output_tensor->strides(), axis_value, 1.f);
+    } else {
+        try_(reference::softmax(type, in_mem, out_mem, input_tensor->shape(),
+                                input_tensor->strides(),
+                                output_tensor->strides(), axis_value, 1.f));
+    }
     return ok(output);
 }
 
diff --git a/src/Native/src/runtime/CMakeLists.txt b/src/Native/src/runtime/CMakeLists.txt
index 2f66042641..f92450b6a0 100644
--- a/src/Native/src/runtime/CMakeLists.txt
+++ b/src/Native/src/runtime/CMakeLists.txt
@@ -66,11 +66,7 @@ else()
     set_property(TARGET simulator PROPERTY POSITION_INDEPENDENT_CODE ON)
     
     add_library(nncaseruntime SHARED dummy.cpp)
-    if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "riscv64")
-      target_link_libraries(nncaseruntime PRIVATE nncasebase kernels simulator simulator_stackvm fmt::fmt)
-    else()
-      target_link_libraries(nncaseruntime PRIVATE nncasebase kernels simulator compiler simulator_stackvm fmt::fmt)
-    endif()
+    target_link_libraries(nncaseruntime PRIVATE nncasebase kernels simulator compiler simulator_stackvm fmt::fmt)
     target_link_libraries(nncaseruntime PUBLIC gsl::gsl-lite)
     set_target_properties(nncaseruntime PROPERTIES
                                         OUTPUT_NAME "Nncase.Runtime.Native")
diff --git a/src/Nncase.Compiler/Compiler.cs b/src/Nncase.Compiler/Compiler.cs
index 2117ec68c5..afd0607878 100644
--- a/src/Nncase.Compiler/Compiler.cs
+++ b/src/Nncase.Compiler/Compiler.cs
@@ -48,27 +48,22 @@ public Compiler(CompileSession compileSession, IModelBuilder modelBuilder, IDump
     /// <inheritdoc/>
     public void ImportIRModule(IRModule module) => _module = module;
 
-    public async Task<IRModule> ImportModuleAsync(Stream content)
+    public Task<IRModule> ImportTFLiteModuleAsync(Stream content)
     {
-        var module = ImportModel(content);
-        if (_dumpper.IsEnabled(DumpFlags.Compile))
-        {
-            _dumpper.DumpModule(module, "IRImport");
-        }
-
-        var preprocess_option = _compileSession.CompileOptions;
-
-        await RunPassAsync(pmg => BroadcastOutputNamesAfterImportPass(pmg), "BroadcastOutputNamesAfterImport");
-        await RunPassAsync(pmg => pmg.Add<ShapeInferPass>(), "ShapeInferAfterImport");
-        await RunPassAsync(pmg => AddPreAndPostProcess(pmg), "AddPreAndPostProcessAfterImport");
+        var module = Importers.ImportTFLite(content, _compileSession);
+        return InitializeModuleAsync(module);
+    }
 
-        var inferSucc = CompilerServices.InferenceType(module.Entry!);
-        if (!inferSucc)
-        {
-            throw new InvalidOperationException("InferShape Failed For This Model!");
-        }
+    public Task<IRModule> ImportOnnxModuleAsync(Stream content)
+    {
+        var module = Importers.ImportOnnx(content, _compileSession);
+        return InitializeModuleAsync(module);
+    }
 
-        return module;
+    public Task<IRModule> ImportNcnnModuleAsync(Stream ncnnParam, Stream ncnnBin)
+    {
+        var module = Importers.ImportNcnn(ncnnParam, ncnnBin, _compileSession);
+        return InitializeModuleAsync(module);
     }
 
     public void BroadcastOutputNamesAfterImportPass(IPassManager passManager)
@@ -284,6 +279,30 @@ public void Gencode(Stream output)
         linkedModel.Serialize(output);
     }
 
+    private async Task<IRModule> InitializeModuleAsync(IRModule module)
+    {
+        _module = module;
+
+        if (_dumpper.IsEnabled(DumpFlags.Compile))
+        {
+            _dumpper.DumpModule(module, "IRImport");
+        }
+
+        var preprocess_option = _compileSession.CompileOptions;
+
+        await RunPassAsync(pmg => BroadcastOutputNamesAfterImportPass(pmg), "BroadcastOutputNamesAfterImport");
+        await RunPassAsync(pmg => pmg.Add<ShapeInferPass>(), "ShapeInferAfterImport");
+        await RunPassAsync(pmg => AddPreAndPostProcess(pmg), "AddPreAndPostProcessAfterImport");
+
+        var inferSucc = CompilerServices.InferenceType(module.Entry!);
+        if (!inferSucc)
+        {
+            throw new InvalidOperationException("InferShape Failed For This Model!");
+        }
+
+        return module;
+    }
+
     private void RegisterTargetIndependQuantPass(IPassManager passManager)
     {
         var quantMode = _compileSession.CompileOptions.QuantizeOptions.ModelQuantMode;
@@ -297,17 +316,6 @@ private void RegisterTargetIndependQuantPass(IPassManager passManager)
         }
     }
 
-    private IRModule ImportModel(Stream content)
-    {
-        _module = _compileSession.CompileOptions.InputFormat switch
-        {
-            "tflite" => Importers.ImportTFLite(content, _compileSession),
-            "onnx" => Importers.ImportOnnx(content, _compileSession),
-            var inputFormat => throw new NotImplementedException($"Not Implement {inputFormat} Importer!"),
-        };
-        return _module;
-    }
-
     private async Task RunPassAsync(Action<IPassManager> register, string name)
     {
         var newName = $"{_runPassCount++}_" + name;
diff --git a/src/Nncase.Compiler/Interop/CApi.cs b/src/Nncase.Compiler/Interop/CApi.cs
index b34c27e672..69bacc8397 100644
--- a/src/Nncase.Compiler/Interop/CApi.cs
+++ b/src/Nncase.Compiler/Interop/CApi.cs
@@ -63,7 +63,9 @@ public unsafe struct CApiMT
     public delegate* unmanaged<IntPtr, IntPtr, IntPtr> CompileSessionCreatePtr;
     public delegate* unmanaged<IntPtr, IntPtr> CompileSessionGetCompilerPtr;
     public delegate* unmanaged<void> CompilerInitializePtr;
-    public delegate* unmanaged<IntPtr, IntPtr, IntPtr> CompilerImportModulePtr;
+    public delegate* unmanaged<IntPtr, IntPtr, IntPtr> CompilerImportTFLiteModulePtr;
+    public delegate* unmanaged<IntPtr, IntPtr, IntPtr> CompilerImportOnnxModulePtr;
+    public delegate* unmanaged<IntPtr, IntPtr, IntPtr, IntPtr> CompilerImportNcnnModulePtr;
     public delegate* unmanaged<IntPtr, void> CompilerCompilePtr;
     public delegate* unmanaged<IntPtr, IntPtr, void> CompilerGencodePtr;
     public delegate* unmanaged<Runtime.TypeCode, IntPtr> DataTypeFromTypeCodePtr;
@@ -132,7 +134,9 @@ public static void Initialize(CApiMT* mt)
         mt->CompileSessionCreatePtr = &CompileSessionCreate;
         mt->CompileSessionGetCompilerPtr = &CompileSessionGetCompiler;
         mt->CompilerInitializePtr = &CompilerInitialize;
-        mt->CompilerImportModulePtr = &CompilerImportModule;
+        mt->CompilerImportTFLiteModulePtr = &CompilerImportTFLiteModule;
+        mt->CompilerImportOnnxModulePtr = &CompilerImportOnnxModule;
+        mt->CompilerImportNcnnModulePtr = &CompilerImportNcnnModule;
         mt->CompilerCompilePtr = &CompilerCompile;
         mt->CompilerGencodePtr = &CompilerGencode;
         mt->DataTypeFromTypeCodePtr = &DataTypeFromTypeCode;
@@ -397,11 +401,30 @@ private static void CompilerInitialize()
     }
 
     [UnmanagedCallersOnly]
-    private static IntPtr CompilerImportModule(IntPtr compilerHandle, IntPtr streamHandle)
+    private static IntPtr CompilerImportTFLiteModule(IntPtr compilerHandle, IntPtr streamHandle)
     {
         var compiler = Get<Compiler>(compilerHandle);
         var stream = Get<CStream>(streamHandle);
-        var module = compiler.ImportModuleAsync(stream).Result;
+        var module = compiler.ImportTFLiteModuleAsync(stream).Result;
+        return GCHandle.ToIntPtr(GCHandle.Alloc(module));
+    }
+
+    [UnmanagedCallersOnly]
+    private static IntPtr CompilerImportOnnxModule(IntPtr compilerHandle, IntPtr streamHandle)
+    {
+        var compiler = Get<Compiler>(compilerHandle);
+        var stream = Get<CStream>(streamHandle);
+        var module = compiler.ImportOnnxModuleAsync(stream).Result;
+        return GCHandle.ToIntPtr(GCHandle.Alloc(module));
+    }
+
+    [UnmanagedCallersOnly]
+    private static IntPtr CompilerImportNcnnModule(IntPtr compilerHandle, IntPtr ncnnParamHandle, IntPtr ncnnBinHandle)
+    {
+        var compiler = Get<Compiler>(compilerHandle);
+        var ncnnParam = Get<CStream>(ncnnParamHandle);
+        var ncnnBin = Get<CStream>(ncnnBinHandle);
+        var module = compiler.ImportNcnnModuleAsync(ncnnParam, ncnnBin).Result;
         return GCHandle.ToIntPtr(GCHandle.Alloc(module));
     }
 
diff --git a/src/Nncase.Core/CompileOptions.cs b/src/Nncase.Core/CompileOptions.cs
index c4daedc4fb..e5d1b2874c 100644
--- a/src/Nncase.Core/CompileOptions.cs
+++ b/src/Nncase.Core/CompileOptions.cs
@@ -115,6 +115,11 @@ public sealed record CompileOptions
     /// </summary>
     public ShapeBucketOptions ShapeBucketOptions { get; set; } = ShapeBucketOptions.Default;
 
+    /// <summary>
+    /// Gets or sets a value indicating whether is benchmark only.
+    /// </summary>
+    public bool IsBenchmarkOnly { get; set; }
+
     /// <summary>
     /// Gets or sets the target compile options.
     /// </summary>
diff --git a/src/Nncase.Core/ICompiler.cs b/src/Nncase.Core/ICompiler.cs
index e49afabf9d..2368b4a7df 100644
--- a/src/Nncase.Core/ICompiler.cs
+++ b/src/Nncase.Core/ICompiler.cs
@@ -16,11 +16,26 @@ namespace Nncase;
 public interface ICompiler
 {
     /// <summary>
-    /// Import DL model as ir module.
+    /// Import TFLite model as ir module.
     /// </summary>
     /// <param name="content">Model content.</param>
     /// <returns>Imported ir module.</returns>
-    Task<IRModule> ImportModuleAsync(Stream content);
+    Task<IRModule> ImportTFLiteModuleAsync(Stream content);
+
+    /// <summary>
+    /// Import Onnx model as ir module.
+    /// </summary>
+    /// <param name="content">Model content.</param>
+    /// <returns>Imported ir module.</returns>
+    Task<IRModule> ImportOnnxModuleAsync(Stream content);
+
+    /// <summary>
+    /// Import Ncnn model as ir module.
+    /// </summary>
+    /// <param name="ncnnParam">Ncnn param stream.</param>
+    /// <param name="ncnnBin">Ncnn bin stream.</param>
+    /// <returns>Imported ir module.</returns>
+    Task<IRModule> ImportNcnnModuleAsync(Stream ncnnParam, Stream ncnnBin);
 
     /// <summary>
     /// import ir module into compiler.
diff --git a/src/Nncase.Core/IR/Buffers/BufferOf.cs b/src/Nncase.Core/IR/Buffers/BufferOf.cs
index baf982d17e..a3bb033275 100644
--- a/src/Nncase.Core/IR/Buffers/BufferOf.cs
+++ b/src/Nncase.Core/IR/Buffers/BufferOf.cs
@@ -16,8 +16,8 @@ public sealed partial class BufferOf : Op
     /// </summary>
     public static readonly ParameterInfo Input = new(typeof(BufferOf), 0, "input", IsTensor());
 
-    public TIR.MemoryLocation MemoryLocation { get; }
+    public Schedule.MemoryLocation MemoryLocation { get; }
 
     /// <inheritdoc/>
-    public override string DisplayProperty() => $"MemoryLocation.{MemoryLocation}";
+    public override string DisplayProperty() => $"Schedule.MemoryLocation.{MemoryLocation}";
 }
diff --git a/src/Nncase.Core/IR/Dimension.cs b/src/Nncase.Core/IR/Dimension.cs
index f799e3a8b5..83b1395ec0 100644
--- a/src/Nncase.Core/IR/Dimension.cs
+++ b/src/Nncase.Core/IR/Dimension.cs
@@ -150,5 +150,15 @@ public bool HasFixedValue(Predicate<int> predicate)
         {
             return Value.HasValue && predicate(Value.Value);
         }
+
+        public bool IsAssignableFrom(Dimension dimension)
+        {
+            if (IsUnknown)
+            {
+                return true;
+            }
+
+            return dimension.Kind == DimensionKind.Fixed && Value == dimension.Value;
+        }
     }
 }
diff --git a/src/Nncase.Core/IR/Fusion.cs b/src/Nncase.Core/IR/Fusion.cs
index d1a8b71aa7..c42800523f 100644
--- a/src/Nncase.Core/IR/Fusion.cs
+++ b/src/Nncase.Core/IR/Fusion.cs
@@ -41,16 +41,6 @@ public Fusion(string name, string moduleKind, Expr body, params Var[] parameters
     {
     }
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Fusion"/> class.
-    /// build function.
-    /// </summary>
-    public Fusion(string type, string name, string moduleKind, Expr body, params Var[] parameters)
-        : base(name, moduleKind, ArrayUtility.Concat(body, SpanUtility.UnsafeCast<Var, Expr>(parameters)))
-    {
-        FusionType = type;
-    }
-
     /// <summary>
     /// Initializes a new instance of the <see cref="Fusion"/> class.
     /// build function.
@@ -60,8 +50,6 @@ public Fusion(string moduleKind, Expr body, params Var[] parameters)
     {
     }
 
-    public string? FusionType { get; }
-
     public Expr Body => Operands[0];
 
     public ReadOnlySpan<Var> Parameters => SpanUtility.UnsafeCast<Expr, Var>(Operands[1..]);
diff --git a/src/Nncase.Core/IR/Shape.cs b/src/Nncase.Core/IR/Shape.cs
index 49ca06b096..c89541194b 100644
--- a/src/Nncase.Core/IR/Shape.cs
+++ b/src/Nncase.Core/IR/Shape.cs
@@ -316,6 +316,29 @@ public override bool Equals(object? other)
             return other is Shape shape && Equals(shape);
         }
 
+        public bool IsAssignableFrom(Shape shape)
+        {
+            if (IsUnranked)
+            {
+                return true;
+            }
+
+            if (shape.IsUnranked || Rank != shape.Rank)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < _dimensions.Length; i++)
+            {
+                if (!_dimensions[i].IsAssignableFrom(shape[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         private static ShapeKind KindOf(ReadOnlySpan<Dimension> dimensions)
         {
             return dimensions.AsValueEnumerable().Any(x => x.IsUnknown) ? ShapeKind.HasUnknownDimension : ShapeKind.Fixed;
diff --git a/src/Nncase.Core/TIR/PrimFunction.cs b/src/Nncase.Core/TIR/PrimFunction.cs
index 2bf94454eb..360be606a3 100644
--- a/src/Nncase.Core/TIR/PrimFunction.cs
+++ b/src/Nncase.Core/TIR/PrimFunction.cs
@@ -28,7 +28,7 @@ public sealed class PrimFunction : BaseFunction
     /// <param name="moduleKind">module kind.</param>
     /// <param name="parameters">Arguments.</param>
     /// <param name="body">Body.</param>
-    public PrimFunction(string name, string moduleKind, Sequential body, ReadOnlySpan<Buffer> parameters)
+w    public PrimFunction(string name, string moduleKind, Sequential body, ReadOnlySpan<Buffer> parameters)
         : base(name, moduleKind, ArrayUtility.Concat(body, SpanUtility.UnsafeCast<Buffer, Expr>(parameters)))
     {
     }
diff --git a/src/Nncase.Core/TensorOfT.cs b/src/Nncase.Core/TensorOfT.cs
index 399521b2be..307af29180 100644
--- a/src/Nncase.Core/TensorOfT.cs
+++ b/src/Nncase.Core/TensorOfT.cs
@@ -60,6 +60,8 @@ public Tensor(Memory<T> buffer, ReadOnlySpan<int> dimensions)
         Buffer = buffer;
     }
 
+    public static Tensor<T> Empty { get; } = new Tensor<T>(0);
+
     /// <summary>
     /// Gets memory storing backing values of this tensor.
     /// </summary>
diff --git a/src/Nncase.Evaluator/Extension/OrtKIExtensions.cs b/src/Nncase.Evaluator/Extension/OrtKIExtensions.cs
index e72ff79827..92e2052521 100644
--- a/src/Nncase.Evaluator/Extension/OrtKIExtensions.cs
+++ b/src/Nncase.Evaluator/Extension/OrtKIExtensions.cs
@@ -83,11 +83,6 @@ public static OrtDataType ToOrtType(this DataType dt)
             return type;
         }
 
-        if (dt is PointerType)
-        {
-            return OrtDataType.UInt64;
-        }
-
         throw new ArgumentOutOfRangeException("Unsupported DataType: " + dt);
     }
 
diff --git a/src/Nncase.Importer/Importers.cs b/src/Nncase.Importer/Importers.cs
index dabfef37a9..1c3cce1459 100644
--- a/src/Nncase.Importer/Importers.cs
+++ b/src/Nncase.Importer/Importers.cs
@@ -8,6 +8,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using Nncase.Importer;
+using Nncase.Importer.Ncnn;
 using Nncase.Importer.TFLite;
 using Nncase.IR;
 
@@ -45,4 +46,18 @@ public static IRModule ImportOnnx(Stream onnx, CompileSession compileSession)
         var importer = new OnnxImporter(onnx, compileSession);
         return importer.Import();
     }
+
+    /// <summary>
+    /// Import ncnn model.
+    /// </summary>
+    /// <param name="ncnnParam">Ncnn param stream.</param>
+    /// <param name="ncnnBin">Ncnn bin stream.</param>
+    /// <param name="compileSession">compile session.</param>
+    /// <returns>Imported IR module.</returns>
+    public static IRModule ImportNcnn(Stream ncnnParam, Stream ncnnBin, CompileSession compileSession)
+    {
+        compileSession.CompileOptions.ModelLayout = "NCHW";
+        var importer = new NcnnImporter(ncnnParam, ncnnBin, compileSession);
+        return importer.Import();
+    }
 }
diff --git a/src/Nncase.Passes/Rules/ShapeBucket/MergeCallToFusion.cs b/src/Nncase.Passes/Rules/ShapeBucket/MergeCallToFusion.cs
index bac3b6f135..08e232585e 100644
--- a/src/Nncase.Passes/Rules/ShapeBucket/MergeCallToFusion.cs
+++ b/src/Nncase.Passes/Rules/ShapeBucket/MergeCallToFusion.cs
@@ -16,6 +16,7 @@
 using static Nncase.Utilities.ReplaceUtility;
 
 namespace Nncase.Passes.Rules.ShapeBucket;
+
 public abstract class MergeFusionBase : RewriteRule<Pattern>
 {
     protected int Counter { get; set; }
diff --git a/src/Nncase.Quantization/Quantization/CalibrationEvaluator.cs b/src/Nncase.Quantization/Quantization/CalibrationEvaluator.cs
index d9e2a89f68..8f4096d88a 100644
--- a/src/Nncase.Quantization/Quantization/CalibrationEvaluator.cs
+++ b/src/Nncase.Quantization/Quantization/CalibrationEvaluator.cs
@@ -113,19 +113,9 @@ public void Dispose()
         };
     }
 
-    private bool ShapeChecker(Shape current, Shape target)
-    {
-        if (current.Count != target.Count)
-        {
-            return false;
-        }
-
-        return current.Zip(target).All(p => p.Second.IsUnknown ? true : p.Second.FixedValue == p.First.FixedValue);
-    }
-
     private bool TypeChecker(IRType cur_type, IRType target_type) => (cur_type, target_type) switch
     {
-        (TensorType a, TensorType b) => a.DType == b.DType && ShapeChecker(a.Shape, b.Shape),
+        (TensorType a, TensorType b) => a.DType == b.DType && b.Shape.IsAssignableFrom(a.Shape),
         (TupleType a, TupleType b) => a.Zip(b).All(p => TypeChecker(p.First, p.Second)),
         (_, _) => true,
     };
diff --git a/src/Nncase.Tests.TestFixture/ModelRunner.cs b/src/Nncase.Tests.TestFixture/ModelRunner.cs
index 76f61721ca..f11934abf0 100644
--- a/src/Nncase.Tests.TestFixture/ModelRunner.cs
+++ b/src/Nncase.Tests.TestFixture/ModelRunner.cs
@@ -42,9 +42,9 @@ public async Task TestRunner()
             CompileOptions.QuantizeOptions.UseSquant = false;
             CompileOptions.DumpFlags = DumpFlags.Rewrite;
 
-            using var file = File.OpenRead(ModelPath());
-            CompileOptions.InputFormat = Path.GetExtension(file.Name).Trim('.');
-            var m = await CompileSession.Compiler.ImportModuleAsync(file);
+            var modelPath = ModelPath();
+            CompileOptions.InputFormat = Path.GetExtension(modelPath).Trim('.');
+            var m = await CompileSession.Compiler.ImportModuleAsync(CompileOptions.InputFormat, modelPath);
             var types = m.Entry!.ParameterTypes.Select(type => (TensorType)type!).ToArray();
             var shapes = types.Select(x => x.Shape).ToArray();
             var isDynamic = shapes.Any(shape => !shape.IsFixed);
diff --git a/src/Nncase.Tests.TestFixture/TestClassBase.cs b/src/Nncase.Tests.TestFixture/TestClassBase.cs
index ee10789d47..a457a53a11 100644
--- a/src/Nncase.Tests.TestFixture/TestClassBase.cs
+++ b/src/Nncase.Tests.TestFixture/TestClassBase.cs
@@ -38,7 +38,7 @@ public TestClassBase()
     /// <summary>
     /// Gets or sets default target name.
     /// </summary>
-    public virtual string DefaultTargetName { get; set; } = "cpu";
+    public virtual string DefaultTargetName { get; set; } = CPUTarget.Kind;
 
     /// <summary>
     /// Gets test output root.
diff --git a/src/Nncase.Tests/Importer/UnitTestImporter.cs b/src/Nncase.Tests/Importer/UnitTestImporter.cs
index d708d2ce35..93506aa4e5 100644
--- a/src/Nncase.Tests/Importer/UnitTestImporter.cs
+++ b/src/Nncase.Tests/Importer/UnitTestImporter.cs
@@ -7,6 +7,7 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Nncase.IO;
 using Nncase.IR;
 using Nncase.Passes.Transforms;
 using Nncase.Tests.TestFixture;
@@ -37,6 +38,16 @@ public async Task TestImportTFLite()
         Assert.True(module.Entry!.InferenceType());
     }
 
+    [Fact]
+    public async Task TestImportNcnn()
+    {
+        using var file = File.OpenRead(Path.Combine(SolutionDirectory, "examples/user_guide/test.param"));
+        var module = Importers.ImportNcnn(file, new ZeroStream(), CompileSession);
+        await InferShapeAsync(module);
+        Assert.NotNull(module.Entry);
+        Assert.True(module.Entry!.InferenceType());
+    }
+
     private Task InferShapeAsync(IRModule module)
     {
         var pmgr = CompileSession.CreatePassManager("InferShapePasses");
diff --git a/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionGroup.cs b/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionGroup.cs
index 4727832692..4ac36d467c 100644
--- a/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionGroup.cs
+++ b/src/Nncase.Tests/Rewrite/Fusion/UnitTestFusionGroup.cs
@@ -18,8 +18,7 @@ public class UnitTestFusionGroup : TestClassBase
 {
     public static readonly TheoryData<IDataFlowFusionCase> DataOne = new()
     {
-        // new DataFlowType16FusionCase(),
-        new DataFlowType2FusionCaseLeft(),
+        new DataFlowType16FusionCase(),
     };
 
     public static readonly TheoryData<IDataFlowFusionCase> DataAll = new()
diff --git a/src/Nncase.Tests/Simulator/UnitTestInterop.cs b/src/Nncase.Tests/Simulator/UnitTestInterop.cs
index f77f90970f..cd9ed60a28 100644
--- a/src/Nncase.Tests/Simulator/UnitTestInterop.cs
+++ b/src/Nncase.Tests/Simulator/UnitTestInterop.cs
@@ -25,8 +25,7 @@ public UnitTestInterop()
         var y = x + 1.0f;
         var main = new Function("main", y, new[] { x });
         var module = new IRModule(main);
-
-        var target = CompilerServices.GetTarget("cpu");
+        var target = CompilerServices.GetTarget(CPUTarget.Kind);
         var modelBuilder = new ModelBuilder(target, CompileOptions);
         var linkedModel = modelBuilder.Build(module);
         using var output = new MemoryStream();
diff --git a/tests/compare_util.py b/tests/compare_util.py
index 9c8770d8e1..7d5a300118 100644
--- a/tests/compare_util.py
+++ b/tests/compare_util.py
@@ -59,7 +59,7 @@ def compare_arrays(gt: np.ndarray, pred: np.ndarray):
 
 
 def euclidean(gt: np.ndarray, pred: np.ndarray, *args):
-    return np.linalg.norm(gt - pred, 2)**2
+    return np.linalg.norm(gt.reshape(-1) - pred.reshape(-1))
 
 
 # def mse(gt: np.ndarray, pred: np.ndarray, *args):
@@ -138,7 +138,7 @@ def compare_binfile(result_path: Tuple[str, str],
             np.savetxt(str(p.parent / (p.stem + '_hist.csv')),
                        np.stack((x[:-1], y)).T, fmt='%f', delimiter=',')
         similarity_info = f"\n{similarity_name} similarity = {similarity}, threshold = {threshold}\n"
-    if similarity_name in ['cosine', 'euclidean', 'segment']:
+    if similarity_name in ['cosine', 'segment']:
         compare_op = lt
     else:
         compare_op = gt
@@ -158,14 +158,14 @@ def compare_ndarray(expected: np.ndarray,
     if expected.size == actual.size:
         similarity = similarity_func[similarity_name](expected.flatten(), actual.flatten())
     else:
-        raise ValueError("The number of elements in gt and result not match\n")
+        return False, f"The numbers of elements in gt({expected.size}) and result({actual.size}) are not match.\n"
 
     if dump_hist:
         y, x = np.histogram(expected - actual, 100)
         np.savetxt(dump_file, np.stack((x[:-1], y)).T, fmt='%f', delimiter=',')
     similarity_info = f"{similarity_name} similarity = {similarity}, threshold = {threshold}\n"
 
-    if similarity_name in ['cosine', 'euclidean', 'segment']:
+    if similarity_name in ['cosine', 'segment']:
         compare_op = lt
     else:
         compare_op = gt
diff --git a/tests/inference.py b/tests/inference.py
index 33dc565cbb..4585ba89a9 100644
--- a/tests/inference.py
+++ b/tests/inference.py
@@ -25,6 +25,7 @@
 import time
 import subprocess
 from update_trace_info import *
+from html import escape
 
 
 def data_shape_list_string(data):
@@ -212,28 +213,28 @@ def run_evb(self, target, kmodel, compile_opt, infer_dir):
 
         if header_dict['type'].find('finish') != -1:
             if self.cfg['infer_report_opt']['enabled']:
-
-                # update trace info
-                model_name = self.cfg['infer_report_opt']['model_name']
-                infer_result = f'0:{model_name} :\n' + detail
-                trace_file = search_file(infer_dir, 'trace_info.py')
-                assert(trace_file != '')
-                update_trace_info(infer_result, trace_file)
-
-                # roofline fps/mac usage
-                estimate_file = search_file(infer_dir, 'estimate_fps.py')
-                assert(estimate_file != '')
-
-                mac_file = search_file(infer_dir, 'mac.csv')
-                assert(mac_file != '')
-
-                cmd_status, cmd_result = subprocess.getstatusoutput(
-                    f'python3 {estimate_file} {mac_file}')
-                assert(cmd_status == 0)
-                data = cmd_result.split(',')
-                assert(len(data) >= 3)
-                self.infer_report_dict['roofline_fps'] = data[1].split(':')[-1].strip()
-                self.infer_report_dict['roofline_mac_usage'] = data[2].split(':')[-1].strip()
+                if not self.dynamic:
+                    # update trace info
+                    model_name = self.cfg['infer_report_opt']['model_name']
+                    infer_result = f'0:{model_name} :\n' + detail
+                    trace_file = search_file(infer_dir, 'trace_info.py')
+                    assert(trace_file != '')
+                    update_trace_info(infer_result, trace_file)
+
+                    # roofline fps/mac usage
+                    estimate_file = search_file(infer_dir, 'estimate_fps.py')
+                    assert(estimate_file != '')
+
+                    mac_file = search_file(infer_dir, 'mac.csv')
+                    assert(mac_file != '')
+
+                    cmd_status, cmd_result = subprocess.getstatusoutput(
+                        f'python3 {estimate_file} {mac_file}')
+                    assert(cmd_status == 0)
+                    data = cmd_result.split(',')
+                    assert(len(data) >= 3)
+                    self.infer_report_dict['roofline_fps'] = data[1].split(':')[-1].strip()
+                    self.infer_report_dict['roofline_mac_usage'] = data[2].split(':')[-1].strip()
 
                 # actual fps
                 fps_pattern = re.compile(
@@ -249,15 +250,16 @@ def run_evb(self, target, kmodel, compile_opt, infer_dir):
                             round(1000 / float(match.group(2)), 3))
                         break
 
-                # actual mac usage
-                draw_trace_file = search_file(infer_dir, 'draw_trace.py')
-                assert(draw_trace_file != '')
-                cmd_status, cmd_result = subprocess.getstatusoutput(
-                    f'python3 {draw_trace_file} {mac_file}')
-                assert(cmd_status == 0)
-                data = cmd_result.split(',')
-                assert(len(data) >= 1)
-                self.infer_report_dict['actual_mac_usage'] = data[0].split(':')[-1].strip()
+                if not self.dynamic:
+                    # actual mac usage
+                    draw_trace_file = search_file(infer_dir, 'draw_trace.py')
+                    assert(draw_trace_file != '')
+                    cmd_status, cmd_result = subprocess.getstatusoutput(
+                        f'python3 {draw_trace_file} {mac_file}')
+                    assert(cmd_status == 0)
+                    data = cmd_result.split(',')
+                    assert(len(data) >= 1)
+                    self.infer_report_dict['actual_mac_usage'] = data[0].split(':')[-1].strip()
 
             client_socket.sendall(f"pls send outputs".encode())
 
@@ -287,8 +289,7 @@ def run_evb(self, target, kmodel, compile_opt, infer_dir):
 
             if self.cfg['infer_report_opt']['enabled']:
                 self.infer_report_dict['result'] = 'Fail'
-                self.infer_report_dict['remark'] = detail.replace('\n', '<br/>')
-                # self.infer_report_dict['remark'] = detail
+                self.infer_report_dict['remark'] = escape(detail)
                 prefix, suffix = os.path.splitext(self.infer_report_file)
                 json_file = f'{prefix}_{os.path.basename(self.case_dir)}{suffix}'
                 dump_dict_to_json(self.infer_report_dict, json_file)
diff --git a/tests/kernels/kernel_test.h b/tests/kernels/kernel_test.h
index c39bc1e77a..7bafdb2cb9 100644
--- a/tests/kernels/kernel_test.h
+++ b/tests/kernels/kernel_test.h
@@ -961,58 +961,43 @@ class KernelTest {
                 auto dtype = lhs.datatype();
                 switch (dtype) {
                 case dt_int8:
-                    std::cout << static_cast<int8_t>(get<int8_t>(lhs, index))
-                              << " ";
+                    std::cout << get<int8_t>(lhs, index) << " ";
                     break;
                 case dt_int16:
-                    std::cout << static_cast<int16_t>(get<int16_t>(lhs, index))
-                              << " ";
+                    std::cout << get<int16_t>(lhs, index) << " ";
                     break;
                 case dt_int32:
-                    std::cout << static_cast<int32_t>(get<int32_t>(lhs, index))
-                              << " ";
+                    std::cout << get<int32_t>(lhs, index) << " ";
                     break;
                 case dt_int64:
-                    std::cout << static_cast<int64_t>(get<int64_t>(lhs, index))
-                              << " ";
+                    std::cout << get<int64_t>(lhs, index) << " ";
                     break;
                 case dt_uint8:
-                    std::cout << static_cast<uint8_t>(get<uint8_t>(lhs, index))
-                              << " ";
+                    std::cout << get<uint8_t>(lhs, index) << " ";
                     break;
                 case dt_uint16:
-                    std::cout
-                        << static_cast<uint16_t>(get<uint16_t>(lhs, index))
-                        << " ";
+                    std::cout << get<uint16_t>(lhs, index) << " ";
                     break;
                 case dt_uint32:
-                    std::cout
-                        << static_cast<uint32_t>(get<uint32_t>(lhs, index))
-                        << " ";
+                    std::cout << get<uint32_t>(lhs, index) << " ";
                     break;
                 case dt_uint64:
-                    std::cout
-                        << static_cast<uint64_t>(get<uint64_t>(lhs, index))
-                        << " ";
+                    std::cout << get<uint64_t>(lhs, index) << " ";
                     break;
                 case dt_float32:
                     std::cout << get<float>(lhs, index) << " ";
                     break;
                 case dt_float64:
-                    std::cout << static_cast<double>(get<double>(lhs, index))
-                              << " ";
+                    std::cout << get<double>(lhs, index) << " ";
                     break;
                 case dt_float16:
-                    std::cout << static_cast<double>(get<half>(lhs, index))
-                              << " ";
+                    std::cout << get<half>(lhs, index) << " ";
                     break;
                 case dt_boolean:
-                    std::cout << static_cast<bool>(get<bool>(lhs, index))
-                              << " ";
+                    std::cout << get<bool>(lhs, index) << " ";
                     break;
                 case dt_bfloat16:
-                    std::cout << static_cast<double>(get<bfloat16>(lhs, index))
-                              << " ";
+                    std::cout << get<bfloat16>(lhs, index) << " ";
                     break;
                 default:
                     break;
@@ -1148,8 +1133,8 @@ class KernelTest {
         size_t arraySize = array.Size();
         dims_t cArray(arraySize);
         for (rapidjson::SizeType i = 0; i < arraySize; i++) {
-            if (array[i].IsUint()) {
-                cArray[i] = array[i].GetUint();
+            if (array[i].IsInt()) {
+                cArray[i] = array[i].GetInt();
             } else {
                 std::cout << "Invalid JSON format. Expected unsigned integer "
                              "values in the array."
@@ -1168,8 +1153,8 @@ class KernelTest {
         size_t arraySize = array.Size();
         std::vector<int64_t> cArray(arraySize);
         for (rapidjson::SizeType i = 0; i < arraySize; i++) {
-            if (array[i].IsUint()) {
-                cArray[i] = array[i].GetUint();
+            if (array[i].IsInt()) {
+                cArray[i] = array[i].GetInt();
             } else {
                 std::cout << "Invalid JSON format. Expected unsigned integer "
                              "values in the array."
@@ -1188,8 +1173,8 @@ class KernelTest {
         size_t arraySize = array.Size();
         axes_t cArray(arraySize);
         for (rapidjson::SizeType i = 0; i < arraySize; i++) {
-            if (array[i].IsUint()) {
-                cArray[i] = array[i].GetUint();
+            if (array[i].IsInt()) {
+                cArray[i] = array[i].GetInt();
             } else {
                 std::cout << "Invalid JSON format. Expected unsigned integer "
                              "values in the array."
diff --git a/tests/kernels/test_batch_normalization.json b/tests/kernels/test_batch_normalization.json
index dc1ed67809..d4ba4a8fd4 100644
--- a/tests/kernels/test_batch_normalization.json
+++ b/tests/kernels/test_batch_normalization.json
@@ -1,4 +1,4 @@
 {
   "lhs_shape":[[1, 8, 24, 24], [1, 3, 3, 16], [2, 4, 8, 8], [8, 8], [1, 3, 16, 1], [1, 1]],
-  "lhs_type":["dt_float32"]
+  "lhs_type":["dt_float32", "dt_float64"]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_constant_of_shape.json b/tests/kernels/test_constant_of_shape.json
index 8ddf991217..fc15e13a77 100644
--- a/tests/kernels/test_constant_of_shape.json
+++ b/tests/kernels/test_constant_of_shape.json
@@ -1,4 +1,4 @@
 {
   "lhs_shape":[[1, 8, 24, 24], [1, 3, 3, 16], [2, 4, 8, 8], [8, 8], [1, 3, 16, 1], [1, 1], [16]],
-  "lhs_type":["dt_int32"]
+  "lhs_type":["dt_int32", "dt_float32"]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_gather.cpp b/tests/kernels/test_gather.cpp
index 819f315c06..5910d17cc1 100644
--- a/tests/kernels/test_gather.cpp
+++ b/tests/kernels/test_gather.cpp
@@ -45,6 +45,13 @@ class GatherTest : public KernelTest,
         init_tensor(input);
 
         size_t indices_value_size = indices_value.size();
+        int64_t min = 0;
+        for (size_t i = 0; i < indices_value_size; i++) {
+            min = indices_value[i] < min ? indices_value[i] : min;
+        }
+        if (-min + 1 >= (int64_t)shape.size()) {
+            indices_value = {0, 0, 0, 0};
+        }
         auto *indices_array =
             (int64_t *)malloc(indices_value_size * sizeof(int64_t));
         std::copy(indices_value.begin(), indices_value.end(), indices_array);
diff --git a/tests/kernels/test_gather.json b/tests/kernels/test_gather.json
index c294a31800..436418b5a6 100644
--- a/tests/kernels/test_gather.json
+++ b/tests/kernels/test_gather.json
@@ -2,6 +2,6 @@
   "lhs_shape":[[2, 3, 5, 7], [2, 2], [2, 3, 1], [5, 5, 7, 7], [11]],
   "indices_shape":[[4], [2, 2], [4, 1]],
   "axis":[0, 1, -1, 2, 3, -2, -3, -4],
-  "indices_value": [[0, 0, -1, -1]],
+  "indices_value": [[0, 0, -1, -1], [-2, 1, -2, 0], [1, -2, -2, -1]],
   "lhs_type":["dt_float32", "dt_int8", "dt_int32", "dt_uint8", "dt_int16", "dt_uint16", "dt_uint32", "dt_uint64", "dt_int64", "dt_float16", "dt_float64", "dt_bfloat16", "dt_boolean"]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_hardmax.json b/tests/kernels/test_hardmax.json
index 49fedb4158..6afb8aef91 100644
--- a/tests/kernels/test_hardmax.json
+++ b/tests/kernels/test_hardmax.json
@@ -1,5 +1,5 @@
 {
   "lhs_shape":[[1, 3, 16, 16], [1, 3, 16], [2, 16], [1]],
-  "lhs_type":["dt_float32"],
+  "lhs_type":["dt_float32", "dt_float16"],
   "axis_value": [-4, -3, -2, -1, 0, 1, 2, 3]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_instance_normalization.json b/tests/kernels/test_instance_normalization.json
index 2a14fe66b3..57ea381b4a 100644
--- a/tests/kernels/test_instance_normalization.json
+++ b/tests/kernels/test_instance_normalization.json
@@ -1,4 +1,4 @@
 {
   "lhs_shape":[[3, 3, 16, 16], [64, 2, 4, 8], [1, 2, 4, 8], [24, 16, 16], [24, 3, 16]],
-  "lhs_type":["dt_float32"]
+  "lhs_type":["dt_float16", "dt_float32"]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_layer_norm.cpp b/tests/kernels/test_layer_norm.cpp
index 55d73cb483..cc8a2696bd 100644
--- a/tests/kernels/test_layer_norm.cpp
+++ b/tests/kernels/test_layer_norm.cpp
@@ -84,13 +84,14 @@ class LayerNormTest : public KernelTest,
 INSTANTIATE_TEST_SUITE_P(layer_norm, LayerNormTest,
                          testing::Combine(testing::Range(0, MAX_CASE_NUM)));
 
+// todo There is a problem with f16 in ortki, and see it later.
 TEST_P(LayerNormTest, layer_norm) {
     auto l_ort = runtime_tensor_2_ort_tensor(input);
     auto scale_ort = runtime_tensor_2_ort_tensor(scale);
     auto b_ort = runtime_tensor_2_ort_tensor(b);
     auto eps = 1e-05f;
 
-    //     expected
+    // expected
     auto output_ort =
         ortki_LayerNormalization(l_ort, scale_ort, b_ort, axis_value, eps, 1L);
     size_t size = 0;
@@ -114,7 +115,9 @@ TEST_P(LayerNormTest, layer_norm) {
                   cosine_similarity_tensor(expected, actual);
 
     if (!result) {
+        std::cout << "actual ";
         print_runtime_tensor(actual);
+        std::cout << "expected ";
         print_runtime_tensor(expected);
     }
 
diff --git a/tests/kernels/test_lrn.json b/tests/kernels/test_lrn.json
index e501b1feef..d9678fdfd2 100644
--- a/tests/kernels/test_lrn.json
+++ b/tests/kernels/test_lrn.json
@@ -1,4 +1,4 @@
 {
-  "lhs_shape":[[1, 3, 16, 16], [1, 3, 8, 8]],
-  "lhs_type":["dt_float32"]
+  "lhs_shape":[[1, 3, 16, 16], [1, 3, 8, 8], [1, 3, 24, 24], [1, 3, 4, 4]],
+  "lhs_type":["dt_float32", "dt_float16"]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_matmul.json b/tests/kernels/test_matmul.json
index 8c89dea255..426e5b1026 100644
--- a/tests/kernels/test_matmul.json
+++ b/tests/kernels/test_matmul.json
@@ -1,5 +1,5 @@
 {
     "lhs_shape":[[3], [1, 3], [3, 3], [1, 3, 3], [4, 2, 3, 3]],
-    "lhs_type":["dt_int32", "dt_int64", "dt_float32", "dt_float64", "dt_uint32", "dt_uint64"],
+    "lhs_type":["dt_int32", "dt_int64", "dt_float32", "dt_float64", "dt_uint32", "dt_uint64", "dt_float16"],
     "rhs_shape":[[3], [3, 1], [3, 3], [1, 3, 3], [4, 2, 3, 3]]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_normal.cpp b/tests/kernels/test_normal.cpp
index 3103c364f9..e507ab8180 100644
--- a/tests/kernels/test_normal.cpp
+++ b/tests/kernels/test_normal.cpp
@@ -41,7 +41,7 @@ class NormalTest : public KernelTest,
         auto value3 = GetFloatNumber("seed_value");
 
         mean_value = value1;
-        float_t mean_ptr[] = {mean_value};
+        float mean_ptr[] = {mean_value};
         mean = hrt::create(
                    typecode, {1},
                    {reinterpret_cast<gsl::byte *>(mean_ptr), sizeof(mean_ptr)},
@@ -49,7 +49,7 @@ class NormalTest : public KernelTest,
                    .expect("create tensor failed");
 
         scale_value = value2;
-        float_t scale_ptr[] = {scale_value};
+        float scale_ptr[] = {scale_value};
         scale = hrt::create(typecode, {1},
                             {reinterpret_cast<gsl::byte *>(scale_ptr),
                              sizeof(scale_ptr)},
@@ -57,7 +57,7 @@ class NormalTest : public KernelTest,
                     .expect("create tensor failed");
 
         seed_value = value3;
-        float_t seed_ptr[] = {seed_value};
+        float seed_ptr[] = {seed_value};
         seed = hrt::create(
                    typecode, {1},
                    {reinterpret_cast<gsl::byte *>(seed_ptr), sizeof(seed_ptr)},
diff --git a/tests/kernels/test_prelu.cpp b/tests/kernels/test_prelu.cpp
index 3c75e59533..8b1ca7d6f0 100644
--- a/tests/kernels/test_prelu.cpp
+++ b/tests/kernels/test_prelu.cpp
@@ -50,6 +50,15 @@ class PreluTest : public KernelTest,
         } else {
             slope = slope_t{0.1};
         }
+
+        size_t slope_size = slope.size();
+        float *slope_array = (float *)malloc(slope_size * sizeof(float));
+        std::copy(slope.begin(), slope.end(), slope_array);
+        slope_tensor = hrt::create(dt_float32, {slope_size},
+                                   {reinterpret_cast<gsl::byte *>(slope_array),
+                                    slope_size * sizeof(float)},
+                                   true, host_runtime_tensor::pool_cpu_only)
+                           .expect("create tensor failed");
     }
 
     void TearDown() override{CLEAR_SUBCASE()}
@@ -73,6 +82,7 @@ class PreluTest : public KernelTest,
 
   protected:
     runtime_tensor input;
+    runtime_tensor slope_tensor;
     slope_t slope;
 };
 
@@ -83,15 +93,14 @@ TEST_P(PreluTest, Prelu) {
     auto l_ort = runtime_tensor_2_ort_tensor(input);
 
     // expected
-    size_t slope_size = slope.size();
-    float *slope_array = (float *)malloc(slope_size * sizeof(float));
-    std::copy(slope.begin(), slope.end(), slope_array);
-    auto slope = hrt::create(dt_float32, {slope_size},
-                             {reinterpret_cast<gsl::byte *>(slope_array),
-                              slope_size * sizeof(float)},
-                             true, host_runtime_tensor::pool_cpu_only)
-                     .expect("create tensor failed");
-    auto slope_ort = runtime_tensor_2_ort_tensor(slope);
+    runtime_tensor slope_tensor_like_input(
+        kernels::stackvm::cast(input.datatype(),
+                               runtime::stackvm::cast_mode_t::kdefault,
+                               slope_tensor.impl())
+            .expect("cast failed")
+            .as<tensor>()
+            .expect("as tensor failed"));
+    auto slope_ort = runtime_tensor_2_ort_tensor(slope_tensor_like_input);
     auto output_ort = ortki_PRelu(l_ort, slope_ort);
     size_t size = 0;
     void *ptr_ort = tensor_buffer(output_ort, &size);
@@ -103,8 +112,9 @@ TEST_P(PreluTest, Prelu) {
                         .expect("create tensor failed");
 
     // actual
-    auto output = kernels::stackvm::prelu(input.impl(), slope.impl())
-                      .expect("prelu failed");
+    auto output =
+        kernels::stackvm::prelu(input.impl(), slope_tensor_like_input.impl())
+            .expect("prelu failed");
     runtime_tensor actual(output.as<tensor>().expect("as tensor failed"));
 
     bool result = is_same_tensor(expected, actual) ||
diff --git a/tests/kernels/test_prelu.json b/tests/kernels/test_prelu.json
index b728e936d6..74167869f4 100644
--- a/tests/kernels/test_prelu.json
+++ b/tests/kernels/test_prelu.json
@@ -1,5 +1,5 @@
 {
   "lhs_shape":[[1, 3, 16, 16], [1, 3, 16], [8, 8], [1, 4, 16], [1], [1, 3, 24, 24]],
-  "lhs_type":["dt_float32"],
+  "lhs_type":["dt_float32", "dt_float16"],
   "slope":[[0.2], [0.1], [0.3], [0.2, 0.1, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1, 0.3], [0.1, 0.2, 0.2, 0.4, 0.2, 0.2, 0.3, 0.8], [0.1, 0.2, 0.2, 0.2, 0.1, 0.2, 0.2, 0.4, 0.1, 0.2, 0.2, 0.8, 0.2, 0.12, 0.2, 0.21], [0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 0.1, 0.2]]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_reduce.json b/tests/kernels/test_reduce.json
index 760e75445e..c9ce225844 100644
--- a/tests/kernels/test_reduce.json
+++ b/tests/kernels/test_reduce.json
@@ -1,5 +1,5 @@
 {
-  "lhs_type":["dt_float32"],
+  "lhs_type":["dt_float16", "dt_float32", "dt_int32", "dt_float64", "dt_uint8", "dt_int8"],
   "rhs_type":["dt_int64"],
   "lhs_shape":[[1, 3, 16, 16]],
   "rhs_shape":[[1]],
diff --git a/tests/kernels/test_reduce_max.cpp b/tests/kernels/test_reduce_max.cpp
index dca0a52b1d..6b0d600331 100644
--- a/tests/kernels/test_reduce_max.cpp
+++ b/tests/kernels/test_reduce_max.cpp
@@ -54,19 +54,141 @@ class ReduceMaxTest : public KernelTest,
                                true, host_runtime_tensor::pool_cpu_only)
                        .expect("create tensor failed");
 
-        float init_value_array[] = {-1}; // the min of input's range
         init_value =
-            hrt::create(typecode1, r_shape,
-                        {reinterpret_cast<gsl::byte *>(init_value_array),
-                         sizeof(init_value_array)},
-                        true, host_runtime_tensor::pool_cpu_only)
+            hrt::create(typecode1, r_shape, host_runtime_tensor::pool_cpu_only)
                 .expect("create tensor failed");
+        init_value_tensor(init_value);
 
         axis_value_array = axis_value;
     }
 
     void TearDown() override { CLEAR_SUBCASE() }
 
+    virtual void init_value_tensor(runtime::runtime_tensor &tensor) {
+        auto dtype = tensor.datatype();
+        switch (dtype) {
+        case dt_int8: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int8_t>(tensor, index) = static_cast<int8_t>(-6);
+                    return ok();
+                });
+            break;
+        }
+        case dt_int16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int16_t>(tensor, index) = static_cast<int16_t>(-6);
+                    return ok();
+                });
+            break;
+        }
+        case dt_int32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int32_t>(tensor, index) = -6;
+                    return ok();
+                });
+            break;
+        }
+        case dt_int64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int64_t>(tensor, index) = static_cast<int64_t>(-6);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint8: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint8_t>(tensor, index) = static_cast<uint8_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint16_t>(tensor, index) = static_cast<uint16_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint32_t>(tensor, index) = static_cast<uint32_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint64_t>(tensor, index) = static_cast<uint64_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<half>(tensor, index) = static_cast<half>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<float>(tensor, index) = static_cast<float>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<double>(tensor, index) = static_cast<double>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_bfloat16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<bfloat16>(tensor, index) = static_cast<bfloat16>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_boolean: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<bool>(tensor, index) = false;
+                    return ok();
+                });
+            break;
+        }
+        default: {
+        }
+        }
+    }
+
   protected:
     runtime_tensor a;
     axes_t axis_value_array;
@@ -99,7 +221,7 @@ TEST_P(ReduceMaxTest, ReduceMax) {
         dims_t shape(tensor_rank(output_ort));
         tensor_shape(output_ort, reinterpret_cast<int64_t *>(shape.data()));
         auto expected =
-            hrt::create(dt_float32, shape,
+            hrt::create(a.datatype(), shape,
                         {reinterpret_cast<gsl::byte *>(ptr_ort), size}, true,
                         host_runtime_tensor::pool_cpu_only)
                 .expect("create tensor failed");
diff --git a/tests/kernels/test_reduce_mean.cpp b/tests/kernels/test_reduce_mean.cpp
index be40249440..66481270ff 100644
--- a/tests/kernels/test_reduce_mean.cpp
+++ b/tests/kernels/test_reduce_mean.cpp
@@ -26,7 +26,7 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace ortki;
 
-#define TEST_CASE_NAME "test_reduce"
+#define TEST_CASE_NAME "test_reduce_mean"
 
 class ReduceMeanTest : public KernelTest,
                        public ::testing::TestWithParam<std::tuple<int>> {
@@ -54,19 +54,141 @@ class ReduceMeanTest : public KernelTest,
                                true, host_runtime_tensor::pool_cpu_only)
                        .expect("create tensor failed");
 
-        float init_value_array[] = {0}; // the min of input's range
         init_value =
-            hrt::create(typecode1, r_shape,
-                        {reinterpret_cast<gsl::byte *>(init_value_array),
-                         sizeof(init_value_array)},
-                        true, host_runtime_tensor::pool_cpu_only)
+            hrt::create(typecode1, r_shape, host_runtime_tensor::pool_cpu_only)
                 .expect("create tensor failed");
+        init_value_tensor(init_value);
 
         axis_value_array = axis_value;
     }
 
     void TearDown() override { CLEAR_SUBCASE() }
 
+    virtual void init_value_tensor(runtime::runtime_tensor &tensor) {
+        auto dtype = tensor.datatype();
+        switch (dtype) {
+        case dt_int8: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int8_t>(tensor, index) = static_cast<int8_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_int16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int16_t>(tensor, index) = static_cast<int16_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_int32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int32_t>(tensor, index) = 0;
+                    return ok();
+                });
+            break;
+        }
+        case dt_int64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int64_t>(tensor, index) = static_cast<int64_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint8: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint8_t>(tensor, index) = static_cast<uint8_t>(63);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint16_t>(tensor, index) = static_cast<uint16_t>(63);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint32_t>(tensor, index) = static_cast<uint32_t>(63);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint64_t>(tensor, index) = static_cast<uint64_t>(63);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<half>(tensor, index) = static_cast<half>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<float>(tensor, index) = static_cast<float>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<double>(tensor, index) = static_cast<double>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_bfloat16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<bfloat16>(tensor, index) = static_cast<bfloat16>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_boolean: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<bool>(tensor, index) = false;
+                    return ok();
+                });
+            break;
+        }
+        default: {
+        }
+        }
+    }
+
   protected:
     runtime_tensor a;
     axes_t axis_value_array;
@@ -99,7 +221,7 @@ TEST_P(ReduceMeanTest, ReduceMean) {
         dims_t shape(tensor_rank(output_ort));
         tensor_shape(output_ort, reinterpret_cast<int64_t *>(shape.data()));
         auto expected =
-            hrt::create(dt_float32, shape,
+            hrt::create(a.datatype(), shape,
                         {reinterpret_cast<gsl::byte *>(ptr_ort), size}, true,
                         host_runtime_tensor::pool_cpu_only)
                 .expect("create tensor failed");
diff --git a/tests/kernels/test_reduce_min.cpp b/tests/kernels/test_reduce_min.cpp
index 7ba7f1f1db..6f960d6c59 100644
--- a/tests/kernels/test_reduce_min.cpp
+++ b/tests/kernels/test_reduce_min.cpp
@@ -54,19 +54,141 @@ class ReduceMinTest : public KernelTest,
                                true, host_runtime_tensor::pool_cpu_only)
                        .expect("create tensor failed");
 
-        float init_value_array[] = {-1}; // the min of input's range
         init_value =
-            hrt::create(typecode1, r_shape,
-                        {reinterpret_cast<gsl::byte *>(init_value_array),
-                         sizeof(init_value_array)},
-                        true, host_runtime_tensor::pool_cpu_only)
+            hrt::create(typecode1, r_shape, host_runtime_tensor::pool_cpu_only)
                 .expect("create tensor failed");
+        init_value_tensor(init_value);
 
         axis_value_array = axis_value;
     }
 
     void TearDown() override { CLEAR_SUBCASE() }
 
+    virtual void init_value_tensor(runtime::runtime_tensor &tensor) {
+        auto dtype = tensor.datatype();
+        switch (dtype) {
+        case dt_int8: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int8_t>(tensor, index) = static_cast<int8_t>(-6);
+                    return ok();
+                });
+            break;
+        }
+        case dt_int16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int16_t>(tensor, index) = static_cast<int16_t>(-6);
+                    return ok();
+                });
+            break;
+        }
+        case dt_int32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int32_t>(tensor, index) = -6;
+                    return ok();
+                });
+            break;
+        }
+        case dt_int64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int64_t>(tensor, index) = static_cast<int64_t>(-6);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint8: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint8_t>(tensor, index) = static_cast<uint8_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint16_t>(tensor, index) = static_cast<uint16_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint32_t>(tensor, index) = static_cast<uint32_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint64_t>(tensor, index) = static_cast<uint64_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<half>(tensor, index) = static_cast<half>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<float>(tensor, index) = static_cast<float>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<double>(tensor, index) = static_cast<double>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_bfloat16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<bfloat16>(tensor, index) = static_cast<bfloat16>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_boolean: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<bool>(tensor, index) = false;
+                    return ok();
+                });
+            break;
+        }
+        default: {
+        }
+        }
+    }
+
   protected:
     runtime_tensor a;
     axes_t axis_value_array;
@@ -99,7 +221,7 @@ TEST_P(ReduceMinTest, ReduceMin) {
         dims_t shape(tensor_rank(output_ort));
         tensor_shape(output_ort, reinterpret_cast<int64_t *>(shape.data()));
         auto expected =
-            hrt::create(dt_float32, shape,
+            hrt::create(a.datatype(), shape,
                         {reinterpret_cast<gsl::byte *>(ptr_ort), size}, true,
                         host_runtime_tensor::pool_cpu_only)
                 .expect("create tensor failed");
diff --git a/tests/kernels/test_reduce_prod.cpp b/tests/kernels/test_reduce_prod.cpp
index 1ffa0579a2..54fc4f2b0f 100644
--- a/tests/kernels/test_reduce_prod.cpp
+++ b/tests/kernels/test_reduce_prod.cpp
@@ -26,7 +26,7 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace ortki;
 
-#define TEST_CASE_NAME "test_reduce"
+#define TEST_CASE_NAME "test_reduce_prod"
 
 class ReduceProdTest : public KernelTest,
                        public ::testing::TestWithParam<std::tuple<int>> {
@@ -54,19 +54,141 @@ class ReduceProdTest : public KernelTest,
                                true, host_runtime_tensor::pool_cpu_only)
                        .expect("create tensor failed");
 
-        float init_value_array[] = {-1}; // the min of input's range
         init_value =
-            hrt::create(typecode1, r_shape,
-                        {reinterpret_cast<gsl::byte *>(init_value_array),
-                         sizeof(init_value_array)},
-                        true, host_runtime_tensor::pool_cpu_only)
+            hrt::create(typecode1, r_shape, host_runtime_tensor::pool_cpu_only)
                 .expect("create tensor failed");
+        init_value_tensor(init_value);
 
         axis_value_array = axis_value;
     }
 
     void TearDown() override { CLEAR_SUBCASE() }
 
+    virtual void init_value_tensor(runtime::runtime_tensor &tensor) {
+        auto dtype = tensor.datatype();
+        switch (dtype) {
+        case dt_int8: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int8_t>(tensor, index) = static_cast<int8_t>(-6);
+                    return ok();
+                });
+            break;
+        }
+        case dt_int16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int16_t>(tensor, index) = static_cast<int16_t>(-6);
+                    return ok();
+                });
+            break;
+        }
+        case dt_int32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int32_t>(tensor, index) = -6;
+                    return ok();
+                });
+            break;
+        }
+        case dt_int64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int64_t>(tensor, index) = static_cast<int64_t>(-6);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint8: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint8_t>(tensor, index) = static_cast<uint8_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint16_t>(tensor, index) = static_cast<uint16_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint32_t>(tensor, index) = static_cast<uint32_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint64_t>(tensor, index) = static_cast<uint64_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<half>(tensor, index) = static_cast<half>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<float>(tensor, index) = static_cast<float>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<double>(tensor, index) = static_cast<double>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_bfloat16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<bfloat16>(tensor, index) = static_cast<bfloat16>(-1);
+                    return ok();
+                });
+            break;
+        }
+        case dt_boolean: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<bool>(tensor, index) = false;
+                    return ok();
+                });
+            break;
+        }
+        default: {
+        }
+        }
+    }
+
   protected:
     runtime_tensor a;
     axes_t axis_value_array;
@@ -99,7 +221,7 @@ TEST_P(ReduceProdTest, ReduceProd) {
         dims_t shape(tensor_rank(output_ort));
         tensor_shape(output_ort, reinterpret_cast<int64_t *>(shape.data()));
         auto expected =
-            hrt::create(dt_float32, shape,
+            hrt::create(a.datatype(), shape,
                         {reinterpret_cast<gsl::byte *>(ptr_ort), size}, true,
                         host_runtime_tensor::pool_cpu_only)
                 .expect("create tensor failed");
diff --git a/tests/kernels/test_reduce_sum.cpp b/tests/kernels/test_reduce_sum.cpp
index a2539b714e..b3ab85e5e9 100644
--- a/tests/kernels/test_reduce_sum.cpp
+++ b/tests/kernels/test_reduce_sum.cpp
@@ -26,7 +26,7 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace ortki;
 
-#define TEST_CASE_NAME "test_reduce"
+#define TEST_CASE_NAME "test_reduce_sum"
 
 class ReduceSumTest : public KernelTest,
                       public ::testing::TestWithParam<std::tuple<int>> {
@@ -54,19 +54,141 @@ class ReduceSumTest : public KernelTest,
                                true, host_runtime_tensor::pool_cpu_only)
                        .expect("create tensor failed");
 
-        float init_value_array[] = {0}; // the min of input's range
         init_value =
-            hrt::create(typecode1, r_shape,
-                        {reinterpret_cast<gsl::byte *>(init_value_array),
-                         sizeof(init_value_array)},
-                        true, host_runtime_tensor::pool_cpu_only)
+            hrt::create(typecode1, r_shape, host_runtime_tensor::pool_cpu_only)
                 .expect("create tensor failed");
+        init_value_tensor(init_value);
 
         axis_value_array = axis_value;
     }
 
     void TearDown() override { CLEAR_SUBCASE() }
 
+    virtual void init_value_tensor(runtime::runtime_tensor &tensor) {
+        auto dtype = tensor.datatype();
+        switch (dtype) {
+        case dt_int8: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int8_t>(tensor, index) = static_cast<int8_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_int16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int16_t>(tensor, index) = static_cast<int16_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_int32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int32_t>(tensor, index) = 0;
+                    return ok();
+                });
+            break;
+        }
+        case dt_int64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<int64_t>(tensor, index) = static_cast<int64_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint8: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint8_t>(tensor, index) = static_cast<uint8_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint16_t>(tensor, index) = static_cast<uint16_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint32_t>(tensor, index) = static_cast<uint32_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_uint64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<uint64_t>(tensor, index) = static_cast<uint64_t>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<half>(tensor, index) = static_cast<half>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float32: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<float>(tensor, index) = static_cast<float>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_float64: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<double>(tensor, index) = static_cast<double>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_bfloat16: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<bfloat16>(tensor, index) = static_cast<bfloat16>(0);
+                    return ok();
+                });
+            break;
+        }
+        case dt_boolean: {
+            NNCASE_UNUSED auto res = kernels::stackvm::apply(
+                tensor.shape(),
+                [&](gsl::span<const size_t> index) -> result<void> {
+                    get<bool>(tensor, index) = false;
+                    return ok();
+                });
+            break;
+        }
+        default: {
+        }
+        }
+    }
+
   protected:
     runtime_tensor a;
     axes_t axis_value_array;
@@ -99,7 +221,7 @@ TEST_P(ReduceSumTest, ReduceSum) {
         dims_t shape(tensor_rank(output_ort));
         tensor_shape(output_ort, reinterpret_cast<int64_t *>(shape.data()));
         auto expected =
-            hrt::create(dt_float32, shape,
+            hrt::create(a.datatype(), shape,
                         {reinterpret_cast<gsl::byte *>(ptr_ort), size}, true,
                         host_runtime_tensor::pool_cpu_only)
                 .expect("create tensor failed");
diff --git a/tests/kernels/test_reduce_window_2d.cpp b/tests/kernels/test_reduce_window_2d.cpp
index 950ee59530..867380795b 100644
--- a/tests/kernels/test_reduce_window_2d.cpp
+++ b/tests/kernels/test_reduce_window_2d.cpp
@@ -26,7 +26,7 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace ortki;
 
-#define TEST_CASE_NAME "test_reduce_window2D"
+#define TEST_CASE_NAME "test_reduce_window_2d"
 
 class ReduceWindow2DTest : public KernelTest,
                            public ::testing::TestWithParam<std::tuple<int>> {
diff --git a/tests/kernels/test_reverse_sequence.cpp b/tests/kernels/test_reverse_sequence.cpp
index 8c2d3647d5..d6aab0416a 100644
--- a/tests/kernels/test_reverse_sequence.cpp
+++ b/tests/kernels/test_reverse_sequence.cpp
@@ -36,6 +36,9 @@ class ReverseSequenceTest : public KernelTest,
 
         auto typecode = GetDataType("lhs_type");
         auto l_shape = GetShapeArray("i_shape");
+        seqLens_array = GetAxesArray("seqLens");
+        batch_axis = GetNumber("batch_axis");
+        time_axis = 1;
 
         input =
             hrt::create(typecode, l_shape, host_runtime_tensor::pool_cpu_only)
@@ -47,6 +50,9 @@ class ReverseSequenceTest : public KernelTest,
 
   protected:
     runtime_tensor input;
+    axes_t seqLens_array;
+    int64_t batch_axis;
+    int64_t time_axis;
 };
 
 INSTANTIATE_TEST_SUITE_P(ReverseSequence, ReverseSequenceTest,
@@ -56,15 +62,19 @@ TEST_P(ReverseSequenceTest, ReverseSequence) {
     auto l_ort = runtime_tensor_2_ort_tensor(input);
 
     // expected
+    size_t seqLens_size = seqLens_array.size();
+    int64_t *seqLens_array_ptr =
+        (int64_t *)malloc(seqLens_size * sizeof(int64_t));
+    std::copy(seqLens_array.begin(), seqLens_array.end(), seqLens_array_ptr);
     size_t size = 0;
-    int64_t seqLens_array[] = {1, 2, 3, 4};
-    auto seqLens = hrt::create(dt_int64, {4},
-                               {reinterpret_cast<gsl::byte *>(seqLens_array),
-                                sizeof(seqLens_array)},
-                               true, host_runtime_tensor::pool_cpu_only)
-                       .expect("create tensor failed");
+    auto seqLens =
+        hrt::create(dt_int64, {seqLens_size},
+                    {reinterpret_cast<gsl::byte *>(seqLens_array_ptr),
+                     seqLens_size * sizeof(int64_t)},
+                    true, host_runtime_tensor::pool_cpu_only)
+            .expect("create tensor failed");
     auto output_ort = ortki_ReverseSequence(
-        l_ort, runtime_tensor_2_ort_tensor(seqLens), 1, 0);
+        l_ort, runtime_tensor_2_ort_tensor(seqLens), batch_axis, time_axis);
     void *ptr_ort = tensor_buffer(output_ort, &size);
     dims_t shape(tensor_rank(output_ort));
     tensor_shape(output_ort, reinterpret_cast<int64_t *>(shape.data()));
@@ -74,14 +84,14 @@ TEST_P(ReverseSequenceTest, ReverseSequence) {
                         .expect("create tensor failed");
 
     // actual
-    int64_t batch_axis_array[] = {1};
+    int64_t batch_axis_array[] = {batch_axis};
     auto batch_axis =
         hrt::create(dt_int64, {1},
                     {reinterpret_cast<gsl::byte *>(batch_axis_array),
                      sizeof(batch_axis_array)},
                     true, host_runtime_tensor::pool_cpu_only)
             .expect("create tensor failed");
-    int64_t time_axis_array[] = {0};
+    int64_t time_axis_array[] = {time_axis};
     auto time_axis =
         hrt::create(dt_int64, {1},
                     {reinterpret_cast<gsl::byte *>(time_axis_array),
@@ -104,19 +114,25 @@ TEST_P(ReverseSequenceTest, ReverseSequence) {
         print_runtime_tensor(expected);
     }
 
-    // compare
+    //     compare
     EXPECT_TRUE(result);
 }
 
 int main(int argc, char *argv[]) {
     READY_TEST_CASE_GENERATE()
-    FOR_LOOP(lhs_type, i)
     FOR_LOOP(i_shape, j)
-    SPLIT_ELEMENT(lhs_type, i)
+    FOR_LOOP(lhs_type, i)
+    FOR_LOOP(seqLens, k)
+    FOR_LOOP(batch_axis, l)
     SPLIT_ELEMENT(i_shape, j)
+    SPLIT_ELEMENT(lhs_type, i)
+    SPLIT_ELEMENT(seqLens, k)
+    SPLIT_ELEMENT(batch_axis, l)
     WRITE_SUB_CASE()
     FOR_LOOP_END()
     FOR_LOOP_END()
+    FOR_LOOP_END()
+    FOR_LOOP_END()
 
     ::testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
diff --git a/tests/kernels/test_reverse_sequence.json b/tests/kernels/test_reverse_sequence.json
index bfc3f9b151..c1252a03fe 100644
--- a/tests/kernels/test_reverse_sequence.json
+++ b/tests/kernels/test_reverse_sequence.json
@@ -1,4 +1,6 @@
 {
-  "i_shape":[[4, 4]],
-  "lhs_type":["dt_float32"]
+  "i_shape":[[2, 4, 2, 2]],
+  "lhs_type":["dt_float32", "dt_uint8", "dt_int8", "dt_float16", "dt_uint32", "dt_uint64", "dt_uint16", "dt_int16", "dt_int32", "dt_int64", "dt_float64", "dt_boolean"],
+  "seqLens":[[1, 1], [1, 2], [2, 2], [3, 3]],
+  "batch_axis":[0]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_slice.json b/tests/kernels/test_slice.json
index 3d64b6de70..a645868b05 100644
--- a/tests/kernels/test_slice.json
+++ b/tests/kernels/test_slice.json
@@ -1,8 +1,8 @@
 {
   "lhs_type":["dt_int32"],
   "input_shape":[[2, 3, 4, 5], [1, 4, 5, 6], [1, 1, 1, 120], [2, 2, 5, 6], [1, 1, 2, 60]],
-  "value1": [[0, 0, 0, 0]],
-  "value2": [[1, 1, 1, 5]],
-  "value3": [[0, 1, 2, 3]],
-  "value4": [[1, 1, 1, 1]]
+  "value1": [[0, 0, 0, 0], [1, 1, 1, 1]],
+  "value2": [[1, 1, 1, 5], [2, 2, 2, 2]],
+  "value3": [[0, 1, 2, 3], [2, 3, 2, 3]],
+  "value4": [[1, 1, 1, 1], [1, 2, 3, 4]]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_softmax.json b/tests/kernels/test_softmax.json
index e1c271bc01..b75a08a704 100644
--- a/tests/kernels/test_softmax.json
+++ b/tests/kernels/test_softmax.json
@@ -1,5 +1,5 @@
 {
   "lhs_shape":[[1, 8, 24, 24], [1, 3, 3, 16], [2, 4, 8, 8], [8, 8], [1, 3, 16, 1], [1, 1], [16], [1, 16]],
   "axis":[0, 1, 2, 3, -4, -3, -2, -1],
-  "lhs_type":["dt_float32"]
+  "lhs_type":["dt_float32", "dt_float16", "dt_float64"]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_tile.json b/tests/kernels/test_tile.json
index 5ec2eb400d..ff30f631f4 100644
--- a/tests/kernels/test_tile.json
+++ b/tests/kernels/test_tile.json
@@ -1,4 +1,4 @@
 {
   "lhs_shape":[[1, 2, 4, 8], [1, 3, 16, 16]],
-  "lhs_type":["dt_float32", "dt_int32", "dt_int16", "dt_float64", "dt_int8", "dt_uint8", "dt_uint16", "dt_uint32", "dt_uint64", "dt_int64", "dt_boolean"]
+  "lhs_type":["dt_float32", "dt_int32", "dt_int16", "dt_float64", "dt_int8", "dt_uint8", "dt_uint16", "dt_uint32", "dt_uint64", "dt_int64", "dt_boolean", "dt_float16"]
 }
\ No newline at end of file
diff --git a/tests/kernels/test_trilu.cpp b/tests/kernels/test_trilu.cpp
index 34ffa3b50b..c4ed5397b1 100644
--- a/tests/kernels/test_trilu.cpp
+++ b/tests/kernels/test_trilu.cpp
@@ -26,82 +26,81 @@ using namespace nncase;
 using namespace nncase::runtime;
 using namespace ortki;
 
-class TriluTest : public KernelTest,
-                  public ::testing::TestWithParam<
-                      std::tuple<nncase::typecode_t, dims_t, float>> {
+class TriluTest
+    : public KernelTest,
+      public ::testing::TestWithParam<
+          std::tuple<nncase::typecode_t, dims_t, int64_t, int32_t>> {
   public:
     void SetUp() override {
-        auto &&[typecode, l_shape, alpha_value] = GetParam();
+        auto &&[typecode, l_shape, k_value, upper_value] = GetParam();
 
         input =
             hrt::create(typecode, l_shape, host_runtime_tensor::pool_cpu_only)
                 .expect("create tensor failed");
         init_tensor(input);
 
-        alpha = alpha_value;
+        int64_t k_ptr[] = {k_value};
+        k = hrt::create(nncase::dt_int64, {1},
+                        {reinterpret_cast<gsl::byte *>(k_ptr), sizeof(k_ptr)},
+                        true, host_runtime_tensor::pool_cpu_only)
+                .expect("create tensor failed");
+        upper = upper_value;
     }
 
     void TearDown() override {}
 
   protected:
     runtime_tensor input;
-    int64_t alpha;
+    runtime_tensor k;
+    int32_t upper;
 };
 
 INSTANTIATE_TEST_SUITE_P(trilu, TriluTest,
                          testing::Combine(testing::Values(dt_uint8),
                                           testing::Values(dims_t{4, 5}),
-                                          testing::Values(-1)));
+                                          testing::Values(0),
+                                          testing::Values(1)));
 
 TEST_P(TriluTest, trilu) {
     //    auto l_ort = runtime_tensor_2_ort_tensor(input);
-
-    int64_t a_ptr[] = {alpha};
-    auto a = hrt::create(nncase::dt_int64, {1},
-                         {reinterpret_cast<gsl::byte *>(a_ptr), sizeof(a_ptr)},
-                         true, host_runtime_tensor::pool_cpu_only)
-                 .expect("create tensor failed");
-
-    //    todo ort no implement Trilu
-    // expected
-    //    auto output_ort = ortki_Trilu(l_ort, runtime_tensor_2_ort_tensor(a),
-    //    0); size_t size = 0; void *ptr_ort = tensor_buffer(output_ort, &size);
+    //    auto k_ort = runtime_tensor_2_ort_tensor(k);
+    //
+    //    // expected
+    //    auto output_ort = ortki_Trilu(l_ort, k_ort, upper);
+    //    size_t size = 0;
+    //    void *ptr_ort = tensor_buffer(output_ort, &size);
     //    dims_t shape(tensor_rank(output_ort));
     //    tensor_shape(output_ort, reinterpret_cast<int64_t *>(shape.data()));
     //    auto expected = hrt::create(input.datatype(), shape,
     //                                {reinterpret_cast<gsl::byte *>(ptr_ort),
     //                                size}, true,
     //                                host_runtime_tensor::pool_cpu_only)
-    //        .expect("create tensor failed");
+    //                        .expect("create tensor failed");
 
     // actual
-    int32_t upper_ptr[] = {0};
+    int32_t upper_ptr[] = {upper};
     auto upper = hrt::create(nncase::dt_int32, {1},
                              {reinterpret_cast<gsl::byte *>(upper_ptr),
                               sizeof(upper_ptr)},
                              true, host_runtime_tensor::pool_cpu_only)
                      .expect("create tensor failed");
 
-    auto output = kernels::stackvm::trilu(input.impl(), a.impl(), upper.impl())
+    auto output = kernels::stackvm::trilu(input.impl(), k.impl(), upper.impl())
                       .expect("trilu failed");
     runtime_tensor actual(output.as<tensor>().expect("as tensor failed"));
 
-    auto output1 = kernels::stackvm::trilu(input.impl(), a.impl(), upper.impl())
-                       .expect("trilu failed");
-    runtime_tensor expected(output.as<tensor>().expect("as tensor failed"));
-
-    bool result = is_same_tensor(expected, actual) ||
-                  cosine_similarity_tensor(expected, actual);
-
-    if (!result) {
-        std::cout << "actual ";
-        print_runtime_tensor(actual);
-        std::cout << "expected ";
-        print_runtime_tensor(expected);
-    }
-
-    // compare
-    EXPECT_TRUE(result);
+    //    bool result = is_same_tensor(expected, actual) ||
+    //                  cosine_similarity_tensor(expected, actual);
+    //
+    //    if (!result) {
+    //        std::cout << "actual ";
+    //        print_runtime_tensor(actual);
+    //        std::cout << "expected ";
+    //        print_runtime_tensor(expected);
+    //    }
+    //
+    //    // compare
+    //    EXPECT_TRUE(result);
 }
 
 int main(int argc, char *argv[]) {
diff --git a/tests/kernels/test_unsqueeze.cpp b/tests/kernels/test_unsqueeze.cpp
index 5f0523a75a..630c2963ed 100644
--- a/tests/kernels/test_unsqueeze.cpp
+++ b/tests/kernels/test_unsqueeze.cpp
@@ -56,23 +56,11 @@ class UnsqueezeTest : public KernelTest,
 INSTANTIATE_TEST_SUITE_P(Unsqueeze, UnsqueezeTest,
                          testing::Combine(testing::Range(0, MAX_CASE_NUM)));
 
-//    testing::Combine(
-//        testing::Values(dt_float32, dt_int32, dt_int16, dt_float64, dt_int8,
-//                        dt_uint8, dt_uint16, dt_uint32, dt_uint64, dt_int64,
-//                        dt_bfloat16, dt_float16, dt_boolean),
-//        testing::Values(dims_t{24, 24}, dims_t{3, 24, 24}, dims_t{24, 24},
-//                        dims_t{24}, dims_t{1, 3, 16}),
-//        testing::Values(axes_t{0}, axes_t{-1}, axes_t{-2}, axes_t{-3},
-//                        axes_t{1}, axes_t{2}, axes_t{3}, axes_t{0, 1},
-//                        axes_t{0, 2}, axes_t{1, -1},
-//                        /*axes_t{-2, -1},
-//          axes_t{2, 1},*/
-//                        axes_t{-4})));
-
 TEST_P(UnsqueezeTest, Unsqueeze) {
     auto l_ort = runtime_tensor_2_ort_tensor(input);
 
     if (axis_array.size() + input.shape().size() == 4) {
+
         // expected
         size_t axis_size = axis_array.size();
         int64_t *axis_array1 = (int64_t *)malloc(axis_size * sizeof(int64_t));
diff --git a/tests/nuc_proxy.py b/tests/nuc_proxy.py
index ff54ac12ac..bdc647ef68 100644
--- a/tests/nuc_proxy.py
+++ b/tests/nuc_proxy.py
@@ -26,6 +26,7 @@
 import shutil
 import time
 import toml
+from typing import Tuple
 
 
 class MySerial:
@@ -56,21 +57,41 @@ def write(self, cmd):
         self.s.flush()
         self.logger.debug('write end')
 
-    def read_until(self, expected):
-        self.logger.debug('read begin')
-        data = self.s.read_until(expected.encode()).decode()
+    # There is something wrong for self.s.read_until() api, refer to https://github.com/pyserial/pyserial/issues/181
+    def read_until(self, expected: str, size=None) -> Tuple[str, bool]:
+        self.logger.debug('read begin: expected = {0}'.format(expected))
+        if isinstance(expected, str):
+            expected = expected.encode()
+        lenterm = len(expected)
+        data = bytearray()
+        expired = True
+        timeout = serial.Timeout(self.s.timeout)
+        while True:
+            c = self.s.read(1)
+            if c:
+                data += c
+                if data[-lenterm:] == expected:
+                    expired = False
+                    break
+                if size is not None and len(data) >= size:
+                    break
+            else:
+                break
+            if timeout.expired():
+                break
         self.logger.debug('read end: data = {0}, size = {1}'.format(data, len(data)))
-        return data
+        return bytes(data).decode(), expired
 
     def run_cmd(self, cmd, expected=''):
         data = ''
+        expired = False
         self.open()
         self.write(cmd)
         if expected != '':
-            data = self.read_until(expected)
+            data, expired = self.read_until(expected)
 
         self.close()
-        return data
+        return data, expired
 
 
 class Target:
@@ -107,7 +128,7 @@ def reboot(self):
         self.s0.run_cmd(self.username)
         self.s0.run_cmd(self.password)
         self.s0.run_cmd('reboot')
-        time.sleep(20)
+        time.sleep(30)
 
 
 def recv_file(conn, case_dir, logger):
@@ -162,20 +183,21 @@ def infer_worker(target):
         cmds, conn, case_dir, output_num = target.infer_queue.get()
         separator = os.path.basename(case_dir) + target.separator
         ret = ''
+        timeout = False
 
         # exit from face_detect after rebooting
         # target.s1.run_cmd('q')
         target.s1.run_cmd('')
 
         for cmd in cmds.split(';'):
-            ret = target.s1.run_cmd(cmd, separator)
+            ret, timeout = target.s1.run_cmd(cmd, separator)
 
         # infer result
         dict = {'type': 'finish', 'len': 0}
         if ret.find('terminate') != -1 or ret.find('Exception') != -1:
             err = 'infer exception'
             target.logger.error(err)
-            msg = f'{err}: {ret}'.encode()
+            msg = f'{err}'.encode()
             dict['type'] = 'exception'
             dict['len'] = len(msg)
             conn.sendall(json.dumps(dict).encode())
@@ -184,7 +206,7 @@ def infer_worker(target):
 
             # reboot target when exception(it is likely that next test case will fail)
             target.reboot()
-        elif ret.find(separator) == -1:
+        elif timeout:
             err = 'infer timeout'
             target.logger.error(err)
             msg = f'{err}'.encode()
diff --git a/tests/onnx_test_runner.py b/tests/onnx_test_runner.py
index 01623c6ce3..dbde85f780 100644
--- a/tests/onnx_test_runner.py
+++ b/tests/onnx_test_runner.py
@@ -76,7 +76,7 @@ def run(self, model_file):
         if not self.inputs:
             self.parse_model(model_file)
 
-        # model_file = self.do_preprocess(model_file)
+        model_file = self.do_preprocess(model_file)
 
         super().run(model_file)
 
diff --git a/tests/test_runner.py b/tests/test_runner.py
index 935c8ceb8e..60948ac2f2 100644
--- a/tests/test_runner.py
+++ b/tests/test_runner.py
@@ -36,6 +36,7 @@
 from evaluator import *
 from compare_util import *
 from test_utils import *
+from html import escape
 
 
 class TestRunner(Evaluator, Inference, metaclass=ABCMeta):
@@ -67,7 +68,7 @@ def __init__(self, case_name, override_cfg: str = None) -> None:
         # [n, c, h, w].zip default_shape => [(n, 1), (c, 1), (h, 48), (w, 48)]
         self.default_shape = [1, 1, 48, 48, 24, 24]
         self.shape_vars = {}
-        # used for tag dynamic model for onnx simplify
+        # used for tag dynamic model
         self.dynamic = False
 
         if self.cfg['infer_report_opt']['enabled']:
@@ -286,7 +287,8 @@ def run(self, model_file: Union[List[str], str]):
 
                             if stage == 'infer' and self.cfg['infer_report_opt']['enabled']:
                                 self.infer_report_dict['result'] = 'Pass' if judge else 'Fail'
-                                self.infer_report_dict['remark'] = result.replace('\n', '<br/>')
+                                self.infer_report_dict['remark'] = escape(
+                                    result).replace('\n', '<br/>')
                                 prefix, suffix = os.path.splitext(self.infer_report_file)
                                 json_file = f'{prefix}_{os.path.basename(self.case_dir)}{suffix}'
                                 dump_dict_to_json(self.infer_report_dict, json_file)
diff --git a/tests/tflite_test_runner.py b/tests/tflite_test_runner.py
index 772449e462..59867442b1 100644
--- a/tests/tflite_test_runner.py
+++ b/tests/tflite_test_runner.py
@@ -24,6 +24,7 @@ class TfliteTestRunner(TestRunner):
     def __init__(self, case_name, overwrite_configs: str = None):
         super().__init__(case_name, overwrite_configs)
         self.model_type = "tflite"
+        self.interp = None
 
     def from_tensorflow(self, module):
         # export model
@@ -57,33 +58,38 @@ def run(self, model_file):
         super().run(model_file)
 
     def parse_model(self, model_path: str):
-        interp = tf.lite.Interpreter(model_path=model_path)
+        self.interp = tf.lite.Interpreter(model_path=model_path)
 
-        def translate_shape(shape, default_shape):
-            return [(i if i > 0 else d) for i, d in zip(shape, default_shape)]
+        def translate_shape(shape):
+            return [i if i > 0 else self.shape_vars["-1"] for i in shape]
 
-        for item in interp.get_input_details():
+        for item in self.interp.get_input_details():
             input_dict = {}
             input_dict['index'] = item['index']
             input_dict['name'] = item['name']
             input_dict['dtype'] = item['dtype']
-            if item['shape_signature'].size == 0:
+
+            if len(self.shape_vars) == 0:
+                # fixed shape
                 shape = item['shape']
             else:
+                # dynamic shape
                 shape = item['shape_signature']
-            # todo: tflite not support set shape var for model with dynamic shape
-            # don't have model with shape var to debug this feature
+
             if len(shape) <= 4:
-                input_dict['model_shape'] = translate_shape(shape, self.default_shape)
+                input_dict['model_shape'] = translate_shape(shape)
             else:
                 if -1 in shape:
                     raise "tflite test_runner not supported dynamic shape which rank > 4"
                 input_dict['model_shape'] = shape
+
+            if -1 in shape:
+                self.dynamic = True
+                self.interp.resize_tensor_input(item['index'], input_dict['model_shape'])
             self.inputs.append(input_dict)
             self.calibs.append(copy.deepcopy(input_dict))
-            # self.dump_range_data.append(copy.deepcopy(input_dict))
 
-        for item in interp.get_output_details():
+        for item in self.interp.get_output_details():
             output_dict = {}
             output_dict['index'] = item['index']
             output_dict['name'] = item['name']
@@ -92,22 +98,21 @@ def translate_shape(shape, default_shape):
             self.outputs.append(output_dict)
 
     def cpu_infer(self, model_file: bytes):
-        interp = tf.lite.Interpreter(model_path=model_file)
-        interp.allocate_tensors()
+        self.interp.allocate_tensors()
         for idx, value in enumerate(self.inputs):
             new_value = self.transform_input(
                 self.data_pre_process(value['data']), "float32", "CPU")[0]
-            interp.set_tensor(value["index"], new_value)
+            self.interp.set_tensor(value["index"], new_value)
             if self.cfg['compile_opt']['preprocess'] and not test_utils.in_ci():
                 dump_bin_file(os.path.join(self.case_dir, f'frame_input_{idx}.bin'), new_value)
                 dump_txt_file(os.path.join(self.case_dir, f'frame_input_{idx}.txt'), new_value)
 
-        interp.invoke()
+        self.interp.invoke()
 
         i = 0
         results = []
         for output in self.outputs:
-            data = interp.get_tensor(output['index'])
+            data = self.interp.get_tensor(output['index'])
             results.append(data)
             if not test_utils.in_ci():
                 dump_bin_file(os.path.join(self.case_dir, f'cpu_result_{i}.bin'), data)
diff --git a/tests/update_trace_info.py b/tests/update_trace_info.py
index 71cb6f85a9..7cf107f01f 100644
--- a/tests/update_trace_info.py
+++ b/tests/update_trace_info.py
@@ -70,15 +70,12 @@ def update_trace_info(infer_result: str, info_file: str):
         line = buf.readline()
         if not line:
             break
-        print('line = {0}'.format(line))
 
         if status == Status.find_titile:
             title = find_titile(line)
-            print('title = {0}'.format(title))
             if title:
                 status = Status.find_time
                 item_num = find_items(info_file)
-                print('item_num = {0}'.format(item_num))
                 if item_num == -1 or item_num == 0:
                     item_num = -1
                     status = Status.find_titile
@@ -86,12 +83,10 @@ def update_trace_info(infer_result: str, info_file: str):
 
         if status is Status.find_time:
             time = find_time(line)
-            print('time = {0}'.format(time))
             if time:
                 times.append(time)
             if (len(times) == item_num):
                 update_items(info_file, times)
-                print('time updated!')
                 times.clear()
                 status = Status.find_titile
             continue
diff --git a/tools/StyleCopAnalyzers.ruleset b/tools/StyleCopAnalyzers.ruleset
index 387a2e1ac9..d93b2053f8 100644
--- a/tools/StyleCopAnalyzers.ruleset
+++ b/tools/StyleCopAnalyzers.ruleset
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<RuleSet Name="StyleCop.Analyzers rules with default action" Description="StyleCop.Analyzers with default action. Rules with IsEnabledByDefault = false are disabled." ToolsVersion="16.0">
+<RuleSet Name="StyleCop.Analyzers rules with default action" Description="StyleCop.Analyzers with default action. Rules with IsEnabledByDefault = false are disabled." ToolsVersion="17.0">
   <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers.DocumentationRules">
     <Rule Id="SA1600" Action="Hidden" />
     <Rule Id="SA1601" Action="Hidden" />
@@ -86,7 +86,7 @@
     <Rule Id="SA1404" Action="Warning" />
     <Rule Id="SA1405" Action="Warning" />
     <Rule Id="SA1406" Action="Warning" />
-    <Rule Id="SA1407" Action="Warning" />
+    <Rule Id="SA1407" Action="None" />
     <Rule Id="SA1408" Action="Warning" />
     <Rule Id="SA1409" Action="None" />
     <Rule Id="SA1410" Action="Warning" />
@@ -177,6 +177,7 @@
     <Rule Id="SA1101" Action="None" />
     <Rule Id="SA1309" Action="None" />
     <Rule Id="SA1402" Action="None" />
+    <Rule Id="SA1407" Action="None" />
     <Rule Id="SA1600" Action="Hidden" />
     <Rule Id="SA1601" Action="Hidden" />
     <Rule Id="SA1649" Action="None" />

From 8177a980a98a9b55ede2983339d1e9e9e34e1631 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Fri, 3 Nov 2023 06:19:05 +0000
Subject: [PATCH 299/308] Apply code-format changes

---
 src/Nncase.Core/TIR/PrimFunction.cs        | 4 ++--
 src/Nncase.Evaluator/NN/Conv2DTranspose.cs | 2 +-
 src/Nncase.Tests/TIR/UnitTestMutators.cs   | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Nncase.Core/TIR/PrimFunction.cs b/src/Nncase.Core/TIR/PrimFunction.cs
index 360be606a3..e8981ba714 100644
--- a/src/Nncase.Core/TIR/PrimFunction.cs
+++ b/src/Nncase.Core/TIR/PrimFunction.cs
@@ -28,8 +28,8 @@ public sealed class PrimFunction : BaseFunction
     /// <param name="moduleKind">module kind.</param>
     /// <param name="parameters">Arguments.</param>
     /// <param name="body">Body.</param>
-w    public PrimFunction(string name, string moduleKind, Sequential body, ReadOnlySpan<Buffer> parameters)
-        : base(name, moduleKind, ArrayUtility.Concat(body, SpanUtility.UnsafeCast<Buffer, Expr>(parameters)))
+    w public PrimFunction(string name, string moduleKind, Sequential body, ReadOnlySpan<Buffer> parameters)
+            : base(name, moduleKind, ArrayUtility.Concat(body, SpanUtility.UnsafeCast<Buffer, Expr>(parameters)))
     {
     }
 
diff --git a/src/Nncase.Evaluator/NN/Conv2DTranspose.cs b/src/Nncase.Evaluator/NN/Conv2DTranspose.cs
index 66c950fdc7..56ae681279 100644
--- a/src/Nncase.Evaluator/NN/Conv2DTranspose.cs
+++ b/src/Nncase.Evaluator/NN/Conv2DTranspose.cs
@@ -107,7 +107,7 @@ public IValue Visit(IEvaluateContext context, Conv2DTranspose conv)
 
         for (int i = 0; i < outputSize; i++)
         {
-            var biasIdx = (i / (outputShape[2] * outputShape[3])) % outputShape[1];
+            var biasIdx = i / (outputShape[2] * outputShape[3]) % outputShape[1];
             outCache[i] = outCache[i] + biasArray[biasIdx];
         }
 
diff --git a/src/Nncase.Tests/TIR/UnitTestMutators.cs b/src/Nncase.Tests/TIR/UnitTestMutators.cs
index b1e0ceb20e..e115f9eeb6 100644
--- a/src/Nncase.Tests/TIR/UnitTestMutators.cs
+++ b/src/Nncase.Tests/TIR/UnitTestMutators.cs
@@ -80,7 +80,7 @@ public async Task TestFoldConstCallWithTuple()
                 var name = getBuffer(count++, LoadT.GlbPp).Name[^4..];
 
                 // System.Console.WriteLine($"{w} {name}");
-                if (((w / 9) % 2) == 0)
+                if ((w / 9 % 2) == 0)
                 {
                     Assert.Equal("ping", name);
                 }

From 415e8c2c44d0fe135b0426d43053792a1c881612 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 3 Nov 2023 15:01:23 +0800
Subject: [PATCH 300/308] fix merge

---
 docs/ncnn_ops.md                              |   19 +
 examples/user_guide/test.param                |   33 +
 src/Nncase.Cli/Program.cs                     |    6 +-
 src/Nncase.Compiler/CompilerExtensions.cs     |   35 +
 src/Nncase.Core/IR/Buffers/BufferOf.cs        |    2 +-
 src/Nncase.Core/IR/NN/Functional.cs           |    2 +
 .../SubstituteVarAndCollectOpaqueBlock.cs     |   54 +
 src/Nncase.Core/TIR/PrimFunction.cs           |    4 +-
 src/Nncase.IO/ZeroStream.cs                   |   51 +
 src/Nncase.Importer/Ncnn/Concat.cs            |   27 +
 src/Nncase.Importer/Ncnn/Convolution.cs       |  101 ++
 src/Nncase.Importer/Ncnn/InnerProduct.cs      |   43 +
 src/Nncase.Importer/Ncnn/NcnnImporter.cs      |  156 +++
 src/Nncase.Importer/Ncnn/NcnnModel.cs         |  108 ++
 src/Nncase.Importer/Ncnn/NcnnModelBin.cs      |   72 ++
 src/Nncase.Importer/Ncnn/ParamDict.cs         |  119 ++
 src/Nncase.Importer/Ncnn/Pooling.cs           |  127 ++
 src/Nncase.Importer/Ncnn/ShuffleChannel.cs    |   37 +
 src/Nncase.Importer/Ncnn/Softmax.cs           |   27 +
 src/Nncase.Importer/Ncnn/Split.cs             |   25 +
 .../Nncase.Tests.TestFixture.csproj           |   11 +-
 .../packages.lock.json                        | 1152 +++++++----------
 src/Nncase.Tests/Targets/UnitTestCPUTarget.cs |  289 +++++
 src/Nncase.Tests/packages.lock.json           |  629 +--------
 tests/importer/ncnn_/__init__.py              |    0
 tests/importer/ncnn_/basic/__init__.py        |    0
 tests/importer/ncnn_/basic/test_conv2d.py     |   87 ++
 tests/kernels/test_reduce_mean.json           |    8 +
 tests/kernels/test_reduce_prod.json           |    8 +
 tests/kernels/test_reduce_sum.json            |    8 +
 tests/kernels/test_reduce_window_2d.json      |    8 +
 tests/ncnn_test_runner.py                     |  211 +++
 32 files changed, 2121 insertions(+), 1338 deletions(-)
 create mode 100644 docs/ncnn_ops.md
 create mode 100644 examples/user_guide/test.param
 create mode 100644 src/Nncase.Compiler/CompilerExtensions.cs
 create mode 100644 src/Nncase.Core/Passes/Mutators/SubstituteVarAndCollectOpaqueBlock.cs
 create mode 100644 src/Nncase.IO/ZeroStream.cs
 create mode 100644 src/Nncase.Importer/Ncnn/Concat.cs
 create mode 100644 src/Nncase.Importer/Ncnn/Convolution.cs
 create mode 100644 src/Nncase.Importer/Ncnn/InnerProduct.cs
 create mode 100644 src/Nncase.Importer/Ncnn/NcnnImporter.cs
 create mode 100644 src/Nncase.Importer/Ncnn/NcnnModel.cs
 create mode 100644 src/Nncase.Importer/Ncnn/NcnnModelBin.cs
 create mode 100644 src/Nncase.Importer/Ncnn/ParamDict.cs
 create mode 100644 src/Nncase.Importer/Ncnn/Pooling.cs
 create mode 100644 src/Nncase.Importer/Ncnn/ShuffleChannel.cs
 create mode 100644 src/Nncase.Importer/Ncnn/Softmax.cs
 create mode 100644 src/Nncase.Importer/Ncnn/Split.cs
 create mode 100644 src/Nncase.Tests/Targets/UnitTestCPUTarget.cs
 create mode 100644 tests/importer/ncnn_/__init__.py
 create mode 100644 tests/importer/ncnn_/basic/__init__.py
 create mode 100644 tests/importer/ncnn_/basic/test_conv2d.py
 create mode 100644 tests/kernels/test_reduce_mean.json
 create mode 100644 tests/kernels/test_reduce_prod.json
 create mode 100644 tests/kernels/test_reduce_sum.json
 create mode 100644 tests/kernels/test_reduce_window_2d.json
 create mode 100644 tests/ncnn_test_runner.py

diff --git a/docs/ncnn_ops.md b/docs/ncnn_ops.md
new file mode 100644
index 0000000000..a48f321b14
--- /dev/null
+++ b/docs/ncnn_ops.md
@@ -0,0 +1,19 @@
+## Supported ncnn ops
+
+## 支持的 ncnn 算子
+
+| Operator | Is Supported |
+|-------|------------------ |
+| Input | ✅ |
+| Clip | ✅ |
+| Concat | ✅ |
+| Convolution | ✅ |
+| ConvolutionDepthWise | ✅ |
+| HardSigmoid | ✅ |
+| HardSwish | ✅ |
+| Innerproduct | ✅ |
+| Pooling | ✅ |
+| ReLU | ✅ |
+| Sigmoid | ✅ |
+| Softmax | ✅ |
+| Split | ✅ |
diff --git a/examples/user_guide/test.param b/examples/user_guide/test.param
new file mode 100644
index 0000000000..50a81d0bc8
--- /dev/null
+++ b/examples/user_guide/test.param
@@ -0,0 +1,33 @@
+7767517
+31 31
+Input                    data                     0 1 data -23330=4,3,224,224,3 0=224 1=224 2=3
+Convolution              conv1                    1 1 data conv1_relu1 -23330=4,3,112,112,32 0=32 1=3 3=2 4=1 5=1 6=864 9=1
+ConvolutionDepthWise     conv2_1/dw               1 1 conv1_relu1 conv2_1/dw_relu2_1/dw -23330=4,3,112,112,32 0=32 1=3 4=1 5=1 6=288 7=32 9=1
+Convolution              conv2_1/sep              1 1 conv2_1/dw_relu2_1/dw conv2_1/sep_relu2_1/sep -23330=4,3,112,112,64 0=64 1=1 5=1 6=2048 9=1
+ConvolutionDepthWise     conv2_2/dw               1 1 conv2_1/sep_relu2_1/sep conv2_2/dw_relu2_2/dw -23330=4,3,56,56,64 0=64 1=3 3=2 4=1 5=1 6=576 7=64 9=1
+Convolution              conv2_2/sep              1 1 conv2_2/dw_relu2_2/dw conv2_2/sep_relu2_2/sep -23330=4,3,56,56,128 0=128 1=1 5=1 6=8192 9=1
+ConvolutionDepthWise     conv3_1/dw               1 1 conv2_2/sep_relu2_2/sep conv3_1/dw_relu3_1/dw -23330=4,3,56,56,128 0=128 1=3 4=1 5=1 6=1152 7=128 9=1
+Convolution              conv3_1/sep              1 1 conv3_1/dw_relu3_1/dw conv3_1/sep_relu3_1/sep -23330=4,3,56,56,128 0=128 1=1 5=1 6=16384 9=1
+ConvolutionDepthWise     conv3_2/dw               1 1 conv3_1/sep_relu3_1/sep conv3_2/dw_relu3_2/dw -23330=4,3,28,28,128 0=128 1=3 3=2 4=1 5=1 6=1152 7=128 9=1
+Convolution              conv3_2/sep              1 1 conv3_2/dw_relu3_2/dw conv3_2/sep_relu3_2/sep -23330=4,3,28,28,256 0=256 1=1 5=1 6=32768 9=1
+ConvolutionDepthWise     conv4_1/dw               1 1 conv3_2/sep_relu3_2/sep conv4_1/dw_relu4_1/dw -23330=4,3,28,28,256 0=256 1=3 4=1 5=1 6=2304 7=256 9=1
+Convolution              conv4_1/sep              1 1 conv4_1/dw_relu4_1/dw conv4_1/sep_relu4_1/sep -23330=4,3,28,28,256 0=256 1=1 5=1 6=65536 9=1
+ConvolutionDepthWise     conv4_2/dw               1 1 conv4_1/sep_relu4_1/sep conv4_2/dw_relu4_2/dw -23330=4,3,14,14,256 0=256 1=3 3=2 4=1 5=1 6=2304 7=256 9=1
+Convolution              conv4_2/sep              1 1 conv4_2/dw_relu4_2/dw conv4_2/sep_relu4_2/sep -23330=4,3,14,14,512 0=512 1=1 5=1 6=131072 9=1
+ConvolutionDepthWise     conv5_1/dw               1 1 conv4_2/sep_relu4_2/sep conv5_1/dw_relu5_1/dw -23330=4,3,14,14,512 0=512 1=3 4=1 5=1 6=4608 7=512 9=1
+Convolution              conv5_1/sep              1 1 conv5_1/dw_relu5_1/dw conv5_1/sep_relu5_1/sep -23330=4,3,14,14,512 0=512 1=1 5=1 6=262144 9=1
+ConvolutionDepthWise     conv5_2/dw               1 1 conv5_1/sep_relu5_1/sep conv5_2/dw_relu5_2/dw -23330=4,3,14,14,512 0=512 1=3 4=1 5=1 6=4608 7=512 9=1
+Convolution              conv5_2/sep              1 1 conv5_2/dw_relu5_2/dw conv5_2/sep_relu5_2/sep -23330=4,3,14,14,512 0=512 1=1 5=1 6=262144 9=1
+ConvolutionDepthWise     conv5_3/dw               1 1 conv5_2/sep_relu5_2/sep conv5_3/dw_relu5_3/dw -23330=4,3,14,14,512 0=512 1=3 4=1 5=1 6=4608 7=512 9=1
+Convolution              conv5_3/sep              1 1 conv5_3/dw_relu5_3/dw conv5_3/sep_relu5_3/sep -23330=4,3,14,14,512 0=512 1=1 5=1 6=262144 9=1
+ConvolutionDepthWise     conv5_4/dw               1 1 conv5_3/sep_relu5_3/sep conv5_4/dw_relu5_4/dw -23330=4,3,14,14,512 0=512 1=3 4=1 5=1 6=4608 7=512 9=1
+Convolution              conv5_4/sep              1 1 conv5_4/dw_relu5_4/dw conv5_4/sep_relu5_4/sep -23330=4,3,14,14,512 0=512 1=1 5=1 6=262144 9=1
+ConvolutionDepthWise     conv5_5/dw               1 1 conv5_4/sep_relu5_4/sep conv5_5/dw_relu5_5/dw -23330=4,3,14,14,512 0=512 1=3 4=1 5=1 6=4608 7=512 9=1
+Convolution              conv5_5/sep              1 1 conv5_5/dw_relu5_5/dw conv5_5/sep_relu5_5/sep -23330=4,3,14,14,512 0=512 1=1 5=1 6=262144 9=1
+ConvolutionDepthWise     conv5_6/dw               1 1 conv5_5/sep_relu5_5/sep conv5_6/dw_relu5_6/dw -23330=4,3,7,7,512 0=512 1=3 3=2 4=1 5=1 6=4608 7=512 9=1
+Convolution              conv5_6/sep              1 1 conv5_6/dw_relu5_6/dw conv5_6/sep_relu5_6/sep -23330=4,3,7,7,1024 0=1024 1=1 5=1 6=524288 9=1
+ConvolutionDepthWise     conv6/dw                 1 1 conv5_6/sep_relu5_6/sep conv6/dw_relu6/dw -23330=4,3,7,7,1024 0=1024 1=3 4=1 5=1 6=9216 7=1024 9=1
+Convolution              conv6/sep                1 1 conv6/dw_relu6/dw conv6/sep_relu6/sep -23330=4,3,7,7,1024 0=1024 1=1 5=1 6=1048576 9=1
+Pooling                  pool6                    1 1 conv6/sep_relu6/sep pool6 -23330=4,1,1024,1,1 0=1 4=1
+InnerProduct             fc7                      1 1 pool6 fc7 -23330=4,1,1000,1,1 0=1000 1=1 2=1024000
+Softmax                  prob                     1 1 fc7 output -23330=4,1,1000,1,1
diff --git a/src/Nncase.Cli/Program.cs b/src/Nncase.Cli/Program.cs
index d4f0d2aa3e..0ef25c0565 100644
--- a/src/Nncase.Cli/Program.cs
+++ b/src/Nncase.Cli/Program.cs
@@ -34,11 +34,7 @@ private static async Task RunAsync(string targetKind, CompileOptions compileOpti
         var target = CompilerServices.GetTarget(targetKind);
         using var compileSession = CompileSession.Create(target, compileOptions);
         var compiler = compileSession.Compiler;
-        IR.IRModule module;
-        using (var model_stream = File.OpenRead(compileOptions.InputFile))
-        {
-            module = await compiler.ImportModuleAsync(model_stream);
-        }
+        IR.IRModule module = await compiler.ImportModuleAsync(Path.GetExtension(compileOptions.InputFile).Trim('.'), compileOptions.InputFile);
 
         // 3. create the calib dataset
         if (compileOptions.QuantizeOptions.ModelQuantMode == Quantization.ModelQuantMode.UsePTQ)
diff --git a/src/Nncase.Compiler/CompilerExtensions.cs b/src/Nncase.Compiler/CompilerExtensions.cs
new file mode 100644
index 0000000000..431acb2674
--- /dev/null
+++ b/src/Nncase.Compiler/CompilerExtensions.cs
@@ -0,0 +1,35 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IO;
+using Nncase.IR;
+
+namespace Nncase;
+
+public static class CompilerExtensions
+{
+    public static async Task<IRModule> ImportModuleAsync(this ICompiler compiler, string modelFormat, string fileName, bool isBenchmarkOnly = false)
+    {
+        using var fileStream = File.OpenRead(fileName);
+        switch (modelFormat.ToUpperInvariant())
+        {
+            case "TFLITE":
+                return await compiler.ImportTFLiteModuleAsync(fileStream);
+            case "ONNX":
+                return await compiler.ImportOnnxModuleAsync(fileStream);
+            case "NCNN":
+                {
+                    using var binStream = isBenchmarkOnly ? (Stream)new ZeroStream() : File.OpenRead(Path.ChangeExtension(fileName, "bin"));
+                    return await compiler.ImportNcnnModuleAsync(fileStream, binStream);
+                }
+
+            default:
+                throw new NotSupportedException($"Unsupported model format: {modelFormat}");
+        }
+    }
+}
diff --git a/src/Nncase.Core/IR/Buffers/BufferOf.cs b/src/Nncase.Core/IR/Buffers/BufferOf.cs
index a3bb033275..47a2541c1b 100644
--- a/src/Nncase.Core/IR/Buffers/BufferOf.cs
+++ b/src/Nncase.Core/IR/Buffers/BufferOf.cs
@@ -16,7 +16,7 @@ public sealed partial class BufferOf : Op
     /// </summary>
     public static readonly ParameterInfo Input = new(typeof(BufferOf), 0, "input", IsTensor());
 
-    public Schedule.MemoryLocation MemoryLocation { get; }
+    public TIR.MemoryLocation MemoryLocation { get; }
 
     /// <inheritdoc/>
     public override string DisplayProperty() => $"Schedule.MemoryLocation.{MemoryLocation}";
diff --git a/src/Nncase.Core/IR/NN/Functional.cs b/src/Nncase.Core/IR/NN/Functional.cs
index 96daf207d3..e8a44d8a38 100644
--- a/src/Nncase.Core/IR/NN/Functional.cs
+++ b/src/Nncase.Core/IR/NN/Functional.cs
@@ -44,6 +44,8 @@ public static class NN
 
     public static Call LRN(Expr input, Expr alpha, Expr beta, Expr bias, Expr size) => new Call(new LRN(), input, alpha, beta, bias, size);
 
+    public static Call Mish(Expr input) => input * Math.Tanh(Softplus(input));
+
     public static Call HardSigmoid(Expr input, Expr alpha, Expr beta) => new Call(new HardSigmoid(), input, alpha, beta);
 
     public static Call HardSwish(Expr input) => new Call(new HardSwish(), input);
diff --git a/src/Nncase.Core/Passes/Mutators/SubstituteVarAndCollectOpaqueBlock.cs b/src/Nncase.Core/Passes/Mutators/SubstituteVarAndCollectOpaqueBlock.cs
new file mode 100644
index 0000000000..da6daf3ed2
--- /dev/null
+++ b/src/Nncase.Core/Passes/Mutators/SubstituteVarAndCollectOpaqueBlock.cs
@@ -0,0 +1,54 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reactive;
+using Nncase.IR;
+using Nncase.TIR;
+
+namespace Nncase.Passes.Mutators;
+
+/// <summary>
+/// Substitute vars and collect the reuse mapping of opaque blocks.
+/// </summary>
+public sealed class SubstituteVarAndCollectOpaqueBlock : ExprRewriter
+{
+    private readonly Func<Var, Expr?> _varMapper;
+    private readonly Dictionary<Block, Block> _opaqueBlocks;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SubstituteVarAndCollectOpaqueBlock"/> class.
+    /// <see cref="SubstituteVarAndCollectOpaqueBlock"/>.
+    /// </summary>
+    public SubstituteVarAndCollectOpaqueBlock(
+        Func<Var, Expr?> varMaper,
+        Dictionary<Block, Block> opaque_blocks)
+    {
+        _varMapper = varMaper;
+        _opaqueBlocks = opaque_blocks;
+    }
+
+    /// <inheritdoc/>
+    protected override Expr RewriteLeafVar(Var expr)
+    {
+        if (_varMapper(expr) is Expr replace)
+        {
+            return replace;
+        }
+
+        return expr;
+    }
+
+    protected override Expr RewriteLeafBlock(Block expr)
+    {
+        var replace = (Block)base.RewriteLeafBlock(expr);
+        if (replace.IterVars.IsEmpty)
+        {
+            _opaqueBlocks.Add(expr, replace);
+        }
+
+        return replace;
+    }
+}
diff --git a/src/Nncase.Core/TIR/PrimFunction.cs b/src/Nncase.Core/TIR/PrimFunction.cs
index e8981ba714..2bf94454eb 100644
--- a/src/Nncase.Core/TIR/PrimFunction.cs
+++ b/src/Nncase.Core/TIR/PrimFunction.cs
@@ -28,8 +28,8 @@ public sealed class PrimFunction : BaseFunction
     /// <param name="moduleKind">module kind.</param>
     /// <param name="parameters">Arguments.</param>
     /// <param name="body">Body.</param>
-    w public PrimFunction(string name, string moduleKind, Sequential body, ReadOnlySpan<Buffer> parameters)
-            : base(name, moduleKind, ArrayUtility.Concat(body, SpanUtility.UnsafeCast<Buffer, Expr>(parameters)))
+    public PrimFunction(string name, string moduleKind, Sequential body, ReadOnlySpan<Buffer> parameters)
+        : base(name, moduleKind, ArrayUtility.Concat(body, SpanUtility.UnsafeCast<Buffer, Expr>(parameters)))
     {
     }
 
diff --git a/src/Nncase.IO/ZeroStream.cs b/src/Nncase.IO/ZeroStream.cs
new file mode 100644
index 0000000000..c9a18cb43e
--- /dev/null
+++ b/src/Nncase.IO/ZeroStream.cs
@@ -0,0 +1,51 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Nncase.IO;
+
+public sealed class ZeroStream : Stream
+{
+    public override bool CanRead => true;
+
+    public override bool CanSeek => true;
+
+    public override bool CanWrite => false;
+
+    public override long Length => 0;
+
+    public override long Position { get; set; }
+
+    public override void Flush()
+    {
+    }
+
+    public override int Read(byte[] buffer, int offset, int count) => count;
+
+    public override long Seek(long offset, SeekOrigin origin)
+    {
+        switch (origin)
+        {
+            case SeekOrigin.Begin:
+                Position = offset;
+                break;
+            case SeekOrigin.Current:
+                Position += offset;
+                break;
+            case SeekOrigin.End:
+                Position = 0;
+                break;
+        }
+
+        return Position;
+    }
+
+    public override void SetLength(long value) => throw new NotSupportedException();
+
+    public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+}
diff --git a/src/Nncase.Importer/Ncnn/Concat.cs b/src/Nncase.Importer/Ncnn/Concat.cs
new file mode 100644
index 0000000000..2363144d4c
--- /dev/null
+++ b/src/Nncase.Importer/Ncnn/Concat.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.Buffers;
+using Nncase.IR.F;
+using Nncase.IR.NN;
+
+namespace Nncase.Importer.Ncnn;
+
+public partial class NcnnImporter
+{
+    private Expr VisitConcat(NcnnLayer layer)
+    {
+        var axis = layer.ParamDict.Get(0, 0);
+
+        var inputs = GetInputExprs(layer).ToArray();
+        var output = Tensors.Concat(new IR.Tuple(inputs), axis);
+        return output;
+    }
+}
diff --git a/src/Nncase.Importer/Ncnn/Convolution.cs b/src/Nncase.Importer/Ncnn/Convolution.cs
new file mode 100644
index 0000000000..5885feef46
--- /dev/null
+++ b/src/Nncase.Importer/Ncnn/Convolution.cs
@@ -0,0 +1,101 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using Nncase.IR;
+using Nncase.IR.Buffers;
+using Nncase.IR.F;
+using Nncase.IR.NN;
+
+namespace Nncase.Importer.Ncnn;
+
+public partial class NcnnImporter
+{
+    private Expr VisitConvolution(NcnnLayer layer)
+    {
+        var numOutput = layer.ParamDict.Get(0, 0);
+        var kernelW = layer.ParamDict.Get(1, 0);
+        var kernelH = layer.ParamDict.Get(11, kernelW);
+        var dilationW = layer.ParamDict.Get(2, 1);
+        var dilationH = layer.ParamDict.Get(12, dilationW);
+        var strideW = layer.ParamDict.Get(3, 1);
+        var strideH = layer.ParamDict.Get(13, strideW);
+        var padLeft = layer.ParamDict.Get(4, 0);
+        var padRight = layer.ParamDict.Get(15, padLeft);
+        var padTop = layer.ParamDict.Get(14, padLeft);
+        var padBottom = layer.ParamDict.Get(16, padTop);
+        var padValue = layer.ParamDict.Get(18, 0.0f);
+        var biasTerm = layer.ParamDict.Get(5, 0);
+        var weightDataSize = layer.ParamDict.Get(6, 0);
+        var group = layer.ParamDict.Get(7, 1);
+        var activationType = layer.ParamDict.Get(9, 0);
+        var activationParams = layer.ParamDict.Get(10, Tensor<float>.Empty).Buffer.Span;
+
+        var numInput = weightDataSize / numOutput / kernelW / kernelH;
+        var kernelExtentW = (dilationW * (kernelW - 1)) + 1;
+        var kernelExtentH = (dilationH * (kernelH - 1)) + 1;
+
+        if (padValue != 0)
+        {
+            throw new NotSupportedException($"Unsupported pad value: {padValue}.");
+        }
+
+        var input = CHWToNCHW(GetInputExprs(layer, 0));
+
+        Expr[] paddingH;
+        Expr[] paddingW;
+
+        if (padLeft is -233 or -234)
+        {
+            var inShape = Tensors.ShapeOf(input);
+            var w = inShape[3];
+            var h = inShape[2];
+            var padW = kernelExtentW + ((w - 1) / strideW * strideW) - w;
+            var padH = kernelExtentH + ((h - 1) / strideH * strideH) - h;
+
+            if (padLeft == -233)
+            {
+                // SAME_UPPER
+                paddingH = new[] { padH / 2, padH - (padH / 2) };
+                paddingW = new[] { padW / 2, padW - (padW / 2) };
+            }
+            else
+            {
+                // SAME_LOWER
+                paddingH = new[] { padH - (padH / 2), padH / 2 };
+                paddingW = new[] { padW - (padW / 2), padW / 2 };
+            }
+        }
+        else
+        {
+            paddingH = new Expr[] { padTop, padBottom };
+            paddingW = new Expr[] { padLeft, padRight };
+        }
+
+        var stride = Tensor.From(new[] { strideH, strideW }, new[] { 2 });
+        var dilation = Tensor.From(new[] { dilationH, dilationW }, new[] { 2 });
+        var clampRange = ToFloatClampRange(activationType, activationParams);
+        var clamp = Tensor.From(new[] { clampRange.Min, clampRange.Max }, new[] { 2 });
+        var padding = Util.ConcatPadding(paddingH, paddingW);
+        var weights = _modelBin.LoadFloat32(new[] { numOutput, numInput, kernelH, kernelW }, true);
+        var bias = biasTerm != 0 ? _modelBin.LoadFloat32(new[] { numOutput }, false) : Tensor.FromScalar(0f, numOutput);
+
+        var conv2d = NN.Conv2D(input, weights, bias, stride, padding, dilation, PadMode.Constant, group, clamp);
+        conv2d = activationType switch
+        {
+            0 or 1 or 3 => conv2d,
+            2 => NN.LeakyRelu(conv2d, activationParams[0]),
+            4 => NN.Sigmoid(conv2d),
+            5 => NN.Mish(conv2d),
+            _ => throw new NotSupportedException($"Unsupported activation type: {activationType}."),
+        };
+        var output = NCHWToCHW(conv2d);
+        return output;
+    }
+}
diff --git a/src/Nncase.Importer/Ncnn/InnerProduct.cs b/src/Nncase.Importer/Ncnn/InnerProduct.cs
new file mode 100644
index 0000000000..80aeb98bb2
--- /dev/null
+++ b/src/Nncase.Importer/Ncnn/InnerProduct.cs
@@ -0,0 +1,43 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using Nncase.IR;
+using Nncase.IR.Buffers;
+using Nncase.IR.F;
+using Nncase.IR.NN;
+
+namespace Nncase.Importer.Ncnn;
+
+public partial class NcnnImporter
+{
+    private Expr VisitInnerProduct(NcnnLayer layer)
+    {
+        var numOutput = layer.ParamDict.Get(0, 0);
+        var biasTerm = layer.ParamDict.Get(1, 0) != 0;
+        var weightDataSize = layer.ParamDict.Get(2, 0);
+        var activationType = layer.ParamDict.Get(9, 0);
+        var activationParams = layer.ParamDict.Get(10, Tensor<float>.Empty).Buffer.Span;
+
+        var numInput = weightDataSize / numOutput;
+
+        var input = Tensors.Unsqueeze(GetInputExprs(layer, 0), new[] { 0 });
+        var weights = Tensors.Transpose(_modelBin.LoadFloat32(new[] { numOutput, numInput }, true), new[] { 1, 0 });
+
+        Expr output = IR.F.Math.MatMul(input, weights);
+        if (biasTerm)
+        {
+            output += _modelBin.LoadFloat32(new[] { numOutput }, false);
+        }
+
+        output = ApplyActivation(output, activationType, activationParams);
+        output = Tensors.Squeeze(output, new[] { 0 });
+        return output;
+    }
+}
diff --git a/src/Nncase.Importer/Ncnn/NcnnImporter.cs b/src/Nncase.Importer/Ncnn/NcnnImporter.cs
new file mode 100644
index 0000000000..a67542aeab
--- /dev/null
+++ b/src/Nncase.Importer/Ncnn/NcnnImporter.cs
@@ -0,0 +1,156 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using FlatBuffers;
+using LanguageExt;
+using NetFabric.Hyperlinq;
+using Nncase.IR;
+using Nncase.IR.F;
+using Nncase.IR.Math;
+using Nncase.IR.NN;
+using Nncase.IR.Tensors;
+using Math = System.Math;
+using Tuple = Nncase.IR.Tuple;
+
+namespace Nncase.Importer.Ncnn;
+
+/// <summary>
+/// Ncnn importer.
+/// </summary>
+public sealed partial class NcnnImporter : BaseImporter
+{
+    private static readonly Dictionary<tflite.TensorType, DataType> _typeMap = new()
+    {
+        { tflite.TensorType.BOOL, DataTypes.Boolean },
+        { tflite.TensorType.FLOAT16, DataTypes.Float16 },
+        { tflite.TensorType.FLOAT32, DataTypes.Float32 },
+        { tflite.TensorType.FLOAT64, DataTypes.Float64 },
+        { tflite.TensorType.INT16, DataTypes.Int16 },
+        { tflite.TensorType.INT32, DataTypes.Int32 },
+        { tflite.TensorType.INT64, DataTypes.Int64 },
+        { tflite.TensorType.INT8, DataTypes.Int8 },
+        { tflite.TensorType.STRING, DataTypes.Utf8Char },
+        { tflite.TensorType.UINT32, DataTypes.UInt32 },
+        { tflite.TensorType.UINT64, DataTypes.UInt64 },
+        { tflite.TensorType.UINT8, DataTypes.UInt8 },
+    };
+
+    private readonly NcnnModel _model;
+    private readonly NcnnModelBin _modelBin;
+    private readonly Dictionary<string, Expr> _outputTensors = new Dictionary<string, Expr>();
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="NcnnImporter"/> class.
+    /// </summary>
+    /// <param name="ncnnParam">Ncnn param stream.</param>
+    /// <param name="ncnnBin">Ncnn bin stream.</param>
+    /// <param name="compileSession">Compile session.</param>
+    public NcnnImporter(Stream ncnnParam, Stream ncnnBin, CompileSession compileSession)
+        : base(compileSession)
+    {
+        _model = NcnnModel.ParseFromStream(ncnnParam);
+        _modelBin = new NcnnModelBin(ncnnBin);
+    }
+
+    /// <inheritdoc/>
+    protected override (IEnumerable<Var> Inputs, Dictionary<Var, Expr[]> VarMap) CreateInputs()
+    {
+        var inputs = new List<Var>();
+        var varMap = new Dictionary<Var, Expr[]>();
+
+        foreach (var layer in _model.Layers.Where(x => x.Type == "Input"))
+        {
+            var input = new Var(layer.Name, TensorType.Unranked(DataTypes.Float32));
+            inputs.Add(input);
+            _outputTensors.Add(layer.Name, input);
+        }
+
+        return (inputs, varMap);
+    }
+
+    protected override void ConvertOp()
+    {
+        foreach (var layer in _model.Layers.Where(x => x.Type != "Input"))
+        {
+            Visit(layer);
+        }
+    }
+
+    protected override Expr CreateOutputs()
+    {
+        var outputTensors = (from l in _model.Layers
+                             from t in l.Tops
+                             select t).Select((x, i) => (x.Name, i)).ToDictionary(x => x.Name, x => x.i);
+        var unusedTensors = (from t in outputTensors.Keys.Except(from l in _model.Layers
+                                                                 from t in l.Bottoms
+                                                                 select t.Name)
+                             orderby outputTensors[t]
+                             select t).ToArray();
+        var outputs = unusedTensors.Select(x => _outputTensors[x]).ToArray();
+        var body = outputs.Length > 1 ? new IR.Tuple(outputs) : outputs[0];
+        return body;
+    }
+
+    private static Expr CHWToNCHW(Expr expr) =>
+        Tensors.Unsqueeze(expr, new[] { 0 });
+
+    private static Expr NCHWToCHW(Expr expr) =>
+        Tensors.Squeeze(expr, new[] { 0 });
+
+    private static ValueRange<float> ToFloatClampRange(int activationType, ReadOnlySpan<float> activationParams) =>
+        activationType switch
+        {
+            1 => new(0, float.PositiveInfinity),
+            3 => new(activationParams[0], activationParams[1]),
+            _ => ValueRange<float>.Full,
+        };
+
+    private static Expr ApplyActivation(Expr input, int activationType, ReadOnlySpan<float> activationParams) =>
+        activationType switch
+        {
+            0 => input,
+            1 => NN.Relu(input),
+            2 => NN.LeakyRelu(input, activationParams[0]),
+            3 => IR.F.Math.Clamp(input, activationParams[0], activationParams[1]),
+            4 => NN.Sigmoid(input),
+            5 => NN.Mish(input),
+            _ => throw new NotSupportedException($"Unsupported activation type: {activationType}."),
+        };
+
+    private void Visit(NcnnLayer layer)
+    {
+        var output = layer.Type switch
+        {
+            "Concat" => VisitConcat(layer),
+            "Convolution" => VisitConvolution(layer),
+            "ConvolutionDepthWise" => VisitConvolution(layer),
+            "InnerProduct" => VisitInnerProduct(layer),
+            "Pooling" => VisitPooling(layer),
+            "ShuffleChannel" => VisitShuffleChannel(layer),
+            "Softmax" => VisitSoftmax(layer),
+            "Split" => VisitSplit(layer),
+            _ => UnSupportedOp(layer.Type),
+        };
+
+        var outputNames = layer.Tops.Select(x => x.Name).ToArray();
+        output.Metadata.OutputNames = outputNames;
+        AddToOutputs(_outputTensors, outputNames, output);
+    }
+
+    private Expr GetInputExprs(NcnnLayer layer, int index) =>
+        _outputTensors[layer.Bottoms[index].Name];
+
+    private (Expr Expr0, Expr Expr1) GetInputExprs(NcnnLayer layer, int index0, int index1) =>
+        (GetInputExprs(layer, index0), GetInputExprs(layer, index1));
+
+    private IEnumerable<Expr> GetInputExprs(NcnnLayer layer) =>
+        layer.Bottoms.Select(x => _outputTensors[x.Name]);
+}
diff --git a/src/Nncase.Importer/Ncnn/NcnnModel.cs b/src/Nncase.Importer/Ncnn/NcnnModel.cs
new file mode 100644
index 0000000000..ec67287e97
--- /dev/null
+++ b/src/Nncase.Importer/Ncnn/NcnnModel.cs
@@ -0,0 +1,108 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+
+namespace Nncase.Importer.Ncnn;
+
+internal class NcnnTensor
+{
+    public string Name { get; set; } = string.Empty;
+
+    public Shape ShapeHint { get; set; } = Shape.Unranked;
+
+    public override string ToString() => $"{Name}: {ShapeHint}";
+}
+
+internal class NcnnLayer
+{
+    public NcnnLayer(string type, string name, int bottomCount, int topCount)
+    {
+        Type = type;
+        Name = name;
+        Bottoms = new NcnnTensor[bottomCount];
+        Tops = new NcnnTensor[topCount];
+    }
+
+    public string Type { get; }
+
+    public string Name { get; }
+
+    public NcnnTensor[] Bottoms { get; }
+
+    public NcnnTensor[] Tops { get; }
+
+    public ParamDict ParamDict { get; } = new();
+
+    public override string ToString() => $"[{Type}] {Name}";
+}
+
+internal class NcnnModel
+{
+    public static readonly int ExpectedMagic = 7767517;
+
+    public NcnnModel(int magic, IReadOnlyList<NcnnLayer> layers)
+    {
+        Magic = magic;
+        Layers = layers;
+    }
+
+    public int Magic { get; }
+
+    public IReadOnlyList<NcnnLayer> Layers { get; }
+
+    public static NcnnModel ParseFromStream(Stream stream)
+    {
+        using var reader = new StreamReader(stream, leaveOpen: true);
+        if (reader.ReadLine() is not string magicStr)
+        {
+            throw new InvalidDataException("parse magic failed");
+        }
+
+        if (reader.ReadLine()?.Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) is not[var layerCountStr, var blobCountStr])
+        {
+            throw new InvalidDataException("parse layer_count or blob_count failed");
+        }
+
+        var magic = int.Parse(magicStr);
+        if (magic != ExpectedMagic)
+        {
+            throw new InvalidDataException("param is too old, please regenerate");
+        }
+
+        var layerCount = int.Parse(layerCountStr);
+        var blobCount = int.Parse(blobCountStr);
+        if (layerCount <= 0 || blobCount <= 0)
+        {
+            throw new InvalidDataException("invalid layer_count or blob_count");
+        }
+
+        var layers = new NcnnLayer[layerCount];
+        foreach (ref var layer in layers.AsSpan())
+        {
+            var fields = reader.ReadLine()!.Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+            layer = new NcnnLayer(fields[0], fields[1], int.Parse(fields[2]), int.Parse(fields[3]));
+
+            int cntFieldIndex = 4;
+            foreach (ref var bottom in layer.Bottoms.AsSpan())
+            {
+                bottom = new NcnnTensor { Name = fields[cntFieldIndex++] };
+            }
+
+            foreach (ref var top in layer.Tops.AsSpan())
+            {
+                top = new NcnnTensor { Name = fields[cntFieldIndex++] };
+            }
+
+            layer.ParamDict.LoadFrom(fields.AsSpan(cntFieldIndex));
+        }
+
+        return new NcnnModel(magic, layers);
+    }
+}
diff --git a/src/Nncase.Importer/Ncnn/NcnnModelBin.cs b/src/Nncase.Importer/Ncnn/NcnnModelBin.cs
new file mode 100644
index 0000000000..a0d60bdc03
--- /dev/null
+++ b/src/Nncase.Importer/Ncnn/NcnnModelBin.cs
@@ -0,0 +1,72 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Toolkit.HighPerformance;
+
+namespace Nncase.Importer.Ncnn;
+
+internal class NcnnModelBin
+{
+    private readonly Stream _stream;
+
+    public NcnnModelBin(Stream stream)
+    {
+        _stream = stream;
+    }
+
+    public Tensor<float> LoadFloat32(ReadOnlySpan<int> shape, bool detectType)
+    {
+        if (!detectType)
+        {
+            var tensor = new Tensor<float>(shape);
+            _stream.ReadExactly(tensor.BytesBuffer);
+            return tensor;
+        }
+        else
+        {
+            return LoadAuto(shape).Cast<float>();
+        }
+    }
+
+    public Tensor LoadAuto(ReadOnlySpan<int> shape)
+    {
+        uint tag;
+        Unsafe.SkipInit(out tag);
+        _stream.ReadExactly(MemoryMarshal.CreateSpan(ref tag, 1).AsBytes());
+
+        if (tag == 0x01306B47)
+        {
+            // half-precision data
+            var tensor = new Tensor<Half>(shape);
+            _stream.ReadExactly(tensor.BytesBuffer);
+            AlignStream(_stream, tensor.BytesBuffer.Length, 4);
+            return tensor.Cast<float>(CastMode.KDefault);
+        }
+        else if (tag == 0)
+        {
+            // raw data
+            var tensor = new Tensor<float>(shape);
+            _stream.ReadExactly(tensor.BytesBuffer);
+            return tensor;
+        }
+        else
+        {
+            throw new NotSupportedException($"Unsupported weight tag: {tag}.");
+        }
+    }
+
+    private static void AlignStream(Stream stream, int size, int alignment)
+    {
+        var rem = size % alignment;
+        var offset = rem == 0 ? 0 : alignment - rem;
+        stream.Seek(offset, SeekOrigin.Current);
+    }
+}
diff --git a/src/Nncase.Importer/Ncnn/ParamDict.cs b/src/Nncase.Importer/Ncnn/ParamDict.cs
new file mode 100644
index 0000000000..bc5c77e6d7
--- /dev/null
+++ b/src/Nncase.Importer/Ncnn/ParamDict.cs
@@ -0,0 +1,119 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Google.Protobuf.WellKnownTypes;
+using Nncase.IR;
+
+namespace Nncase.Importer.Ncnn;
+
+internal enum ParamKind
+{
+    Null,
+    IntOrFloat,
+    Int,
+    Float,
+    ArrayOfIntOrFloat,
+    ArrayOfInt,
+    ArrayOfFloat,
+}
+
+internal struct ParamValue
+{
+    public ParamKind Kind;
+
+    public int IntValue;
+
+    public float FloatValue;
+
+    public Tensor? TensorValue;
+}
+
+internal class ParamDict
+{
+    public static readonly int NcnnMaxParamCount = 32;
+
+    private readonly Dictionary<int, ParamValue> _values = new();
+
+    public void LoadFrom(ReadOnlySpan<string> fields)
+    {
+        foreach (var field in fields)
+        {
+            if (field.Split('=', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) is not[var idStr, var valueStr])
+            {
+                break;
+            }
+
+            var id = int.Parse(idStr);
+            if (id >= NcnnMaxParamCount)
+            {
+                throw new InvalidDataException($"id < NCNN_MAX_PARAM_COUNT failed (id={id}, NCNN_MAX_PARAM_COUNT={NcnnMaxParamCount})");
+            }
+
+            var paramValue = default(ParamValue);
+            var isArray = id <= -23300;
+            var isFloat = valueStr.AsSpan().IndexOfAny('.', 'e', 'E') != -1;
+            if (isArray)
+            {
+                id = -id - 23300;
+                var elements = valueStr.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+                if (elements == null || elements.Length == 0)
+                {
+                    throw new InvalidDataException("ParamDict read array length failed");
+                }
+
+                var length = int.Parse(elements[0]);
+                if (isFloat)
+                {
+                    var value = new Tensor<float>(length);
+                    for (var i = 0; i < length; i++)
+                    {
+                        value[i] = float.Parse(elements[i + 1]);
+                    }
+
+                    paramValue.Kind = ParamKind.ArrayOfFloat;
+                    paramValue.TensorValue = value;
+                }
+                else
+                {
+                    var value = new Tensor<int>(length);
+                    for (var i = 1; i < length; i++)
+                    {
+                        value[i] = int.Parse(elements[i + 1]);
+                    }
+
+                    paramValue.Kind = ParamKind.ArrayOfInt;
+                    paramValue.TensorValue = value;
+                }
+            }
+            else
+            {
+                if (isFloat)
+                {
+                    paramValue.Kind = ParamKind.Float;
+                    paramValue.FloatValue = float.Parse(valueStr);
+                }
+                else
+                {
+                    paramValue.Kind = ParamKind.Int;
+                    paramValue.IntValue = int.Parse(valueStr);
+                }
+            }
+
+            _values.Add(id, paramValue);
+        }
+    }
+
+    public int Get(int id, int defaultValue) => _values.TryGetValue(id, out var value) ? value.IntValue : defaultValue;
+
+    public float Get(int id, float defaultValue) => _values.TryGetValue(id, out var value) ? value.FloatValue : defaultValue;
+
+    public Tensor<T> Get<T>(int id, Tensor<T> defaultValue)
+        where T : unmanaged, IEquatable<T>
+        => _values.TryGetValue(id, out var value) ? value.TensorValue!.Cast<T>() : defaultValue;
+}
diff --git a/src/Nncase.Importer/Ncnn/Pooling.cs b/src/Nncase.Importer/Ncnn/Pooling.cs
new file mode 100644
index 0000000000..edc486d71d
--- /dev/null
+++ b/src/Nncase.Importer/Ncnn/Pooling.cs
@@ -0,0 +1,127 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.Buffers;
+using Nncase.IR.F;
+using Nncase.IR.NN;
+
+namespace Nncase.Importer.Ncnn;
+
+public partial class NcnnImporter
+{
+    private Expr VisitPooling(NcnnLayer layer)
+    {
+        var poolingType = layer.ParamDict.Get(0, 0);
+        var kernelW = layer.ParamDict.Get(1, 0);
+        var kernelH = layer.ParamDict.Get(11, kernelW);
+        var strideW = layer.ParamDict.Get(2, 1);
+        var strideH = layer.ParamDict.Get(12, strideW);
+        var padLeft = layer.ParamDict.Get(3, 0);
+        var padRight = layer.ParamDict.Get(14, padLeft);
+        var padTop = layer.ParamDict.Get(13, padLeft);
+        var padBottom = layer.ParamDict.Get(15, padTop);
+        var globalPooling = layer.ParamDict.Get(4, 0) != 0;
+        var padMode = layer.ParamDict.Get(5, 0);
+        var avgpoolCountIncludePad = layer.ParamDict.Get(6, 0) != 0;
+        var adaptivePooling = layer.ParamDict.Get(7, 0) != 0;
+        var outW = layer.ParamDict.Get(8, 0);
+        var outH = layer.ParamDict.Get(18, outW);
+
+        Expr pooling;
+        var input = CHWToNCHW(GetInputExprs(layer, 0));
+        (var reduceOp, var initValue) = poolingType switch
+        {
+            0 => (ReduceOp.Max, float.NegativeInfinity),
+            1 => (ReduceOp.Mean, 0f),
+            _ => throw new NotSupportedException($"Unsupported pooling type: {poolingType}."),
+        };
+        var filter = Tensor.From(new[] { kernelH, kernelW }, new[] { 2 });
+        var stride = Tensor.From(new[] { strideH, strideW }, new[] { 2 });
+        var dilation = Tensor.FromScalar(0, new[] { 2, 2 });
+
+        if (globalPooling)
+        {
+            pooling = Tensors.Reduce(reduceOp, input, new[] { 2, 3 }, initValue, false);
+        }
+        else if (adaptivePooling)
+        {
+            var padding = Tensor.FromScalar(0, new[] { 2, 2 });
+            var inShape = Tensors.ShapeOf(input);
+            var w = inShape[3];
+            var h = inShape[2];
+            var kernelExtentH = h - outH + 1;
+            var kernelExtentW = w - outW + 1;
+            var adaptiveFilter = Tensors.Stack(new IR.Tuple(kernelExtentH, kernelExtentW), 0);
+            var adaptiveStride = Tensor.FromScalar(1, 2);
+
+            pooling = NN.ReduceWindow2D(reduceOp, input, initValue, adaptiveFilter, adaptiveStride, padding, dilation, false, avgpoolCountIncludePad);
+        }
+        else
+        {
+            Expr[] paddingH;
+            Expr[] paddingW;
+
+            if (padMode == 1)
+            {
+                // valid padding
+                paddingH = new Expr[] { padTop, padBottom };
+                paddingW = new Expr[] { padLeft, padRight };
+            }
+            else
+            {
+                var inShape = Tensors.ShapeOf(input);
+                var w = inShape[3];
+                var h = inShape[2];
+
+                if (padMode == 0)
+                {
+                    // full padding
+                    var tailW = (w + padLeft + padRight - kernelW) % strideW;
+                    var tailH = (h + padTop + padBottom - kernelH) % strideH;
+
+                    var tailPadW = IR.F.Math.Select(IR.F.Math.Equal(tailW, 0), 0, tailW);
+                    var tailPadH = IR.F.Math.Select(IR.F.Math.Equal(tailH, 0), 0, tailH);
+
+                    paddingH = new Expr[] { padTop, padBottom + tailPadH };
+                    paddingW = new Expr[] { padLeft, padRight + tailPadW };
+                }
+                else if (padMode is 2 or 3)
+                {
+                    // valid padding
+                    var padH = kernelH + ((h - 1) / strideH * strideH) - h;
+                    var padW = kernelW + ((w - 1) / strideW * strideW) - w;
+
+                    if (padMode == 2)
+                    {
+                        // tensorflow padding=SAME or onnx padding=SAME_UPPER
+                        paddingH = new Expr[] { padH / 2, padH - (padH / 2) };
+                        paddingW = new Expr[] { padW / 2, padW - (padW / 2) };
+                    }
+                    else
+                    {
+                        // onnx padding=SAME_LOWER
+                        paddingH = new Expr[] { padH - (padH / 2), padH / 2 };
+                        paddingW = new Expr[] { padW - (padW / 2), padW / 2 };
+                    }
+                }
+                else
+                {
+                    throw new NotSupportedException($"Unsupported pad mode: {padMode}.");
+                }
+            }
+
+            var padding = Util.ConcatPadding(paddingH, paddingW);
+            pooling = NN.ReduceWindow2D(reduceOp, input, initValue, filter, stride, padding, dilation, false, avgpoolCountIncludePad);
+        }
+
+        var output = NCHWToCHW(pooling);
+        return output;
+    }
+}
diff --git a/src/Nncase.Importer/Ncnn/ShuffleChannel.cs b/src/Nncase.Importer/Ncnn/ShuffleChannel.cs
new file mode 100644
index 0000000000..dd4f760951
--- /dev/null
+++ b/src/Nncase.Importer/Ncnn/ShuffleChannel.cs
@@ -0,0 +1,37 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.Buffers;
+using Nncase.IR.F;
+using Nncase.IR.NN;
+
+namespace Nncase.Importer.Ncnn;
+
+public partial class NcnnImporter
+{
+    private Expr VisitShuffleChannel(NcnnLayer layer)
+    {
+        var group = layer.ParamDict.Get(0, 1);
+        var reverse = layer.ParamDict.Get(1, 0) != 0;
+
+        var input = GetInputExprs(layer, 0);
+        var inShape = Tensors.ShapeOf(input);
+        var channels = inShape[0];
+        var h = inShape[1];
+        var w = inShape[2];
+        var realGroup = reverse ? channels / group : (Expr)group;
+        var channelsPerGroup = channels / realGroup;
+
+        var rshape1 = Tensors.Reshape(input, Tensors.Stack(new IR.Tuple(realGroup, channelsPerGroup, h, w), 0));
+        var tp = Tensors.Transpose(rshape1, new[] { 1, 0, 2, 3 });
+        var output = Tensors.Reshape(tp, Tensors.Stack(new IR.Tuple(channels, h, w), 0));
+        return output;
+    }
+}
diff --git a/src/Nncase.Importer/Ncnn/Softmax.cs b/src/Nncase.Importer/Ncnn/Softmax.cs
new file mode 100644
index 0000000000..0e1744992b
--- /dev/null
+++ b/src/Nncase.Importer/Ncnn/Softmax.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.Buffers;
+using Nncase.IR.F;
+using Nncase.IR.NN;
+
+namespace Nncase.Importer.Ncnn;
+
+public partial class NcnnImporter
+{
+    private Expr VisitSoftmax(NcnnLayer layer)
+    {
+        var axis = layer.ParamDict.Get(0, 0);
+
+        var input = GetInputExprs(layer, 0);
+        var output = NN.Softmax(input, axis);
+        return output;
+    }
+}
diff --git a/src/Nncase.Importer/Ncnn/Split.cs b/src/Nncase.Importer/Ncnn/Split.cs
new file mode 100644
index 0000000000..a6327ee653
--- /dev/null
+++ b/src/Nncase.Importer/Ncnn/Split.cs
@@ -0,0 +1,25 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nncase.IR;
+using Nncase.IR.Buffers;
+using Nncase.IR.F;
+using Nncase.IR.NN;
+
+namespace Nncase.Importer.Ncnn;
+
+public partial class NcnnImporter
+{
+    private Expr VisitSplit(NcnnLayer layer)
+    {
+        var input = GetInputExprs(layer, 0);
+        var output = new IR.Tuple(Enumerable.Repeat(input, layer.Tops.Length).ToArray());
+        return output;
+    }
+}
diff --git a/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj b/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
index 3e1336e99c..18e43d118d 100644
--- a/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
+++ b/src/Nncase.Tests.TestFixture/Nncase.Tests.TestFixture.csproj
@@ -4,13 +4,15 @@
         <ImplicitUsings>enable</ImplicitUsings>
         <RootNamespace>Nncase.Tests</RootNamespace>
     </PropertyGroup>
-    
+
     <ItemGroup>
+        <PackageVersion Include="NETStandard.Library" Version="2.0.3" />
         <PackageReference Include="Fody">
-          <PrivateAssets>all</PrivateAssets>
-          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
         <PackageReference Include="MethodBoundaryAspect.Fody" />
+        <PackageReference Include="NETStandard.Library" />
         <PackageReference Include="Xunit.Combinatorial" />
         <PackageReference Include="Xunit.DependencyInjection" />
         <PackageReference Include="System.Linq.Async" />
@@ -20,9 +22,10 @@
         </PackageReference>
         <PackageReference Include="xunit.v3.assert" />
     </ItemGroup>
-    
+
     <ItemGroup>
         <ProjectReference Include="..\..\modules\Nncase.Modules.StackVM\Nncase.Modules.StackVM.csproj" />
+        <ProjectReference Include="..\Nncase.Compiler\Nncase.Compiler.csproj" />
         <ProjectReference Include="..\Nncase.Core\Nncase.Core.csproj" />
         <ProjectReference Include="..\Nncase.CodeGen\Nncase.CodeGen.csproj" />
         <ProjectReference Include="..\Nncase.Simulator\Nncase.Simulator.csproj" />
diff --git a/src/Nncase.Tests.TestFixture/packages.lock.json b/src/Nncase.Tests.TestFixture/packages.lock.json
index a01c8fb4ff..b70a73730e 100644
--- a/src/Nncase.Tests.TestFixture/packages.lock.json
+++ b/src/Nncase.Tests.TestFixture/packages.lock.json
@@ -17,6 +17,15 @@
           "Fody": "6.0.5"
         }
       },
+      "NETStandard.Library": {
+        "type": "Direct",
+        "requested": "[2.0.3, )",
+        "resolved": "2.0.3",
+        "contentHash": "st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "1.1.0"
+        }
+      },
       "StyleCop.Analyzers": {
         "type": "Direct",
         "requested": "[1.2.0-beta.435, )",
@@ -134,12 +143,18 @@
         "resolved": "6.0.0",
         "contentHash": "UcSjPsst+DfAdJGVDsu346FX0ci0ah+lw3WRtn18NUwEqRt70HaOQ7lI72vy3+1LxtqI3T5GWwV39rQSrCzAeg=="
       },
+      "Microsoft.CSharp": {
+        "type": "Transitive",
+        "resolved": "4.7.0",
+        "contentHash": "pTj+D3uJWyN3My70i2Hqo+OXixq3Os2D1nJ2x92FFo6sk8fYS1m1WLNTs0Dc1uPaViH0YvEEwvzddQ7y4rhXmA=="
+      },
       "Microsoft.Extensions.Configuration": {
         "type": "Transitive",
-        "resolved": "2.1.0",
-        "contentHash": "SS8ce1GYQTkZoOq5bskqQ+m7xiXQjnKRiGfVNZkkX2SX0HpXNRsKnSUaywRRuCje3v2KT9xeacsM3J9/G2exsQ==",
+        "resolved": "6.0.0",
+        "contentHash": "tq2wXyh3fL17EMF2bXgRhU7JrbO3on93MRKYxzz4JzzvuGSA1l0W3GI9/tl8EO89TH+KWEymP7bcFway6z9fXg==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "2.1.0"
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Primitives": "6.0.0"
         }
       },
       "Microsoft.Extensions.Configuration.Abstractions": {
@@ -152,418 +167,340 @@
       },
       "Microsoft.Extensions.Configuration.Binder": {
         "type": "Transitive",
-        "resolved": "2.1.0",
-        "contentHash": "Fls0O54Ielz1DiVYpcmiUpeizN1iKGGI5yAWAoShfmUvMcQ8jAGOK1a+DaflHA5hN9IOKvmSos0yewDYAIY0ZA==",
+        "resolved": "6.0.0",
+        "contentHash": "b3ErKzND8LIC7o08QAVlKfaEIYEvLJbtmVbFZVBRXeu9YkKfSSzLZfR1SUfQPBIy9mKLhEtJgGYImkcMNaKE0A==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration": "2.1.0"
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0"
         }
       },
-      "Microsoft.Extensions.DependencyInjection": {
+      "Microsoft.Extensions.Configuration.CommandLine": {
         "type": "Transitive",
-        "resolved": "2.1.0",
-        "contentHash": "gqQviLfuA31PheEGi+XJoZc1bc9H9RsPa9Gq9XuDct7XGWSR9eVXjK5Sg7CSUPhTFHSuxUFY12wcTYLZ4zM1hg==",
+        "resolved": "6.0.0",
+        "contentHash": "3nL1qCkZ1Oxx14ZTzgo4MmlO7tso7F+TtMZAY2jUAtTLyAcDp+EDjk3RqafoKiNaePyPvvlleEcBxh3b2Hzl1g==",
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.1.0"
+          "Microsoft.Extensions.Configuration": "6.0.0",
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0"
         }
       },
-      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+      "Microsoft.Extensions.Configuration.EnvironmentVariables": {
         "type": "Transitive",
         "resolved": "6.0.0",
-        "contentHash": "xlzi2IYREJH3/m6+lUrQlujzX8wDitm4QGnUu6kUXTQAWPuZY8i+ticFJbzfqaetLA6KR/rO6Ew/HuYD+bxifg=="
+        "contentHash": "DjYkzqvhiHCq38LW71PcIxXk6nhtV6VySP9yDcSO0goPl7YCU1VG1f2Wbgy58lkA10pWkjHCblZPUyboCB93ZA==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration": "6.0.0",
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0"
+        }
       },
-      "Microsoft.Extensions.FileProviders.Abstractions": {
+      "Microsoft.Extensions.Configuration.FileExtensions": {
         "type": "Transitive",
         "resolved": "6.0.0",
-        "contentHash": "0pd4/fho0gC12rQswaGQxbU34jOS1TPS8lZPpkFCH68ppQjHNHYle9iRuHeev1LhrJ94YPvzcRd8UmIuFk23Qw==",
+        "contentHash": "V4Dth2cYMZpw3HhGw9XUDIijpI6gN+22LDt0AhufIgOppCUfpWX4483OmN+dFXRJkJLc8Tv0Q8QK+1ingT2+KQ==",
         "dependencies": {
+          "Microsoft.Extensions.Configuration": "6.0.0",
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileProviders.Physical": "6.0.0",
           "Microsoft.Extensions.Primitives": "6.0.0"
         }
       },
-      "Microsoft.Extensions.FileProviders.Physical": {
+      "Microsoft.Extensions.Configuration.Json": {
         "type": "Transitive",
-        "resolved": "2.1.0",
-        "contentHash": "A9xLomqD4tNFqDfleapx2C14ZcSjCTzn/4Od0W/wBYdlLF2tYDJ204e75HjpWDVTkr03kgdZbM3QZ6ZeDsrBYg==",
+        "resolved": "6.0.0",
+        "contentHash": "GJGery6QytCzS/BxJ96klgG9in3uH26KcUBbiVG/coNDXCRq6LGVVlUT4vXq34KPuM+R2av+LeYdX9h4IZOCUg==",
         "dependencies": {
-          "Microsoft.Extensions.FileProviders.Abstractions": "2.1.0",
-          "Microsoft.Extensions.FileSystemGlobbing": "2.1.0"
+          "Microsoft.Extensions.Configuration": "6.0.0",
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Configuration.FileExtensions": "6.0.0",
+          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0",
+          "System.Text.Json": "6.0.0"
         }
       },
-      "Microsoft.Extensions.FileSystemGlobbing": {
+      "Microsoft.Extensions.Configuration.UserSecrets": {
         "type": "Transitive",
-        "resolved": "2.1.0",
-        "contentHash": "JEwwhwbVTEXJu4W4l/FFx7FG9Fh5R8999mZl6qJImjM/LY4DxQsFYzpSkziMdY022n7TQpNUxJlH9bKZc7TqWw=="
-      },
-      "Microsoft.Extensions.Logging": {
-        "type": "Transitive",
-        "resolved": "2.1.0",
-        "contentHash": "kuZbZMMHb7ibzhLdn9/R1+PAAFKntlF10tOw4loB8VuQkHvSrBE6IzW1rhBLsEdmLXOgi2zFbwcXFrxzSM6ybA==",
+        "resolved": "6.0.0",
+        "contentHash": "lB0Hb2V4+RUHy+LjEcqEr4EcV4RWc9EnjAV2GdtWQEdljQX+R4hGREftI7sInU9okP93pDrJiaj6QUJ6ZsslOA==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration.Binder": "2.1.0",
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.1.0",
-          "Microsoft.Extensions.Logging.Abstractions": "2.1.0",
-          "Microsoft.Extensions.Options": "2.1.0"
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Configuration.Json": "6.0.0",
+          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileProviders.Physical": "6.0.0"
         }
       },
-      "Microsoft.Extensions.Primitives": {
+      "Microsoft.Extensions.DependencyInjection": {
         "type": "Transitive",
         "resolved": "6.0.0",
-        "contentHash": "9+PnzmQFfEFNR9J2aDTfJGGupShHjOuGw4VUv+JB044biSHrnmCIMD+mJHmb2H7YryrfBEXDurxQ47gJZdCKNQ==",
+        "contentHash": "k6PWQMuoBDGGHOQTtyois2u4AwyVcIwL2LaSLlTZQm2CYcJ1pxbt6jfAnpWmzENA/wfrYRI/X9DTLoUkE4AsLw==",
         "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
           "System.Runtime.CompilerServices.Unsafe": "6.0.0"
         }
       },
-      "Microsoft.NETCore.Platforms": {
-        "type": "Transitive",
-        "resolved": "1.0.1",
-        "contentHash": "2G6OjjJzwBfNOO8myRV/nFrbTw5iA+DEm0N+qUqhrOmaVtn4pC77h38I1jsXGw5VH55+dPfQsqHD0We9sCl9FQ=="
-      },
-      "Microsoft.NETCore.Targets": {
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "Transitive",
-        "resolved": "1.0.1",
-        "contentHash": "rkn+fKobF/cbWfnnfBOQHKVKIOpxMZBvlSHkqDWgBpwGDcLRduvs3D9OLGeV6GWGvVwNlVi2CBbTjuPmtHvyNw=="
+        "resolved": "6.0.0",
+        "contentHash": "xlzi2IYREJH3/m6+lUrQlujzX8wDitm4QGnUu6kUXTQAWPuZY8i+ticFJbzfqaetLA6KR/rO6Ew/HuYD+bxifg=="
       },
-      "Microsoft.Win32.Primitives": {
+      "Microsoft.Extensions.FileProviders.Abstractions": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "fQnBHO9DgcmkC9dYSJoBqo6sH1VJwJprUHh8F3hbcRlxiQiBUuTntdk8tUwV490OqC2kQUrinGwZyQHTieuXRA==",
+        "resolved": "6.0.0",
+        "contentHash": "0pd4/fho0gC12rQswaGQxbU34jOS1TPS8lZPpkFCH68ppQjHNHYle9iRuHeev1LhrJ94YPvzcRd8UmIuFk23Qw==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
+          "Microsoft.Extensions.Primitives": "6.0.0"
         }
       },
-      "NetFabric.Hyperlinq.Abstractions": {
-        "type": "Transitive",
-        "resolved": "1.3.0",
-        "contentHash": "WXnEcGwmXfa8gW9N2MlcaPNUzM3NLMwnAhacbtH554F8YcoXbIkTB+uGa1Aa+9gyb/9JZgYVHnmADgJUKP52nA=="
-      },
-      "NETStandard.Library": {
+      "Microsoft.Extensions.FileProviders.Physical": {
         "type": "Transitive",
-        "resolved": "1.6.0",
-        "contentHash": "ypsCvIdCZ4IoYASJHt6tF2fMo7N30NLgV1EbmC+snO490OMl9FvVxmumw14rhReWU3j3g7BYudG6YCrchwHJlA==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.Win32.Primitives": "4.0.1",
-          "System.AppContext": "4.1.0",
-          "System.Collections": "4.0.11",
-          "System.Collections.Concurrent": "4.0.12",
-          "System.Console": "4.0.0",
-          "System.Diagnostics.Debug": "4.0.11",
-          "System.Diagnostics.Tools": "4.0.1",
-          "System.Diagnostics.Tracing": "4.1.0",
-          "System.Globalization": "4.0.11",
-          "System.Globalization.Calendars": "4.0.1",
-          "System.IO": "4.1.0",
-          "System.IO.Compression": "4.1.0",
-          "System.IO.Compression.ZipFile": "4.0.1",
-          "System.IO.FileSystem": "4.0.1",
-          "System.IO.FileSystem.Primitives": "4.0.1",
-          "System.Linq": "4.1.0",
-          "System.Linq.Expressions": "4.1.0",
-          "System.Net.Http": "4.1.0",
-          "System.Net.Primitives": "4.0.11",
-          "System.Net.Sockets": "4.1.0",
-          "System.ObjectModel": "4.0.12",
-          "System.Reflection": "4.1.0",
-          "System.Reflection.Extensions": "4.0.1",
-          "System.Reflection.Primitives": "4.0.1",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Runtime.Handles": "4.0.1",
-          "System.Runtime.InteropServices": "4.1.0",
-          "System.Runtime.InteropServices.RuntimeInformation": "4.0.0",
-          "System.Runtime.Numerics": "4.0.1",
-          "System.Security.Cryptography.Algorithms": "4.2.0",
-          "System.Security.Cryptography.Encoding": "4.0.0",
-          "System.Security.Cryptography.Primitives": "4.0.0",
-          "System.Security.Cryptography.X509Certificates": "4.1.0",
-          "System.Text.Encoding": "4.0.11",
-          "System.Text.Encoding.Extensions": "4.0.11",
-          "System.Text.RegularExpressions": "4.1.0",
-          "System.Threading": "4.0.11",
-          "System.Threading.Tasks": "4.0.11",
-          "System.Threading.Timer": "4.0.1",
-          "System.Xml.ReaderWriter": "4.0.11",
-          "System.Xml.XDocument": "4.0.11"
-        }
-      },
-      "runtime.native.System": {
-        "type": "Transitive",
-        "resolved": "4.0.0",
-        "contentHash": "QfS/nQI7k/BLgmLrw7qm7YBoULEvgWnPI+cYsbfCVFTW8Aj+i8JhccxcFMu1RWms0YZzF+UHguNBK4Qn89e2Sg==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1"
-        }
-      },
-      "runtime.native.System.IO.Compression": {
-        "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "Ob7nvnJBox1aaB222zSVZSkf4WrebPG4qFscfK7vmD7P7NxoSxACQLtO7ytWpqXDn2wcd/+45+EAZ7xjaPip8A==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1"
-        }
-      },
-      "runtime.native.System.Net.Http": {
-        "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "Nh0UPZx2Vifh8r+J+H2jxifZUD3sBrmolgiFWJd2yiNrxO0xTa6bAw3YwRn1VOiSen/tUXMS31ttNItCZ6lKuA==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1"
-        }
-      },
-      "runtime.native.System.Security.Cryptography": {
-        "type": "Transitive",
-        "resolved": "4.0.0",
-        "contentHash": "2CQK0jmO6Eu7ZeMgD+LOFbNJSXHFVQbCJJkEyEwowh1SCgYnrn9W9RykMfpeeVGw7h4IBvYikzpGUlmZTUafJw==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1"
+        "resolved": "6.0.0",
+        "contentHash": "QvkL7l0nM8udt3gfyu0Vw8bbCXblxaKOl7c2oBfgGy4LCURRaL9XWZX1FWJrQc43oMokVneVxH38iz+bY1sbhg==",
+        "dependencies": {
+          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileSystemGlobbing": "6.0.0",
+          "Microsoft.Extensions.Primitives": "6.0.0"
         }
       },
-      "StyleCop.Analyzers.Unstable": {
+      "Microsoft.Extensions.FileSystemGlobbing": {
         "type": "Transitive",
-        "resolved": "1.2.0.435",
-        "contentHash": "ouwPWZxbOV3SmCZxIRqHvljkSzkCyi1tDoMzQtDb/bRP8ctASV/iRJr+A2Gdj0QLaLmWnqTWDrH82/iP+X80Lg=="
+        "resolved": "6.0.0",
+        "contentHash": "ip8jnL1aPiaPeKINCqaTEbvBFDmVx9dXQEBZ2HOBRXPD1eabGNqP/bKlsIcp7U2lGxiXd5xIhoFcmY8nM4Hdiw=="
       },
-      "System.AppContext": {
+      "Microsoft.Extensions.Logging": {
         "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "3QjO4jNV7PdKkmQAVp9atA+usVnKRwI3Kx1nMwJ93T0LcQfx7pKAYk0nKz5wn1oP5iqlhZuy6RXOFdhr7rDwow==",
+        "resolved": "6.0.0",
+        "contentHash": "eIbyj40QDg1NDz0HBW0S5f3wrLVnKWnDJ/JtZ+yJDFnDj90VoPuoPmFkeaXrtu+0cKm5GRAwoDf+dBWXK0TUdg==",
         "dependencies": {
-          "System.Runtime": "4.1.0"
+          "Microsoft.Extensions.DependencyInjection": "6.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Options": "6.0.0",
+          "System.Diagnostics.DiagnosticSource": "6.0.0"
         }
       },
-      "System.Buffers": {
+      "Microsoft.Extensions.Logging.Configuration": {
         "type": "Transitive",
-        "resolved": "4.5.1",
-        "contentHash": "Rw7ijyl1qqRS0YQD/WycNst8hUUMgrMH4FCn1nNm27M4VxchZ1js3fVjQaANHO5f3sN4isvP4a+Met9Y4YomAg=="
+        "resolved": "6.0.0",
+        "contentHash": "ZDskjagmBAbv+K8rYW9VhjPplhbOE63xUD0DiuydZJwt15dRyoqicYklLd86zzeintUc7AptDkHn+YhhYkYo8A==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration": "6.0.0",
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Configuration.Binder": "6.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Logging": "6.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Options": "6.0.0",
+          "Microsoft.Extensions.Options.ConfigurationExtensions": "6.0.0"
+        }
       },
-      "System.Collections": {
+      "Microsoft.Extensions.Logging.Console": {
         "type": "Transitive",
-        "resolved": "4.0.11",
-        "contentHash": "YUJGz6eFKqS0V//mLt25vFGrrCvOnsXjlvFQs+KimpwNxug9x0Pzy4PlFMU3Q2IzqAa9G2L4LsK3+9vCBK7oTg==",
+        "resolved": "6.0.0",
+        "contentHash": "gsqKzOEdsvq28QiXFxagmn1oRB9GeI5GgYCkoybZtQA0IUb7QPwf1WmN3AwJeNIsadTvIFQCiVK0OVIgKfOBGg==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Logging": "6.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Logging.Configuration": "6.0.0",
+          "Microsoft.Extensions.Options": "6.0.0",
+          "System.Text.Json": "6.0.0"
         }
       },
-      "System.Collections.Concurrent": {
+      "Microsoft.Extensions.Logging.Debug": {
         "type": "Transitive",
-        "resolved": "4.0.12",
-        "contentHash": "2gBcbb3drMLgxlI0fBfxMA31ec6AEyYCHygGse4vxceJan8mRIWeKJ24BFzN7+bi/NFTgdIgufzb94LWO5EERQ==",
+        "resolved": "6.0.0",
+        "contentHash": "M9g/JixseSZATJE9tcMn9uzoD4+DbSglivFqVx8YkRJ7VVPmnvCEbOZ0AAaxsL1EKyI4cz07DXOOJExxNsUOHw==",
         "dependencies": {
-          "System.Collections": "4.0.11",
-          "System.Diagnostics.Debug": "4.0.11",
-          "System.Diagnostics.Tracing": "4.1.0",
-          "System.Globalization": "4.0.11",
-          "System.Reflection": "4.1.0",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Threading": "4.0.11",
-          "System.Threading.Tasks": "4.0.11"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Logging": "6.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "6.0.0"
         }
       },
-      "System.Collections.Immutable": {
+      "Microsoft.Extensions.Logging.EventLog": {
         "type": "Transitive",
-        "resolved": "7.0.0",
-        "contentHash": "dQPcs0U1IKnBdRDBkrCTi1FoajSTBzLcVTpjO4MBCMC7f4pDOIPzgBoX8JjG7X6uZRJ8EBxsi8+DR1JuwjnzOQ=="
+        "resolved": "6.0.0",
+        "contentHash": "rlo0RxlMd0WtLG3CHI0qOTp6fFn7MvQjlrCjucA31RqmiMFCZkF8CHNbe8O7tbBIyyoLGWB1he9CbaA5iyHthg==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Logging": "6.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Options": "6.0.0",
+          "System.Diagnostics.EventLog": "6.0.0"
+        }
       },
-      "System.Console": {
+      "Microsoft.Extensions.Logging.EventSource": {
         "type": "Transitive",
-        "resolved": "4.0.0",
-        "contentHash": "qSKUSOIiYA/a0g5XXdxFcUFmv1hNICBD7QZ0QhGYVipPIhvpiydY8VZqr1thmCXvmn8aipMg64zuanB4eotK9A==",
+        "resolved": "6.0.0",
+        "contentHash": "BeDyyqt7nkm/nr+Gdk+L8n1tUT/u33VkbXAOesgYSNsxDM9hJ1NOBGoZfj9rCbeD2+9myElI6JOVVFmnzgeWQA==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.IO": "4.1.0",
-          "System.Runtime": "4.1.0",
-          "System.Text.Encoding": "4.0.11"
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Logging": "6.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Options": "6.0.0",
+          "Microsoft.Extensions.Primitives": "6.0.0",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0",
+          "System.Text.Json": "6.0.0"
         }
       },
-      "System.Diagnostics.Debug": {
+      "Microsoft.Extensions.Options.ConfigurationExtensions": {
         "type": "Transitive",
-        "resolved": "4.0.11",
-        "contentHash": "w5U95fVKHY4G8ASs/K5iK3J5LY+/dLFd4vKejsnI/ZhBsWS9hQakfx3Zr7lRWKg4tAw9r4iktyvsTagWkqYCiw==",
+        "resolved": "6.0.0",
+        "contentHash": "bXWINbTn0vC0FYc9GaQTISbxhQLAMrvtbuvD9N6JelEaIS/Pr62wUCinrq5bf1WRBGczt1v4wDhxFtVFNcMdUQ==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Configuration.Binder": "6.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Options": "6.0.0",
+          "Microsoft.Extensions.Primitives": "6.0.0"
         }
       },
-      "System.Diagnostics.DiagnosticSource": {
+      "Microsoft.Extensions.Primitives": {
         "type": "Transitive",
         "resolved": "6.0.0",
-        "contentHash": "frQDfv0rl209cKm1lnwTgFPzNigy2EKk1BS3uAvHvlBVKe5cymGyHO+Sj+NLv5VF/AhHsqPIUUwya5oV4CHMUw==",
+        "contentHash": "9+PnzmQFfEFNR9J2aDTfJGGupShHjOuGw4VUv+JB044biSHrnmCIMD+mJHmb2H7YryrfBEXDurxQ47gJZdCKNQ==",
         "dependencies": {
           "System.Runtime.CompilerServices.Unsafe": "6.0.0"
         }
       },
-      "System.Diagnostics.Tools": {
+      "Microsoft.NETCore.Platforms": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "xBfJ8pnd4C17dWaC9FM6aShzbJcRNMChUMD42I6772KGGrqaFdumwhn9OdM68erj1ueNo3xdQ1EwiFjK5k8p0g==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
-        }
+        "resolved": "1.1.0",
+        "contentHash": "kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A=="
       },
-      "System.Diagnostics.Tracing": {
+      "Microsoft.NETCore.Targets": {
         "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "vDN1PoMZCkkdNjvZLql592oYJZgS7URcJzJ7bxeBgGtx5UtR5leNm49VmfHGqIffX4FKacHbI3H6UyNSHQknBg==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
-        }
+        "resolved": "1.1.0",
+        "contentHash": "aOZA3BWfz9RXjpzt0sRJJMjAscAUm3Hoa4UWAfceV9UTYxgwZ1lZt5nO2myFf+/jetYQo4uTP7zS8sJY67BBxg=="
       },
-      "System.Globalization": {
+      "NetFabric.Hyperlinq.Abstractions": {
         "type": "Transitive",
-        "resolved": "4.0.11",
-        "contentHash": "B95h0YLEL2oSnwF/XjqSWKnwKOy/01VWkNlsCeMTFJLLabflpGV26nK164eRs5GiaRSBGpOxQ3pKoSnnyZN5pg==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
-        }
+        "resolved": "1.3.0",
+        "contentHash": "WXnEcGwmXfa8gW9N2MlcaPNUzM3NLMwnAhacbtH554F8YcoXbIkTB+uGa1Aa+9gyb/9JZgYVHnmADgJUKP52nA=="
       },
-      "System.Globalization.Calendars": {
+      "StyleCop.Analyzers.Unstable": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "L1c6IqeQ88vuzC1P81JeHmHA8mxq8a18NUBNXnIY/BVb+TCyAaGIFbhpZt60h9FJNmisymoQkHEFSE9Vslja1Q==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Globalization": "4.0.11",
-          "System.Runtime": "4.1.0"
-        }
+        "resolved": "1.2.0.435",
+        "contentHash": "ouwPWZxbOV3SmCZxIRqHvljkSzkCyi1tDoMzQtDb/bRP8ctASV/iRJr+A2Gdj0QLaLmWnqTWDrH82/iP+X80Lg=="
       },
-      "System.Globalization.Extensions": {
+      "System.Buffers": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "KKo23iKeOaIg61SSXwjANN7QYDr/3op3OWGGzDzz7mypx0Za0fZSeG0l6cco8Ntp8YMYkIQcAqlk8yhm5/Uhcg==",
+        "resolved": "4.5.1",
+        "contentHash": "Rw7ijyl1qqRS0YQD/WycNst8hUUMgrMH4FCn1nNm27M4VxchZ1js3fVjQaANHO5f3sN4isvP4a+Met9Y4YomAg=="
+      },
+      "System.Collections": {
+        "type": "Transitive",
+        "resolved": "4.3.0",
+        "contentHash": "3Dcj85/TBdVpL5Zr+gEEBUuFe2icOnLalmEh9hfck1PTYbbyWuZgh4fmm2ysCLTrqLQw6t3TgTyJ+VLp+Qb+Lw==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "System.Globalization": "4.0.11",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Runtime.InteropServices": "4.1.0"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.Runtime": "4.3.0"
         }
       },
-      "System.IO": {
+      "System.Collections.Immutable": {
         "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "3KlTJceQc3gnGIaHZ7UBZO26SHL1SHE4ddrmiwumFnId+CEHP+O8r386tZKaE6zlk5/mF8vifMBzHj9SaXN+mQ==",
+        "resolved": "7.0.0",
+        "contentHash": "dQPcs0U1IKnBdRDBkrCTi1FoajSTBzLcVTpjO4MBCMC7f4pDOIPzgBoX8JjG7X6uZRJ8EBxsi8+DR1JuwjnzOQ=="
+      },
+      "System.Diagnostics.Contracts": {
+        "type": "Transitive",
+        "resolved": "4.3.0",
+        "contentHash": "eelRRbnm+OloiQvp9CXS0ixjNQldjjkHO4iIkR5XH2VIP8sUB/SIpa1TdUW6/+HDcQ+MlhP3pNa1u5SbzYuWGA==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Text.Encoding": "4.0.11",
-          "System.Threading.Tasks": "4.0.11"
+          "System.Runtime": "4.3.0"
         }
       },
-      "System.IO.Compression": {
+      "System.Diagnostics.Debug": {
         "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "TjnBS6eztThSzeSib+WyVbLzEdLKUcEHN69VtS3u8aAsSc18FU6xCZlNWWsEd8SKcXAE+y1sOu7VbU8sUeM0sg==",
+        "resolved": "4.3.0",
+        "contentHash": "ZUhUOdqmaG5Jk3Xdb8xi5kIyQYAA4PnTNlHx1mu9ZY3qv4ELIdKbnL/akbGaKi2RnNUWaZsAs31rvzFdewTj2g==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "System.Collections": "4.0.11",
-          "System.Diagnostics.Debug": "4.0.11",
-          "System.IO": "4.1.0",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Runtime.Handles": "4.0.1",
-          "System.Runtime.InteropServices": "4.1.0",
-          "System.Text.Encoding": "4.0.11",
-          "System.Threading": "4.0.11",
-          "System.Threading.Tasks": "4.0.11",
-          "runtime.native.System": "4.0.0",
-          "runtime.native.System.IO.Compression": "4.1.0"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.Runtime": "4.3.0"
         }
       },
-      "System.IO.Compression.ZipFile": {
+      "System.Diagnostics.DiagnosticSource": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "hBQYJzfTbQURF10nLhd+az2NHxsU6MU7AB8RUf4IolBP5lOAm4Luho851xl+CqslmhI5ZH/el8BlngEk4lBkaQ==",
+        "resolved": "6.0.0",
+        "contentHash": "frQDfv0rl209cKm1lnwTgFPzNigy2EKk1BS3uAvHvlBVKe5cymGyHO+Sj+NLv5VF/AhHsqPIUUwya5oV4CHMUw==",
         "dependencies": {
-          "System.Buffers": "4.0.0",
-          "System.IO": "4.1.0",
-          "System.IO.Compression": "4.1.0",
-          "System.IO.FileSystem": "4.0.1",
-          "System.IO.FileSystem.Primitives": "4.0.1",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Text.Encoding": "4.0.11"
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
         }
       },
-      "System.IO.FileSystem": {
+      "System.Diagnostics.EventLog": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "lcyUiXTsETK2ALsZrX+nWuHSIQeazhqPphLfaRxzdGaG93+0kELqpgEHtwWOlQe7+jSFnKwaCAgL4kjeZCQJnw=="
+      },
+      "System.Globalization": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "IBErlVq5jOggAD69bg1t0pJcHaDbJbWNUZTPI96fkYWzwYbN6D9wRHMULLDd9dHsl7C2YsxXL31LMfPI1SWt8w==",
+        "resolved": "4.3.0",
+        "contentHash": "kYdVd2f2PAdFGblzFswE4hkNANJBKRmsfa2X5LG2AcWE1c7/4t0pYae1L8vfZ5xvE2nK/R9JprtToA61OSHWIg==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.IO": "4.1.0",
-          "System.IO.FileSystem.Primitives": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Handles": "4.0.1",
-          "System.Text.Encoding": "4.0.11",
-          "System.Threading.Tasks": "4.0.11"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.Runtime": "4.3.0"
         }
       },
-      "System.IO.FileSystem.Primitives": {
+      "System.IO": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "kWkKD203JJKxJeE74p8aF8y4Qc9r9WQx4C0cHzHPrY3fv/L/IhWnyCHaFJ3H1QPOH6A93whlQ2vG5nHlBDvzWQ==",
+        "resolved": "4.3.0",
+        "contentHash": "3qjaHvxQPDpSOYICjUoTsmoq5u6QJAFRUITgeT/4gqkF1bajbSmb1kwSxEA8AHlofqgcKJcM8udgieRNhaJ5Cg==",
         "dependencies": {
-          "System.Runtime": "4.1.0"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.Runtime": "4.3.0",
+          "System.Text.Encoding": "4.3.0",
+          "System.Threading.Tasks": "4.3.0"
         }
       },
       "System.Linq": {
         "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "bQ0iYFOQI0nuTnt+NQADns6ucV4DUvMdwN6CbkB1yj8i7arTGiTN5eok1kQwdnnNWSDZfIUySQY+J3d5KjWn0g==",
+        "resolved": "4.3.0",
+        "contentHash": "5DbqIUpsDp0dFftytzuMmc0oeMdQwjcP/EWxsksIz/w1TcFRkZ3yKKz0PqiYFMmEwPSWw+qNVqD7PJ889JzHbw==",
         "dependencies": {
-          "System.Collections": "4.0.11",
-          "System.Diagnostics.Debug": "4.0.11",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0"
+          "System.Collections": "4.3.0",
+          "System.Diagnostics.Debug": "4.3.0",
+          "System.Resources.ResourceManager": "4.3.0",
+          "System.Runtime": "4.3.0",
+          "System.Runtime.Extensions": "4.3.0"
         }
       },
       "System.Linq.Expressions": {
         "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "I+y02iqkgmCAyfbqOmSDOgqdZQ5tTj80Akm5BPSS8EeB0VGWdy6X1KCoYe8Pk6pwDoAKZUOdLVxnTJcExiv5zw==",
-        "dependencies": {
-          "System.Collections": "4.0.11",
-          "System.Diagnostics.Debug": "4.0.11",
-          "System.Globalization": "4.0.11",
-          "System.IO": "4.1.0",
-          "System.Linq": "4.1.0",
-          "System.ObjectModel": "4.0.12",
-          "System.Reflection": "4.1.0",
-          "System.Reflection.Emit": "4.0.1",
-          "System.Reflection.Emit.ILGeneration": "4.0.1",
-          "System.Reflection.Emit.Lightweight": "4.0.1",
-          "System.Reflection.Extensions": "4.0.1",
-          "System.Reflection.Primitives": "4.0.1",
-          "System.Reflection.TypeExtensions": "4.1.0",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Threading": "4.0.11"
+        "resolved": "4.3.0",
+        "contentHash": "PGKkrd2khG4CnlyJwxwwaWWiSiWFNBGlgXvJpeO0xCXrZ89ODrQ6tjEWS/kOqZ8GwEOUATtKtzp1eRgmYNfclg==",
+        "dependencies": {
+          "System.Collections": "4.3.0",
+          "System.Diagnostics.Debug": "4.3.0",
+          "System.Globalization": "4.3.0",
+          "System.IO": "4.3.0",
+          "System.Linq": "4.3.0",
+          "System.ObjectModel": "4.3.0",
+          "System.Reflection": "4.3.0",
+          "System.Reflection.Emit": "4.3.0",
+          "System.Reflection.Emit.ILGeneration": "4.3.0",
+          "System.Reflection.Emit.Lightweight": "4.3.0",
+          "System.Reflection.Extensions": "4.3.0",
+          "System.Reflection.Primitives": "4.3.0",
+          "System.Reflection.TypeExtensions": "4.3.0",
+          "System.Resources.ResourceManager": "4.3.0",
+          "System.Runtime": "4.3.0",
+          "System.Runtime.Extensions": "4.3.0",
+          "System.Threading": "4.3.0"
+        }
+      },
+      "System.Linq.Queryable": {
+        "type": "Transitive",
+        "resolved": "4.3.0",
+        "contentHash": "In1Bmmvl/j52yPu3xgakQSI0YIckPUr870w4K5+Lak3JCCa8hl+my65lABOuKfYs4ugmZy25ScFerC4nz8+b6g==",
+        "dependencies": {
+          "System.Collections": "4.3.0",
+          "System.Diagnostics.Debug": "4.3.0",
+          "System.Linq": "4.3.0",
+          "System.Linq.Expressions": "4.3.0",
+          "System.Reflection": "4.3.0",
+          "System.Reflection.Extensions": "4.3.0",
+          "System.Resources.ResourceManager": "4.3.0",
+          "System.Runtime": "4.3.0"
         }
       },
       "System.Memory": {
@@ -571,169 +508,112 @@
         "resolved": "4.5.5",
         "contentHash": "XIWiDvKPXaTveaB7HVganDlOCRoj03l+jrwNvcge/t8vhGYKvqV+dMv6G4SAX2NoNmN0wZfVPTAlFwZcZvVOUw=="
       },
-      "System.Net.Http": {
-        "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "ULq9g3SOPVuupt+Y3U+A37coXzdNisB1neFCSKzBwo182u0RDddKJF8I5+HfyXqK6OhJPgeoAwWXrbiUXuRDsg==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "System.Collections": "4.0.11",
-          "System.Diagnostics.Debug": "4.0.11",
-          "System.Diagnostics.DiagnosticSource": "4.0.0",
-          "System.Diagnostics.Tracing": "4.1.0",
-          "System.Globalization": "4.0.11",
-          "System.Globalization.Extensions": "4.0.1",
-          "System.IO": "4.1.0",
-          "System.IO.FileSystem": "4.0.1",
-          "System.Net.Primitives": "4.0.11",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Runtime.Handles": "4.0.1",
-          "System.Runtime.InteropServices": "4.1.0",
-          "System.Security.Cryptography.Algorithms": "4.2.0",
-          "System.Security.Cryptography.Encoding": "4.0.0",
-          "System.Security.Cryptography.OpenSsl": "4.0.0",
-          "System.Security.Cryptography.Primitives": "4.0.0",
-          "System.Security.Cryptography.X509Certificates": "4.1.0",
-          "System.Text.Encoding": "4.0.11",
-          "System.Threading": "4.0.11",
-          "System.Threading.Tasks": "4.0.11",
-          "runtime.native.System": "4.0.0",
-          "runtime.native.System.Net.Http": "4.0.1",
-          "runtime.native.System.Security.Cryptography": "4.0.0"
-        }
-      },
-      "System.Net.Primitives": {
-        "type": "Transitive",
-        "resolved": "4.0.11",
-        "contentHash": "hVvfl4405DRjA2408luZekbPhplJK03j2Y2lSfMlny7GHXlkByw1iLnc9mgKW0GdQn73vvMcWrWewAhylXA4Nw==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Handles": "4.0.1"
-        }
-      },
-      "System.Net.Sockets": {
-        "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "xAz0N3dAV/aR/9g8r0Y5oEqU1JRsz29F5EGb/WVHmX3jVSLqi2/92M5hTad2aNWovruXrJpJtgZ9fccPMG9uSw==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.IO": "4.1.0",
-          "System.Net.Primitives": "4.0.11",
-          "System.Runtime": "4.1.0",
-          "System.Threading.Tasks": "4.0.11"
-        }
-      },
       "System.ObjectModel": {
         "type": "Transitive",
-        "resolved": "4.0.12",
-        "contentHash": "tAgJM1xt3ytyMoW4qn4wIqgJYm7L7TShRZG4+Q4Qsi2PCcj96pXN7nRywS9KkB3p/xDUjc2HSwP9SROyPYDYKQ==",
+        "resolved": "4.3.0",
+        "contentHash": "bdX+80eKv9bN6K4N+d77OankKHGn6CH711a6fcOpMQu2Fckp/Ft4L/kW9WznHpyR0NRAvJutzOMHNNlBGvxQzQ==",
         "dependencies": {
-          "System.Collections": "4.0.11",
-          "System.Diagnostics.Debug": "4.0.11",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Threading": "4.0.11"
+          "System.Collections": "4.3.0",
+          "System.Diagnostics.Debug": "4.3.0",
+          "System.Resources.ResourceManager": "4.3.0",
+          "System.Runtime": "4.3.0",
+          "System.Threading": "4.3.0"
         }
       },
       "System.Reflection": {
         "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "JCKANJ0TI7kzoQzuwB/OoJANy1Lg338B6+JVacPl4TpUwi3cReg3nMLplMq2uqYfHFQpKIlHAUVAJlImZz/4ng==",
+        "resolved": "4.3.0",
+        "contentHash": "KMiAFoW7MfJGa9nDFNcfu+FpEdiHpWgTcS2HdMpDvt9saK3y/G4GwprPyzqjFH9NTaGPQeWNHU+iDlDILj96aQ==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.IO": "4.1.0",
-          "System.Reflection.Primitives": "4.0.1",
-          "System.Runtime": "4.1.0"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.IO": "4.3.0",
+          "System.Reflection.Primitives": "4.3.0",
+          "System.Runtime": "4.3.0"
         }
       },
       "System.Reflection.Emit": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "P2wqAj72fFjpP6wb9nSfDqNBMab+2ovzSDzUZK7MVIm54tBJEPr9jWfSjjoTpPwj1LeKcmX3vr0ttyjSSFM47g==",
+        "resolved": "4.3.0",
+        "contentHash": "228FG0jLcIwTVJyz8CLFKueVqQK36ANazUManGaJHkO0icjiIypKW7YLWLIWahyIkdh5M7mV2dJepllLyA1SKg==",
         "dependencies": {
-          "System.IO": "4.1.0",
-          "System.Reflection": "4.1.0",
-          "System.Reflection.Emit.ILGeneration": "4.0.1",
-          "System.Reflection.Primitives": "4.0.1",
-          "System.Runtime": "4.1.0"
+          "System.IO": "4.3.0",
+          "System.Reflection": "4.3.0",
+          "System.Reflection.Emit.ILGeneration": "4.3.0",
+          "System.Reflection.Primitives": "4.3.0",
+          "System.Runtime": "4.3.0"
         }
       },
       "System.Reflection.Emit.ILGeneration": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "Ov6dU8Bu15Bc7zuqttgHF12J5lwSWyTf1S+FJouUXVMSqImLZzYaQ+vRr1rQ0OZ0HqsrwWl4dsKHELckQkVpgA==",
+        "resolved": "4.3.0",
+        "contentHash": "59tBslAk9733NXLrUJrwNZEzbMAcu8k344OYo+wfSVygcgZ9lgBdGIzH/nrg3LYhXceynyvTc8t5/GD4Ri0/ng==",
         "dependencies": {
-          "System.Reflection": "4.1.0",
-          "System.Reflection.Primitives": "4.0.1",
-          "System.Runtime": "4.1.0"
+          "System.Reflection": "4.3.0",
+          "System.Reflection.Primitives": "4.3.0",
+          "System.Runtime": "4.3.0"
         }
       },
       "System.Reflection.Emit.Lightweight": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "sSzHHXueZ5Uh0OLpUQprhr+ZYJrLPA2Cmr4gn0wj9+FftNKXx8RIMKvO9qnjk2ebPYUjZ+F2ulGdPOsvj+MEjA==",
+        "resolved": "4.3.0",
+        "contentHash": "oadVHGSMsTmZsAF864QYN1t1QzZjIcuKU3l2S9cZOwDdDueNTrqq1yRj7koFfIGEnKpt6NjpL3rOzRhs4ryOgA==",
         "dependencies": {
-          "System.Reflection": "4.1.0",
-          "System.Reflection.Emit.ILGeneration": "4.0.1",
-          "System.Reflection.Primitives": "4.0.1",
-          "System.Runtime": "4.1.0"
+          "System.Reflection": "4.3.0",
+          "System.Reflection.Emit.ILGeneration": "4.3.0",
+          "System.Reflection.Primitives": "4.3.0",
+          "System.Runtime": "4.3.0"
         }
       },
       "System.Reflection.Extensions": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "GYrtRsZcMuHF3sbmRHfMYpvxZoIN2bQGrYGerUiWLEkqdEUQZhH3TRSaC/oI4wO0II1RKBPlpIa1TOMxIcOOzQ==",
+        "resolved": "4.3.0",
+        "contentHash": "rJkrJD3kBI5B712aRu4DpSIiHRtr6QlfZSQsb0hYHrDCZORXCFjQfoipo2LaMUHoT9i1B7j7MnfaEKWDFmFQNQ==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Reflection": "4.1.0",
-          "System.Runtime": "4.1.0"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.Reflection": "4.3.0",
+          "System.Runtime": "4.3.0"
         }
       },
       "System.Reflection.Primitives": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "4inTox4wTBaDhB7V3mPvp9XlCbeGYWVEM9/fXALd52vNEAVisc1BoVWQPuUuD0Ga//dNbA/WeMy9u9mzLxGTHQ==",
+        "resolved": "4.3.0",
+        "contentHash": "5RXItQz5As4xN2/YUDxdpsEkMhvw3e6aNveFXUn4Hl/udNTCNhnKp8lT9fnc3MhvGKh1baak5CovpuQUXHAlIA==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.Runtime": "4.3.0"
         }
       },
       "System.Reflection.TypeExtensions": {
         "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "tsQ/ptQ3H5FYfON8lL4MxRk/8kFyE0A+tGPXmVP967cT/gzLHYxIejIYSxp4JmIeFHVP78g/F2FE1mUUTbDtrg==",
+        "resolved": "4.3.0",
+        "contentHash": "7u6ulLcZbyxB5Gq0nMkQttcdBTx57ibzw+4IOXEfR+sXYQoHvjW5LTLyNr8O22UIMrqYbchJQJnos4eooYzYJA==",
         "dependencies": {
-          "System.Reflection": "4.1.0",
-          "System.Runtime": "4.1.0"
+          "System.Reflection": "4.3.0",
+          "System.Runtime": "4.3.0"
         }
       },
       "System.Resources.ResourceManager": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "TxwVeUNoTgUOdQ09gfTjvW411MF+w9MBYL7AtNVc+HtBCFlutPLhUCdZjNkjbhj3bNQWMdHboF0KIWEOjJssbA==",
+        "resolved": "4.3.0",
+        "contentHash": "/zrcPkkWdZmI4F92gL/TPumP98AVDu/Wxr3CSJGQQ+XN6wbRZcyfSKVoPo17ilb3iOr0cCRqJInGwNMolqhS8A==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Globalization": "4.0.11",
-          "System.Reflection": "4.1.0",
-          "System.Runtime": "4.1.0"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.Globalization": "4.3.0",
+          "System.Reflection": "4.3.0",
+          "System.Runtime": "4.3.0"
         }
       },
       "System.Runtime": {
         "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "v6c/4Yaa9uWsq+JMhnOFewrYkgdNHNG2eMKuNqRn8P733rNXeRCGvV5FkkjBXn2dbVkPXOsO0xjsEeM1q2zC0g==",
+        "resolved": "4.3.0",
+        "contentHash": "JufQi0vPQ0xGnAczR13AUFglDyVYt4Kqnz1AZaiKZ5+GICq0/1MH/mO/eAJHt/mHW1zjKBJd7kV26SrxddAhiw==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0"
         }
       },
       "System.Runtime.CompilerServices.Unsafe": {
@@ -743,256 +623,58 @@
       },
       "System.Runtime.Extensions": {
         "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "CUOHjTT/vgP0qGW22U4/hDlOqXmcPq5YicBaXdUR2UiUoLwBT+olO6we4DVbq57jeX5uXH2uerVZhf0qGj+sVQ==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
-        }
-      },
-      "System.Runtime.Handles": {
-        "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "nCJvEKguXEvk2ymk1gqj625vVnlK3/xdGzx0vOKicQkoquaTBJTP13AIYkocSUwHCLNBwUbXTqTWGDxBTWpt7g==",
+        "resolved": "4.3.0",
+        "contentHash": "guW0uK0fn5fcJJ1tJVXYd7/1h5F+pea1r7FLSOz/f8vPEqbR2ZAknuRDvTQ8PzAilDveOxNjSfr0CHfIQfFk8g==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
-        }
-      },
-      "System.Runtime.InteropServices": {
-        "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "16eu3kjHS633yYdkjwShDHZLRNMKVi/s0bY8ODiqJ2RfMhDMAwxZaUaWVnZ2P71kr/or+X9o/xFWtNqz8ivieQ==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Reflection": "4.1.0",
-          "System.Reflection.Primitives": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Handles": "4.0.1"
-        }
-      },
-      "System.Runtime.InteropServices.RuntimeInformation": {
-        "type": "Transitive",
-        "resolved": "4.0.0",
-        "contentHash": "hWPhJxc453RCa8Z29O91EmfGeZIHX1ZH2A8L6lYQVSaKzku2DfArSfMEb1/MYYzPQRJZeu0c9dmYeJKxW5Fgng==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "System.Reflection": "4.1.0",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.InteropServices": "4.1.0",
-          "System.Threading": "4.0.11",
-          "runtime.native.System": "4.0.0"
-        }
-      },
-      "System.Runtime.Numerics": {
-        "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "+XbKFuzdmLP3d1o9pdHu2nxjNr2OEPqGzKeegPLCUMM71a0t50A/rOcIRmGs9wR7a8KuHX6hYs/7/TymIGLNqg==",
-        "dependencies": {
-          "System.Globalization": "4.0.11",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0"
-        }
-      },
-      "System.Security.Cryptography.Algorithms": {
-        "type": "Transitive",
-        "resolved": "4.2.0",
-        "contentHash": "8JQFxbLVdrtIOKMDN38Fn0GWnqYZw/oMlwOUG/qz1jqChvyZlnUmu+0s7wLx7JYua/nAXoESpHA3iw11QFWhXg==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "System.Collections": "4.0.11",
-          "System.IO": "4.1.0",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Runtime.Handles": "4.0.1",
-          "System.Runtime.InteropServices": "4.1.0",
-          "System.Runtime.Numerics": "4.0.1",
-          "System.Security.Cryptography.Encoding": "4.0.0",
-          "System.Security.Cryptography.Primitives": "4.0.0",
-          "System.Text.Encoding": "4.0.11",
-          "runtime.native.System.Security.Cryptography": "4.0.0"
-        }
-      },
-      "System.Security.Cryptography.Cng": {
-        "type": "Transitive",
-        "resolved": "4.2.0",
-        "contentHash": "cUJ2h+ZvONDe28Szw3st5dOHdjndhJzQ2WObDEXAWRPEQBtVItVoxbXM/OEsTthl3cNn2dk2k0I3y45igCQcLw==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "System.IO": "4.1.0",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Runtime.Handles": "4.0.1",
-          "System.Runtime.InteropServices": "4.1.0",
-          "System.Security.Cryptography.Algorithms": "4.2.0",
-          "System.Security.Cryptography.Encoding": "4.0.0",
-          "System.Security.Cryptography.Primitives": "4.0.0",
-          "System.Text.Encoding": "4.0.11"
-        }
-      },
-      "System.Security.Cryptography.Csp": {
-        "type": "Transitive",
-        "resolved": "4.0.0",
-        "contentHash": "/i1Usuo4PgAqgbPNC0NjbO3jPW//BoBlTpcWFD1EHVbidH21y4c1ap5bbEMSGAXjAShhMH4abi/K8fILrnu4BQ==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "System.IO": "4.1.0",
-          "System.Reflection": "4.1.0",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Runtime.Handles": "4.0.1",
-          "System.Runtime.InteropServices": "4.1.0",
-          "System.Security.Cryptography.Algorithms": "4.2.0",
-          "System.Security.Cryptography.Encoding": "4.0.0",
-          "System.Security.Cryptography.Primitives": "4.0.0",
-          "System.Text.Encoding": "4.0.11",
-          "System.Threading": "4.0.11"
-        }
-      },
-      "System.Security.Cryptography.Encoding": {
-        "type": "Transitive",
-        "resolved": "4.0.0",
-        "contentHash": "FbKgE5MbxSQMPcSVRgwM6bXN3GtyAh04NkV8E5zKCBE26X0vYW0UtTa2FIgkH33WVqBVxRgxljlVYumWtU+HcQ==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "System.Collections": "4.0.11",
-          "System.Collections.Concurrent": "4.0.12",
-          "System.Linq": "4.1.0",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Runtime.Handles": "4.0.1",
-          "System.Runtime.InteropServices": "4.1.0",
-          "System.Security.Cryptography.Primitives": "4.0.0",
-          "System.Text.Encoding": "4.0.11",
-          "runtime.native.System.Security.Cryptography": "4.0.0"
-        }
-      },
-      "System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.0.0",
-        "contentHash": "HUG/zNUJwEiLkoURDixzkzZdB5yGA5pQhDP93ArOpDPQMteURIGERRNzzoJlmTreLBWr5lkFSjjMSk8ySEpQMw==",
-        "dependencies": {
-          "System.Collections": "4.0.11",
-          "System.IO": "4.1.0",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Runtime.Handles": "4.0.1",
-          "System.Runtime.InteropServices": "4.1.0",
-          "System.Runtime.Numerics": "4.0.1",
-          "System.Security.Cryptography.Algorithms": "4.2.0",
-          "System.Security.Cryptography.Encoding": "4.0.0",
-          "System.Security.Cryptography.Primitives": "4.0.0",
-          "System.Text.Encoding": "4.0.11",
-          "runtime.native.System.Security.Cryptography": "4.0.0"
-        }
-      },
-      "System.Security.Cryptography.Primitives": {
-        "type": "Transitive",
-        "resolved": "4.0.0",
-        "contentHash": "Wkd7QryWYjkQclX0bngpntW5HSlMzeJU24UaLJQ7YTfI8ydAVAaU2J+HXLLABOVJlKTVvAeL0Aj39VeTe7L+oA==",
-        "dependencies": {
-          "System.Diagnostics.Debug": "4.0.11",
-          "System.Globalization": "4.0.11",
-          "System.IO": "4.1.0",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Threading": "4.0.11",
-          "System.Threading.Tasks": "4.0.11"
-        }
-      },
-      "System.Security.Cryptography.X509Certificates": {
-        "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "4HEfsQIKAhA1+ApNn729Gi09zh+lYWwyIuViihoMDWp1vQnEkL2ct7mAbhBlLYm+x/L4Rr/pyGge1lIY635e0w==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "System.Collections": "4.0.11",
-          "System.Diagnostics.Debug": "4.0.11",
-          "System.Globalization": "4.0.11",
-          "System.Globalization.Calendars": "4.0.1",
-          "System.IO": "4.1.0",
-          "System.IO.FileSystem": "4.0.1",
-          "System.IO.FileSystem.Primitives": "4.0.1",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Runtime.Handles": "4.0.1",
-          "System.Runtime.InteropServices": "4.1.0",
-          "System.Runtime.Numerics": "4.0.1",
-          "System.Security.Cryptography.Algorithms": "4.2.0",
-          "System.Security.Cryptography.Cng": "4.2.0",
-          "System.Security.Cryptography.Csp": "4.0.0",
-          "System.Security.Cryptography.Encoding": "4.0.0",
-          "System.Security.Cryptography.OpenSsl": "4.0.0",
-          "System.Security.Cryptography.Primitives": "4.0.0",
-          "System.Text.Encoding": "4.0.11",
-          "System.Threading": "4.0.11",
-          "runtime.native.System": "4.0.0",
-          "runtime.native.System.Net.Http": "4.0.1",
-          "runtime.native.System.Security.Cryptography": "4.0.0"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.Runtime": "4.3.0"
         }
       },
       "System.Text.Encoding": {
         "type": "Transitive",
-        "resolved": "4.0.11",
-        "contentHash": "U3gGeMlDZXxCEiY4DwVLSacg+DFWCvoiX+JThA/rvw37Sqrku7sEFeVBBBMBnfB6FeZHsyDx85HlKL19x0HtZA==",
+        "resolved": "4.3.0",
+        "contentHash": "BiIg+KWaSDOITze6jGQynxg64naAPtqGHBwDrLaCtixsa5bKiR8dpPOHA7ge3C0JJQizJE+sfkz1wV+BAKAYZw==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.Runtime": "4.3.0"
         }
       },
-      "System.Text.Encoding.Extensions": {
+      "System.Text.Encodings.Web": {
         "type": "Transitive",
-        "resolved": "4.0.11",
-        "contentHash": "jtbiTDtvfLYgXn8PTfWI+SiBs51rrmO4AAckx4KR6vFK9Wzf6tI8kcRdsYQNwriUeQ1+CtQbM1W4cMbLXnj/OQ==",
+        "resolved": "6.0.0",
+        "contentHash": "Vg8eB5Tawm1IFqj4TVK1czJX89rhFxJo9ELqc/Eiq0eXy13RK00eubyU6TJE6y+GQXjyV5gSfiewDUZjQgSE0w==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Text.Encoding": "4.0.11"
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
         }
       },
-      "System.Text.RegularExpressions": {
+      "System.Text.Json": {
         "type": "Transitive",
-        "resolved": "4.1.0",
-        "contentHash": "i88YCXpRTjCnoSQZtdlHkAOx4KNNik4hMy83n0+Ftlb7jvV6ZiZWMpnEZHhjBp6hQVh8gWd/iKNPzlPF7iyA2g==",
+        "resolved": "6.0.0",
+        "contentHash": "zaJsHfESQvJ11vbXnNlkrR46IaMULk/gHxYsJphzSF+07kTjPHv+Oc14w6QEOfo3Q4hqLJgStUaYB9DBl0TmWg==",
         "dependencies": {
-          "System.Collections": "4.0.11",
-          "System.Globalization": "4.0.11",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Threading": "4.0.11"
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0",
+          "System.Text.Encodings.Web": "6.0.0"
         }
       },
       "System.Threading": {
         "type": "Transitive",
-        "resolved": "4.0.11",
-        "contentHash": "N+3xqIcg3VDKyjwwCGaZ9HawG9aC6cSDI+s7ROma310GQo8vilFZa86hqKppwTHleR/G0sfOzhvgnUxWCR/DrQ==",
+        "resolved": "4.3.0",
+        "contentHash": "VkUS0kOBcUf3Wwm0TSbrevDDZ6BlM+b/HRiapRFWjM5O0NS0LviG0glKmFK+hhPDd1XFeSdU1GmlLhb2CoVpIw==",
         "dependencies": {
-          "System.Runtime": "4.1.0",
-          "System.Threading.Tasks": "4.0.11"
+          "System.Runtime": "4.3.0",
+          "System.Threading.Tasks": "4.3.0"
         }
       },
       "System.Threading.Tasks": {
         "type": "Transitive",
-        "resolved": "4.0.11",
-        "contentHash": "k1S4Gc6IGwtHGT8188RSeGaX86Qw/wnrgNLshJvsdNUOPP9etMmo8S07c+UlOAx4K/xLuN9ivA1bD0LVurtIxQ==",
+        "resolved": "4.3.0",
+        "contentHash": "LbSxKEdOUhVe8BezB/9uOGGppt+nZf6e1VFyw6v3DN6lqitm0OSn2uXMOdtP0M3W4iMcqcivm2J6UgqiwwnXiA==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
+          "Microsoft.NETCore.Platforms": "1.1.0",
+          "Microsoft.NETCore.Targets": "1.1.0",
+          "System.Runtime": "4.3.0"
         }
       },
       "System.Threading.Tasks.Extensions": {
@@ -1000,56 +682,10 @@
         "resolved": "4.5.4",
         "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg=="
       },
-      "System.Threading.Timer": {
+      "System.ValueTuple": {
         "type": "Transitive",
-        "resolved": "4.0.1",
-        "contentHash": "saGfUV8uqVW6LeURiqxcGhZ24PzuRNaUBtbhVeuUAvky1naH395A/1nY0P2bWvrw/BreRtIB/EzTDkGBpqCwEw==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.0.1",
-          "Microsoft.NETCore.Targets": "1.0.1",
-          "System.Runtime": "4.1.0"
-        }
-      },
-      "System.Xml.ReaderWriter": {
-        "type": "Transitive",
-        "resolved": "4.0.11",
-        "contentHash": "ZIiLPsf67YZ9zgr31vzrFaYQqxRPX9cVHjtPSnmx4eN6lbS/yEyYNr2vs1doGDEscF0tjCZFsk9yUg1sC9e8tg==",
-        "dependencies": {
-          "System.Collections": "4.0.11",
-          "System.Diagnostics.Debug": "4.0.11",
-          "System.Globalization": "4.0.11",
-          "System.IO": "4.1.0",
-          "System.IO.FileSystem": "4.0.1",
-          "System.IO.FileSystem.Primitives": "4.0.1",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Runtime.InteropServices": "4.1.0",
-          "System.Text.Encoding": "4.0.11",
-          "System.Text.Encoding.Extensions": "4.0.11",
-          "System.Text.RegularExpressions": "4.1.0",
-          "System.Threading.Tasks": "4.0.11",
-          "System.Threading.Tasks.Extensions": "4.0.0"
-        }
-      },
-      "System.Xml.XDocument": {
-        "type": "Transitive",
-        "resolved": "4.0.11",
-        "contentHash": "Mk2mKmPi0nWaoiYeotq1dgeNK1fqWh61+EK+w4Wu8SWuTYLzpUnschb59bJtGywaPq7SmTuPf44wrXRwbIrukg==",
-        "dependencies": {
-          "System.Collections": "4.0.11",
-          "System.Diagnostics.Debug": "4.0.11",
-          "System.Diagnostics.Tools": "4.0.1",
-          "System.Globalization": "4.0.11",
-          "System.IO": "4.1.0",
-          "System.Reflection": "4.1.0",
-          "System.Resources.ResourceManager": "4.0.1",
-          "System.Runtime": "4.1.0",
-          "System.Runtime.Extensions": "4.1.0",
-          "System.Text.Encoding": "4.0.11",
-          "System.Threading": "4.0.11",
-          "System.Xml.ReaderWriter": "4.0.11"
-        }
+        "resolved": "4.5.0",
+        "contentHash": "okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ=="
       },
       "xunit.abstractions": {
         "type": "Transitive",
@@ -1085,6 +721,25 @@
           "Nncase.IO": "[1.0.0, )"
         }
       },
+      "nncase.compiler": {
+        "type": "Project",
+        "dependencies": {
+          "DryIoc.Microsoft.DependencyInjection": "[6.1.0, )",
+          "DryIoc.dll": "[5.3.1, )",
+          "Microsoft.Extensions.Hosting": "[6.0.0, )",
+          "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Core": "[1.0.0, )",
+          "Nncase.Diagnostics": "[1.0.0, )",
+          "Nncase.EGraph": "[1.0.0, )",
+          "Nncase.Evaluator": "[1.0.0, )",
+          "Nncase.Graph": "[1.0.0, )",
+          "Nncase.Importer": "[1.0.0, )",
+          "Nncase.Modules.StackVM": "[1.0.0, )",
+          "Nncase.Passes": "[1.0.0, )",
+          "Nncase.Quantization": "[1.0.0, )",
+          "Nncase.Simulator": "[1.0.0, )"
+        }
+      },
       "nncase.core": {
         "type": "Project",
         "dependencies": {
@@ -1099,6 +754,12 @@
           "System.Reactive": "[5.0.0, )"
         }
       },
+      "nncase.diagnostics": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.Core": "[1.0.0, )"
+        }
+      },
       "nncase.egraph": {
         "type": "Project",
         "dependencies": {
@@ -1124,6 +785,15 @@
           "Nncase.Evaluator": "[1.0.0, )"
         }
       },
+      "nncase.importer": {
+        "type": "Project",
+        "dependencies": {
+          "LanguageExt.Core": "[4.4.0, )",
+          "Nncase.Core": "[1.0.0, )",
+          "Onnx.Protobuf": "[1.0.0, )",
+          "TFLite.Schema": "[1.0.0, )"
+        }
+      },
       "nncase.io": {
         "type": "Project"
       },
@@ -1143,18 +813,50 @@
           "Nncase.Graph": "[1.0.0, )"
         }
       },
+      "nncase.quantization": {
+        "type": "Project",
+        "dependencies": {
+          "Newtonsoft.Json": "[13.0.3, )",
+          "Nncase.Core": "[1.0.0, )",
+          "Nncase.Passes": "[1.0.0, )",
+          "OrtKISharp": "[0.0.2, )",
+          "System.Linq.Async": "[6.0.1, )"
+        }
+      },
       "nncase.simulator": {
         "type": "Project",
         "dependencies": {
           "Nncase.Core": "[1.0.0, )"
         }
       },
+      "onnx.protobuf": {
+        "type": "Project",
+        "dependencies": {
+          "Google.Protobuf": "[3.19.4, )"
+        }
+      },
+      "tflite.schema": {
+        "type": "Project",
+        "dependencies": {
+          "Nncase.FlatBuffers": "[2.0.0, )"
+        }
+      },
       "DryIoc.dll": {
         "type": "CentralTransitive",
         "requested": "[5.3.1, )",
         "resolved": "5.3.1",
         "contentHash": "E3zclUh2CIBks1t2uBD1k18pyGFJ1YSKCrbCDbB7qCdl2RAB+k68AyDpjeplhF1ot2XPV82AgyCWBXMf0ggL1g=="
       },
+      "DryIoc.Microsoft.DependencyInjection": {
+        "type": "CentralTransitive",
+        "requested": "[6.1.0, )",
+        "resolved": "6.1.0",
+        "contentHash": "GJtCx0XgvdRXmZDtJH5FW7vMhaN2nPwOlwV7EIWN+f4+Rw2+eRCfHihtR8l9ozfgVaHkA8+zmA8PpHGKKIflcw==",
+        "dependencies": {
+          "DryIoc.dll": "5.2.2",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0"
+        }
+      },
       "Extension.Mathematics": {
         "type": "CentralTransitive",
         "requested": "[1.2.12, )",
@@ -1187,17 +889,51 @@
         "resolved": "3.19.4",
         "contentHash": "fd07/ykL4O4FhqrZIELm5lmiyOHfdPg9+o+hWr6tcfRdS7tHXnImg/2wtogLzlW2eEmr0J7j6ZrZvaWOLiJbxQ=="
       },
+      "LanguageExt.Core": {
+        "type": "CentralTransitive",
+        "requested": "[4.4.0, )",
+        "resolved": "4.4.0",
+        "contentHash": "3VARp4kl87gaVNO0vg70A9Brk48cEWEVTG6p30cVN0gCI7ftrDBqkEyy8hUCVweBJUqs4J5ZFrw2tu6dp+gnQQ==",
+        "dependencies": {
+          "Microsoft.Bcl.AsyncInterfaces": "6.0.0",
+          "Microsoft.CSharp": "4.7.0",
+          "System.Diagnostics.Contracts": "4.3.0",
+          "System.Linq": "4.3.0",
+          "System.Linq.Queryable": "4.3.0",
+          "System.Memory": "4.5.4",
+          "System.Reflection.Emit": "4.3.0",
+          "System.Reflection.Emit.Lightweight": "4.3.0",
+          "System.Threading.Tasks.Extensions": "4.5.4",
+          "System.ValueTuple": "4.5.0"
+        }
+      },
       "Microsoft.Extensions.Hosting": {
         "type": "CentralTransitive",
         "requested": "[6.0.0, )",
-        "resolved": "2.1.0",
-        "contentHash": "nqOrLtBqpwRT006vdQ2Vp87uiuYztiZcZAndFqH91ZH4SQgr8wImCVQwzUgTxx1DSrpIW765+xrZTZqsoGtvqg==",
+        "resolved": "6.0.0",
+        "contentHash": "M8VzD0ni5VarIRT8njnwK4K2WSAo0kZH4Zc3mKcSGkP4CjDZ91T9ZEFmmwhmo4z7x8AFq+tW0WFi9wX+K2cxkQ==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration": "2.1.0",
-          "Microsoft.Extensions.DependencyInjection": "2.1.0",
-          "Microsoft.Extensions.FileProviders.Physical": "2.1.0",
-          "Microsoft.Extensions.Hosting.Abstractions": "2.1.0",
-          "Microsoft.Extensions.Logging": "2.1.0"
+          "Microsoft.Extensions.Configuration": "6.0.0",
+          "Microsoft.Extensions.Configuration.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Configuration.Binder": "6.0.0",
+          "Microsoft.Extensions.Configuration.CommandLine": "6.0.0",
+          "Microsoft.Extensions.Configuration.EnvironmentVariables": "6.0.0",
+          "Microsoft.Extensions.Configuration.FileExtensions": "6.0.0",
+          "Microsoft.Extensions.Configuration.Json": "6.0.0",
+          "Microsoft.Extensions.Configuration.UserSecrets": "6.0.0",
+          "Microsoft.Extensions.DependencyInjection": "6.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileProviders.Physical": "6.0.0",
+          "Microsoft.Extensions.Hosting.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Logging": "6.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Logging.Configuration": "6.0.0",
+          "Microsoft.Extensions.Logging.Console": "6.0.0",
+          "Microsoft.Extensions.Logging.Debug": "6.0.0",
+          "Microsoft.Extensions.Logging.EventLog": "6.0.0",
+          "Microsoft.Extensions.Logging.EventSource": "6.0.0",
+          "Microsoft.Extensions.Options": "6.0.0"
         }
       },
       "Microsoft.Extensions.Hosting.Abstractions": {
@@ -1244,6 +980,18 @@
           "System.Runtime.CompilerServices.Unsafe": "5.0.0"
         }
       },
+      "Newtonsoft.Json": {
+        "type": "CentralTransitive",
+        "requested": "[13.0.3, )",
+        "resolved": "13.0.3",
+        "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
+      },
+      "Nncase.FlatBuffers": {
+        "type": "CentralTransitive",
+        "requested": "[2.0.0, )",
+        "resolved": "2.0.0",
+        "contentHash": "ir3uek0+7Y8SwOUGUR8y94sgpVDWLAjKGBm9z7cLe/38GyPxWbIYHPnHZHksNTExTsx3Ie9GtwagkgR/jm64hA=="
+      },
       "OrtKISharp": {
         "type": "CentralTransitive",
         "requested": "[0.0.2, )",
diff --git a/src/Nncase.Tests/Targets/UnitTestCPUTarget.cs b/src/Nncase.Tests/Targets/UnitTestCPUTarget.cs
new file mode 100644
index 0000000000..9ea99522c9
--- /dev/null
+++ b/src/Nncase.Tests/Targets/UnitTestCPUTarget.cs
@@ -0,0 +1,289 @@
+// Copyright (c) Canaan Inc. All rights reserved.
+// Licensed under the Apache license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Nncase.CodeGen;
+using Nncase.Diagnostics;
+using Nncase.IR;
+using Nncase.IR.Tensors;
+using Nncase.Runtime.Interop;
+using Nncase.Targets;
+using Nncase.Tests.TestFixture;
+using Nncase.Utilities;
+using Xunit;
+using static Nncase.IR.F.Tensors;
+using GetItem = Nncase.IR.Tensors.GetItem;
+
+namespace Nncase.Tests.Targets;
+
+[AutoSetupTestMethod(InitSession = true)]
+public class UnitTestCPUTarget : TestClassBase
+{
+    public UnitTestCPUTarget()
+    {
+        DefaultTargetName = CPUTarget.Kind;
+    }
+
+    public static IEnumerable<object[]> TestGetItemData =>
+        new[]
+        {
+            new object[] { new[] { 0, 1 } },
+            new object[] { new[] { 0, -1 } },
+        };
+
+    public static IEnumerable<object[]> TestIfData =>
+        new[]
+        {
+            new object[] { true },
+            new object[] { false },
+        };
+
+    [Fact]
+    [AutoSetupTestMethod(InitSession = false)]
+    public void TestCPUTargetKind()
+    {
+        Assert.Equal("cpu", CPUTarget.Kind);
+    }
+
+    [Fact]
+    [AutoSetupTestMethod(InitSession = false)]
+    public void TestCreateCPUTarget()
+    {
+        var target = CompilerServices.GetTarget(CPUTarget.Kind);
+        Assert.NotNull(target);
+    }
+
+    [Theory]
+    [CombinatorialData]
+    public void TestCreateStackVMModuleBuilder([CombinatorialValues("stackvm")] string moduleKind)
+    {
+        var moduleBuilder = CompileSession.Target.CreateModuleBuilder(moduleKind, CompileOptions);
+        Assert.NotNull(moduleBuilder);
+    }
+
+    [Fact]
+    public void TestSimpleCodeGen()
+    {
+        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
+        var y = x + 1.0f;
+        TestCodeGen(y, new[] { x });
+    }
+
+    [Fact]
+    public void TestCodeGenUseVarMultiTimes()
+    {
+        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
+        var y = x + 1.0f + x;
+        TestCodeGen(y, new[] { x });
+    }
+
+    [Fact]
+    public void TestCodeGenTuple()
+    {
+        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
+        var y = x + 1.0f + x;
+        var z = y * 2.0f;
+        TestCodeGen(new IR.Tuple(y, z), new[] { x });
+    }
+
+    [Fact]
+    public void TestCodeGenVisitLeafVar()
+    {
+        var main = new Function(new Var(), Array.Empty<Var>());
+        var module = new IRModule(main);
+        var modelBuilder = CompileSession.GetRequiredService<IModelBuilder>();
+        Assert.Throws<InvalidOperationException>(() => modelBuilder.Build(module));
+    }
+
+    [Fact]
+    public void TestSimpleBinary()
+    {
+        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
+        var y = x + 1.0f;
+        var main = new Function("main", y, new[] { x });
+        var module = new IRModule(main);
+        GenerateKModelAndRun(module, new[] { 1.0f }, new[] { 2.0f });
+    }
+
+    [Fact]
+    public void TestCodegenCallParamOrder()
+    {
+        // order is true: x - 3 = 2 - 3 = -1
+        // order is false: 3 - x = 3 - 2 = 1
+        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
+        var y = x - 3f;
+        var main = new Function("main", y, new[] { x });
+        GenerateKModelAndRunFromFn(main, new[] { 2f }, (Tensor)new[] { -1f });
+    }
+
+    [Fact]
+    public void TestSimpleTupleOutput()
+    {
+        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
+        var main = new Function("main", new IR.Tuple(x + 1.0f, x * 3.0f), new[] { x });
+        var module = new IRModule(main);
+        GenerateKModelAndRun(module, new[] { 1.0f }, new[] { (Tensor)2.0f, 3.0f });
+    }
+
+    [Fact]
+    public void TestTupleOrder()
+    {
+        var x = new Var("x", new TensorType(DataTypes.Float32, new[] { 1 }));
+        var main = new Function("main", new IR.Tuple(x + 1.0f, x + 2f, x + 3f), new[] { x });
+        GenerateKModelAndRunFromFn(main, new[] { 1f }, new[] { (Tensor)2f, 3f, 4f });
+    }
+
+    [Theory]
+    [MemberData(nameof(TestGetItemData))]
+    public void TestGetItem(int[] index)
+    {
+        var input = Tensor.From(new[] { 1, 2, 3, 4, 5, 6 }, new[] { 1, 2, 3 });
+        var x = new Var("x", new TensorType(DataTypes.Int32, new[] { 1, 2, 3 }));
+        var second = GetItem(x, index);
+        var main = new Function("main", second, new[] { x });
+        var dict = new Dictionary<Var, IValue>() { { x, Value.FromTensor(input) } };
+        GenerateKModelAndRunFromFn(main, input, second.Evaluate(dict).AsTensor());
+    }
+
+    [Fact]
+    public void TestCallFunction()
+    {
+        var a = new Var("a");
+        var b = a + 1.0f;
+        var funcA = new Function("funcA", b, new[] { a });
+
+        var x = new Var("x");
+        var y = new Call(funcA, x + 1.0f);
+        var main = new Function("main", y, new[] { x });
+        var module = new IRModule(main);
+        module.Add(funcA);
+        GenerateKModelAndRun(module, new[] { 1.0f }, new[] { 3.0f });
+    }
+
+    [Theory]
+    [MemberData(nameof(TestIfData))]
+    public void TestIf(bool input)
+    {
+        var condVar = new Var(new TensorType(DataTypes.Boolean, Shape.Scalar));
+        var then = IR.F.Math.Abs(3f);
+        var @else = IR.F.NN.Relu(Cast(3, DataTypes.Float32));
+        var @if = IR.F.Math.Abs(new If(condVar, then, @else));
+
+        Assert.True(@if.InferenceType());
+        var main = new Function("main", @if, new[] { condVar });
+
+        var output = @if.Evaluate(new Dictionary<Var, IValue> { { condVar, Value.FromTensor(input) } }).AsTensor();
+        GenerateKModelAndRunFromFn(main, input, output);
+    }
+
+    [Fact]
+    public void TestStackVMNestIf()
+    {
+        var condVar = new Var(new TensorType(DataTypes.Boolean, Shape.Scalar));
+        _ = (Expr)3 - 1;
+        var @else = (Expr)3 + 1;
+        var elseThen = (Expr)8 * 8;
+        var elsif = new If(condVar, elseThen, @else);
+
+        var main = new Function("main", 2 * elsif, new[] { condVar });
+
+        var input = (Tensor)true;
+        var output = (Tensor)128;
+        GenerateKModelAndRunFromFn(main, input, output);
+    }
+
+    [Fact]
+    public void TestNestIfWithThenBegin()
+    {
+        CompileOptions.DumpFlags = DumpFlags.CodeGen;
+        var condVar = new Var(new TensorType(DataTypes.Boolean, Shape.Scalar));
+        var cast = Cast(condVar, DataTypes.Int32);
+        var i = new If(condVar, cast * new If(condVar, 3 + cast, 2), 6);
+        var main = new Function("main", i, new[] { condVar });
+        Dumpper.DumpIR(main, "main");
+        var input = (Tensor)true;
+        var output = (Tensor)4;
+        GenerateKModelAndRunFromFn(main, input, output);
+    }
+
+    [Fact]
+    public void TestNestIfWithElseBegin()
+    {
+        var condVar = new Var(new TensorType(DataTypes.Boolean, Shape.Scalar));
+        var i = new If(condVar, 3, new If(condVar, 1, 2));
+        var main = new Function("main", i, new[] { condVar });
+        var input = (Tensor)false;
+        var output = (Tensor)2;
+        GenerateKModelAndRunFromFn(main, input, output);
+    }
+
+    private void TestCodeGen(Expr body, Var[] vars, [CallerMemberName] string? name = null)
+    {
+        var main = new Function("main", body, vars);
+        var module = new IRModule(main);
+        var modelBuilder = CompileSession.GetRequiredService<IModelBuilder>();
+        var linkedModel = modelBuilder.Build(module);
+        using var output = File.Open($"{name}.kmodel", FileMode.Create);
+        linkedModel.Serialize(output);
+        Assert.NotEqual(0, output.Length);
+    }
+
+    private void GenerateKModelAndRun(IRModule module, Tensor input, Tensor[] expectedOutput, [CallerMemberName] string? name = null)
+    {
+        var modelBuilder = CompileSession.GetRequiredService<IModelBuilder>();
+        var linkedModel = modelBuilder.Build(module);
+        using (var output = File.Open($"{name}.kmodel", FileMode.Create))
+        {
+            linkedModel.Serialize(output);
+            Assert.NotEqual(0, output.Length);
+        }
+
+        byte[] kmodel;
+        using (var output = new MemoryStream())
+        {
+            linkedModel.Serialize(output);
+            kmodel = output.ToArray();
+        }
+
+        var interp = RTInterpreter.Create();
+        interp.LoadModel(kmodel);
+        var entry = interp.Entry;
+        Assert.NotNull(entry);
+
+        var rtInput = RTTensor.FromTensor(input);
+        var rtOutput = entry!.Invoke(rtInput);
+        var rtOutputs = rtOutput is RTTensor t ? new[] { t } : ((RTTuple)rtOutput).Fields.Cast<RTTensor>().ToArray();
+        Assert.Equal(expectedOutput.Length, rtOutputs.Length);
+
+        for (int i = 0; i < rtOutputs.Length; i++)
+        {
+            var outBuffer = rtOutputs[i].Buffer.Buffer.AsHost()!;
+            using (var mmOwner = outBuffer.Map(RTMapAccess.Read))
+            {
+                Assert.Equal(expectedOutput[i].BytesBuffer.ToArray(), mmOwner.Memory.Span.ToArray());
+            }
+        }
+    }
+
+    private void GenerateKModelAndRun(IRModule module, Tensor input, Tensor expectedOutput, [CallerMemberName] string? name = null)
+    {
+        GenerateKModelAndRun(module, input, new[] { expectedOutput }, name);
+    }
+
+    private void GenerateKModelAndRunFromFn(Function fn, Tensor input, Tensor expectedOutput, [CallerMemberName] string? name = null)
+    {
+        GenerateKModelAndRun(new IRModule(fn), input, new[] { expectedOutput }, name);
+    }
+
+    private void GenerateKModelAndRunFromFn(Function fn, Tensor input, Tensor[] expectedOutput, [CallerMemberName] string? name = null)
+    {
+        GenerateKModelAndRun(new IRModule(fn), input, expectedOutput, name);
+    }
+}
diff --git a/src/Nncase.Tests/packages.lock.json b/src/Nncase.Tests/packages.lock.json
index cf25699afc..beff5e02b5 100644
--- a/src/Nncase.Tests/packages.lock.json
+++ b/src/Nncase.Tests/packages.lock.json
@@ -470,16 +470,6 @@
           "Newtonsoft.Json": "9.0.1"
         }
       },
-      "Microsoft.Win32.Primitives": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "9ZQKCWxH7Ijp9BfahvL2Zyf1cJIk8XYLF6Yjzr2yi0b2cOut/HQ31qf1ThHAgCc3WiZMdnWcfJCgN82/0UunxA==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.Runtime": "4.3.0"
-        }
-      },
       "NetFabric.Hyperlinq.Abstractions": {
         "type": "Transitive",
         "resolved": "1.3.0",
@@ -487,53 +477,10 @@
       },
       "NETStandard.Library": {
         "type": "Transitive",
-        "resolved": "1.6.1",
-        "contentHash": "WcSp3+vP+yHNgS8EV5J7pZ9IRpeDuARBPN28by8zqff1wJQXm26PVU8L3/fYLBJVU7BtDyqNVWq2KlCVvSSR4A==",
+        "resolved": "2.0.3",
+        "contentHash": "st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.Win32.Primitives": "4.3.0",
-          "System.AppContext": "4.3.0",
-          "System.Collections": "4.3.0",
-          "System.Collections.Concurrent": "4.3.0",
-          "System.Console": "4.3.0",
-          "System.Diagnostics.Debug": "4.3.0",
-          "System.Diagnostics.Tools": "4.3.0",
-          "System.Diagnostics.Tracing": "4.3.0",
-          "System.Globalization": "4.3.0",
-          "System.Globalization.Calendars": "4.3.0",
-          "System.IO": "4.3.0",
-          "System.IO.Compression": "4.3.0",
-          "System.IO.Compression.ZipFile": "4.3.0",
-          "System.IO.FileSystem": "4.3.0",
-          "System.IO.FileSystem.Primitives": "4.3.0",
-          "System.Linq": "4.3.0",
-          "System.Linq.Expressions": "4.3.0",
-          "System.Net.Http": "4.3.0",
-          "System.Net.Primitives": "4.3.0",
-          "System.Net.Sockets": "4.3.0",
-          "System.ObjectModel": "4.3.0",
-          "System.Reflection": "4.3.0",
-          "System.Reflection.Extensions": "4.3.0",
-          "System.Reflection.Primitives": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Runtime.Handles": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0",
-          "System.Runtime.InteropServices.RuntimeInformation": "4.3.0",
-          "System.Runtime.Numerics": "4.3.0",
-          "System.Security.Cryptography.Algorithms": "4.3.0",
-          "System.Security.Cryptography.Encoding": "4.3.0",
-          "System.Security.Cryptography.Primitives": "4.3.0",
-          "System.Security.Cryptography.X509Certificates": "4.3.0",
-          "System.Text.Encoding": "4.3.0",
-          "System.Text.Encoding.Extensions": "4.3.0",
-          "System.Text.RegularExpressions": "4.3.0",
-          "System.Threading": "4.3.0",
-          "System.Threading.Tasks": "4.3.0",
-          "System.Threading.Timer": "4.3.0",
-          "System.Xml.ReaderWriter": "4.3.0",
-          "System.Xml.XDocument": "4.3.0"
+          "Microsoft.NETCore.Platforms": "1.1.0"
         }
       },
       "NuGet.Frameworks": {
@@ -541,126 +488,11 @@
         "resolved": "5.0.0",
         "contentHash": "c5JVjuVAm4f7E9Vj+v09Z9s2ZsqFDjBpcsyS3M9xRo0bEdm/LVZSzLxxNvfvAwRiiE8nwe1h2G4OwiwlzFKXlA=="
       },
-      "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "HdSSp5MnJSsg08KMfZThpuLPJpPwE5hBXvHwoKWosyHHfe8Mh5WKT0ylEOf6yNzX6Ngjxe4Whkafh5q7Ymac4Q=="
-      },
-      "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "+yH1a49wJMy8Zt4yx5RhJrxO/DBDByAiCzNwiETI+1S4mPdCu0OY4djdciC7Vssk0l22wQaDLrXxXkp+3+7bVA=="
-      },
-      "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "c3YNH1GQJbfIPJeCnr4avseugSqPrxwIqzthYyZDN6EuOyNOzq+y2KSUfRcXauya1sF4foESTgwM5e1A8arAKw=="
-      },
-      "runtime.native.System": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "c/qWt2LieNZIj1jGnVNsE2Kl23Ya2aSTBuXMD6V7k9KWr6l16Tqdwq+hJScEpWER9753NWC8h96PaVNY5Ld7Jw==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0"
-        }
-      },
-      "runtime.native.System.IO.Compression": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "INBPonS5QPEgn7naufQFXJEp3zX6L4bwHgJ/ZH78aBTpeNfQMtf7C6VrAFhlq2xxWBveIOWyFzQjJ8XzHMhdOQ==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0"
-        }
-      },
-      "runtime.native.System.Net.Http": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "ZVuZJqnnegJhd2k/PtAbbIcZ3aZeITq3sj06oKfMBSfphW3HDmk/t4ObvbOk/JA/swGR0LNqMksAh/f7gpTROg==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0"
-        }
-      },
-      "runtime.native.System.Security.Cryptography.Apple": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "DloMk88juo0OuOWr56QG7MNchmafTLYWvABy36izkrLI5VledI0rq28KGs1i9wbpeT9NPQrx/wTf8U2vazqQ3Q==",
-        "dependencies": {
-          "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple": "4.3.0"
-        }
-      },
-      "runtime.native.System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "NS1U+700m4KFRHR5o4vo9DSlTmlCKu/u7dtE5sUHVIPB+xpXxYQvgBgA6wEIeCz6Yfn0Z52/72WYsToCEPJnrw==",
-        "dependencies": {
-          "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0",
-          "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0",
-          "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0",
-          "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0",
-          "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0",
-          "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0",
-          "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0",
-          "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0",
-          "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0",
-          "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0"
-        }
-      },
-      "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "b3pthNgxxFcD+Pc0WSEoC0+md3MyhRS6aCEeenvNE3Fdw1HyJ18ZhRFVJJzIeR/O/jpxPboB805Ho0T3Ul7w8A=="
-      },
-      "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "KeLz4HClKf+nFS7p/6Fi/CqyLXh81FpiGzcmuS8DGi9lUqSnZ6Es23/gv2O+1XVGfrbNmviF7CckBpavkBoIFQ=="
-      },
-      "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "kVXCuMTrTlxq4XOOMAysuNwsXWpYeboGddNGpIgNSZmv1b6r/s/DPk0fYMB7Q5Qo4bY68o48jt4T4y5BVecbCQ=="
-      },
-      "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "X7IdhILzr4ROXd8mI1BUCQMSHSQwelUlBjF1JyTKCjXaOGn2fB4EKBxQbCK2VjO3WaWIdlXZL3W6TiIVnrhX4g=="
-      },
-      "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "nyFNiCk/r+VOiIqreLix8yN+q3Wga9+SE8BCgkf+2BwEKiNx6DyvFjCgkfV743/grxv8jHJ8gUK4XEQw7yzRYg=="
-      },
-      "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "ytoewC6wGorL7KoCAvRfsgoJPJbNq+64k2SqW6JcOAebWsFUvCCYgfzQMrnpvPiEl4OrblUlhF2ji+Q1+SVLrQ=="
-      },
-      "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "I8bKw2I8k58Wx7fMKQJn2R8lamboCAiHfHeV/pS65ScKWMMI0+wJkLYlEKvgW1D/XvSl/221clBoR2q9QNNM7A=="
-      },
-      "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "VB5cn/7OzUfzdnC8tqAIMQciVLiq2epm2NrAm1E9OjNRyG4lVhfR61SMcLizejzQP8R8Uf/0l5qOIbUEi+RdEg=="
-      },
       "StyleCop.Analyzers.Unstable": {
         "type": "Transitive",
         "resolved": "1.2.0.435",
         "contentHash": "ouwPWZxbOV3SmCZxIRqHvljkSzkCyi1tDoMzQtDb/bRP8ctASV/iRJr+A2Gdj0QLaLmWnqTWDrH82/iP+X80Lg=="
       },
-      "System.AppContext": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "fKC+rmaLfeIzUhagxY17Q9siv/sPrjjKcfNg1Ic8IlQkZLipo8ljcaZQu4VtI4Jqbzjc2VTjzGLF6WmsRXAEgA==",
-        "dependencies": {
-          "System.Runtime": "4.3.0"
-        }
-      },
       "System.Buffers": {
         "type": "Transitive",
         "resolved": "4.5.1",
@@ -676,40 +508,11 @@
           "System.Runtime": "4.3.0"
         }
       },
-      "System.Collections.Concurrent": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "ztl69Xp0Y/UXCL+3v3tEU+lIy+bvjKNUmopn1wep/a291pVPK7dxBd6T7WnlQqRog+d1a/hSsgRsmFnIBKTPLQ==",
-        "dependencies": {
-          "System.Collections": "4.3.0",
-          "System.Diagnostics.Debug": "4.3.0",
-          "System.Diagnostics.Tracing": "4.3.0",
-          "System.Globalization": "4.3.0",
-          "System.Reflection": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Threading": "4.3.0",
-          "System.Threading.Tasks": "4.3.0"
-        }
-      },
       "System.Collections.Immutable": {
         "type": "Transitive",
         "resolved": "7.0.0",
         "contentHash": "dQPcs0U1IKnBdRDBkrCTi1FoajSTBzLcVTpjO4MBCMC7f4pDOIPzgBoX8JjG7X6uZRJ8EBxsi8+DR1JuwjnzOQ=="
       },
-      "System.Console": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "DHDrIxiqk1h03m6khKWV2X8p/uvN79rgSqpilL6uzpmSfxfU5ng8VcPtW4qsDsQDHiTv6IPV9TmD5M/vElPNLg==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.IO": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Text.Encoding": "4.3.0"
-        }
-      },
       "System.Diagnostics.Contracts": {
         "type": "Transitive",
         "resolved": "4.3.0",
@@ -741,26 +544,6 @@
         "resolved": "6.0.0",
         "contentHash": "lcyUiXTsETK2ALsZrX+nWuHSIQeazhqPphLfaRxzdGaG93+0kELqpgEHtwWOlQe7+jSFnKwaCAgL4kjeZCQJnw=="
       },
-      "System.Diagnostics.Tools": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "UUvkJfSYJMM6x527dJg2VyWPSRqIVB0Z7dbjHst1zmwTXz5CcXSYJFWRpuigfbO1Lf7yfZiIaEUesfnl/g5EyA==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.Runtime": "4.3.0"
-        }
-      },
-      "System.Diagnostics.Tracing": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "rswfv0f/Cqkh78rA5S8eN8Neocz234+emGCtTF3lxPY96F+mmmUen6tbn0glN6PMvlKQb9bPAY5e9u7fgPTkKw==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.Runtime": "4.3.0"
-        }
-      },
       "System.Globalization": {
         "type": "Transitive",
         "resolved": "4.3.0",
@@ -771,30 +554,6 @@
           "System.Runtime": "4.3.0"
         }
       },
-      "System.Globalization.Calendars": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "GUlBtdOWT4LTV3I+9/PJW+56AnnChTaOqqTLFtdmype/L500M2LIyXgmtd9X2P2VOkmJd5c67H5SaC2QcL1bFA==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.Globalization": "4.3.0",
-          "System.Runtime": "4.3.0"
-        }
-      },
-      "System.Globalization.Extensions": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "FhKmdR6MPG+pxow6wGtNAWdZh7noIOpdD5TwQ3CprzgIE1bBBoim0vbR1+AWsWjQmU7zXHgQo4TWSP6lCeiWcQ==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "System.Globalization": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0"
-        }
-      },
       "System.IO": {
         "type": "Transitive",
         "resolved": "4.3.0",
@@ -807,67 +566,6 @@
           "System.Threading.Tasks": "4.3.0"
         }
       },
-      "System.IO.Compression": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "YHndyoiV90iu4iKG115ibkhrG+S3jBm8Ap9OwoUAzO5oPDAWcr0SFwQFm0HjM8WkEZWo0zvLTyLmbvTkW1bXgg==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "System.Buffers": "4.3.0",
-          "System.Collections": "4.3.0",
-          "System.Diagnostics.Debug": "4.3.0",
-          "System.IO": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Runtime.Handles": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0",
-          "System.Text.Encoding": "4.3.0",
-          "System.Threading": "4.3.0",
-          "System.Threading.Tasks": "4.3.0",
-          "runtime.native.System": "4.3.0",
-          "runtime.native.System.IO.Compression": "4.3.0"
-        }
-      },
-      "System.IO.Compression.ZipFile": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "G4HwjEsgIwy3JFBduZ9quBkAu+eUwjIdJleuNSgmUojbH6O3mlvEIme+GHx/cLlTAPcrnnL7GqvB9pTlWRfhOg==",
-        "dependencies": {
-          "System.Buffers": "4.3.0",
-          "System.IO": "4.3.0",
-          "System.IO.Compression": "4.3.0",
-          "System.IO.FileSystem": "4.3.0",
-          "System.IO.FileSystem.Primitives": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Text.Encoding": "4.3.0"
-        }
-      },
-      "System.IO.FileSystem": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "3wEMARTnuio+ulnvi+hkRNROYwa1kylvYahhcLk4HSoVdl+xxTFVeVlYOfLwrDPImGls0mDqbMhrza8qnWPTdA==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.IO": "4.3.0",
-          "System.IO.FileSystem.Primitives": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Handles": "4.3.0",
-          "System.Text.Encoding": "4.3.0",
-          "System.Threading.Tasks": "4.3.0"
-        }
-      },
-      "System.IO.FileSystem.Primitives": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "6QOb2XFLch7bEc4lIcJH49nJN2HV+OC3fHDgsLVsBVBk3Y4hFAnOBGzJ2lUu7CyDDFo9IBWkSsnbkT6IBwwiMw==",
-        "dependencies": {
-          "System.Runtime": "4.3.0"
-        }
-      },
       "System.Linq": {
         "type": "Transitive",
         "resolved": "4.3.0",
@@ -924,63 +622,6 @@
         "resolved": "4.5.5",
         "contentHash": "XIWiDvKPXaTveaB7HVganDlOCRoj03l+jrwNvcge/t8vhGYKvqV+dMv6G4SAX2NoNmN0wZfVPTAlFwZcZvVOUw=="
       },
-      "System.Net.Http": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "sYg+FtILtRQuYWSIAuNOELwVuVsxVyJGWQyOnlAzhV4xvhyFnON1bAzYYC+jjRW8JREM45R0R5Dgi8MTC5sEwA==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "System.Collections": "4.3.0",
-          "System.Diagnostics.Debug": "4.3.0",
-          "System.Diagnostics.DiagnosticSource": "4.3.0",
-          "System.Diagnostics.Tracing": "4.3.0",
-          "System.Globalization": "4.3.0",
-          "System.Globalization.Extensions": "4.3.0",
-          "System.IO": "4.3.0",
-          "System.IO.FileSystem": "4.3.0",
-          "System.Net.Primitives": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Runtime.Handles": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0",
-          "System.Security.Cryptography.Algorithms": "4.3.0",
-          "System.Security.Cryptography.Encoding": "4.3.0",
-          "System.Security.Cryptography.OpenSsl": "4.3.0",
-          "System.Security.Cryptography.Primitives": "4.3.0",
-          "System.Security.Cryptography.X509Certificates": "4.3.0",
-          "System.Text.Encoding": "4.3.0",
-          "System.Threading": "4.3.0",
-          "System.Threading.Tasks": "4.3.0",
-          "runtime.native.System": "4.3.0",
-          "runtime.native.System.Net.Http": "4.3.0",
-          "runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0"
-        }
-      },
-      "System.Net.Primitives": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "qOu+hDwFwoZPbzPvwut2qATe3ygjeQBDQj91xlsaqGFQUI5i4ZnZb8yyQuLGpDGivEPIt8EJkd1BVzVoP31FXA==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Handles": "4.3.0"
-        }
-      },
-      "System.Net.Sockets": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "m6icV6TqQOAdgt5N/9I5KNpjom/5NFtkmGseEH+AK/hny8XrytLH3+b5M8zL/Ycg3fhIocFpUMyl/wpFnVRvdw==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.IO": "4.3.0",
-          "System.Net.Primitives": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Threading.Tasks": "4.3.0"
-        }
-      },
       "System.ObjectModel": {
         "type": "Transitive",
         "resolved": "4.3.0",
@@ -1109,198 +750,6 @@
           "System.Runtime": "4.3.0"
         }
       },
-      "System.Runtime.Handles": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "OKiSUN7DmTWeYb3l51A7EYaeNMnvxwE249YtZz7yooT4gOZhmTjIn48KgSsw2k2lYdLgTKNJw/ZIfSElwDRVgg==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.Runtime": "4.3.0"
-        }
-      },
-      "System.Runtime.InteropServices": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "uv1ynXqiMK8mp1GM3jDqPCFN66eJ5w5XNomaK2XD+TuCroNTLFGeZ+WCmBMcBDyTFKou3P6cR6J/QsaqDp7fGQ==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.Reflection": "4.3.0",
-          "System.Reflection.Primitives": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Handles": "4.3.0"
-        }
-      },
-      "System.Runtime.InteropServices.RuntimeInformation": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "cbz4YJMqRDR7oLeMRbdYv7mYzc++17lNhScCX0goO2XpGWdvAt60CGN+FHdePUEHCe/Jy9jUlvNAiNdM+7jsOw==",
-        "dependencies": {
-          "System.Reflection": "4.3.0",
-          "System.Reflection.Extensions": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0",
-          "System.Threading": "4.3.0",
-          "runtime.native.System": "4.3.0"
-        }
-      },
-      "System.Runtime.Numerics": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "yMH+MfdzHjy17l2KESnPiF2dwq7T+xLnSJar7slyimAkUh/gTrS9/UQOtv7xarskJ2/XDSNvfLGOBQPjL7PaHQ==",
-        "dependencies": {
-          "System.Globalization": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0"
-        }
-      },
-      "System.Security.Cryptography.Algorithms": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "W1kd2Y8mYSCgc3ULTAZ0hOP2dSdG5YauTb1089T0/kRcN2MpSAW1izOFROrJgxSlMn3ArsgHXagigyi+ibhevg==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "System.Collections": "4.3.0",
-          "System.IO": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Runtime.Handles": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0",
-          "System.Runtime.Numerics": "4.3.0",
-          "System.Security.Cryptography.Encoding": "4.3.0",
-          "System.Security.Cryptography.Primitives": "4.3.0",
-          "System.Text.Encoding": "4.3.0",
-          "runtime.native.System.Security.Cryptography.Apple": "4.3.0",
-          "runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0"
-        }
-      },
-      "System.Security.Cryptography.Cng": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "03idZOqFlsKRL4W+LuCpJ6dBYDUWReug6lZjBa3uJWnk5sPCUXckocevTaUA8iT/MFSrY/2HXkOt753xQ/cf8g==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "System.IO": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Runtime.Handles": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0",
-          "System.Security.Cryptography.Algorithms": "4.3.0",
-          "System.Security.Cryptography.Encoding": "4.3.0",
-          "System.Security.Cryptography.Primitives": "4.3.0",
-          "System.Text.Encoding": "4.3.0"
-        }
-      },
-      "System.Security.Cryptography.Csp": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "X4s/FCkEUnRGnwR3aSfVIkldBmtURMhmexALNTwpjklzxWU7yjMk7GHLKOZTNkgnWnE0q7+BCf9N2LVRWxewaA==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "System.IO": "4.3.0",
-          "System.Reflection": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Runtime.Handles": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0",
-          "System.Security.Cryptography.Algorithms": "4.3.0",
-          "System.Security.Cryptography.Encoding": "4.3.0",
-          "System.Security.Cryptography.Primitives": "4.3.0",
-          "System.Text.Encoding": "4.3.0",
-          "System.Threading": "4.3.0"
-        }
-      },
-      "System.Security.Cryptography.Encoding": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "1DEWjZZly9ae9C79vFwqaO5kaOlI5q+3/55ohmq/7dpDyDfc8lYe7YVxJUZ5MF/NtbkRjwFRo14yM4OEo9EmDw==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "System.Collections": "4.3.0",
-          "System.Collections.Concurrent": "4.3.0",
-          "System.Linq": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Runtime.Handles": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0",
-          "System.Security.Cryptography.Primitives": "4.3.0",
-          "System.Text.Encoding": "4.3.0",
-          "runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0"
-        }
-      },
-      "System.Security.Cryptography.OpenSsl": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "h4CEgOgv5PKVF/HwaHzJRiVboL2THYCou97zpmhjghx5frc7fIvlkY1jL+lnIQyChrJDMNEXS6r7byGif8Cy4w==",
-        "dependencies": {
-          "System.Collections": "4.3.0",
-          "System.IO": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Runtime.Handles": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0",
-          "System.Runtime.Numerics": "4.3.0",
-          "System.Security.Cryptography.Algorithms": "4.3.0",
-          "System.Security.Cryptography.Encoding": "4.3.0",
-          "System.Security.Cryptography.Primitives": "4.3.0",
-          "System.Text.Encoding": "4.3.0",
-          "runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0"
-        }
-      },
-      "System.Security.Cryptography.Primitives": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "7bDIyVFNL/xKeFHjhobUAQqSpJq9YTOpbEs6mR233Et01STBMXNAc/V+BM6dwYGc95gVh/Zf+iVXWzj3mE8DWg==",
-        "dependencies": {
-          "System.Diagnostics.Debug": "4.3.0",
-          "System.Globalization": "4.3.0",
-          "System.IO": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Threading": "4.3.0",
-          "System.Threading.Tasks": "4.3.0"
-        }
-      },
-      "System.Security.Cryptography.X509Certificates": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "t2Tmu6Y2NtJ2um0RtcuhP7ZdNNxXEgUm2JeoA/0NvlMjAhKCnM1NX07TDl3244mVp3QU6LPEhT3HTtH1uF7IYw==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "System.Collections": "4.3.0",
-          "System.Diagnostics.Debug": "4.3.0",
-          "System.Globalization": "4.3.0",
-          "System.Globalization.Calendars": "4.3.0",
-          "System.IO": "4.3.0",
-          "System.IO.FileSystem": "4.3.0",
-          "System.IO.FileSystem.Primitives": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Runtime.Handles": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0",
-          "System.Runtime.Numerics": "4.3.0",
-          "System.Security.Cryptography.Algorithms": "4.3.0",
-          "System.Security.Cryptography.Cng": "4.3.0",
-          "System.Security.Cryptography.Csp": "4.3.0",
-          "System.Security.Cryptography.Encoding": "4.3.0",
-          "System.Security.Cryptography.OpenSsl": "4.3.0",
-          "System.Security.Cryptography.Primitives": "4.3.0",
-          "System.Text.Encoding": "4.3.0",
-          "System.Threading": "4.3.0",
-          "runtime.native.System": "4.3.0",
-          "runtime.native.System.Net.Http": "4.3.0",
-          "runtime.native.System.Security.Cryptography.OpenSsl": "4.3.0"
-        }
-      },
       "System.Text.Encoding": {
         "type": "Transitive",
         "resolved": "4.3.0",
@@ -1311,17 +760,6 @@
           "System.Runtime": "4.3.0"
         }
       },
-      "System.Text.Encoding.Extensions": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "YVMK0Bt/A43RmwizJoZ22ei2nmrhobgeiYwFzC4YAN+nue8RF6djXDMog0UCn+brerQoYVyaS+ghy9P/MUVcmw==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.Runtime": "4.3.0",
-          "System.Text.Encoding": "4.3.0"
-        }
-      },
       "System.Text.Encodings.Web": {
         "type": "Transitive",
         "resolved": "6.0.0",
@@ -1339,14 +777,6 @@
           "System.Text.Encodings.Web": "6.0.0"
         }
       },
-      "System.Text.RegularExpressions": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "RpT2DA+L660cBt1FssIE9CAGpLFdFPuheB7pLpKpn6ZXNby7jDERe8Ua/Ne2xGiwLVG2JOqziiaVCGDon5sKFA==",
-        "dependencies": {
-          "System.Runtime": "4.3.0"
-        }
-      },
       "System.Threading": {
         "type": "Transitive",
         "resolved": "4.3.0",
@@ -1371,62 +801,11 @@
         "resolved": "4.5.4",
         "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg=="
       },
-      "System.Threading.Timer": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "Z6YfyYTCg7lOZjJzBjONJTFKGN9/NIYKSxhU5GRd+DTwHSZyvWp1xuI5aR+dLg+ayyC5Xv57KiY4oJ0tMO89fQ==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0",
-          "Microsoft.NETCore.Targets": "1.1.0",
-          "System.Runtime": "4.3.0"
-        }
-      },
       "System.ValueTuple": {
         "type": "Transitive",
         "resolved": "4.5.0",
         "contentHash": "okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ=="
       },
-      "System.Xml.ReaderWriter": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "GrprA+Z0RUXaR4N7/eW71j1rgMnEnEVlgii49GZyAjTH7uliMnrOU3HNFBr6fEDBCJCIdlVNq9hHbaDR621XBA==",
-        "dependencies": {
-          "System.Collections": "4.3.0",
-          "System.Diagnostics.Debug": "4.3.0",
-          "System.Globalization": "4.3.0",
-          "System.IO": "4.3.0",
-          "System.IO.FileSystem": "4.3.0",
-          "System.IO.FileSystem.Primitives": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Runtime.InteropServices": "4.3.0",
-          "System.Text.Encoding": "4.3.0",
-          "System.Text.Encoding.Extensions": "4.3.0",
-          "System.Text.RegularExpressions": "4.3.0",
-          "System.Threading.Tasks": "4.3.0",
-          "System.Threading.Tasks.Extensions": "4.3.0"
-        }
-      },
-      "System.Xml.XDocument": {
-        "type": "Transitive",
-        "resolved": "4.3.0",
-        "contentHash": "5zJ0XDxAIg8iy+t4aMnQAu0MqVbqyvfoUVl1yDV61xdo3Vth45oA2FoY4pPkxYAH5f8ixpmTqXeEIya95x0aCQ==",
-        "dependencies": {
-          "System.Collections": "4.3.0",
-          "System.Diagnostics.Debug": "4.3.0",
-          "System.Diagnostics.Tools": "4.3.0",
-          "System.Globalization": "4.3.0",
-          "System.IO": "4.3.0",
-          "System.Reflection": "4.3.0",
-          "System.Resources.ResourceManager": "4.3.0",
-          "System.Runtime": "4.3.0",
-          "System.Runtime.Extensions": "4.3.0",
-          "System.Text.Encoding": "4.3.0",
-          "System.Threading": "4.3.0",
-          "System.Xml.ReaderWriter": "4.3.0"
-        }
-      },
       "Tomlyn": {
         "type": "Transitive",
         "resolved": "0.14.3",
@@ -1575,7 +954,9 @@
         "type": "Project",
         "dependencies": {
           "MethodBoundaryAspect.Fody": "[2.0.148, )",
+          "NETStandard.Library": "[2.0.3, )",
           "Nncase.CodeGen": "[1.0.0, )",
+          "Nncase.Compiler": "[1.0.0, )",
           "Nncase.Core": "[1.0.0, )",
           "Nncase.Modules.StackVM": "[1.0.0, )",
           "Nncase.Passes": "[1.0.0, )",
diff --git a/tests/importer/ncnn_/__init__.py b/tests/importer/ncnn_/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/importer/ncnn_/basic/__init__.py b/tests/importer/ncnn_/basic/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/importer/ncnn_/basic/test_conv2d.py b/tests/importer/ncnn_/basic/test_conv2d.py
new file mode 100644
index 0000000000..b892594cad
--- /dev/null
+++ b/tests/importer/ncnn_/basic/test_conv2d.py
@@ -0,0 +1,87 @@
+# Copyright 2019-2021 Canaan Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# pylint: disable=invalid-name, unused-argument, import-outside-toplevel
+
+import pytest
+import numpy as np
+from ncnn_test_runner import Net, NcnnTestRunner
+
+
+def _make_module(i_channels, i_size, k_size, o_channels, strides, padding, dilations):
+    w = np.random.rand(*k_size, i_channels, o_channels).astype(np.float32) - 0.5
+
+    net = Net()
+    input = net.Input("input", i_size[1], i_size[0], i_channels)
+    net.Convolution("conv1", input, o_channels, k_size[1], k_size[0], dilations[1], dilations[0],
+                    strides[1], strides[0], padding[0], padding[1], padding[2], padding[3], 0.0, w)
+
+    return net
+
+
+i_channels = [
+    3,
+    16
+]
+
+i_sizes = [
+    [12, 24],
+    [38, 65]
+]
+
+k_sizes = [
+    [1, 1],
+    [3, 3],
+]
+
+o_channels = [
+    1,
+    8
+]
+
+strides = [
+    (1, 1),
+    (5, 5)
+]
+
+paddings = [
+    (1, 1, 1, 1)
+]
+
+padding_modes = [
+    'zeros'
+]
+
+dilations = [
+    [1, 1],
+    [2, 2]
+]
+
+
+@pytest.mark.parametrize('i_channels', i_channels)
+@pytest.mark.parametrize('i_size', i_sizes)
+@pytest.mark.parametrize('k_size', k_sizes)
+@pytest.mark.parametrize('o_channels', o_channels)
+@pytest.mark.parametrize('strides', strides)
+@pytest.mark.parametrize('padding', paddings)
+@pytest.mark.parametrize('dilations', dilations)
+def test_conv2d(i_channels, i_size, k_size, o_channels, strides, padding, dilations, request):
+    module = _make_module(i_channels, i_size, k_size, o_channels,
+                          strides, padding, dilations)
+    runner = NcnnTestRunner(request.node.name)
+    model_param, model_bin = runner.from_ncnn(module)
+    runner.run(model_param, model_bin)
+
+
+if __name__ == "__main__":
+    pytest.main(['-vv', 'test_conv2d.py'])
diff --git a/tests/kernels/test_reduce_mean.json b/tests/kernels/test_reduce_mean.json
new file mode 100644
index 0000000000..bbbc152705
--- /dev/null
+++ b/tests/kernels/test_reduce_mean.json
@@ -0,0 +1,8 @@
+{
+  "lhs_type":["dt_float16", "dt_float32", "dt_int32", "dt_float64"],
+  "rhs_type":["dt_int64"],
+  "lhs_shape":[[1, 3, 16, 16]],
+  "rhs_shape":[[1]],
+  "bool_value": [0,1],
+  "axis_value":[[0], [-1], [-2], [-3], [1], [2], [3], [2, 3], [-2, -1], [1, 2, 3], [-1, -2, -3], [0, 1, 2, 3], [-1, -2, -3, -4]]
+}
\ No newline at end of file
diff --git a/tests/kernels/test_reduce_prod.json b/tests/kernels/test_reduce_prod.json
new file mode 100644
index 0000000000..6c9953dc4e
--- /dev/null
+++ b/tests/kernels/test_reduce_prod.json
@@ -0,0 +1,8 @@
+{
+  "lhs_type":["dt_float16", "dt_float32", "dt_int32"],
+  "rhs_type":["dt_int64"],
+  "lhs_shape":[[1, 3, 16, 16]],
+  "rhs_shape":[[1]],
+  "bool_value": [0,1],
+  "axis_value":[[0], [-1], [-2], [-3], [1], [2], [3], [2, 3], [-2, -1], [1, 2, 3], [-1, -2, -3], [0, 1, 2, 3], [-1, -2, -3, -4]]
+}
\ No newline at end of file
diff --git a/tests/kernels/test_reduce_sum.json b/tests/kernels/test_reduce_sum.json
new file mode 100644
index 0000000000..bbbc152705
--- /dev/null
+++ b/tests/kernels/test_reduce_sum.json
@@ -0,0 +1,8 @@
+{
+  "lhs_type":["dt_float16", "dt_float32", "dt_int32", "dt_float64"],
+  "rhs_type":["dt_int64"],
+  "lhs_shape":[[1, 3, 16, 16]],
+  "rhs_shape":[[1]],
+  "bool_value": [0,1],
+  "axis_value":[[0], [-1], [-2], [-3], [1], [2], [3], [2, 3], [-2, -1], [1, 2, 3], [-1, -2, -3], [0, 1, 2, 3], [-1, -2, -3, -4]]
+}
\ No newline at end of file
diff --git a/tests/kernels/test_reduce_window_2d.json b/tests/kernels/test_reduce_window_2d.json
new file mode 100644
index 0000000000..618e616b51
--- /dev/null
+++ b/tests/kernels/test_reduce_window_2d.json
@@ -0,0 +1,8 @@
+{
+  "lhs_type":["dt_float32"],
+  "lhs_shape":[[1, 3, 16, 16], [1, 3, 16, 24]],
+  "dilations":[[1, 1]],
+  "filter": [[3, 3], [9, 9]],
+  "stride": [[1, 1], [2, 2]],
+  "onnxPads":[[1, 1, 1, 1], [0, 0, 0, 0]]
+}
\ No newline at end of file
diff --git a/tests/ncnn_test_runner.py b/tests/ncnn_test_runner.py
new file mode 100644
index 0000000000..71635f4473
--- /dev/null
+++ b/tests/ncnn_test_runner.py
@@ -0,0 +1,211 @@
+from posixpath import join
+from typing import Sequence
+import ncnn
+import shutil
+import os
+import numpy as np
+from numpy.core.defchararray import array
+from numpy.lib.function_base import select
+from test_runner import *
+import io
+
+
+class Layer:
+    def __init__(self, type: str, name: str, inputs: Sequence[str] = [], outputs: Sequence[str] = [], params: dict = {}) -> None:
+        self.type = type
+        self.name = name
+        self.inputs = inputs
+        self.outputs = outputs
+        self.params = params
+
+    def __str__(self) -> str:
+        s = f"{self.type} {self.name} {len(self.inputs)} {len(self.outputs)}"
+        s += ''.join([' ' + v for v in self.inputs])
+        s += ''.join([' ' + v for v in self.outputs])
+        s += ''.join([f" {k}={v}" for k, v in self.params.items()])
+        return s
+
+    def __repr__(self) -> str:
+        return str(self)
+
+
+class Net:
+    def __init__(self) -> None:
+        self.layers = []
+        self.bin = io.BytesIO()
+        self.blobs = 0
+
+    def Input(self, name: str, w: int, h: int, c: int) -> str:
+        self._add_layer("Input", name, outputs=[name], params={'0': w, '1': h, '2': c})
+        return name
+
+    def Convolution(self, name: str, input: str, outch: int, kernel_w: int, kernel_h: int,
+                    dilation_w: int, dilation_h: int, stride_w: int, stride_h: int,
+                    pad_left: int, pad_right: int, pad_top: int, pad_bottom: int,
+                    pad_value: float, weights: np.ndarray, bias: np.ndarray = None) -> str:
+        self._add_layer("Convolution", name, inputs=[input], outputs=[name], params={
+            '0': outch,
+            '1': kernel_w,
+            '11': kernel_h,
+            '2': dilation_w,
+            '12': dilation_h,
+            '3': stride_w,
+            '13': stride_h,
+            '4': pad_left,
+            '15': pad_right,
+            '14': pad_top,
+            '16': pad_bottom,
+            '18': pad_value,
+            '5': 0 if bias is None else 1,
+            '6': weights.size
+        })
+        self._add_bin(0, weights)
+        if bias is not None:
+            self._add_bin(1, bias)
+        return name
+
+    def Pooling(self, name: str, input: str, pooling_type: int, kernel_w: int, kernel_h: int,
+                stride_w: int, stride_h: int,
+                pad_left: int, pad_right: int, pad_top: int, pad_bottom: int,
+                global_pooling: bool, weights: np.ndarray, bias: np.ndarray = None) -> str:
+        self._add_layer("Pooling", name, inputs=[input], outputs=[name], params={
+            '0': pooling_type,
+            '1': kernel_w,
+            '11': kernel_h,
+            '2': stride_w,
+            '12': stride_h,
+            '3': pad_left,
+            '13': pad_right,
+            '4': pad_top,
+            '15': pad_bottom,
+            '4': 1 if global_pooling else 0,
+            '5': 0 if bias is None else 1,
+            '6': weights.size
+        })
+        self._add_bin(0, weights)
+        if bias is not None:
+            self._add_bin(1, bias)
+        return name
+
+    def _add_layer(self, type: str, name: str, inputs: Sequence[str] = [], outputs: Sequence[str] = [], params: dict = []):
+        self.layers.append(Layer(type, name, inputs, outputs, params))
+        self.blobs += len(outputs)
+
+    def _add_bin(self, tag: int, arr: np.ndarray):
+        self.bin.write(tag.to_bytes(4, byteorder='little'))
+        self.bin.write(arr.tobytes())
+
+
+class NcnnTestRunner(TestRunner):
+    def __init__(self, case_name, overwrite_configs: str = None):
+        super().__init__(case_name, overwrite_configs)
+        self.model_type = "ncnn"
+
+    def from_ncnn(self, net: Net):
+        param_file = os.path.join(self.case_dir, 'test.param')
+        with open(param_file, 'w') as fp:
+            print("7767517", file=fp)
+            print(f"{len(net.layers)} {net.blobs}", file=fp)
+            for l in net.layers:
+                print(str(l), file=fp)
+
+        bin_file = os.path.join(self.case_dir, 'test.bin')
+        with open(bin_file, 'wb') as fb:
+            fb.write(net.bin.getbuffer())
+
+        return param_file, bin_file
+
+    def run(self, param_file, bin_file):
+        if self.case_dir != os.path.dirname(param_file):
+            new_file = os.path.join(self.case_dir, 'test.param')
+            shutil.copy(param_file, new_file)
+            param_file = new_file
+        if self.case_dir != os.path.dirname(bin_file):
+            new_file = os.path.join(self.case_dir, 'test.bin')
+            shutil.copy(bin_file, new_file)
+            bin_file = new_file
+
+        if not self.inputs:
+            self.parse_model(param_file)
+
+        super().run([param_file, bin_file])
+
+    def parse_model(self, param_file: str):
+        all_inputs = []
+        all_outputs = []
+        with open(param_file, 'r') as fp:
+            for line in fp:
+                tokens = line.split(' ', 4)
+                if len(tokens) < 4:
+                    continue
+                op_type = tokens[0]
+                name = tokens[1]
+                in_num = int(tokens[2])
+                out_num = int(tokens[3])
+                tokens = tokens[-1].split(' ', in_num)
+                inputs = tokens[:in_num]
+                tokens = tokens[-1].split(' ', out_num)
+                outputs = tokens[:out_num]
+                all_inputs += inputs
+                all_outputs += outputs
+
+                if op_type != 'Input':
+                    continue
+                param_kvs = []
+                for kv in tokens[-1].split(' '):
+                    kv_tokens = kv.split('=')
+                    param_kvs.append((int(kv_tokens[0]), int(kv_tokens[1])))
+                params = dict(param_kvs)
+                input_dict = {}
+                input_dict['name'] = outputs[0]
+                input_dict['dtype'] = np.float32
+                shape = [params[2], params[1], params[0]]
+                input_dict['shape'] = shape
+                input_dict['model_shape'] = shape
+                self.inputs.append(input_dict)
+                self.calibs.append(copy.deepcopy(input_dict))
+
+        used_inputs = set(inputs)
+        seen_outputs = set()
+        for n in all_outputs:
+            if not n in used_inputs and not n in seen_outputs:
+                seen_outputs.add(n)
+                input_dict = {}
+                input_dict['name'] = n
+                self.outputs.append(input_dict)
+
+    def cpu_infer(self, model_file: List[str]):
+        outputs = []
+        with ncnn.Net() as net:
+            ret = net.load_param(model_file[0])
+            assert ret == 0
+            ret = net.load_model(model_file[1])
+            assert ret == 0
+
+            with net.create_extractor() as ex:
+                for input in self.inputs:
+                    new_value = self.transform_input(
+                        self.data_pre_process(input['data']), "float32", "CPU")[0]
+                    in_mat = ncnn.Mat(new_value)
+                    ex.input(input['name'], in_mat)
+                    if self.cfg['compile_opt']['preprocess'] and not test_utils.in_ci():
+                        dump_bin_file(os.path.join(
+                            self.case_dir, f'frame_input_{i}.bin'), new_value)
+                        dump_txt_file(os.path.join(
+                            self.case_dir, f'frame_input_{i}.txt'), new_value)
+
+                i = 0
+                for output in self.outputs:
+                    out_mat = ncnn.Mat()
+                    ex.extract(output['name'], out_mat)
+                    out_arr = np.array(out_mat)
+                    out_mat.release()
+                    outputs.append(out_arr)
+                    if not test_utils.in_ci():
+                        dump_bin_file(os.path.join(self.case_dir, f'cpu_result_{i}.bin'), out_arr)
+                        dump_txt_file(os.path.join(self.case_dir, f'cpu_result_{i}.txt'), out_arr)
+                    i += 1
+        return outputs
+
+    def import_model(self, compiler, model_content, import_options):
+        compiler.import_ncnn(model_content[0], model_content[1], import_options)

From 2ff5aa412472ce025c1e28061a366e79b26682c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 3 Nov 2023 15:23:34 +0800
Subject: [PATCH 301/308] fix runtime build

---
 src/Native/src/kernels/stackvm/tensor_ops.cpp | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/Native/src/kernels/stackvm/tensor_ops.cpp b/src/Native/src/kernels/stackvm/tensor_ops.cpp
index b9ea85d40b..2cb452aa3d 100644
--- a/src/Native/src/kernels/stackvm/tensor_ops.cpp
+++ b/src/Native/src/kernels/stackvm/tensor_ops.cpp
@@ -47,8 +47,9 @@ result<value_t> nncase::kernels::stackvm::batch_normalization(
 }
 
 result<value_t> nncase::kernels::stackvm::layer_norm(
-    int32_t axis, float epsilon, value_t input, value_t scale, value_t bias,
-    value_t output, [[maybe_unused]] kernel_context &context) {
+    int32_t axis, float epsilon, [[maybe_unused]] bool use_mean, value_t input,
+    value_t scale, value_t bias, value_t output,
+    [[maybe_unused]] kernel_context &context) {
     try_input(input_mem, input);
     try_input(scale_mem, scale);
     try_input(bias_mem, bias);
@@ -124,7 +125,7 @@ nncase::kernels::stackvm::clamp(value_t input, value_t min, value_t max,
     KERNEL_FINISH;
 }
 
-result<value_t> nncase::kernels::stackvm::concat(value_t input, value_t axis,
+result<value_t> nncase::kernels::stackvm::concat(int32_t axis, value_t input,
                                                  value_t output,
                                                  kernel_context &context) {
     try_tuple_input(inputs_mem, input);
@@ -132,7 +133,7 @@ result<value_t> nncase::kernels::stackvm::concat(value_t input, value_t axis,
     try_var(strides, get_strides(input_tuple));
     try_tuple_field0(input0, input_tuple);
     auto dtype = input0->dtype();
-    try_positive_axis_with_rank(axis_value, axis, input0->shape().size());
+    auto axis_value = positive_index(axis, input0->shape().size());
     auto out_shape = concat_infer_shape(shapes, axis_value);
     try_output(out_mem, output, dtype, out_shape);
     auto concat_dims = dims_t();
@@ -293,14 +294,15 @@ nncase::kernels::stackvm::flatten(value_t input, value_t axis, value_t output,
     KERNEL_FINISH;
 }
 
-result<value_t> nncase::kernels::stackvm::gather(value_t input, value_t axis,
+result<value_t> nncase::kernels::stackvm::gather(int32_t axis, value_t input,
                                                  value_t index, value_t output,
                                                  kernel_context &context) {
     try_input(input_mem, input);
     try_input(index_mem, index);
     auto dtype = input_tensor->dtype();
     try_var(typecode, to_typecode(dtype));
-    try_positive_axis(axis_value, axis, input_tensor);
+    // try_positive_axis(axis_value, axis, input_tensor);
+    auto axis_value = positive_index(axis, input_tensor->shape().size());
     auto out_shape = gather_infer_shape(input_tensor->shape(),
                                         index_tensor->shape(), axis_value);
     try_output(out_mem, output, dtype, out_shape);

From 18425b67a6950554b8811213f26f6f196020168f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 3 Nov 2023 15:53:42 +0800
Subject: [PATCH 302/308] fix kernel test build

---
 tests/kernels/test_concat.cpp |  9 +--------
 tests/kernels/test_gather.cpp | 19 ++++++-------------
 2 files changed, 7 insertions(+), 21 deletions(-)

diff --git a/tests/kernels/test_concat.cpp b/tests/kernels/test_concat.cpp
index c7da18b3bf..9aedb892f8 100644
--- a/tests/kernels/test_concat.cpp
+++ b/tests/kernels/test_concat.cpp
@@ -86,14 +86,7 @@ TEST_P(ConcatTest, Concat) {
     fields.push_back(field2);
     auto output_tuple = tuple(std::in_place, std::move(fields));
 
-    int64_t axis_ptr[] = {axis_value};
-    auto axis =
-        hrt::create(dt_int64, {1},
-                    {reinterpret_cast<gsl::byte *>(axis_ptr), sizeof(axis_ptr)},
-                    true, host_runtime_tensor::pool_cpu_only)
-            .expect("create tensor failed");
-
-    auto output = kernels::stackvm::concat(output_tuple, axis.impl())
+    auto output = kernels::stackvm::concat((int)axis_value, output_tuple)
                       .expect("concat failed");
 
     runtime_tensor actual(output.as<tensor>().expect("as tensor failed"));
diff --git a/tests/kernels/test_gather.cpp b/tests/kernels/test_gather.cpp
index 5910d17cc1..203987da86 100644
--- a/tests/kernels/test_gather.cpp
+++ b/tests/kernels/test_gather.cpp
@@ -37,7 +37,7 @@ class GatherTest : public KernelTest,
         auto shape = GetShapeArray("lhs_shape");
         auto indices_shape = GetShapeArray("indices_shape");
         auto indices_value = GetDataArray("indices_value");
-        auto value = GetNumber("axis");
+        auto axis = GetNumber("axis");
         auto typecode = GetDataType("lhs_type");
 
         input = hrt::create(typecode, shape, host_runtime_tensor::pool_cpu_only)
@@ -61,17 +61,11 @@ class GatherTest : public KernelTest,
                               true, host_runtime_tensor::pool_cpu_only)
                       .expect("create tensor failed");
 
-        batchDims_value = value >= 0
-                              ? (size_t)value >= shape.size() ? -1 : value
-                          : -(size_t)value > shape.size() ? -1
-                                                          : value;
+        batchDims_value = axis >= 0
+                              ? (size_t)axis >= shape.size() ? -1 : axis
+                          : -(size_t)axis > shape.size() ? -1
+                                                          : axis;
 
-        int64_t batchDims_array[1] = {batchDims_value};
-        batchDims = hrt::create(dt_int64, dims_t{1},
-                                {reinterpret_cast<gsl::byte *>(batchDims_array),
-                                 sizeof(batchDims_array)},
-                                true, host_runtime_tensor::pool_cpu_only)
-                        .expect("create tensor failed");
     }
 
     void TearDown() override { CLEAR_SUBCASE() }
@@ -79,7 +73,6 @@ class GatherTest : public KernelTest,
   protected:
     runtime_tensor input;
     runtime_tensor indices;
-    runtime_tensor batchDims;
     int64_t batchDims_value;
 };
 
@@ -103,7 +96,7 @@ TEST_P(GatherTest, gather) {
 
     // actual
     auto output =
-        kernels::stackvm::gather(input.impl(), batchDims.impl(), indices.impl())
+        kernels::stackvm::gather(batchDims_value, input.impl(), indices.impl())
             .expect("gather failed");
     runtime_tensor actual(output.as<tensor>().expect("as tensor failed"));
 

From 3acb57907d913db9894bf5150a566e22fdd26193 Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Fri, 3 Nov 2023 07:55:41 +0000
Subject: [PATCH 303/308] Apply code-format changes

---
 tests/kernels/test_gather.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/tests/kernels/test_gather.cpp b/tests/kernels/test_gather.cpp
index 203987da86..65d5ca45c8 100644
--- a/tests/kernels/test_gather.cpp
+++ b/tests/kernels/test_gather.cpp
@@ -61,11 +61,9 @@ class GatherTest : public KernelTest,
                               true, host_runtime_tensor::pool_cpu_only)
                       .expect("create tensor failed");
 
-        batchDims_value = axis >= 0
-                              ? (size_t)axis >= shape.size() ? -1 : axis
+        batchDims_value = axis >= 0 ? (size_t)axis >= shape.size() ? -1 : axis
                           : -(size_t)axis > shape.size() ? -1
-                                                          : axis;
-
+                                                         : axis;
     }
 
     void TearDown() override { CLEAR_SUBCASE() }

From f7b424de3b1b078380c7ee4fd0e8497cdabb0def Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 3 Nov 2023 16:03:23 +0800
Subject: [PATCH 304/308] fix use mean

---
 tests/kernels/test_layer_norm.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/kernels/test_layer_norm.cpp b/tests/kernels/test_layer_norm.cpp
index cc8a2696bd..bee3cf4d89 100644
--- a/tests/kernels/test_layer_norm.cpp
+++ b/tests/kernels/test_layer_norm.cpp
@@ -106,7 +106,7 @@ TEST_P(LayerNormTest, layer_norm) {
 
     // actual
     auto output =
-        kernels::stackvm::layer_norm((int32_t)axis_value, eps, input.impl(),
+        kernels::stackvm::layer_norm((int32_t)axis_value, eps, false, input.impl(),
                                      scale.impl(), b.impl())
             .expect("layer_norm failed");
     runtime_tensor actual(output.as<tensor>().expect("as tensor failed"));

From c15ea57df7b34fb103b6dff8609797f3c0cc19ee Mon Sep 17 00:00:00 2001
From: zhen8838 <zhen8838@users.noreply.github.com>
Date: Fri, 3 Nov 2023 08:06:36 +0000
Subject: [PATCH 305/308] Apply code-format changes

---
 tests/kernels/test_layer_norm.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/kernels/test_layer_norm.cpp b/tests/kernels/test_layer_norm.cpp
index bee3cf4d89..5591bfe57d 100644
--- a/tests/kernels/test_layer_norm.cpp
+++ b/tests/kernels/test_layer_norm.cpp
@@ -106,8 +106,8 @@ TEST_P(LayerNormTest, layer_norm) {
 
     // actual
     auto output =
-        kernels::stackvm::layer_norm((int32_t)axis_value, eps, false, input.impl(),
-                                     scale.impl(), b.impl())
+        kernels::stackvm::layer_norm((int32_t)axis_value, eps, false,
+                                     input.impl(), scale.impl(), b.impl())
             .expect("layer_norm failed");
     runtime_tensor actual(output.as<tensor>().expect("as tensor failed"));
 

From bf64183ec483d35633f55f75cf4074a45ab3d9d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Fri, 3 Nov 2023 18:32:33 +0800
Subject: [PATCH 306/308] optimize dot dump

---
 src/Nncase.Diagnostics/Diagnostics/ILDotPrintVisitor.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Nncase.Diagnostics/Diagnostics/ILDotPrintVisitor.cs b/src/Nncase.Diagnostics/Diagnostics/ILDotPrintVisitor.cs
index 409a4846af..c20883fc05 100644
--- a/src/Nncase.Diagnostics/Diagnostics/ILDotPrintVisitor.cs
+++ b/src/Nncase.Diagnostics/Diagnostics/ILDotPrintVisitor.cs
@@ -363,13 +363,13 @@ protected override ILDotOption VisitCall(Call expr)
                     _ => throw new NotSupportedException($"Target type {expr.Target.GetType()} is not supported."),
                 }))
                 {
-                    if (child is Const or None)
+                    if (child is None)
                     {
                         continue;
                     }
 
                     var portName = $"P{count++}";
-                    row.AddCell(arg_name, cell => cell.PortName = portName);
+                    row.AddCell(child switch { Const c => c.CheckedType.ToString(), _ => arg_name }, cell => cell.PortName = portName);
                     connect_list.Add((child, portName));
                 }
             });
@@ -385,7 +385,7 @@ protected override ILDotOption VisitCall(Call expr)
             // 4. connect edge.
             foreach (var (child, port_name) in connect_list)
             {
-                if (child is BaseFunction)
+                if (child is BaseFunction or Const)
                 {
                     continue;
                 }

From 17dbcc46d5168478a263493f389c22ddf6c83deb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 6 Nov 2023 19:26:45 +0800
Subject: [PATCH 307/308] fix merge

---
 tests/kernels/test_reduce_window2D.json | 8 --------
 1 file changed, 8 deletions(-)
 delete mode 100644 tests/kernels/test_reduce_window2D.json

diff --git a/tests/kernels/test_reduce_window2D.json b/tests/kernels/test_reduce_window2D.json
deleted file mode 100644
index 5b4773fe43..0000000000
--- a/tests/kernels/test_reduce_window2D.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "lhs_type":["dt_float32"],
-  "lhs_shape":[[1, 3, 16, 16]],
-  "dilations":[[1, 1]],
-  "filter": [[3, 3]],
-  "stride": [[1, 1]],
-  "onnxPads":[[1, 1, 1, 1], [0, 0, 0, 0]]
-}
\ No newline at end of file

From 4411d9e181d6f77b32006e8c83a3015c0389e811 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E5=90=AF=E8=88=AA?= <597323109@qq.com>
Date: Mon, 6 Nov 2023 19:46:55 +0800
Subject: [PATCH 308/308] fix output when test cli

---
 src/Native/src/test_cli.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Native/src/test_cli.cpp b/src/Native/src/test_cli.cpp
index cd900254ef..3e95be5a64 100644
--- a/src/Native/src/test_cli.cpp
+++ b/src/Native/src/test_cli.cpp
@@ -78,7 +78,7 @@ result<void> run_core(const std::string &kmodel_path,
                            .count() /
                        1e6);
 
-        if (i == (loop_count - 1)) {
+        if (i == (loop_count - 1) && (entry->parameters_size() < bins.size())) {
             if (ret.is_a<tensor>()) {
                 auto output_bin = bins.back();
                 std::ofstream output_stream(output_bin, std::ios::binary);