init v0.23.0

Signed-off-by: Sun Ruoxi <sunruoxi@4paradigm.com>

csrc/common/include/cann_compat.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <stdint.h>
+
+// B080 op_common/log/log.h stopped exposing the unqualified OP module id used
+// by inherited ops-transformer tiling/error headers. Include the CANN log type
+// header early so OP still comes from the active CANN version.
+#if defined(__has_include)
+#if __has_include("base/log_types.h")
+#include "base/log_types.h"
+#elif __has_include("toolchain/log_types.h")
+#include "toolchain/log_types.h"
+#endif
+#endif
+
+#if !defined(LOG_TYPES_H_) && !defined(OP)
+#define OP 63
+#endif
+
+#if defined(LOG_CPP) && !defined(DLOG_PUB_H_)
+#ifdef __cplusplus
+extern "C" {
+#endif
+int32_t CheckLogLevel(int32_t moduleId, int32_t logLevel);
+void DlogRecord(int32_t moduleId, int32_t level, const char *fmt, ...);
+#ifdef __cplusplus
+}
+#endif
+#define DLOG_PUB_H_
+#endif

csrc/common/include/common/op_api_def.h

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file op_api_def.h
+ * \brief
+ */
+
+#ifndef Transformer_COMMON_OP_API_DEF_H
+#define Transformer_COMMON_OP_API_DEF_H
+
+namespace op {
+    constexpr size_t MAX_SUPPORT_DIMS_NUMS = 8;
+    constexpr size_t BN_MIN_SUPPORT_DIMS_NUMS = 2;
+    constexpr int8_t FP16FP32_KEEP_DTYPE = -1;
+    constexpr int8_t KEEP_DTYPE = 0;
+    constexpr int8_t ALLOW_FP32_DOWN_PRECISION = 1;
+    constexpr int8_t USE_FP16 = 2;
+    constexpr int8_t USE_HF32 = 3;
+    constexpr size_t MAX_MASK_LEN64 = 64;
+} // namespace op
+#endif // Transformer_COMMON_OP_API_DEF_H

csrc/common/include/common/tensor_util.cpp

@@ -0,0 +1,230 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+#include "tensor_util.h"
+#include "aclnn_kernels/transdata.h"
+#include "aclnn_kernels/transpose.h"
+#include "aclnn_kernels/reshape.h"
+#include "aclnn_kernels/cast.h"
+#include "aclnn_kernels/contiguous.h"
+#include "level0/unsqueeze.h"
+#include "level0/squeeze.h"
+#include "level0/fill.h"
+#include "aclnn/aclnn_base.h"
+
+namespace op {
+const aclIntArray* getAllDims(const aclTensor* self, aclOpExecutor* executor) {
+  auto input_shape = self->GetViewShape();
+  const size_t input_dim_num = input_shape.GetDimNum();
+  std::vector<int64_t> dims(input_dim_num);
+  for (size_t idx = 0; idx < input_dim_num; idx++) {
+    dims[idx] = idx;
+  }
+  return executor->AllocIntArray(dims.data(), input_dim_num);
+}
+
+constexpr size_t MAX_DIM_CNT = 5;
+const aclTensor* ResizeFrom1D(const aclTensor* cdim, const aclTensor* input, bool isSupportNcdhw, aclOpExecutor* executor) {
+  auto cdimContiguous = l0op::Contiguous(cdim, executor);
+  if (cdimContiguous == nullptr) {
+    return cdimContiguous;
+  }
+
+  auto cdimCast = l0op::Cast(cdimContiguous, DataType::DT_FLOAT, executor);
+  if (cdimCast == nullptr) {
+    return cdimCast;
+  }
+
+  size_t inputDim = input->GetViewShape().GetDimNum();
+
+  const int64_t appendDim[] = {0, 2, 3};
+  aclIntArray* newShape = executor->AllocIntArray(appendDim, sizeof(appendDim) / sizeof(int64_t));
+  if (inputDim == MAX_DIM_CNT) {
+    const int64_t value[] = {0, 2, 3, 4};
+    newShape = executor->AllocIntArray(value, sizeof(value) / sizeof(int64_t));
+  }
+  auto cdimUnsqueeze = l0op::UnsqueezeNd(cdimCast, newShape, executor);
+  if (cdimUnsqueeze == nullptr) {
+    return cdimUnsqueeze;
+  }
+
+  op::Format format = inputDim == MAX_DIM_CNT ? Format::FORMAT_NCDHW : Format::FORMAT_NCHW;
+  auto cdimFormat = l0op::ReFormat(cdimUnsqueeze, format);
+  if (cdimFormat == nullptr) {
+    return cdimFormat;
+  }
+
+  if ((inputDim == MAX_DIM_CNT) && !isSupportNcdhw) {
+    return l0op::TransDataSpecial(cdimFormat, Format::FORMAT_NDC1HWC0, 0, executor);
+  } 
+  
+  return cdimFormat;
+}
+
+const aclTensor* ResizeTo1D(const aclTensor* result, const aclTensor* output, bool isSupportNcdhw, aclOpExecutor* executor) {
+  auto resultTransdata = result;
+  size_t resultDim = result->GetViewShape().GetDimNum();
+  if (resultDim >= MAX_DIM_CNT && !isSupportNcdhw) {
+    resultTransdata = l0op::TransDataSpecial(result, Format::FORMAT_NCDHW, 0, executor);
+    if (resultTransdata == nullptr) {
+      return resultTransdata;
+    }
+  }
+
+  const int64_t appendDim[] = {0, 2, 3};
+  aclIntArray* newShape = executor->AllocIntArray(appendDim, sizeof(appendDim) / sizeof(int64_t));
+  if (resultTransdata->GetViewShape().GetDimNum() == MAX_DIM_CNT) {
+    const int64_t value[] = {0, 2, 3, 4};
+    newShape = executor->AllocIntArray(value, sizeof(value) / sizeof(int64_t));
+  }
+  auto resultNchw = l0op::SqueezeNd(resultTransdata, newShape, executor);
+  if (resultNchw == nullptr) {
+    return resultNchw;
+  }
+
+  auto resultNd = l0op::ReFormat(resultNchw, Format::FORMAT_ND);
+  if (resultNd == nullptr) {
+    return resultNd;
+  }
+
+  auto resultCast = l0op::Cast(resultNd, output->GetDataType(), executor);
+  if (resultCast == nullptr) {
+    return resultCast;
+  }
+
+  return l0op::ViewCopy(resultCast, output, executor);
+}
+
+const aclTensor* ResizeFromND(const aclTensor* input, aclOpExecutor* executor) {
+  const int nchw_dims = 4;
+  auto inputShape = input->GetViewShape();
+  int64_t nchwShape[nchw_dims];
+  for (size_t i = 0; i < nchw_dims; i++) {
+    nchwShape[i] = i < inputShape.GetDimNum() ? inputShape[i] : 1;
+  }
+  aclIntArray* nchwArray = executor->AllocIntArray(nchwShape, nchw_dims);
+
+  auto inputReshape = l0op::Reshape(input, nchwArray, executor);
+  if (inputReshape == nullptr) {
+    return inputReshape;
+  }
+
+  return l0op::ReFormat(inputReshape, Format::FORMAT_NCHW);
+}
+
+const aclTensor* ResizeToND(const aclTensor* output, const aclTensor* input, aclOpExecutor* executor) {
+  auto inputShape = input->GetViewShape();
+  size_t dimNum = inputShape.GetDimNum();
+
+  int64_t ndShape[dimNum];
+  for (size_t i = 0; i < inputShape.GetDimNum(); i++) {
+    ndShape[i] = inputShape[i];
+  }
+  aclIntArray* ndArray = executor->AllocIntArray(ndShape, dimNum);
+
+  auto outputReshape = l0op::Reshape(output, ndArray, executor);
+  if (outputReshape == nullptr) {
+    return outputReshape;
+  }
+
+  return l0op::ReFormat(outputReshape, input->GetViewFormat());
+}
+
+const aclTensor* ResizeFrom5D(const aclTensor* input, aclOpExecutor* executor) {
+  auto inputShape = input->GetViewShape();
+  // NCDHW -> NDCHW
+  const int64_t value[] = {0, 2, 1, 3, 4};
+  aclIntArray* ndchwShape = executor->AllocIntArray(value, MAX_DIM_CNT);
+  auto inputTranspose = l0op::Transpose(input, ndchwShape, executor);
+  if (inputTranspose == nullptr) {
+    return inputTranspose;
+  }
+
+  // NDCHW -> NCHW
+  const int64_t nchwShape[] = {inputShape[0] * inputShape[2], inputShape[1], inputShape[3], inputShape[4]};
+  aclIntArray* nchwArray = executor->AllocIntArray(nchwShape, sizeof(nchwShape) / sizeof(int64_t));
+  auto inputReshape = l0op::Reshape(inputTranspose, nchwArray, executor);
+  if (inputReshape == nullptr) {
+    return inputReshape;
+  }
+
+  return l0op::ReFormat(inputReshape, Format::FORMAT_NCHW);
+}
+
+const aclTensor* ResizeTo5D(const aclTensor* output, const aclTensor* input, aclOpExecutor* executor) {
+  auto inputShape = input->GetViewShape();
+  // nchw -> ndchw
+  const int64_t ndchwShape[] = {inputShape[0], inputShape[2], inputShape[1], inputShape[3], inputShape[4]};
+  aclIntArray* ndchwArray = executor->AllocIntArray(ndchwShape, MAX_DIM_CNT);
+  auto outputReshape = l0op::Reshape(output, ndchwArray, executor);
+  if (outputReshape == nullptr) {
+    return outputReshape;
+  }
+
+  auto outputFormat = l0op::ReFormat(outputReshape, Format::FORMAT_NCDHW);
+  if (outputFormat == nullptr) {
+    return outputFormat;
+  }
+  // ndchw -> ncdhw
+  const int64_t ncdhwShape[] = {0, 2, 1, 3, 4};
+  aclIntArray* ncdhwArray = executor->AllocIntArray(ncdhwShape, MAX_DIM_CNT);
+  return l0op::Transpose(outputFormat, ncdhwArray, executor);
+}
+
+aclTensor* FillScalar(int64_t dim, int value, aclOpExecutor* executor) {
+  const aclScalar* dimScalar = executor->AllocScalar(dim);
+  const aclTensor* dimTensor = executor->ConvertToTensor(dimScalar, op::DataType::DT_INT32);
+  aclIntArray* outShape = executor->AllocIntArray(&dim, 1);
+
+  const aclScalar* valueScalar = executor->AllocScalar(value);
+  const aclTensor* valueTensor = executor->ConvertToTensor(valueScalar, op::DataType::DT_FLOAT);
+
+  auto fillTensor = l0op::Fill(dimTensor, valueTensor, outShape, executor);
+  if (fillTensor == nullptr) {
+    return nullptr;
+  }
+
+  return const_cast<aclTensor*>(fillTensor);
+}
+
+aclTensor* FillVector(const op::Shape dstShape, const aclTensor* src, float value, aclOpExecutor* executor) {
+  op::FVector<int64_t, op::MAX_DIM_NUM> fillDims = op::ToShapeVector(dstShape);
+  auto shapes = executor->AllocIntArray(fillDims.data(), src->GetViewShape().GetDimNum());
+  const aclTensor* dimTensor = executor->ConvertToTensor(shapes, op::DataType::DT_INT32);
+  const aclScalar* valueScalar = executor->AllocScalar(value);
+  const aclTensor* valueTensor = executor->ConvertToTensor(valueScalar, src->GetDataType());
+  auto fillTensor = l0op::Fill(dimTensor, valueTensor, shapes, executor);
+  if (fillTensor == nullptr) {
+    return nullptr;
+  }
+  fillTensor = l0op::ReFormat(fillTensor, op::Format::FORMAT_ND);
+  return const_cast<aclTensor*>(fillTensor);
+}
+
+aclnnStatus ProcessEmptyTensorWithValue(aclTensor* src, float initValue, aclOpExecutor* executor) {
+  auto srcShape = src->GetViewShape();
+  auto dst = FillVector(srcShape, src, initValue, executor);
+  auto dstCopyResult = l0op::ViewCopy(dst, src, executor);
+  CHECK_RET(dstCopyResult != nullptr, ACLNN_ERR_INNER_NULLPTR);
+  return ACLNN_SUCCESS;
+}
+
+op::DataType CombineCategories(op::DataType higher, op::DataType lower) {
+  if (IsFloatingType(higher)) {
+    return higher;
+  }
+
+  if (IsFloatingType(lower) || higher == op::DataType::DT_BOOL) {
+    return op::PromoteType(higher, lower);
+  }
+
+  return (higher != op::DataType::DT_UNDEFINED) ? higher : lower;
+}
+}  // namespace op

csrc/common/include/common/tensor_util.h

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+#include "aclnn/aclnn_base.h"
+#include "opdev/common_types.h"
+
+namespace op {
+const aclIntArray* getAllDims(const aclTensor* self, aclOpExecutor* executor);
+
+const aclTensor* ResizeFrom1D(const aclTensor* cdim, const aclTensor* input, bool isSupportNcdhw,
+                              aclOpExecutor* executor);
+
+const aclTensor* ResizeTo1D(const aclTensor* result, const aclTensor* output, bool isSupportNcdhw,
+                            aclOpExecutor* executor);
+
+const aclTensor* ResizeFromND(const aclTensor* input, aclOpExecutor* executor);
+
+const aclTensor* ResizeToND(const aclTensor* output, const aclTensor* input, aclOpExecutor* executor);
+
+const aclTensor* ResizeFrom5D(const aclTensor* input, aclOpExecutor* executor);
+
+const aclTensor* ResizeTo5D(const aclTensor* output, const aclTensor* input, aclOpExecutor* executor);
+
+aclTensor* FillScalar(int64_t dim, int value, aclOpExecutor* executor);
+
+aclnnStatus ProcessEmptyTensorWithValue(aclTensor* src, float initValue, aclOpExecutor* executor);
+
+op::DataType CombineCategories(op::DataType higher, op::DataType lower);
+}  // namespace op
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+aclnnStatus BatchNorm(const aclTensor* input, const aclTensor* weight, const aclTensor* bias, aclTensor* runningMean,
+                      aclTensor* runningVar, bool training, float momentum, float eps, aclTensor** output,
+                      aclTensor* saveMean, aclTensor* saveInvstd, aclOpExecutor* executor);
+
+#ifdef __cplusplus
+}
+#endif

csrc/common/include/err/ops_err.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file ops_err.h
+ * \brief
+ */
+
+#ifndef Transformer_COMMON_OPS_ERR_H
+#define Transformer_COMMON_OPS_ERR_H
+
+#include "log/log.h"
+
+#define OPS_INNER_ERR_STUB(ERR_CODE_STR, OPS_DESC, FMT, ...)                                                           \
+    do {                                                                                                               \
+        OpLogSub(OP, DLOG_ERROR, OPS_DESC, FMT, ##__VA_ARGS__);                                                    \
+        REPORT_INNER_ERR_MSG(ERR_CODE_STR, FMT, ##__VA_ARGS__);                                                        \
+    } while (0)
+
+
+/* 基础报错 */
+#define OPS_REPORT_VECTOR_INNER_ERR(OPS_DESC, ...) OPS_INNER_ERR_STUB("E89999", OPS_DESC, __VA_ARGS__)
+#define OPS_REPORT_CUBE_INNER_ERR(OPS_DESC, ...) OPS_INNER_ERR_STUB("E69999", OPS_DESC, __VA_ARGS__)
+
+#endif // Transformer_COMMON_OPS_ERR_H

csrc/common/include/external/aclnn_kernels/cast.h

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+#ifndef COMMON_INC_EXTERNAL_ACLNN_KERNELS_CAST_H
+#define COMMON_INC_EXTERNAL_ACLNN_KERNELS_CAST_H
+
+#include "opdev/op_executor.h"
+#include "opdev/make_op_executor.h"
+
+namespace l0op {
+const aclTensor* Cast(const aclTensor* self, op::DataType dstDtype, aclOpExecutor* executor);
+
+// 专攻卷积反向定制
+const aclTensor* CastOnlyForConvBackward(const aclTensor* self, op::DataType dstDtype, aclOpExecutor* executor);
+} // namespace l0op
+
+#endif // COMMON_INC_EXTERNAL_ACLNN_KERNELS_CAST_H

csrc/common/include/external/aclnn_kernels/common/op_error_check.h

@@ -0,0 +1,251 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+#ifndef OP_ERROR_CHECK_H__
+#define OP_ERROR_CHECK_H__
+
+#include "opdev/op_log.h"
+#include "opdev/common_types.h"
+#include "opdev/data_type_utils.h"
+#include "opdev/shape_utils.h"
+
+const int32_t NCHW_N_DIM = 0;
+const int32_t NCHW_C_DIM = 1;
+const int32_t NHWC_N_DIM = 0;
+const int32_t NHWC_C_DIM = 3;
+
+static inline bool IsNullptr(const aclTensor *tensor, const char *name) {
+  if (tensor == nullptr) {
+    OP_LOGE(ACLNN_ERR_PARAM_NULLPTR, "Expected a proper Tensor but got null for argument %s.", name);
+    return true;
+  }
+  return false;
+}
+
+static inline bool IsNullptr(const aclTensorList *tensorList, const char *name) {
+  if (tensorList == nullptr) {
+    OP_LOGE(ACLNN_ERR_PARAM_NULLPTR, "Expected a proper TensorList but got null for argument %s.", name);
+    return true;
+  }
+  return false;
+}
+
+static inline bool IsNullptr(const aclScalar *scalar, const char *name) {
+  if (scalar == nullptr) {
+    OP_LOGE(ACLNN_ERR_PARAM_NULLPTR, "Expected a value of type number for argument %s but instead found type null.",
+            name);
+    return true;
+  }
+  return false;
+}
+
+static inline bool IsNullptr(const aclIntArray *intArr, const char *name) {
+  if (intArr == nullptr) {
+    OP_LOGE(ACLNN_ERR_PARAM_NULLPTR, "Expected a value of type List[int] for argument %s but instead found type null.",
+            name);
+    return true;
+  }
+  return false;
+}
+
+static inline bool IsNullptr(const aclBoolArray *boolArr, const char *name) {
+  if (boolArr == nullptr) {
+    OP_LOGE(ACLNN_ERR_PARAM_NULLPTR, "Expected a value of type List[bool] for argument %s but instead found type null.",
+            name);
+    return true;
+  }
+  return false;
+}
+
+static inline bool IsNullptr(const aclFloatArray *floatArr, const char *name) {
+  if (floatArr == nullptr) {
+    OP_LOGE(ACLNN_ERR_PARAM_NULLPTR, "Expected a value of type List[float] for argument %s but instead found type \
+            null.", name);
+    return true;
+  }
+  return false;
+}
+
+static inline bool CheckDims(const aclTensor *tensor) {
+  const auto& xShape = tensor->GetViewShape();
+  for(size_t i = 0; i < xShape.GetDimNum(); i++) {
+    if (xShape.GetDim(i) > INT32_MAX) {
+      OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The tensor's shape cannot be larger than %d.", INT32_MAX);
+      return false;
+    }
+  }
+  return true;
+}
+
+static inline bool CheckReduceOutShape(const aclTensor *inferOut, const aclTensor *out)
+{
+  auto const &xShape = inferOut->GetViewShape();
+  auto const &yShape = out->GetViewShape();
+  if (xShape != yShape) {
+    if (!(xShape.GetShapeSize() == 1 && yShape.GetShapeSize() == 1)) {
+      OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The out tensor's shape[%s] is not equal with inferOut shape[%s].",
+              op::ToString(out->GetViewShape()).GetString(), op::ToString(inferOut->GetViewShape()).GetString());
+      return false;
+    }
+  }
+  return true;
+}
+
+static inline bool CheckNCDimValid(const aclTensor *self, const aclTensor *out) {
+  auto format = self->GetStorageFormat();
+  int64_t selfDimN = 0;
+  int64_t selfDimC = 0;
+  int64_t outDimN = 0;
+  int64_t outDimC = 0;
+  if (format == op::Format::FORMAT_NCHW) {
+    selfDimN = self->GetViewShape().GetDim(NCHW_N_DIM);
+    selfDimC = self->GetViewShape().GetDim(NCHW_C_DIM);
+    outDimN = out->GetViewShape().GetDim(NCHW_N_DIM);
+    outDimC = out->GetViewShape().GetDim(NCHW_C_DIM);
+  } else if (format == op::Format::FORMAT_NHWC) {
+    selfDimN = self->GetViewShape().GetDim(NHWC_N_DIM);
+    selfDimC = self->GetViewShape().GetDim(NHWC_C_DIM);
+    outDimN = out->GetViewShape().GetDim(NHWC_N_DIM);
+    outDimC = out->GetViewShape().GetDim(NHWC_C_DIM);
+  } else {
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+            "Input and output format only support [NCHW, NHWC] format .");
+    return false;
+  }
+  if ((selfDimN != outDimN) || (selfDimC != outDimC)) {
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+            "The selfDimN[%ld]/outDimN[%ld] or selfDimC[%ld]/outDimC[%ld] not equal .",
+            selfDimN, outDimN, selfDimC, outDimC);
+    return false;
+  }
+  return true;
+}
+
+
+#define OP_CHECK_NULL(param, retExpr) \
+  if (IsNullptr(param, #param)) { \
+    retExpr; \
+  }
+
+#define OP_CHECK_DTYPE_NOT_SUPPORT(tensor, supportList, retExpr) \
+  if (!CheckType(tensor->GetDataType(), supportList)) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Tensor %s not implemented for %s, should be in dtype support list %s.", \
+            #tensor, op::ToString(tensor->GetDataType()).GetString(), op::ToString(supportList).GetString()); \
+    retExpr; \
+  }
+
+#define OP_CHECK_DTYPE_NOT_MATCH(tensor, expectedDtype, retExpr) \
+  if (tensor->GetDataType() != expectedDtype) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Tensor %s expected dtype is %s but found %s.", \
+            #tensor, op::ToString(expectedDtype).GetString(), op::ToString(tensor->GetDataType()).GetString()); \
+    retExpr; \
+  }
+
+#define OP_CHECK_DTYPE_NOT_SAME(tensor1, tensor2, retExpr) \
+  if (tensor1->GetDataType() != tensor2->GetDataType()) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected both tensors to have same dtype, but found %s %s and %s %s.", \
+            #tensor1, op::ToString(tensor1->GetDataType()).GetString(), \
+            #tensor2, op::ToString(tensor2->GetDataType()).GetString()); \
+    retExpr; \
+  }
+
+#define OP_CHECK_RESULT_DTYPE_CAST_FAILED(dtype, desiredDtype, retExpr); \
+  if (!CanCast(dtype, desiredDtype)) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Result type %s can't be cast to the desired output type %s.", \
+            op::ToString(dtype).GetString(), op::ToString(desiredDtype).GetString()); \
+    retExpr; \
+  }
+
+#define OP_CHECK_BROADCAST(tensor1, tensor2, retExpr) \
+  if (!CheckBroadcastShape(tensor1->GetViewShape(), tensor2->GetViewShape())) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The size of tensor %s %s must match the size of tensor %s %s.", \
+            #tensor1, op::ToString(tensor1->GetViewShape()).GetString(), \
+            #tensor2, op::ToString(tensor2->GetViewShape()).GetString()); \
+    retExpr; \
+  }
+
+#define OP_CHECK_BROADCAST_WITH_SHAPE(tensor, shape, retExpr) \
+  if (!CheckBroadcastShape(tensor->GetViewShape(), shape)) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The size of tensor %s %s must match the size %s.", \
+            #tensor, op::ToString(tensor->GetViewShape()).GetString(), op::ToString(shape).GetString()); \
+    retExpr; \
+  }
+
+#define OP_CHECK_BROADCAST_AND_INFER_SHAPE(tensor1, tensor2, retShape, retExpr) \
+  if (!BroadcastInferShape(tensor1->GetViewShape(), tensor2->GetViewShape(), retShape)) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The size of tensor %s %s must match the size of tensor %s %s.", \
+            #tensor1, op::ToString(tensor1->GetViewShape()).GetString(), \
+            #tensor2, op::ToString(tensor2->GetViewShape()).GetString()); \
+    retExpr; \
+  }
+
+#define OP_CHECK_SHAPE_NOT_EQUAL(tensor1, tensor2, retExpr) \
+  if (tensor1->GetViewShape() != tensor2->GetViewShape()) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected tensor for %s to have same size as tensor for %s, but %s does not " \
+            "equal %s.", #tensor1, #tensor2, op::ToString(tensor1->GetViewShape()).GetString(), \
+            op::ToString(tensor2->GetViewShape()).GetString()); \
+    retExpr; \
+  }
+
+#define OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(tensor, shape, retExpr) \
+  if (tensor->GetViewShape() != shape) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected tensor for %s to have same size as %s, but got %s.", \
+            #tensor, op::ToString(shape).GetString(), op::ToString(tensor->GetViewShape()).GetString()); \
+    retExpr; \
+  }
+
+#define OP_CHECK_WRONG_DIMENSION(tensor, expectedDimNum, retExpr) \
+  if (tensor->GetViewShape().GetDimNum() != expectedDimNum) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected %zu dimension input, but got %s with sizes %s.", \
+            static_cast<size_t>(expectedDimNum), #tensor, op::ToString(tensor->GetViewShape()).GetString()); \
+    retExpr; \
+  }
+
+#define OP_CHECK_MAX_DIM(tensor, maxDim, retExpr) \
+  if (tensor->GetViewShape().GetDimNum() > static_cast<size_t>(maxDim)) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The %s tensor cannot be larger than %zu dimensions.", \
+            #tensor, static_cast<size_t>(maxDim)); \
+    retExpr; \
+  }
+
+#define OP_CHECK_MIN_DIM(tensor, minDim, retExpr) \
+  if (tensor->GetViewShape().GetDimNum() < static_cast<size_t>(minDim)) { \
+    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The %s tensor must have at least %zu dimensions.", \
+            #tensor, static_cast<size_t>(minDim)); \
+    retExpr; \
+  }
+
+#define OP_CHECK_COMM_INPUT(workspaceSize, executor) \
+  if (workspaceSize == nullptr || executor == nullptr) { \
+    OP_LOGE(ACLNN_ERR_PARAM_NULLPTR, "The workspaceSize or executor is nullptr."); \
+    return ACLNN_ERR_PARAM_NULLPTR; \
+  }
+
+#define OP_CHECK_ADD_TO_LAUNCHER_LIST_AICORE(cond, retExpr, errMsg, ...) \
+  if (cond) { \
+    OP_LOGE(ACLNN_ERR_INNER_STATIC_WORKSPACE_INVALID, errMsg, ##__VA_ARGS__); \
+    retExpr; \
+  }
+
+#define OP_CHECK_INFERSHAPE(cond, retExpr, errMsg, ...) \
+  if (cond) { \
+    OP_LOGE(ACLNN_ERR_INNER_INFERSHAPE_ERROR, errMsg, ##__VA_ARGS__); \
+    retExpr; \
+  }
+
+#define OP_CHECK_TENSORLIST_SIZE_EQUAL(tensorlist1, tensorlist2, retExpr)                                         \
+    if ((tensorlist1)->Size() != (tensorlist2)->Size()) {                                                         \
+        OP_LOGE(ACLNN_ERR_PARAM_INVALID,                                                                          \
+                "The %s tensorlist and %s tensorlist must have the same number of tensors, but got %ld and %ld.", \
+                #tensorlist1, #tensorlist2, (tensorlist1)->Size(), (tensorlist2)->Size());                        \
+        retExpr;                                                                                                  \
+    }
+
+#endif

csrc/common/include/external/aclnn_kernels/contiguous.h

@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+#ifndef COMMON_INC_EXTERNAL_ACLNN_KERNELS_CONTIGUOUS_H
+#define COMMON_INC_EXTERNAL_ACLNN_KERNELS_CONTIGUOUS_H
+
+#include "opdev/op_def.h"
+#include "opdev/common_types.h"
+
+namespace l0op {
+
+typedef struct {
+    // 每个op::Shape 18ns
+    int64_t viewOffset;
+
+    // Transpose
+    op::Shape transposeSrcShape;
+    op::Shape transposeDstShape;
+    op::FVector<int64_t, op::MAX_DIM_NUM> perm;
+
+    // broadcast to
+    op::Shape broadcastSrcShape;
+    op::Shape broadcastDstShape;
+    op::FVector<int64_t, op::MAX_DIM_NUM> shape;
+
+    // slice
+    op::Shape sliceSrcShape;
+    op::Shape sliceDstShape;
+    op::FVector<int64_t, op::MAX_DIM_NUM> offset;
+    op::FVector<int64_t, op::MAX_DIM_NUM> size;
+
+    // strided slice
+    op::Shape stridedsliceSrcShape;
+    op::Shape stridedsliceDstShape;
+    op::FVector<int64_t, op::MAX_DIM_NUM> begin;
+    op::FVector<int64_t, op::MAX_DIM_NUM> end;
+    op::FVector<int64_t, op::MAX_DIM_NUM> strides;
+
+    // optimizer
+    bool mayBroadcast;
+    bool mayTranspose;
+    bool maySlice;
+    bool mayStridedslice;
+} ContiguousParam;
+
+/**
+ * @brief 将非连续Tensor转换为连续Tensor
+ * @param x
+ * @param executor
+ * @return aclTensor 转换后的tensor
+ */
+const aclTensor* Contiguous(const aclTensor* x, aclOpExecutor* executor);
+
+/**
+ * @brief 将连续tensor拷贝到非连续的tensor上
+ * @param x
+ * @param y
+ * @param executor
+ * @return aclTensor 转换后的tensor
+ */
+const aclTensor* ViewCopy(const aclTensor* x, const aclTensor* y, aclOpExecutor* executor);
+
+/**
+ * @brief 对Tensor创建一个View，要求Tensor满足PickView的条件
+ * @param x 输入Tensor，可以是一整块的非连续Tensor
+ * @param executor
+ * @return 输出Shape是一个连续Tensor
+ */
+const aclTensor* PickViewAsContiguous(const aclTensor* x, aclOpExecutor* executor);
+
+const aclTensor* ReViewToOut(const aclTensor* x, const aclTensor* y, aclOpExecutor* executor);
+
+// ============内部接口=============
+bool CanOptimizeContiguous(
+    const op::Shape& viewShape, const op::Strides& strides, int64_t offset, int64_t storageSize,
+    ContiguousParam& param);
+
+bool CanOptimizeView(const op::Shape& viewShape, const op::Strides& strides, int64_t offset, ContiguousParam& param);
+// ============内部接口=============
+} // namespace l0op
+
+#endif // COMMON_INC_EXTERNAL_ACLNN_KERNELS_CONTIGUOUS_H

csrc/common/include/external/aclnn_kernels/pad.h

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+#ifndef COMMON_INC_EXTERNAL_ACLNN_KERNELS_PAD_H
+#define COMMON_INC_EXTERNAL_ACLNN_KERNELS_PAD_H
+
+#include "opdev/op_executor.h"
+#include "opdev/make_op_executor.h"
+
+namespace l0op {
+const aclTensor* Pad(const aclTensor* self, const aclTensor* paddings, aclOpExecutor* executor);
+}
+#endif // COMMON_INC_EXTERNAL_ACLNN_KERNELS_PAD_H

csrc/common/include/external/aclnn_kernels/reshape.h

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+#ifndef COMMON_INC_EXTERNAL_ACLNN_KERNELS_RESHAPE_H
+#define COMMON_INC_EXTERNAL_ACLNN_KERNELS_RESHAPE_H
+
+#include "opdev/shape_utils.h"
+#include "opdev/op_def.h"
+
+namespace l0op {
+/**
+ * @brief Modify input tensor's shape.
+ * @param x Input Tensor. Should be contiguous.
+ * @param shape Target Shape. Only one dimension can be -1.
+ * @param executor aclOpExecutor.ldd
+ * @return *aclTensor Output tensor.
+ */
+const aclTensor* Reshape(const aclTensor* x, const op::Shape& shape, aclOpExecutor* executor);
+
+/**
+ * @brief Modify input tensor's shape.
+ * @param x Input Tensor. Should be contiguous.
+ * @param shape Target Shape. Only one dimension can be -1.
+ * @param executor aclOpExecutor.
+ * @return *aclTensor Output tensor.
+ */
+const aclTensor* Reshape(const aclTensor* x, const aclIntArray* shape, aclOpExecutor* executor);
+} // namespace l0op
+
+#endif // COMMON_INC_EXTERNAL_ACLNN_KERNELS_RESHAPE_H

csrc/common/include/external/aclnn_kernels/slice.h

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+#ifndef COMMON_INC_EXTERNAL_ACLNN_KERNELS_SLICE_H
+#define COMMON_INC_EXTERNAL_ACLNN_KERNELS_SLICE_H
+
+#include "opdev/op_def.h"
+
+namespace l0op {
+
+const aclTensor* Slice(
+    const aclTensor* x, const aclTensor* y, const aclTensor* offset, const aclTensor* size, aclOpExecutor* executor);
+
+const aclTensor* Slice(
+    const aclTensor* x, const aclIntArray* offsets, const aclIntArray* size, aclOpExecutor* executor);
+} // namespace l0op
+
+#endif // COMMON_INC_EXTERNAL_ACLNN_KERNELS_SLICE_H

csrc/common/include/external/aclnn_kernels/transdata.h

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+#ifndef COMMON_INC_EXTERNAL_ACLNN_KERNELS_TRANSDATA_H
+#define COMMON_INC_EXTERNAL_ACLNN_KERNELS_TRANSDATA_H
+
+#include "opdev/op_executor.h"
+
+namespace l0op {
+
+const aclTensor* ReFormat(const aclTensor* x, const op::Format& format, aclOpExecutor* executor = nullptr);
+
+/**
+ * TransData
+ * Formal Transdata. Set the c0 size strictly based on the data type and chip block size.
+ * support data type as follows: fp16,fp32,int32,uint32,int8,uint8
+ * fp16: block_size/2
+ * fp32/int32/uint32: block_size/4 (this is different from `TransDataSpecial`)
+ * int8/uint8: block_size/1
+ *
+ * @param x : aclTensor need to transpose
+ * @param dstPrimaryFormat: dstPrimaryFormat like NC1HWC0
+ * @param groups: groups
+ * @param executor: executor should not be null
+ * @return trans format tensor
+ */
+const aclTensor* TransData(const aclTensor* x, op::Format dstPrimaryFormat, int64_t groups, aclOpExecutor* executor);
+/**
+ * Special Transdata. Set the c0 size strictly based on the data type and chip block size.
+ * this transdata c0 size rule:
+ *     fp16: block_size/2
+ *     fp32/int32/uint32: block_size/2
+ *     int8/uint8: block_size/1
+ * bool not supported, should do:
+ *     (NCHW, bool)-> cast -> (NCHW, fp16) -> TransDataSpecial -> (5HD, fp16) -> cast -> (5HD, bool)
+ *     (5HD, bool)-> cast -> (5HD, fp16) -> TransDataSpecial -> (NCHW, fp16) -> cast -> (NCHW, bool)
+ *
+ * @param x : aclTensor need to transpose
+ * @param dstPrimaryFormat: dstPrimaryFormat like NC1HWC0
+ * @param groups: groups
+ * @param executor: executor should not be null
+ * @return trans format tensor
+ */
+const aclTensor* TransDataSpecial(
+    const aclTensor* x, op::Format dstPrimaryFormat, int64_t groups, aclOpExecutor* executor);
+
+} // namespace l0op
+
+#endif // COMMON_INC_EXTERNAL_ACLNN_KERNELS_TRANSDATA_H

csrc/common/include/external/aclnn_kernels/transpose.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+#ifndef COMMON_INC_EXTERNAL_ACLNN_KERNELS_TRANSPOSE_H
+#define COMMON_INC_EXTERNAL_ACLNN_KERNELS_TRANSPOSE_H
+
+#include "opdev/op_def.h"
+
+namespace l0op {
+
+const aclTensor* Transpose(const aclTensor* x, const aclTensor* y, const aclTensor* perm, aclOpExecutor* executor);
+const aclTensor* Transpose(const aclTensor* x, const aclIntArray* perm, aclOpExecutor* executor);
+} // namespace l0op
+
+#endif // COMMON_INC_EXTERNAL_ACLNN_KERNELS_TRANSPOSE_H

csrc/common/include/external/aclnn_util.h

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file aclnn_util.h
+ * \brief
+ */
+#ifndef Transformer_COMMON_ACLNN_UTIL_H
+#define Transformer_COMMON_ACLNN_UTIL_H
+
+#define ACLNN_API __attribute__((visibility("default")))
+
+#endif  // Transformer_COMMON_ACLNN_UTIL_H

csrc/common/include/fallback/fallback.h

@@ -0,0 +1,499 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file fallback.h
+ * \brief
+ */
+
+#ifndef ACLNNFALLBACK_OPAPI_H_
+#define ACLNNFALLBACK_OPAPI_H_
+
+#include <dlfcn.h>
+
+#include <functional>
+#include <tuple>
+#include <type_traits>
+#include <vector>
+
+#include "aclnn/aclnn_base.h"
+#include "fallback/fallback_comm.h"
+#include "mc2_log.h"
+#include "runtime/base.h"
+#include "log/log.h"
+
+namespace fallback {
+using namespace std;
+using namespace gert;
+using namespace ge;
+using namespace std;
+
+namespace std_utils {
+  template <std::size_t... Is>
+  struct index_sequence {};
+
+  template <std::size_t N, std::size_t... Is>
+  struct make_index_sequence_helper : make_index_sequence_helper<N - 1, N - 1, Is...> {};
+
+  template <std::size_t... Is>
+  struct make_index_sequence_helper<0, Is...> {
+    using type = index_sequence<Is...>;
+  };
+
+  template <std::size_t N>
+  using make_index_sequence = typename make_index_sequence_helper<N>::type;
+}
+
+using aclOpExecutor = struct aclOpExecutor;
+using aclTensor = struct aclTensor;
+using aclScalar = struct aclScalar;
+using aclIntArray = struct aclIntArray;
+using aclFloatArray = struct aclFloatArray;
+using aclBoolArray = struct aclBoolArray;
+using aclTensorList = struct aclTensorList;
+
+using _aclCreateTensor = aclTensor* (*)(const int64_t* view_dims, uint64_t view_dims_num, aclDataType data_type,
+                                        const int64_t* stride, int64_t offset, aclFormat format,
+                                        const int64_t* storage_dims, uint64_t storage_dims_num, void* tensor_data);
+
+using _aclCreateScalar = aclScalar* (*)(void* value, aclDataType data_type);
+using _aclCreateIntArray = aclIntArray* (*)(const int64_t* value, uint64_t size);
+using _aclCreateFloatArray = aclFloatArray* (*)(const float* value, uint64_t size);
+using _aclCreateBoolArray = aclBoolArray* (*)(const bool* value, uint64_t size);
+using _aclCreateTensorList = aclTensorList* (*)(const aclTensor* const *value, uint64_t size);
+
+using _aclDestroyTensor = int (*)(const aclTensor* tensor);
+using _aclDestroyScalar = int (*)(const aclScalar* scalar);
+using _aclDestroyIntArray = int (*)(const aclIntArray* array);
+using _aclDestroyFloatArray = int (*)(const aclFloatArray* array);
+using _aclDestroyBoolArray = int (*)(const aclBoolArray* array);
+using _aclDestroyTensorList = int (*)(const aclTensorList* array);
+
+#define GET_OP_API_FUNC(apiName) reinterpret_cast<_##apiName>(GetOpApiFuncAddr(#apiName))
+
+inline const char* GetOpApiLibName(void) {
+  return "libopapi.so";
+}
+
+inline const char* GetCustOpApiLibName(void) {
+  return "libcust_opapi.so";
+}
+
+inline void* GetOpApiFuncAddrInLib(void* handler, const char* libName, const char* apiName) {
+  auto funcAddr = dlsym(handler, apiName);
+  if (funcAddr == nullptr) {
+    OP_LOGW("aclnnfallback", "dlsym %s from %s failed, error:%s.", apiName, libName, dlerror());
+  }
+  return funcAddr;
+}
+
+inline void* GetOpApiLibHandler(const char* libName) {
+  auto handler = dlopen(libName, RTLD_LAZY);
+  if (handler == nullptr) {
+    OP_LOGW("aclnnfallback", "dlopen %s failed, error:%s.", libName, dlerror());
+  }
+  return handler;
+}
+
+inline void* GetAclnnArrdByApiName(const char *apiName) {
+    vector<std:: string> libs = {"libaclnn_ops_infer.so", "libaclnn_ops_train.so", "libaclnn_math.so",
+                                 "libaclnn_rand.so", "libaclnn_sparse.so", "libaclnn_fft.so"};
+    for (const auto &libName : libs) {
+        static auto libHandler = GetOpApiLibHandler(libName.c_str());
+        if (libHandler != nullptr) {
+            auto funcAddr = GetOpApiFuncAddrInLib(libHandler, libName.c_str(), apiName);
+            if (funcAddr != nullptr) {
+                return funcAddr;
+            }
+        }
+    }
+    OP_LOGE("aclnnfallback", "api %s can't find in any aclnn lib.", apiName);
+    return nullptr;
+}
+
+inline void* GetOpApiFuncAddr(const char* apiName) {
+  static auto custOpApiHandler = GetOpApiLibHandler(GetCustOpApiLibName());
+  if (custOpApiHandler != nullptr) {
+    auto funcAddr = GetOpApiFuncAddrInLib(custOpApiHandler, GetCustOpApiLibName(), apiName);
+    if (funcAddr != nullptr) {
+      return funcAddr;
+    }
+  }
+
+  static auto opApiHandler = GetOpApiLibHandler(GetOpApiLibName());
+  if (opApiHandler != nullptr) {
+      auto funcAddr = GetOpApiFuncAddrInLib(opApiHandler, GetOpApiLibName(), apiName);
+      if (funcAddr != nullptr) {
+          return funcAddr;
+      }
+  }
+  OP_LOGD("aclnnfallback", "opapi lib is not exist,will use aclnn lib.");
+  return GetAclnnArrdByApiName(apiName);
+}
+
+inline aclTensor* ConvertType(aclTensor* ge_tensor) {
+  return ge_tensor;
+}
+
+inline aclIntArray* ConvertType(const std::vector<int64_t> &arr) {
+  if (arr.empty()) {
+    return nullptr;
+  }
+  static const auto aclCreateIntArray = GET_OP_API_FUNC(aclCreateIntArray);
+  auto array = aclCreateIntArray(arr.data(), arr.size());
+  return array;
+}
+
+inline aclDataType GetConvertType(const gert::Tensor* ge_tensor) {
+  // convert data type
+  auto dataType_ge = ge_tensor->GetDataType();
+  auto dataType = aclDataType::ACL_FLOAT16;
+  if (dataType_ge == DT_FLOAT) {
+    dataType = aclDataType::ACL_FLOAT;
+  } else if (dataType_ge == DT_BF16) {
+    dataType = aclDataType::ACL_BF16;
+  } else if (dataType_ge == DT_BOOL) {
+    dataType = aclDataType::ACL_BOOL;
+  } else if (dataType_ge == DT_INT64) {
+    dataType = aclDataType::ACL_INT64;
+  } else if (dataType_ge == DT_INT32) {
+    dataType = aclDataType::ACL_INT32;
+  } else if (dataType_ge == DT_UINT64) {
+    dataType = aclDataType::ACL_UINT64;
+  } else if (dataType_ge == DT_UINT32) {
+    dataType = aclDataType::ACL_UINT32;
+  } else if (dataType_ge == DT_INT8) {
+    dataType = aclDataType::ACL_INT8;
+  } else if (dataType_ge == DT_UINT8) {
+    dataType = aclDataType::ACL_UINT8;
+  } else if (dataType_ge == DT_INT4) {
+    dataType = aclDataType::ACL_INT4;
+  } else if (dataType_ge == DT_FLOAT8_E4M3FN) {
+    dataType = aclDataType::ACL_FLOAT8_E4M3FN;
+  } else {
+    dataType = aclDataType::ACL_FLOAT16;
+  }
+
+  return dataType;
+}
+
+inline aclTensor* ConvertType(const gert::Tensor* ge_tensor) {
+  if (ge_tensor == nullptr) {
+    return nullptr;
+  }
+
+  static const auto aclCreateTensor = GET_OP_API_FUNC(aclCreateTensor);
+  OP_CHECK_IF(aclCreateTensor == nullptr, OP_LOGE("aclnnfallback", "aclCreateTensor nullptr"), return nullptr);
+
+  void* device_addr = nullptr;
+  device_addr = const_cast<void*>(ge_tensor->GetAddr());
+
+  auto dataType = GetConvertType(ge_tensor);
+
+  OP_LOGD("aclnnfallback", "aclCreateTensor: tensor type is %d", dataType);
+
+  // convert shape
+  auto gert_shape = ge_tensor->GetStorageShape();
+  std::vector<int64_t> shape;
+  for (size_t i = 0; i < gert_shape.GetDimNum(); ++i) {
+    shape.push_back(gert_shape.GetDim(i));
+  }
+
+  // 计算连续tensor的strides
+  std::vector<int64_t> strides(shape.size(), 1);
+  for (int64_t i = shape.size() - 2; i >= 0; i--) {
+    strides[i] = shape[i + 1] * strides[i + 1];
+  }
+
+  aclTensor* out = aclCreateTensor(shape.data(), shape.size(), dataType, strides.data(),
+                                   0, aclFormat::ACL_FORMAT_ND,
+                                   shape.data(), shape.size(), device_addr);
+
+  OP_CHECK_IF(out == nullptr,
+    OP_LOGE("aclnnfallback", "out nullptr"), return nullptr);
+
+  return out;
+}
+
+inline aclTensorList* ConvertType(std::vector<const gert::Tensor*>& ge_tenserList) {
+  OP_CHECK_IF(ge_tenserList.size() == 0,
+    OP_LOGE("aclnnfallback", "ge_tenserList size 0"), return nullptr);
+
+  static const auto aclCreateTensorList = GET_OP_API_FUNC(aclCreateTensorList);
+  OP_CHECK_IF(aclCreateTensorList == nullptr,
+    OP_LOGE("aclnnfallback", "ge_tenserList size 0"), return nullptr);
+
+  std::vector<aclTensor*> tmp;
+  for (size_t i = 0; i < ge_tenserList.size(); i++) {
+    auto t_acl = ConvertType(ge_tenserList[i]);
+    tmp.push_back(t_acl);
+  }
+
+  aclTensorList* tensorList = aclCreateTensorList(tmp.data(), tmp.size());
+  return tensorList;
+}
+
+template <typename T>
+inline aclScalar* ConvertScalarType(T value) {
+  static const auto aclCreateScalar = GET_OP_API_FUNC(aclCreateScalar);
+  OP_CHECK_IF(aclCreateScalar == nullptr,
+    OP_LOGE("aclnnfallback", "aclCreateScalar nullptr"), return nullptr);
+  if (typeid(value) == typeid(float)) {
+    return aclCreateScalar(&value, aclDataType::ACL_FLOAT);
+  }
+  return nullptr;
+}
+
+template <typename T>
+T ConvertType(T value) {
+  return value;
+}
+
+inline aclTensor* ConvertMmType(const gert::Tensor* ge_tensor, bool transpose, bool enable_NZ=false) {
+  if (ge_tensor == nullptr) {
+    return nullptr;
+  }
+  auto gert_shape = ge_tensor->GetStorageShape();
+  if (gert_shape.GetDimNum() <= 1) {
+    return ConvertType(ge_tensor);
+  }
+
+  static const auto aclCreateTensor = GET_OP_API_FUNC(aclCreateTensor);
+  OP_CHECK_IF(aclCreateTensor == nullptr, OP_LOGE("aclnnfallback", "aclCreateTensor nullptr"), return nullptr);
+
+  void* device_addr = const_cast<void*>(ge_tensor->GetAddr());
+  // convert data type
+  auto dataType_ge = ge_tensor->GetDataType();
+  auto dataType = ToAclDataType(dataType_ge);
+  // convert shape
+  std::vector<int64_t> shape;
+  for (size_t i = 0; i < gert_shape.GetDimNum(); ++i) {
+    shape.push_back(gert_shape.GetDim(i));
+  }
+  // 计算连续tensor的strides
+  std::vector<int64_t> strides(shape.size(), 1);
+  for (int64_t i = shape.size() - 2; i >= 0; i--) {
+    strides[i] = shape[i + 1] * strides[i + 1];
+  }
+
+  auto viewShape = shape;
+  // 对于transpose后的tensor对后两维度进行strides, viewShape转换
+  if (transpose) {
+    // dimM 为倒数第二维， dimN 为倒数第一维度
+    auto dimM = shape.size() - 2;
+    auto dimN = shape.size() - 1;
+    auto swap =  strides[dimN];
+    strides[dimN] = strides[dimM];
+    strides[dimM] = swap;
+    // 修改viewShape
+    viewShape[dimN] = shape[dimM];
+    viewShape[dimM] = shape[dimN];
+  }
+  auto acl_format = aclFormat::ACL_FORMAT_ND;
+  if (enable_NZ && GetPrimaryFormat(ge_tensor->GetStorageFormat()) == ge::Format::FORMAT_FRACTAL_NZ) {
+    acl_format = aclFormat::ACL_FORMAT_FRACTAL_NZ;
+  }
+  aclTensor* out = aclCreateTensor(viewShape.data(), shape.size(), dataType, strides.data(),
+                                   0, acl_format, shape.data(), shape.size(), device_addr);
+  OP_CHECK_IF(out == nullptr, OP_LOGE("aclnnfallback", "out nullptr"), return nullptr);
+
+  return out;
+}
+
+inline void Release(aclTensor* p) {
+  static const auto aclDestroyTensor = GET_OP_API_FUNC(aclDestroyTensor);
+  OP_CHECK_IF(aclDestroyTensor == nullptr,
+    OP_LOGE("aclnnfallback", "aclDestroyTensor is null"), return);
+  aclDestroyTensor(p);
+}
+
+inline void Release(aclScalar* p) {
+  static const auto aclDestroyScalar = GET_OP_API_FUNC(aclDestroyScalar);
+  OP_CHECK_IF(aclDestroyScalar == nullptr,
+    OP_LOGE("aclnnfallback", "aclDestroyScalar is null"), return);
+  aclDestroyScalar(p);
+}
+
+inline void Release(aclIntArray* p) {
+  static const auto aclDestroyIntArray = GET_OP_API_FUNC(aclDestroyIntArray);
+  OP_CHECK_IF(aclDestroyIntArray == nullptr,
+    OP_LOGE("aclnnfallback", "aclDestroyIntArray is null"), return);
+  aclDestroyIntArray(p);
+}
+
+inline void Release(aclBoolArray* p) {
+  static const auto aclDestroyBoolArray = GET_OP_API_FUNC(aclDestroyBoolArray);
+  OP_CHECK_IF(aclDestroyBoolArray == nullptr,
+    OP_LOGE("aclnnfallback", "aclDestroyBoolArray is null"), return);
+  aclDestroyBoolArray(p);
+}
+
+inline void Release(aclTensorList* p) {
+  static const auto aclDestroyTensorList = GET_OP_API_FUNC(aclDestroyTensorList);
+  OP_CHECK_IF(aclDestroyTensorList == nullptr,
+    OP_LOGE("aclnnfallback", "aclDestroyTensorList is null"), return);
+  aclDestroyTensorList(p);
+}
+
+template <typename T>
+void Release(T value) {
+  (void)value;
+}
+
+template <typename Tuple, size_t... I>
+void CallRelease(Tuple t, std_utils::index_sequence<I...>) {
+  (void)std::initializer_list<int>{(Release(std::get<I>(t)), 0)...};
+}
+
+template <typename Tuple>
+void ReleaseConvertTypes(Tuple& t) {
+  static constexpr auto size = std::tuple_size<Tuple>::value;
+  CallRelease(t, std_utils::make_index_sequence<size>{});
+}
+
+template <typename... Ts>
+auto ConvertTypes(Ts&... args) -> decltype(std::make_tuple(ConvertType(args)...)) {
+    auto tp = std::make_tuple(ConvertType(args)...);
+    return tp;
+}
+
+template <typename Function, typename Tuple, size_t... I>
+auto call(Function f, Tuple t, std_utils::index_sequence<I...>)  -> int {
+  return f(std::get<I>(t)...);
+}
+
+template <typename Function, typename Tuple>
+auto call(Function f, Tuple t) -> int {
+  static constexpr auto size = std::tuple_size<Tuple>::value;
+  return call(f, t, std_utils::make_index_sequence<size>{});
+}
+
+template <typename Tuple, size_t... I>
+auto ConvertToOpApiFunc(const Tuple& params, void* opApiAddr, std_utils::index_sequence<I...>)
+    -> int (*)(typename std::decay<decltype(std::get<I>(params))>::type...) {
+    using LocalOpApiFunc = int (*)(typename std::decay<decltype(std::get<I>(params))>::type...);
+    auto func = reinterpret_cast<LocalOpApiFunc>(opApiAddr);
+    return func;
+}
+
+template <typename Tuple>
+auto ConvertToOpApiFunc(const Tuple& params, void* opApiAddr)
+    -> typename std::enable_if<std::tuple_size<Tuple>::value != 0,
+    decltype(ConvertToOpApiFunc(params, opApiAddr, std_utils::make_index_sequence<std::tuple_size<Tuple>::value>{}))>::type {
+    static constexpr auto size = std::tuple_size<Tuple>::value;
+    return ConvertToOpApiFunc(params, opApiAddr, std_utils::make_index_sequence<size>{});
+}
+
+template <typename Tuple>
+class ConvertedParams {
+ public:
+  ConvertedParams(Tuple&& convertedParams) : convertedParams_(std::move(convertedParams)){};
+  ConvertedParams(ConvertedParams&& other) : convertedParams_(std::move(other.convertedParams_)) {
+    other.validParams_ = false;
+  };
+  ConvertedParams& operator=(ConvertedParams&& other) {
+    if (this == &other) {
+      return *this;
+    }
+
+    convertedParams_ = std::move(other.convertedParams_);
+    validParams_ = true;
+    other.validParams_ = false;
+    return *this;
+  }
+
+  ConvertedParams() = delete;
+  ConvertedParams(const ConvertedParams& other) = delete;
+  ConvertedParams& operator=(const ConvertedParams& other) = delete;
+
+  ~ConvertedParams() {
+    if (validParams_) {
+      ReleaseConvertTypes(convertedParams_);
+    }
+  }
+
+  const Tuple& GetConvertedParams() const {
+    return convertedParams_;
+  }
+
+ private:
+  Tuple convertedParams_;
+  bool validParams_{true};
+};
+
+using InitHugeMemThreadLocal = int (*)(void*, bool);
+using UnInitHugeMemThreadLocal = void (*)(void*, bool);
+using ReleaseHugeMem = void (*)(void*, bool);
+using PTAGetExecCache = aclOpExecutor* (*)(uint64_t, uint64_t*);
+using InitPTACacheThreadLocal = void (*)();
+using SetPTAHashKey = void (*)(uint64_t);
+using CanUsePTACache = bool (*)(const char*);
+
+using ResetCacheThreadLocal = void (*)();
+
+#define EXEC_OPAPI_CMD(aclnn_api, ...)                                                                               \
+  ({                                                                                                                 \
+    static auto ret = GRAPH_SUCCESS;                                                                                 \
+    do {                                                                                                             \
+      static const auto ResetCacheThreadLocalAddr = GetOpApiFuncAddr("ResetCacheThreadLocal");                       \
+      static const auto getWorkspaceSizeFuncAddr = GetOpApiFuncAddr(#aclnn_api "GetWorkspaceSize");                  \
+      static const auto opApiFuncAddr = GetOpApiFuncAddr(#aclnn_api);                                                \
+      if (getWorkspaceSizeFuncAddr == nullptr || opApiFuncAddr == nullptr || ResetCacheThreadLocalAddr == nullptr) { \
+        OP_LOGE("aclnnfallback", "%s or %s not in  %s or %s  or ResetCacheThreadLocal not found.",                   \
+                #aclnn_api "GetWorkspaceSize", #aclnn_api, GetOpApiLibName(), GetOpApiLibName());                    \
+        ret = GRAPH_FAILED;                                                                                          \
+        break;                                                                                                       \
+      }                                                                                                              \
+      auto ResetCacheThreadLocalFunc = reinterpret_cast<ResetCacheThreadLocal>(ResetCacheThreadLocalAddr);           \
+      ResetCacheThreadLocalFunc();                                                                                   \
+      uint64_t workspace_size = 0;                                                                                   \
+      uint64_t* workspace_size_addr = &workspace_size;                                                               \
+      aclOpExecutor* executor = nullptr;                                                                             \
+      aclOpExecutor** executor_addr = &executor;                                                                     \
+      auto converted_params = ConvertTypes(__VA_ARGS__, workspace_size_addr, executor_addr);                         \
+      static auto getWorkspaceSizeFunc = ConvertToOpApiFunc(converted_params, getWorkspaceSizeFuncAddr);             \
+      auto workspace_status = call(getWorkspaceSizeFunc, converted_params);                                          \
+      if (workspace_status != 0) {                                                                                   \
+        OP_LOGE("aclnnfallback", "call %s failed:", #aclnn_api);                                                     \
+        ret = GRAPH_FAILED;                                                                                          \
+        break;                                                                                                       \
+      }                                                                                                              \
+      void* workspace_addr = nullptr;                                                                                \
+      if (workspace_size > 0) {                                                                                      \
+        workspace_addr = host_api_ctx->MallocWorkspace(workspace_size);                                              \
+        if (workspace_addr == nullptr) {                                                                             \
+          OP_LOGE("aclnnfallback", "call %s allocate workspace failed", #aclnn_api);                                 \
+          ret = GRAPH_FAILED;                                                                                        \
+          break;                                                                                                     \
+        }                                                                                                            \
+      }                                                                                                              \
+      auto acl_stream = host_api_ctx->GetStream();                                                                   \
+      auto acl_call = [converted_params, workspace_addr, workspace_size, host_api_ctx, acl_stream,                   \
+                       executor]() -> int {                                                                          \
+        using OpApiFunc = int (*)(void*, uint64_t, aclOpExecutor*, const aclrtStream);                               \
+        OpApiFunc opApiFunc = reinterpret_cast<OpApiFunc>(opApiFuncAddr);                                            \
+        auto api_ret_inner = opApiFunc(workspace_addr, workspace_size, executor, acl_stream);                              \
+        ReleaseConvertTypes(converted_params);                                                                       \
+        host_api_ctx->FreeWorkspace();                                                                               \
+        if (api_ret_inner != 0) {                                                                                          \
+          OP_LOGE("aclnnfallback", "call %s allocate workspace failed api_ret_inner: %d", #aclnn_api, api_ret_inner);           \
+          return GRAPH_FAILED;                                                                                       \
+        }                                                                                                            \
+        return api_ret_inner;                                                                                              \
+      };                                                                                                             \
+                                                                                                                     \
+      ret = acl_call();                                                                                              \
+    } while (false);                                                                                                 \
+    (ret);                                                                                                           \
+  })
+
+}  // namespace fallback
+
+#endif  //  ACLNNFALLBACK_OPAPI_H_

csrc/common/include/fallback/fallback_2stages.h

@@ -0,0 +1,126 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+#ifndef ACLNNFALLBACK_OPAPI_TWOSTAGES_H_
+#define ACLNNFALLBACK_OPAPI_TWOSTAGES_H_
+
+#include <dlfcn.h>
+
+#include <functional>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include "aclnn/aclnn_base.h"
+#include "fallback.h"
+#include "fallback_comm.h"
+#include "fallback_comm_2stages.h"
+#include "log/log.h"
+#include "mc2_log.h"
+
+namespace fallback {
+using namespace std;
+using namespace gert;
+using namespace ge;
+
+inline void Collect(aclTensor *p, std::vector<OpApiAnyValue> &params) {
+  static const auto aclDestroyTensor = GET_OP_API_FUNC(aclDestroyTensor);
+  OPS_ERR_IF(aclDestroyTensor == nullptr,
+            OP_LOGE("aclnnfallback", "aclDestroyTensor is null"), return);
+  params.emplace_back(OpApiAnyValue{p, [](void *param) {aclDestroyTensor(static_cast<aclTensor *>(param));}});
+}
+
+inline void Collect(aclScalar *p, std::vector<OpApiAnyValue> &params) {
+  static const auto aclDestroyScalar = GET_OP_API_FUNC(aclDestroyScalar);
+  OPS_ERR_IF(aclDestroyScalar == nullptr,
+            OP_LOGE("aclnnfallback", "aclDestroyScalar is null"), return);
+  params.emplace_back(OpApiAnyValue{p, [](void *param) {aclDestroyScalar(static_cast<aclScalar *>(param));}});
+}
+
+inline void Collect(aclIntArray *p, std::vector<OpApiAnyValue> &params) {
+  static const auto aclDestroyIntArray = GET_OP_API_FUNC(aclDestroyIntArray);
+  OPS_ERR_IF(aclDestroyIntArray == nullptr,
+            OP_LOGE("aclnnfallback", "aclDestroyIntArray is null"), return);
+  params.emplace_back(OpApiAnyValue{p, [](void *param) {aclDestroyIntArray(static_cast<aclIntArray *>(param));}});
+}
+
+inline void Collect(aclBoolArray *p, std::vector<OpApiAnyValue> &params) {
+  static const auto aclDestroyBoolArray = GET_OP_API_FUNC(aclDestroyBoolArray);
+  OPS_ERR_IF(aclDestroyBoolArray == nullptr,
+            OP_LOGE("aclnnfallback", "aclDestroyBoolArray is null"), return);
+  params.emplace_back(OpApiAnyValue{p, [](void *param) {aclDestroyBoolArray(static_cast<aclBoolArray *>(param));}});
+}
+
+inline void Collect(aclTensorList *p, std::vector<OpApiAnyValue> &params) {
+  static const auto aclDestroyTensorList = GET_OP_API_FUNC(aclDestroyTensorList);
+  OPS_ERR_IF(aclDestroyTensorList == nullptr,
+            OP_LOGE("aclnnfallback", "aclDestroyTensorList is null"), return);
+  params.emplace_back(OpApiAnyValue{p, [](void *param) {aclDestroyTensorList(static_cast<aclTensorList *>(param));}});
+}
+
+template <typename T>
+void Collect(T value, std::vector<OpApiAnyValue> &params) {
+  (void)value;
+  params.emplace_back(OpApiAnyValue{nullptr, nullptr});
+}
+
+template <typename Tuple, size_t... I>
+void CallCollect(Tuple t, std_utils::index_sequence<I...>, std::vector<OpApiAnyValue> &params) {
+  (void)std::initializer_list<int>{(Collect(std::get<I>(t), params), 0)...};
+}
+
+template <typename Tuple>
+void CollectConvertedTypes(Tuple &t, std::vector<OpApiAnyValue> &params) {
+  static constexpr auto size = std::tuple_size<Tuple>::value;
+  CallCollect(t, std_utils::make_index_sequence<size>{}, params);
+}
+
+#define EXEC_OPAPI_PREPARE_CMD(aclnn_api, ...)                                                                       \
+  ({                                                                                                                 \
+    static auto ret = GRAPH_SUCCESS;                                                                                 \
+    do {                                                                                                             \
+      static const auto ResetCacheThreadLocalAddr = GetOpApiFuncAddr("ResetCacheThreadLocal");                       \
+      static const auto getWorkspaceSizeFuncAddr = GetOpApiFuncAddr(#aclnn_api "GetWorkspaceSize");                  \
+      static const auto opApiFuncAddr = GetOpApiFuncAddr(#aclnn_api);                                                \
+      if (getWorkspaceSizeFuncAddr == nullptr || opApiFuncAddr == nullptr || ResetCacheThreadLocalAddr == nullptr) { \
+        OP_LOGE("aclnnfallback", "%s or %s not in  %s or %s  or ResetCacheThreadLocal not found.",                   \
+                #aclnn_api "GetWorkspaceSize", #aclnn_api, GetOpApiLibName(), GetOpApiLibName());                    \
+        ret = GRAPH_FAILED;                                                                                          \
+        break;                                                                                                       \
+      }                                                                                                              \
+      auto *op_api_params = new (std::nothrow) OpApiParams();                                                        \
+      auto ResetCacheThreadLocalFunc = reinterpret_cast<ResetCacheThreadLocal>(ResetCacheThreadLocalAddr);           \
+      ResetCacheThreadLocalFunc();                                                                                   \
+      op_api_params->op_api_func = reinterpret_cast<OpApiFunc>(opApiFuncAddr);                                       \
+      uint64_t workspace_size = 0;                                                                                   \
+      uint64_t* workspace_size_addr = &workspace_size;                                                               \
+      aclOpExecutor** executor_addr = &op_api_params->executor;                                                      \
+      auto converted_params = ConvertTypes(__VA_ARGS__, workspace_size_addr, executor_addr);                         \
+      using TupleT = decltype(converted_params);                                                                     \
+      constexpr size_t tuple_size = std::tuple_size<TupleT>::value;                                                  \
+      op_api_params->converted_params.reserve(tuple_size);                                                           \
+      CollectConvertedTypes(converted_params, op_api_params->converted_params);                                      \
+      host_api_ctx->SetOpApiParamsWithDefaultDeleter<OpApiParams>(op_api_params);                                    \
+      static auto getWorkspaceSizeFunc = ConvertToOpApiFunc(converted_params, getWorkspaceSizeFuncAddr);             \
+      auto workspace_status = call(getWorkspaceSizeFunc, converted_params);                                          \
+      if (workspace_status != 0) {                                                                                   \
+        OP_LOGE("aclnnfallback", "call %s failed:", #aclnn_api);                                                     \
+        ret = GRAPH_FAILED;                                                                                          \
+        break;                                                                                                       \
+      }                                                                                                              \
+      ret = host_api_ctx->SetWorkspaceSizes({workspace_size});                                                       \
+    } while (false);                                                                                                 \
+    (ret);                                                                                                           \
+  })
+
+}  // namespace fallback
+
+#endif //  ACLNNFALLBACK_OPAPI_TWOSTAGES_H_

csrc/common/include/fallback/fallback_comm.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file fallback_comm.h
+ * \brief
+ */
+
+#ifndef INC_EXTERNAL_GRAPH_FALLBACK_COMMON_H_
+#define INC_EXTERNAL_GRAPH_FALLBACK_COMMON_H_
+
+#include "aclnn/aclnn_base.h"
+#include "exe_graph/runtime/op_execute_context.h"
+#include "exe_graph/runtime/tensor.h"
+#include "register/op_impl_registry.h"
+#if __has_include("runtime/base.h")
+#include "runtime/base.h"
+#else
+#include "runtime/rt_external_base.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+namespace fallback {
+
+aclDataType ToAclDataType(ge::DataType dtype);
+}  // namespace fallback
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // INC_EXTERNAL_GRAPH_FALLBACK_COMMON_H_

csrc/common/include/fallback/fallback_comm_2stages.h

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+#ifndef INC_EXTERNAL_GRAPH_FALLBACK_COMMON_TWOSTAGES_H_
+#define INC_EXTERNAL_GRAPH_FALLBACK_COMMON_TWOSTAGES_H_
+
+#include "aclnn/aclnn_base.h"
+#include "aclnn/acl_meta.h"
+#include "exe_graph/runtime/op_execute_context.h"
+#include "exe_graph/runtime/op_execute_prepare_context.h"
+#include "exe_graph/runtime/op_execute_launch_context.h"
+#include "exe_graph/runtime/tensor.h"
+#include "register/op_impl_kernel_registry.h"
+#include "register/op_impl_registry.h"
+#if __has_include("runtime/base.h")
+#include "runtime/base.h"
+#else
+#include "runtime/rt_external_base.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+namespace fallback {
+
+using OpApiAnyValueDeleter = void (*)(void *);
+typedef struct {
+  void *pointer;
+  OpApiAnyValueDeleter deleter;
+} OpApiAnyValue;
+
+// aclnn算子params结构体，用于传递算子一阶段到二阶段的参数，定义在算子仓，由算子感知，GE框架不感知
+using OpApiFunc = int (*)(void *, uint64_t, aclOpExecutor *, const aclrtStream);
+struct OpApiParams {
+  std::vector<OpApiAnyValue> converted_params; // 算子下发依赖的参数
+  aclOpExecutor *executor = nullptr; // aclOpExecutor指针
+  OpApiFunc op_api_func = nullptr; // aclnnxx函数指针，实现算子launch下发
+};
+
+// aclnn算子注册的二阶段launch func，函数实现可以与算子类型无关，所有算子使用同一个二阶段注册接口
+ge::graphStatus ExecuteOpLaunch(gert::OpExecuteLaunchContext *context);
+}  // namespace fallback
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // INC_EXTERNAL_GRAPH_FALLBACK_COMMON_TWOSTAGES_H_

csrc/common/include/framework/onnx_common.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file onnx_common.h
+ * \brief
+ */
+
+#ifndef MATH_COMMON_ONNX_COMMON_H
+#define MATH_COMMON_ONNX_COMMON_H
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include "stub_ops.h"
+#include "register/register.h"
+#include "graph/operator.h"
+#include "graph/graph.h"
+#include "base/err_msg.h"
+#include "log/log.h"
+#include "onnx/proto/ge_onnx.pb.h"
+
+namespace domi {
+template <typename T>
+inline std::string GetOpName(const T& op)
+{
+  ge::AscendString op_ascend_name;
+  ge::graphStatus ret = op.GetName(op_ascend_name);
+  if (ret != ge::GRAPH_SUCCESS) {
+    std::string op_name = "None";
+    return op_name;
+  }
+  return op_ascend_name.GetString();
+}
+
+template<typename T>
+inline ge::Tensor Vec2Tensor(vector<T>& vals, const vector<int64_t>& dims, ge::DataType dtype, ge::Format format = ge::FORMAT_ND) {
+  ge::Shape shape(dims);
+  ge::TensorDesc desc(shape, format, dtype);
+  ge::Tensor tensor(desc, reinterpret_cast<uint8_t*>(vals.data()), vals.size() * sizeof(T));
+  return tensor;
+}
+
+template<typename T>
+inline ge::Tensor CreateScalar(T val, ge::DataType dtype, ge::Format format = ge::FORMAT_ND) {
+  vector<int64_t> dims_scalar = {};
+  ge::Shape shape(dims_scalar);
+  ge::TensorDesc desc(shape, format, dtype);
+  ge::Tensor tensor(desc, reinterpret_cast<uint8_t*>(&val), sizeof(T));
+  return tensor;
+}
+
+inline Status ChangeFormatFromOnnx(ge::Operator& op, const int idx, ge::Format format, bool is_input) {
+  if (is_input) {
+    ge::TensorDesc org_tensor = op.GetInputDesc(idx);
+    org_tensor.SetOriginFormat(format);
+    org_tensor.SetFormat(format);
+    auto ret = op.UpdateInputDesc(idx, org_tensor);
+    if (ret != ge::GRAPH_SUCCESS) {
+      OP_LOGE(GetOpName(op).c_str(), "change input format failed.");
+      return FAILED;
+    }
+  } else {
+    ge::TensorDesc org_tensor_y = op.GetOutputDesc(idx);
+    org_tensor_y.SetOriginFormat(format);
+    org_tensor_y.SetFormat(format);
+    auto ret_y = op.UpdateOutputDesc(idx, org_tensor_y);
+    if (ret_y != ge::GRAPH_SUCCESS) {
+      OP_LOGE(GetOpName(op).c_str(), "change output format failed.");
+      return FAILED;
+    }
+  }
+  return SUCCESS;
+}
+}  // namespace domi
+
+#endif  //  MATH_COMMON_ONNX_COMMON_H

csrc/common/include/kernel/common.h

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file common.h
+ * \brief
+ */
+ 
+#ifndef INCLUDE_COMMON_H
+#define INCLUDE_COMMON_H
+
+#define CONST_2 2
+
+#define SET_FLAG(trigger, waiter, e) AscendC::SetFlag<AscendC::HardEvent::trigger##_##waiter>((e))
+#define WAIT_FLAG(trigger, waiter, e) AscendC::WaitFlag<AscendC::HardEvent::trigger##_##waiter>((e))
+#define PIPE_BARRIER(pipe) AscendC::PipeBarrier<PIPE_##pipe>()
+
+#ifndef FORCE_INLINE
+#define FORCE_INLINE inline __attribute__((always_inline))
+#endif
+
+#endif

csrc/common/include/kernel/common_func.h

@@ -0,0 +1,117 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file common_func.h
+ * \brief
+ */
+
+ #ifndef INCLUDE_COMMON_FUNC_H
+ #define INCLUDE_COMMON_FUNC_H
+ 
+ #include <limits>
+ #include <type_traits>
+ 
+ #ifdef __CCE_KT_TEST__
+ #include "stub_def.h"
+ #include "stub_fun.h"
+ #else
+ #include "kernel_macros.h"
+ #endif
+ 
+ template <uint32_t ALIGN, typename T = uint32_t>
+ inline __aicore__ T RoundUp(const T val)
+ {
+     static_assert(ALIGN != 0, "align must not be zero");
+     static_assert(std::is_arithmetic<T>::value, "T must be an arithmetic type");
+     T align = ALIGN;
+     if (val + align - 1 < val) {
+         return val;
+     }
+     return (val + align - 1) / align * align;
+ }
+ 
+ template <typename T>
+ inline __aicore__ T RoundUp(const T val, const T align)
+ {
+     static_assert(std::is_arithmetic<T>::value, "T must be an arithmetic type");
+     if (align == 0 || val + align - 1 < val) {
+         return val;
+     }
+     return (val + align - 1) / align * align;
+ }
+ 
+ template <uint32_t DIVISOR, typename T = uint32_t>
+ inline __aicore__ T CeilDiv(const T dividend)
+ {
+     static_assert(DIVISOR != 0, "align must not be zero");
+     static_assert(std::is_arithmetic<T>::value, "T must be an arithmetic type");
+     T divisor = DIVISOR;
+     if (dividend + divisor - 1 < dividend) {
+         return dividend;
+     }
+     return (dividend + divisor - 1) / divisor;
+ }
+ 
+ template <typename T>
+ constexpr T T_MAX = std::numeric_limits<T>::max();
+ 
+ template <typename T>
+ inline __aicore__ T CeilDiv(const T dividend, const T divisor)
+ {
+     static_assert(std::is_arithmetic<T>::value, "T must be an arithmetic type");
+     if (divisor == 0 || dividend + divisor - 1 < dividend) {
+         return T_MAX<T>;
+     }
+     return (dividend + divisor - 1) / divisor;
+ }
+ 
+ template <typename T>
+ __aicore__ inline T Min(const T lhs, const T rhs)
+ {
+     return lhs < rhs ? lhs : rhs;
+ }
+ 
+ template <typename Dtype> __aicore__ __attribute__((always_inline)) inline uint32_t BlockSize()
+ {
+     return 32 / sizeof(Dtype);
+ }
+ 
+ template <typename Dtype> __aicore__ __attribute__((always_inline)) inline uint32_t MatrixSize()
+ {
+     return 512 / sizeof(Dtype);
+ }
+ 
+ template <typename Dtype> __aicore__ __attribute__((always_inline)) inline uint64_t BlockSizeRoundUp(uint64_t num)
+ {
+     return (num + BlockSize<Dtype>() - 1) / BlockSize<Dtype>() * BlockSize<Dtype>();
+ }
+ 
+ template <typename Dtype> __aicore__ __attribute__((always_inline)) inline uint64_t NumBlocksRoundUp(uint64_t num)
+ {
+     return (num + BlockSize<Dtype>() - 1) / BlockSize<Dtype>();
+ }
+ 
+ template <typename Dtype> __aicore__ __attribute__((always_inline)) inline uint64_t MatrixSizeRoundUp(uint64_t num)
+ {
+     return (num + MatrixSize<Dtype>() - 1) / MatrixSize<Dtype>() * MatrixSize<Dtype>();
+ }
+ 
+ template <typename Dtype> __aicore__ __attribute__((always_inline)) inline uint64_t NumMatrixsRoundUp(uint64_t num)
+ {
+     return (num + MatrixSize<Dtype>() - 1) / MatrixSize<Dtype>();
+ }
+ 
+ template <typename Dtype> __aicore__ __attribute__((always_inline)) inline uint64_t L0HalfSize()
+ {
+     return 32 * 1024 / sizeof(Dtype);
+ }
+ 
+ #endif

csrc/common/include/kernel/dropmask.h

@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file dropmask.h
+ * \brief
+ */
+
+#ifndef DROPMASK_H
+#define DROPMASK_H
+
+#include "util.h"
+
+using AscendC::DROPOUT_MODE_BIT_MISALIGN;
+using AscendC::DropOutShapeInfo;
+using AscendC::DropOut;
+
+struct DropMaskInfo {
+    // for compute dropout mask offset
+    // 参数按B N G S1 S2全部切分设置进行偏移计算，没有切分的轴对应的参数设置为合适的0或者原始值
+    int64_t n2G; // n2 * g
+    int64_t gSize; // g
+    int64_t s1Size; // s1
+    int64_t s2Size; // s2
+    int64_t gOutIdx; // g out index
+    int64_t bSSOffset; // boidx * s1 * s2 ===bSSOffset
+    int64_t n2OutIdx; // n out index
+    int64_t s1OutIdx; // s1 out index   ===s1oIdx
+    int64_t s1InnerIdx; // s1 inner index, 配比 ===loopIdx
+    int64_t s1BaseSize; // S1基本块大小
+    int64_t splitS1BaseSize; // s1 split size ===vec1S1BaseSize
+    int64_t s2StartIdx; // s2 start index
+    int64_t s2Idx; // s2 index =====s2LoopCount
+    int64_t s2BaseNratioSize; // s2的配比长度: s2BaseSize(S2基本块大小) * nRatio
+
+    // for copy in dropout mask
+    uint32_t s1CopySize;
+    uint32_t s2CopySize;
+    int64_t s2TotalSize;
+
+    // for compute dropout mask
+    uint32_t firstAxis;
+    uint32_t lstAxis;
+    uint32_t maskLstAxis;
+    int64_t vecCoreOffset = 0;
+    float keepProb;
+
+    bool boolMode;
+};
+
+template <bool hasDrop>
+__aicore__ inline int64_t ComputeDropOffset(DropMaskInfo &dropMaskInfo)
+{
+    if constexpr (hasDrop == true) {
+        // boidx * n2 * g* s1 * s2
+        int64_t bOffset = dropMaskInfo.bSSOffset * dropMaskInfo.n2G;
+        // n2oIdx * g * s1 *s2
+        int64_t n2Offset = dropMaskInfo.n2OutIdx * dropMaskInfo.gSize * dropMaskInfo.s1Size * dropMaskInfo.s2Size;
+        // goIdx * s1 * s2
+        int64_t gOffset = dropMaskInfo.gOutIdx * dropMaskInfo.s1Size * dropMaskInfo.s2Size;
+        // s1oIdx * s1BaseSize * s2Size + s1innerindex * vec1S1BaseSize * s2Size
+        int64_t s1Offset = (dropMaskInfo.s1OutIdx * dropMaskInfo.s1BaseSize + dropMaskInfo.vecCoreOffset +
+                            dropMaskInfo.s1InnerIdx * dropMaskInfo.splitS1BaseSize) * dropMaskInfo.s2Size;
+        // s2StartIdx + s2index * s2BaseNratioSize
+        int64_t s2Offset = dropMaskInfo.s2StartIdx + dropMaskInfo.s2Idx * dropMaskInfo.s2BaseNratioSize;
+        return bOffset + n2Offset + gOffset + s1Offset + s2Offset;
+    } else {
+        return 0;
+    }
+}
+
+template <bool hasDrop>
+__aicore__ inline void CopyInDropMask(LocalTensor<uint8_t>&dstTensor, GlobalTensor<uint8_t>& srcBoolTensor,
+    GlobalTensor<uint8_t>& srcByteTensor, DropMaskInfo &dropMaskInfo, int64_t alignedSize = blockBytes)
+{
+    if constexpr (hasDrop == true) {
+        int64_t dropMaskOffset = ComputeDropOffset<hasDrop>(dropMaskInfo);
+        if (unlikely(dropMaskInfo.boolMode)) {
+            BoolCopyIn(dstTensor, srcBoolTensor, dropMaskOffset,
+                       dropMaskInfo.s1CopySize, dropMaskInfo.s2CopySize, dropMaskInfo.s2TotalSize, alignedSize);
+        } else {
+            Bit2Int8CopyIn(dstTensor, srcByteTensor, dropMaskOffset, 1,
+                           dropMaskInfo.s1CopySize, dropMaskInfo.s2CopySize, dropMaskInfo.s2TotalSize, alignedSize);
+        }
+        return;
+    }
+}
+
+template <typename T, bool hasDrop>
+__aicore__ inline void ComputeDropMask(LocalTensor<T>& dstTensor, LocalTensor<T>& srcTensor,
+    LocalTensor<uint8_t>& dropoutBuffer, LocalTensor<uint8_t>& tmpDropBuffer, DropMaskInfo &dropMaskInfo)
+{
+    if constexpr (hasDrop == true) {
+        DropOutShapeInfo dropOutShapeInfo;
+        dropOutShapeInfo.firstAxis = dropMaskInfo.firstAxis;
+        dropOutShapeInfo.srcLastAxis = dropMaskInfo.lstAxis;
+
+        if (unlikely(dropMaskInfo.boolMode)) {
+            dropOutShapeInfo.maskLastAxis = CeilDiv(dropMaskInfo.maskLstAxis, blockBytes) * blockBytes;
+            DropOut(dstTensor, srcTensor, dropoutBuffer, tmpDropBuffer, dropMaskInfo.keepProb, dropOutShapeInfo);
+        } else {
+            dropOutShapeInfo.maskLastAxis = CeilDiv(dropMaskInfo.maskLstAxis / byteBitRatio, blockBytes) * blockBytes;
+            if (likely(dropMaskInfo.lstAxis / byteBitRatio % blockBytes == 0)) {
+                DropOut(dstTensor, srcTensor, dropoutBuffer, tmpDropBuffer, dropMaskInfo.keepProb, dropOutShapeInfo);
+            } else {
+                DropOut<T, false, DROPOUT_MODE_BIT_MISALIGN>(dstTensor, srcTensor, dropoutBuffer, tmpDropBuffer,
+                                                             dropMaskInfo.keepProb, dropOutShapeInfo);
+            }
+        }
+        return;
+    }
+}
+
+#endif // DROPMASK_H

csrc/common/include/kernel/gm_to_l1_iterator.h

@@ -0,0 +1,169 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file gm_to_l1_iterator.h
+ * \brief
+ */
+
+#ifndef GM_TO_L1_ITERATOR_H
+#define GM_TO_L1_ITERATOR_H
+
+#include "iterator.h"
+
+constexpr uint32_t STRIDE_LIMIT_H = 65536;
+
+// Partial specialization for V220, ND_in, ND_out
+template <ArchType ArchTag, typename DataType>
+struct gm_to_l1<ArchTag, DataType, DataFormatT::ND, DataFormatT::ND> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::l1l0BlockSize / sizeof(DataType);
+
+    __aicore__ gm_to_l1(AscendC::LocalTensor<DataType> l1Tensor,
+                        AscendC::GlobalTensor<DataType> gmTensor,
+                        uint32_t nTileActual,
+                        uint32_t nTileCeil,
+                        uint32_t nVal,
+                        uint32_t dTileActual,
+                        uint32_t dTileCeil,
+                        uint32_t dVal)
+    {
+        AscendC::DataCopy(l1Tensor,
+                          gmTensor,
+                          AscendC::DataCopyParams(1,                                              // nBurst
+                                                  CeilDiv<BLOCK_SIZE>(nTileActual * dTileActual), // lenBurst
+                                                  0,                                              // srcGap
+                                                  0));                                            // dstGap
+    };
+};
+
+// Partial specialization for NZ_in, NZ_out
+template <ArchType ArchTag, typename DataType>
+struct gm_to_l1<ArchTag, DataType, DataFormatT::NZ, DataFormatT::NZ> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::l1l0BlockSize / sizeof(DataType);
+
+    __aicore__ gm_to_l1(AscendC::LocalTensor<DataType> l1Tensor,
+                        AscendC::GlobalTensor<DataType> gmTensor,
+                        uint32_t nTileActual,
+                        uint32_t nTileCeil,
+                        uint32_t nVal,
+                        uint32_t dTileActual,
+                        uint32_t dTileCeil,
+                        uint32_t dVal)
+    {
+        uint64_t srcStride = nTileCeil - nTileActual;
+        if (srcStride < STRIDE_LIMIT_H) {
+            AscendC::DataCopy(l1Tensor, gmTensor,
+                              AscendC::DataCopyParams(dTileActual / BLOCK_SIZE, // nBurst
+                                                      nTileActual,              // lenBurst
+                                                      nTileCeil - nTileActual,  // srcGap
+                                                      0));                      // dstGap
+        } else {
+            for (uint64_t i = 0; i < dTileActual / BLOCK_SIZE; i++) {
+                uint64_t dstOffset = i * nTileActual * BLOCK_SIZE;
+                uint64_t srcOffset = i * nTileCeil * BLOCK_SIZE;
+                AscendC::DataCopy(l1Tensor[dstOffset], gmTensor[srcOffset],
+                                  AscendC::DataCopyParams(1,           // nBurst
+                                                          nTileActual, // lenBurst
+                                                          0,           // srcGap
+                                                          0));         // dstGap
+            }
+        }
+    };
+};
+
+// Partial specialization for V220, ND_in, ND_out
+template <ArchType ArchTag, typename DataType>
+struct gm_to_l1<ArchTag, DataType, DataFormatT::ND, DataFormatT::NZ> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::l1l0BlockSize / sizeof(DataType);
+
+    __aicore__ gm_to_l1(AscendC::LocalTensor<DataType> l1Tensor,
+                        AscendC::GlobalTensor<DataType> gmTensor,
+                        uint32_t nTileActual,
+                        uint32_t nTileCeil,
+                        uint32_t nVal,
+                        uint32_t dTileActual,
+                        uint32_t dTileCeil,
+                        uint32_t dVal)
+    {
+        if (dVal < STRIDE_LIMIT_H) {
+            AscendC::DataCopy(l1Tensor,
+                              gmTensor,
+                              AscendC::Nd2NzParams(1,           // ndNum
+                                                   nTileActual, // nValue
+                                                   dTileActual, // dValue
+                                                   0,           // srcNdMatrixStride, unused
+                                                   dVal,        // srcDValue
+                                                   nTileCeil,   // dstNzC0Stride
+                                                   1,           // dstNzNStride
+                                                   0));         // dstNzMatrixStride, unused
+        } else {
+            for (uint32_t i = 0; i < nTileActual; i++) {
+                AscendC::DataCopy(l1Tensor[i * BLOCK_SIZE],
+                                  gmTensor[i * dVal],
+                                  AscendC::Nd2NzParams(1,           // ndNum
+                                                       1,           // nValue
+                                                       dTileActual, // dValue
+                                                       0,           // srcNdMatrixStride, unused
+                                                       0,           // srcDValue
+                                                       nTileCeil,   // dstNzC0Stride
+                                                       0,           // dstNzNStride
+                                                       0));         // dstNzMatrixStride, unused
+            }
+        }
+    };
+};
+
+// Partial specialization for V220, ND_in, NZ_out
+template <ArchType ArchTag, typename DataType>
+struct gm_to_l1<ArchTag, DataType, DataFormatT::ND, DataFormatT::ZN> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::l1l0BlockSize / sizeof(DataType);
+
+    __aicore__ gm_to_l1(AscendC::LocalTensor<DataType> l1Tensor,
+                        AscendC::GlobalTensor<DataType> gmTensor,
+                        uint32_t nTileActual,
+                        uint32_t nTileCeil,
+                        uint32_t nVal,
+                        uint32_t dTileActual,
+                        uint32_t dTileCeil,
+                        uint32_t dVal)
+    {
+        if (dVal < STRIDE_LIMIT_H) {
+            AscendC::DataCopy(l1Tensor,
+                              gmTensor,
+                              AscendC::Nd2NzParams(1,           // ndNum
+                                                   nTileActual, // nValue
+                                                   dTileActual, // dValue
+                                                   0,           // srcNdMatrixStride, unused
+                                                   dVal,        // srcDValue
+                                                   nTileCeil,   // dstNzC0Stride
+                                                   1,           // dstNzNStride
+                                                   0));         // dstNzMatrixStride, unused
+        } else {
+            for (uint32_t i = 0; i < nTileActual; ++i) {
+                AscendC::DataCopy(l1Tensor,
+                                  gmTensor,
+                                  AscendC::Nd2NzParams(1,           // ndNum
+                                                       1,           // nValue
+                                                       dTileActual, // dValue
+                                                       0,           // srcNdMatrixStride, unused
+                                                       0,           // srcDValue
+                                                       nTileCeil,   // dstNzC0Stride
+                                                       0,           // dstNzNStride
+                                                       0));         // dstNzMatrixStride, unused
+            }
+        }
+    };
+};
+
+#endif // GM_TO_L1_ITERATOR_H

csrc/common/include/kernel/gm_to_ub_iterator.h

@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file gm_to_ub_iterator.h
+ * \brief
+ */
+
+#ifndef GM_TO_UB_ITERATOR_H
+#define GM_TO_UB_ITERATOR_H
+
+#include "iterator.h"
+
+constexpr uint32_t STRIDE_LIMIT_I = 65536;
+
+template <ArchType ArchTag, typename DType> struct gm_to_ub {
+    __aicore__ inline gm_to_ub(AscendC::LocalTensor<DType> dstTensor, AscendC::GlobalTensor<DType> srcTensor,
+                               uint8_t sid, uint16_t nBurst, uint16_t lenBurst, uint16_t srcStride, uint16_t dstStride)
+    {
+        AscendC::DataCopy(dstTensor, srcTensor, AscendC::DataCopyParams(nBurst, lenBurst, srcStride, dstStride));
+    };
+};
+
+template <ArchType ArchTag, typename DType> struct gm_to_ub_align {
+    __aicore__ inline gm_to_ub_align(AscendC::LocalTensor<DType> dstTensor, AscendC::GlobalTensor<DType> srcTensor,
+                                     uint8_t sid, uint16_t nBurst, uint32_t lenBurst, uint8_t leftPaddingNum,
+                                     uint8_t rightPaddingNum, uint32_t srcGap, uint32_t dstGap)
+    {
+        AscendC::DataCopyPad(dstTensor, srcTensor, AscendC::DataCopyExtParams(nBurst, lenBurst, srcGap, dstGap, 0),
+                             AscendC::DataCopyPadExtParams<DType>(false, leftPaddingNum, rightPaddingNum, 0));
+    };
+};
+
+template <ArchType ArchTag, typename DType> struct ub_to_ub {
+    __aicore__ inline ub_to_ub(AscendC::LocalTensor<DType> dstTensor, AscendC::LocalTensor<DType> srcTensor,
+                               uint8_t sid, uint16_t nBurst, uint16_t lenBurst, uint16_t srcStride, uint16_t dstStride)
+    {
+        AscendC::DataCopy(dstTensor, srcTensor, AscendC::DataCopyParams(nBurst, lenBurst, srcStride, dstStride));
+    };
+};
+
+template <ArchType ArchTag, typename DataType, DataFormatT InDataFormat = DataFormatT::ND,
+          DataFormatT OutDataFormat = DataFormatT::ND>
+struct ub_to_gm {
+    __aicore__ inline ub_to_gm(AscendC::GlobalTensor<DataType> dstTensor, AscendC::LocalTensor<DataType> srcTensor,
+                               uint8_t sid, uint16_t nBurst, uint16_t lenBurst, uint16_t srcStride, uint16_t dstStride)
+    {
+        AscendC::DataCopy(dstTensor, srcTensor, AscendC::DataCopyParams(nBurst, lenBurst, srcStride, dstStride));
+    };
+};
+
+template <ArchType ArchTag, typename DataType> struct ub_to_gm<ArchTag, DataType, DataFormatT::NZ, DataFormatT::NZ> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::l1l0BlockSize / sizeof(DataType);
+
+    __aicore__ ub_to_gm(AscendC::GlobalTensor<DataType> gmTensor, AscendC::LocalTensor<DataType> l1Tensor,
+                        uint32_t nTileActual, uint32_t nTileCeil, uint32_t nVal, uint32_t dTileActual,
+                        uint32_t dTileCeil, uint32_t dVal)
+    {
+        uint64_t dstStride = nTileCeil - nTileActual;
+        if (dstStride < STRIDE_LIMIT_I) {
+            AscendC::DataCopy(gmTensor, l1Tensor,
+                              AscendC::DataCopyParams(dTileActual / BLOCK_SIZE, // nBurst
+                                                      nTileActual,              // lenBurst
+                                                      0,                        // srcGap
+                                                      dstStride));              // dstGap
+        } else {
+            for (uint64_t i = 0; i < dTileActual / BLOCK_SIZE; i++) {
+                uint64_t srcOffset = i * nTileActual * BLOCK_SIZE;
+                uint64_t dstOffset = i * nTileCeil * BLOCK_SIZE;
+                AscendC::DataCopy(gmTensor[dstOffset], l1Tensor[srcOffset],
+                                  AscendC::DataCopyParams(1,           // nBurst
+                                                          nTileActual, // lenBurst
+                                                          0,           // srcGap
+                                                          0));         // dstGap
+            }
+        }
+    };
+};
+
+template <ArchType ArchTag, typename DType> struct ub_to_gm_align {
+    __aicore__ inline ub_to_gm_align(AscendC::GlobalTensor<DType> dstTensor, AscendC::LocalTensor<DType> srcTensor,
+                                     uint8_t sid, uint16_t nBurst, uint32_t lenBurst, uint8_t leftPaddingNum,
+                                     uint8_t rightPaddingNum, uint32_t srcGap, uint32_t dstGap)
+    {
+        AscendC::DataCopyPad(dstTensor, srcTensor, AscendC::DataCopyExtParams(nBurst, lenBurst, srcGap, dstGap, 0));
+    };
+};
+
+#endif // GM_TO_UB_ITERATOR_H

csrc/common/include/kernel/hardware.h

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file hardware.h
+ * \brief
+ */
+
+#ifndef INCLUDE_HARDWARE_H
+#define INCLUDE_HARDWARE_H
+ 
+enum class ArchType { ASCEND_V220, ASCEND_V200, ASCEND_M200 };
+ 
+template <ArchType ArchTag>
+struct HardwareInfo {
+    static uint32_t const l2BW = 5;
+    static uint32_t const hbmBW = 1;
+    static uint32_t const supportMix = 0;
+    static uint32_t const l1Size = 512 * 1024;
+    static uint32_t const l0ASize = 64 * 1024;
+    static uint32_t const l0BSize = 64 * 1024;
+    static uint32_t const l0CSize = 128 * 1024;
+    static uint32_t const l2Size = 192 * 1024 * 1024;
+    static uint32_t const biasSize = 1024;
+    static uint32_t const fixBufSize = 7 * 1024;
+    static uint32_t const ubSize = 192 * 1024;
+    static uint32_t const fractalSize = 512;
+    static uint32_t const l1l0BlockSize = 32;
+    static uint32_t const btBlockSize = 64;
+    static uint32_t const fbBlockSize = 128;
+};
+
+#endif

csrc/common/include/kernel/iterator.h

@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file iterator.h
+ * \brief
+ */
+
+#ifndef INCLUDE_ITERTOR_H
+#define INCLUDE_ITERTOR_H
+
+#include "common_func.h"
+#include "hardware.h"
+#include "kernel_operator.h"
+#include "layout.h"
+#include "mem.h"
+
+/////////////////////////////////////////////////////
+// gm_to_l1
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DataType, DataFormatT FormatInGM, DataFormatT FormatInL1>
+struct gm_to_l1 {
+    __aicore__ gm_to_l1(AscendC::LocalTensor<DataType> l1Tensor,
+                        AscendC::GlobalTensor<DataType> gmTensor,
+                        uint32_t nTileActual,
+                        uint32_t nTileCeil,
+                        uint32_t nVal,
+                        uint32_t dTileActual,
+                        uint32_t dTileCeil,
+                        uint32_t dVal) {};
+};
+
+/////////////////////////////////////////////////////
+// l1_to_l0_a
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DataType, bool IsTransPose, DataFormatT DFmtIn, DataFormatT DFmtOut>
+struct l1_to_l0_a {
+    __aicore__ l1_to_l0_a(AscendC::LocalTensor<DataType> l0Tensor,
+                          AscendC::LocalTensor<DataType> l1Tensor,
+                          uint32_t mTileCeil,
+                          uint32_t kPartCeil,
+                          uint32_t mSrcStride,
+                          uint32_t kSrcStride,
+                          uint32_t mDstStride,
+                          uint32_t kDstStride) {};
+};
+
+/////////////////////////////////////////////////////
+// l1_to_l0_b
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DataType, bool IsTransPose, DataFormatT DFmtIn, DataFormatT DFmtOut>
+struct l1_to_l0_b {
+    __aicore__ l1_to_l0_b(AscendC::LocalTensor<DataType> l0Tensor,
+                          AscendC::LocalTensor<DataType> l1Tensor,
+                          uint32_t nTileCeil,
+                          uint32_t kPartCeil,
+                          uint32_t nSrcStride,
+                          uint32_t kSrcStride,
+                          uint32_t nDstStride,
+                          uint32_t kDstStride) {};
+};
+
+// l1_to_l0_a
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DataType, bool IsTransPose, bool IsVectore>
+struct l1_to_l0_a_v1 {
+    __aicore__ l1_to_l0_a_v1(AscendC::LocalTensor<DataType> l0_tensor,
+                             AscendC::LocalTensor<DataType> l1_tensor,
+                             uint32_t m_tile_ceil,
+                             uint32_t k_tile_ceil,
+                             uint32_t k_part,
+                             uint32_t k_part_ceil,
+                             uint32_t k_part_idx) {};
+};
+
+/////////////////////////////////////////////////////
+// l1_to_l0_b
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DataType, bool IsTransPose, bool IsVectore>
+struct l1_to_l0_b_v1 {
+    __aicore__ l1_to_l0_b_v1(AscendC::LocalTensor<DataType> l0_tensor,
+                             AscendC::LocalTensor<DataType> l1_tensor,
+                             int32_t n_tile_ceil,
+                             int32_t k_tile_ceil,
+                             int32_t k_part_ceil,
+                             int32_t k_part_idx) {};
+};
+
+/////////////////////////////////////////////////////
+// l0c_to_gm
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, DataFormatT OutFormatType, typename OutDataType, typename L0CDataType>
+struct l0c_to_gm {
+    __aicore__ l0c_to_gm(AscendC::GlobalTensor<OutDataType> gmTensor,
+                         AscendC::LocalTensor<L0CDataType> l0cTensor,
+                         uint32_t mTileActual,
+                         uint32_t nTileActual,
+                         uint32_t mTileCeil,
+                         uint32_t nActual) {};
+};
+
+/////////////////////////////////////////////////////
+// l0c_to_l1
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, DataFormatT LayoutOut, typename ElementOut, typename ElementIn>
+struct l0c_to_l1 {
+    __aicore__ l0c_to_l1(AscendC::LocalTensor<ElementOut> l1Tensor,
+                         AscendC::LocalTensor<ElementIn> l0cTensor,
+                         AscendC::LocalTensor<uint64_t> deqTensor,
+                         uint32_t mTileActual,
+                         uint32_t nTileActual,
+                         uint32_t mTileCeil,
+                         uint32_t nActual) {};
+};
+
+#endif

csrc/common/include/kernel/l0c_to_gm_iterator.h

@@ -0,0 +1,213 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file l0c_to_gm_iterator.h
+ * \brief
+ */
+
+#ifndef L0C_TO_GM_ITERATOR_H
+#define L0C_TO_GM_ITERATOR_H
+
+#ifdef __CCE_KT_TEST__
+#define __bf16 bfloat16_t
+#endif
+
+#include "iterator.h"
+constexpr uint32_t BLOCK_NUM = 16;
+constexpr uint32_t BLOCK_SIZE_INT8 = 32;
+
+template <>
+struct l0c_to_gm<ArchType::ASCEND_V220, DataFormatT::ND, half, float> {
+    /**
+     * @brief Copy data from L0C buffer to global memory, partial specialized for
+     *
+     * @param gmTensor the destination tensor on global memory, which is stored in ND format.
+     * @param l0cTensor the source tensor on L0C buffer, which is stored in FRACTAL_NZ format.
+     * @param mTileActual the m-direction size of the matrix in L0C buffer.
+     * @param nTileActual the n-direction size of the matrix in L0C buffer.
+     * @param srcStride the source stride between the adjacent fractal matrices along n-direction in unit of C0_SIZE.
+     * @param dstStride the leading dimension of the destination matrix in unit of element.
+     */
+    __aicore__ l0c_to_gm(AscendC::GlobalTensor<half> gmTensor,
+                         AscendC::LocalTensor<float> l0cTensor,
+                         uint32_t mTileActual,
+                         uint32_t nTileActual,
+                         uint32_t srcStride,
+                         uint32_t dstStride)
+    {
+#ifdef __DAV_C220_CUBE__
+        auto intriParams = AscendC::FixpipeParamsV220(nTileActual, // nSize
+                                                      mTileActual, // mSize
+                                                      srcStride,   // srcStride
+                                                      dstStride,   // dstStride
+                                                      false);      // enRelu
+
+        intriParams.quantPre = QuantMode_t::F322F16;
+        AscendC::Fixpipe<half, float, AscendC::CFG_ROW_MAJOR>(gmTensor, l0cTensor, intriParams);
+#else
+        AscendC::FixpipeParams<float> intriParams(
+            (nTileActual + BLOCK_NUM - 1) / AscendC::BLOCK_CUBE,
+            static_cast<uint16_t>(mTileActual * BLOCK_NUM * sizeof(float) / BLOCK_SIZE_INT8),
+            0,
+            dstStride);
+        intriParams.nz2ndParams = {true, 1, 0, 0, static_cast<uint16_t>(nTileActual)};
+        intriParams.quantParams = {QuantMode_t::F322F16};
+        AscendC::Fixpipe(gmTensor, l0cTensor, intriParams);
+#endif
+    };
+};
+
+template <>
+struct l0c_to_gm<ArchType::ASCEND_V220, DataFormatT::ND, half, int32_t> {
+    __aicore__ l0c_to_gm(AscendC::GlobalTensor<half> gmTensor,
+                         AscendC::LocalTensor<int32_t> l0cTensor,
+                         uint32_t mTileActual,
+                         uint32_t nTileActual,
+                         uint32_t srcStride,
+                         uint32_t dstStride)
+    {
+#ifdef __DAV_C220_CUBE__
+        auto intriParams = AscendC::FixpipeParamsV220(nTileActual, // nSize
+                                                      mTileActual, // mSize
+                                                      srcStride,   // srcStride
+                                                      dstStride,   // dstStride
+                                                      false);      // enRelu
+
+        intriParams.quantPre = QuantMode_t::VDEQF16;
+        AscendC::Fixpipe<half, int32_t, AscendC::CFG_ROW_MAJOR>(gmTensor, l0cTensor, intriParams);
+#else
+        AscendC::FixpipeParams<int32_t> intriParams(
+            (nTileActual + BLOCK_NUM - 1) / AscendC::BLOCK_CUBE,
+            static_cast<uint16_t>(mTileActual * BLOCK_NUM * sizeof(float) / BLOCK_SIZE_INT8),
+            0,
+            dstStride);
+        intriParams.nz2ndParams = {true, 1, 0, 0, static_cast<uint16_t>(nTileActual)};
+        intriParams.quantParams = {QuantMode_t::VDEQF16};
+        AscendC::Fixpipe(gmTensor, l0cTensor, intriParams);
+#endif
+    };
+};
+
+template <>
+struct l0c_to_gm<ArchType::ASCEND_V220, DataFormatT::ND, __bf16, float> {
+    __aicore__ l0c_to_gm(AscendC::GlobalTensor<__bf16> gmTensor,
+                         AscendC::LocalTensor<float> l0cTensor,
+                         uint32_t mTileActual,
+                         uint32_t nTileActual,
+                         uint32_t srcStride,
+                         uint32_t dstStride)
+    {
+#ifdef __DAV_C220_CUBE__
+        auto intriParams = AscendC::FixpipeParamsV220(nTileActual, // nSize
+                                                      mTileActual, // mSize
+                                                      srcStride,   // srcStride
+                                                      dstStride,   // dstStride
+                                                      false);      // enRelu
+
+        intriParams.quantPre = QuantMode_t::F322BF16;
+        AscendC::Fixpipe<__bf16, float, AscendC::CFG_ROW_MAJOR>(gmTensor, l0cTensor, intriParams);
+#else
+        AscendC::FixpipeParams<float> intriParams(
+            (nTileActual + BLOCK_NUM - 1) / AscendC::BLOCK_CUBE,
+            static_cast<uint16_t>(mTileActual * BLOCK_NUM * sizeof(float) / BLOCK_SIZE_INT8),
+            0,
+            dstStride);
+        intriParams.nz2ndParams = {true, 1, 0, 0, static_cast<uint16_t>(nTileActual)};
+        intriParams.quantParams = {QuantMode_t::F322BF16};
+        AscendC::Fixpipe(gmTensor, l0cTensor, intriParams);
+#endif
+    };
+};
+
+// Partial specialization ND, float
+template <>
+struct l0c_to_gm<ArchType::ASCEND_V220, DataFormatT::ND, float, float> {
+    __aicore__ l0c_to_gm(AscendC::GlobalTensor<float> gmTensor,
+                         AscendC::LocalTensor<float> l0cTensor,
+                         uint32_t mTileActual,
+                         uint32_t nTileActual,
+                         uint32_t srcStride,
+                         uint32_t dstStride)
+    {
+#ifdef __DAV_C220_CUBE__
+        auto intriParams = AscendC::FixpipeParamsV220(nTileActual, // nSize
+                                                      mTileActual, // mSize
+                                                      srcStride,   // srcStride
+                                                      dstStride,   // dstStride
+                                                      false);      // enRelu
+
+        intriParams.quantPre = QuantMode_t::NoQuant;
+        AscendC::Fixpipe<float, float, AscendC::CFG_ROW_MAJOR>(gmTensor, l0cTensor, intriParams);
+#else
+        AscendC::FixpipeParams<float> intriParams(
+            (nTileActual + BLOCK_NUM - 1) / AscendC::BLOCK_CUBE,
+            static_cast<uint16_t>(mTileActual * BLOCK_NUM * sizeof(float) / BLOCK_SIZE_INT8),
+            0,
+            dstStride);
+        intriParams.nz2ndParams = {true, 1, 0, 0, static_cast<uint16_t>(nTileActual)};
+        intriParams.quantParams = {QuantMode_t::NoQuant};
+        AscendC::Fixpipe(gmTensor, l0cTensor, intriParams);
+#endif
+    };
+};
+
+template <>
+struct l0c_to_gm<ArchType::ASCEND_V220, DataFormatT::NZ, half, float> {
+    __aicore__ l0c_to_gm(AscendC::GlobalTensor<half> gmTensor,
+                         AscendC::LocalTensor<float> l0cTensor,
+                         uint32_t mTileActual,
+                         uint32_t nTileActual,
+                         uint32_t srcStride,
+                         uint32_t dstStride)
+    {
+#ifdef __DAV_C220_CUBE__
+        auto intriParams = AscendC::FixpipeParamsV220(nTileActual, // nSize
+                                                      mTileActual, // mSize
+                                                      srcStride,   // srcStride
+                                                      dstStride,   // dstStride
+                                                      false);      // enRelu
+
+        intriParams.quantPre = QuantMode_t::F322F16;
+        AscendC::Fixpipe<half, float, AscendC::CFG_NZ>(gmTensor, l0cTensor, intriParams);
+#else
+        AscendC::FixpipeParams<float> intriParams(
+            (nTileActual + BLOCK_NUM - 1) / AscendC::BLOCK_CUBE,
+            static_cast<uint16_t>(mTileActual * BLOCK_NUM * sizeof(float) / BLOCK_SIZE_INT8),
+            0,
+            dstStride - (nTileActual * sizeof(half) / sizeof(float)));
+        intriParams.quantParams = {QuantMode_t::F322F16};
+        AscendC::Fixpipe(gmTensor, l0cTensor, intriParams);
+#endif
+    };
+};
+
+template <>
+struct l0c_to_gm<ArchType::ASCEND_V220, DataFormatT::ND, int32_t, int32_t> {
+    __aicore__ l0c_to_gm(AscendC::GlobalTensor<int32_t> gmTensor,
+                         AscendC::LocalTensor<int32_t> l0cTensor,
+                         uint32_t mTileActual,
+                         uint32_t nTileActual,
+                         uint32_t srcStride,
+                         uint32_t dstStride){
+#ifdef __DAV_C220_CUBE__
+        auto intriParams = AscendC::FixpipeParamsV220(nTileActual, // nSize
+                                                      mTileActual, // mSize
+                                                      srcStride,   // srcStride
+                                                      dstStride,   // dstStride
+                                                      false);      // enRelu
+
+        intriParams.quantPre = QuantMode_t::NoQuant;
+        AscendC::Fixpipe<int32_t, int32_t, AscendC::CFG_ROW_MAJOR>(gmTensor, l0cTensor, intriParams);
+#endif
+};
+};
+
+#endif // L0C_TO_GM_ITERATOR_H

csrc/common/include/kernel/l0c_to_l1_iterator.h

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file l0c_to_l1_iterator.h
+ * \brief
+ */
+
+#ifndef L0C_TO_L1_ITERATOR_H
+#define L0C_TO_L1_ITERATOR_H
+
+#include "iterator.h"
+/////////////////////////////////////////////////////
+// l0c_to_l1
+/////////////////////////////////////////////////////
+
+// Partial specialization ZN, half, int32_t
+template <ArchType ArchTag>
+struct l0c_to_l1<ArchTag, DataFormatT::ZN, half, int32_t> {
+    using ElementOut = half;
+    using ElementIn = int32_t;
+    __aicore__ l0c_to_l1(AscendC::LocalTensor<ElementOut> l1Tensor,
+                         AscendC::LocalTensor<ElementIn> l0cTensor,
+                         AscendC::LocalTensor<uint64_t> deqTensor,
+                         uint32_t mTileActual,
+                         uint32_t nTileActual,
+                         uint32_t mTileCeil,
+                         uint32_t nActual)
+    {
+        constexpr uint32_t BLOCK_NUM = 16;
+        constexpr uint32_t BLOCK_SIZE = 32;
+        AscendC::FixpipeParams<ElementIn> intriParams(
+            (nTileActual + BLOCK_NUM - 1) / AscendC::BLOCK_CUBE,
+            static_cast<uint16_t>(mTileActual * BLOCK_NUM * sizeof(float) / BLOCK_SIZE),
+            0,
+            mTileCeil - static_cast<uint16_t>(mTileActual * BLOCK_NUM * sizeof(float) / BLOCK_SIZE) *
+                            sizeof(ElementOut) / sizeof(ElementIn));
+        intriParams.nz2ndParams = {false, 1, 0, 0, static_cast<uint16_t>(nTileActual)};
+        intriParams.quantParams = {QuantMode_t::VDEQF16};
+        AscendC::Fixpipe(l1Tensor, l0cTensor, deqTensor, intriParams);
+    };
+};
+
+#endif // L0C_TO_L1_ITERATOR_H

csrc/common/include/kernel/l0c_to_ub_iterator.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file l0c_to_ub_iterator.h
+ * \brief
+ */
+#ifndef L0C_TO_UB_ITERATOR_H
+#define L0C_TO_UB_ITERATOR_H
+
+#include "iterator.h"
+
+/////////////////////////////////////////////////////
+// l0c_to_ub
+/////////////////////////////////////////////////////
+
+// Partial specialization ZN, half, int32_t
+template <ArchType ArchTag, typename ElementIn, typename ElementOut, bool MatrixMode = true> struct l0c_to_ub {
+    __aicore__ l0c_to_ub(AscendC::LocalTensor<ElementOut> ubTensor, AscendC::LocalTensor<ElementIn> l0cTensor,
+                         uint16_t nBurst, uint16_t lenBurst, uint16_t srcStride, uint16_t dstStride)
+    {
+        constexpr auto mode =
+            MatrixMode ? AscendC::BlockMode::BLOCK_MODE_MATRIX : AscendC::BlockMode::BLOCK_MODE_VECTOR;
+        AscendC::DataCopy(ubTensor, l0cTensor,
+                          AscendC::DataCopyParams(nBurst,                              // count
+                                                  lenBurst,                            // len
+                                                  srcStride,                           // srcStrideIn
+                                                  dstStride),                          // dstStrideIn
+                          AscendC::DataCopyEnhancedParams(mode,                        // blockModeIn
+                                                          AscendC::DeqScale::DEQ_NONE, // deqScaleIn
+                                                          0,                           // deqValueIn
+                                                          0,                           // sidStoreModeIn
+                                                          false,                       // isReluIn
+                                                          pad_t::PAD_NONE,             // padModeIn
+                                                          0)                           // padValueIn
+        );
+    };
+};
+
+template <ArchType ArchTag>
+struct l0c_to_ub<ArchTag, int32_t, half> {
+    __aicore__ l0c_to_ub(AscendC::LocalTensor<half> ubTensor,
+                         AscendC::LocalTensor<int32_t> l0cTensor,
+                         uint16_t nBurst,
+                         uint16_t lenBurst,
+                         uint16_t srcStride,
+                         uint16_t dstStride)
+    {
+        AscendC::DataCopy(ubTensor, l0cTensor,
+                          AscendC::DataCopyParams(nBurst,                                        // count
+                                                  lenBurst,                                      // len
+                                                  srcStride,                                     // srcStrideIn
+                                                  dstStride),                                    // dstStrideIn
+                          AscendC::DataCopyEnhancedParams(AscendC::BlockMode::BLOCK_MODE_MATRIX, // blockModeIn
+                                                          AscendC::DeqScale::VDEQ16,             // deqScaleIn
+                                                          0,                                     // deqValueIn
+                                                          0,                                     // sidStoreModeIn
+                                                          false,                                 // isReluIn
+                                                          pad_t::PAD_NONE,                       // padModeIn
+                                                          0)                                     // padValueIn
+        );
+    };
+};
+
+#endif // L0C_TO_UB_ITERATOR_H

csrc/common/include/kernel/l1_to_bt_iterator.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file l1_to_bt_iterator.h
+ * \brief
+ */
+#ifndef L1_TO_BT_ITERATOR_H
+#define L1_TO_BT_ITERATOR_H
+
+#include "iterator.h"
+
+/////////////////////////////////////////////////////
+// l1_to_bt
+/////////////////////////////////////////////////////
+
+// Partial specialization for V220
+template <ArchType ArchTag, typename DataType>
+struct l1_to_bt {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::btBlockSize / sizeof(DataType);
+
+    __aicore__ l1_to_bt(AscendC::LocalTensor<DataType> biasTableTensor,
+                        AscendC::LocalTensor<DataType> biasL1Tensor,
+                        uint32_t ntileActual)
+    {
+        AscendC::DataCopy(
+            biasTableTensor, biasL1Tensor, {1, static_cast<uint16_t>(CeilDiv<BLOCK_SIZE>(ntileActual)), 0, 0});
+    };
+};
+
+#endif // L1_TO_BT_ITERATOR_H

csrc/common/include/kernel/l1_to_fb_iterator.h

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file l1_to_fb_iterator.h
+ * \brief
+ */
+
+#ifndef L1_TO_FB_ITERATOR_H
+#define L1_TO_FB_ITERATOR_H
+
+#include "iterator.h"
+
+/////////////////////////////////////////////////////
+// l1_to_fb
+/////////////////////////////////////////////////////
+
+// Partial specialization for V220
+template <ArchType ArchTag, typename DataType>
+struct l1_to_fb {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::fbBlockSize / sizeof(DataType);
+
+    __aicore__
+    l1_to_fb(AscendC::LocalTensor<DataType> fbTensor, AscendC::LocalTensor<DataType> l1Tensor, uint32_t ntileActual)
+    {
+        copy_cbuf_to_fbuf((__fbuf__ DataType *)fbTensor.GetPhyAddr(),
+                          (__cbuf__ DataType *)l1Tensor.GetPhyAddr(),
+                          1,
+                          CeilDiv<BLOCK_SIZE>(ntileActual),
+                          0,
+                          0);
+    };
+};
+
+#endif // L1_TO_FB_ITERATOR_H

csrc/common/include/kernel/l1_to_l0_iterator.h

@@ -0,0 +1,259 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file l1_to_l0_iterator.h
+ * \brief
+ */
+
+#ifndef L1_TO_L0_ITERATOR_H
+#define L1_TO_L0_ITERATOR_H
+
+#include "iterator.h"
+
+/////////////////////////////////////////////////////
+// l1_to_l0_a
+/////////////////////////////////////////////////////
+
+// Partial specialization for vector
+template <ArchType ArchTag, typename DataType, bool IsTransPose>
+struct l1_to_l0_a<ArchTag, DataType, IsTransPose, DataFormatT::VECTOR, DataFormatT::VECTOR> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t FRACTAL_SIZE = HardwareParams::fractalSize / sizeof(DataType);
+
+    __aicore__ l1_to_l0_a(AscendC::LocalTensor<DataType> l0Tensor,
+                          AscendC::LocalTensor<DataType> l1Tensor,
+                          uint32_t mTileCeil,
+                          uint32_t kPartCeil,
+                          uint32_t mSrcStride,
+                          uint32_t kSrcStride,
+                          uint32_t mDstStride,
+                          uint32_t kDstStride)
+    {
+        AscendC::LoadData(l0Tensor,
+                          l1Tensor,
+                          AscendC::LoadData2dParams(0,           // baseIdx
+                                                    kPartCeil,   // repeat
+                                                    kSrcStride,  // srcStride
+                                                    0,           // sid
+                                                    kDstStride,  // dstStride
+                                                    IsTransPose, // transpose
+                                                    0));         // addrCalMode
+    };
+};
+
+// Partial specialization for no transpose, not vector
+template <ArchType ArchTag, typename DataType>
+struct l1_to_l0_a<ArchTag, DataType, false, DataFormatT::ZN, DataFormatT::ZZ> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::l1l0BlockSize / sizeof(DataType);
+    static constexpr uint32_t FRACTAL_SIZE = HardwareParams::fractalSize / sizeof(DataType);
+    static constexpr uint32_t BLOCK_NUM_PER_FRACTAL = HardwareParams::fractalSize / HardwareParams::l1l0BlockSize;
+
+    __aicore__ l1_to_l0_a(AscendC::LocalTensor<DataType> l0Tensor,
+                          AscendC::LocalTensor<DataType> l1Tensor,
+                          uint32_t mTileCeil,
+                          uint32_t kPartCeil,
+                          uint32_t mSrcStride,
+                          uint32_t kSrcStride,
+                          uint32_t mDstStride,
+                          uint32_t kDstStride)
+    {
+        for (uint32_t i = 0; i < mTileCeil / BLOCK_NUM_PER_FRACTAL; i++) {
+            AscendC::LoadData(l0Tensor[i * mDstStride * FRACTAL_SIZE],
+                              l1Tensor[i * mSrcStride * FRACTAL_SIZE],
+                              AscendC::LoadData2dParams(0,                                             // baseIdx
+                                                        static_cast<uint16_t>(kPartCeil / BLOCK_SIZE), // repeat
+                                                        kSrcStride,                                    // srcStride
+                                                        0,                                             // sid
+                                                        kDstStride - 1,                                // dstStride
+                                                        false,                                         // transpose
+                                                        0));                                           // addrCalMode
+        }
+    };
+};
+
+// Partial specialization for transpose, not vector
+template <ArchType ArchTag, typename DataType>
+struct l1_to_l0_a<ArchTag, DataType, true, DataFormatT::ZN, DataFormatT::ZZ> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::l1l0BlockSize / sizeof(DataType);
+    static constexpr uint32_t FRACTAL_SIZE = HardwareParams::fractalSize / sizeof(DataType);
+    static constexpr uint32_t BLOCK_NUM_PER_FRACTAL = HardwareParams::fractalSize / HardwareParams::l1l0BlockSize;
+
+    __aicore__ l1_to_l0_a(AscendC::LocalTensor<DataType> l0Tensor,
+                          AscendC::LocalTensor<DataType> l1Tensor,
+                          uint32_t mTileCeil,
+                          uint32_t kPartCeil,
+                          uint32_t mSrcStride,
+                          uint32_t kSrcStride,
+                          uint32_t mDstStride,
+                          uint32_t kDstStride)
+    {
+        for (uint32_t i = 0; i < mTileCeil / BLOCK_SIZE; i++) {
+            AscendC::LoadData(l0Tensor[i * mDstStride * FRACTAL_SIZE],
+                              l1Tensor[i * mSrcStride * FRACTAL_SIZE],
+                              AscendC::LoadData2dParams(0,
+                                                        static_cast<uint16_t>(kPartCeil / BLOCK_NUM_PER_FRACTAL),
+                                                        kSrcStride,
+                                                        0,
+                                                        kDstStride - 1,
+                                                        true,
+                                                        0));
+        }
+    };
+};
+
+template <ArchType ArchTag, typename DataType>
+struct l1_to_l0_a<ArchTag, DataType, false, DataFormatT::NZ, DataFormatT::ZZ> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    // 16 * 32
+    static constexpr uint32_t ROW_BLOCK_SIZE = 16;
+    static constexpr uint32_t COL_BLOCK_SIZE = 32 / sizeof(DataType);
+    static constexpr uint32_t FRACTAL_SIZE = HardwareParams::fractalSize / sizeof(DataType);
+    static constexpr uint32_t BLOCK_NUM_PER_FRACTAL = HardwareParams::fractalSize / HardwareParams::l1l0BlockSize;
+
+    __aicore__ l1_to_l0_a(AscendC::LocalTensor<DataType> l0Tensor,
+                          AscendC::LocalTensor<DataType> l1Tensor,
+                          uint32_t mTileCeil,
+                          uint32_t kPartCeil,
+                          uint32_t mSrcStride,
+                          uint32_t kSrcStride,
+                          uint32_t mDstStride,
+                          uint32_t kDstStride)
+    {
+        for (uint32_t i = 0; i < mTileCeil / ROW_BLOCK_SIZE; i++) {
+            AscendC::LoadData(l0Tensor[i * ROW_BLOCK_SIZE * kPartCeil],
+                              l1Tensor[i * FRACTAL_SIZE],
+                              AscendC::LoadData2dParams(0,
+                                                        static_cast<uint16_t>(kPartCeil / COL_BLOCK_SIZE),
+                                                        mTileCeil / ROW_BLOCK_SIZE,
+                                                        0,
+                                                        0,
+                                                        false,
+                                                        0));
+        }
+    };
+};
+
+/////////////////////////////////////////////////////
+// l1_to_l0_b
+/////////////////////////////////////////////////////
+
+// Partial specialization for vector
+template <ArchType ArchTag, typename DataType, bool IsTransPose>
+struct l1_to_l0_b<ArchTag, DataType, IsTransPose, DataFormatT::VECTOR, DataFormatT::VECTOR> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t FRACTAL_SIZE = HardwareParams::fractalSize / sizeof(DataType);
+
+    __aicore__ l1_to_l0_b(AscendC::LocalTensor<DataType> l0Tensor,
+                          AscendC::LocalTensor<DataType> l1Tensor,
+                          uint32_t nTileCeil,
+                          uint32_t kPartCeil,
+                          uint32_t nSrcStride,
+                          uint32_t kSrcStride,
+                          uint32_t nDstStride,
+                          uint32_t kDstStride)
+    {
+        AscendC::LoadData(
+            l0Tensor, l1Tensor, AscendC::LoadData2dParams(0, kPartCeil, kSrcStride, 0, kDstStride, IsTransPose, 0));
+    };
+};
+
+template <ArchType ArchTag>
+struct l1_to_l0_b<ArchTag, int8_t, true, DataFormatT::NZ, DataFormatT::ZN> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    using DataType = int8_t;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::l1l0BlockSize / sizeof(DataType);
+
+    __aicore__ l1_to_l0_b(AscendC::LocalTensor<DataType> l0Tensor,
+                          AscendC::LocalTensor<DataType> l1Tensor,
+                          uint32_t nTileCeil,
+                          uint32_t kPartCeil,
+                          uint32_t nSrcStride,
+                          uint32_t kSrcStride,
+                          uint32_t nDstStride,
+                          uint32_t kDstStride)
+    {
+        for (uint32_t i = 0; i < nTileCeil / BLOCK_SIZE; i++) {
+            AscendC::LoadDataWithTranspose(l0Tensor[i * kPartCeil * BLOCK_SIZE],
+                                           l1Tensor[i * BLOCK_SIZE * BLOCK_SIZE],
+                                           AscendC::LoadData2dTransposeParams(0,                      // startIndexIn
+                                                                              kPartCeil / BLOCK_SIZE, // repeatTimesIn
+                                                                              nTileCeil / BLOCK_SIZE, // srcStrideIn
+                                                                              1,                      // dstGapIn
+                                                                              0,                      // dstfracGapIn
+                                                                              0)                      // addrModeIn
+            );
+        }
+    };
+};
+
+// Partial specialization for no transpose, not vector
+template <ArchType ArchTag, typename DataType>
+struct l1_to_l0_b<ArchTag, DataType, false, DataFormatT::ZN, DataFormatT::NZ> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::l1l0BlockSize / sizeof(DataType);
+    static constexpr uint32_t FRACTAL_SIZE = HardwareParams::fractalSize / sizeof(DataType);
+    static constexpr uint32_t BLOCK_NUM_PER_FRACTAL = HardwareParams::fractalSize / HardwareParams::l1l0BlockSize;
+
+    __aicore__ l1_to_l0_b(AscendC::LocalTensor<DataType> l0Tensor,
+                          AscendC::LocalTensor<DataType> l1Tensor,
+                          uint32_t nTileCeil,
+                          uint32_t kPartCeil,
+                          uint32_t nSrcStride,
+                          uint32_t kSrcStride,
+                          uint32_t nDstStride,
+                          uint32_t kDstStride)
+    {
+        for (uint32_t i = 0; i < kPartCeil / BLOCK_NUM_PER_FRACTAL; i++) {
+            AscendC::LoadData(l0Tensor[i * kDstStride * FRACTAL_SIZE],
+                              l1Tensor[i * kSrcStride * FRACTAL_SIZE],
+                              AscendC::LoadData2dParams(0,                                             // baseIdx
+                                                        static_cast<uint16_t>(nTileCeil / BLOCK_SIZE), // repeat
+                                                        nSrcStride,                                    // srcStride
+                                                        0,                                             // sid
+                                                        nDstStride - 1,                                // dstStride
+                                                        true,                                          // transpose
+                                                        0));                                           // addrCalMode
+        }
+    };
+};
+
+// Partial specialization for transpose, not vector
+template <ArchType ArchTag, typename DataType>
+struct l1_to_l0_b<ArchTag, DataType, true, DataFormatT::ZN, DataFormatT::NZ> {
+    using HardwareParams = HardwareInfo<ArchTag>;
+    static constexpr uint32_t BLOCK_SIZE = HardwareParams::l1l0BlockSize / sizeof(DataType);
+    static constexpr uint32_t FRACTAL_SIZE = HardwareParams::fractalSize / sizeof(DataType);
+    static constexpr uint32_t BLOCK_NUM_PER_FRACTAL = HardwareParams::fractalSize / HardwareParams::l1l0BlockSize;
+    __aicore__ l1_to_l0_b(AscendC::LocalTensor<DataType> l0Tensor,
+                          AscendC::LocalTensor<DataType> l1Tensor,
+                          uint32_t nTileCeil,
+                          uint32_t kPartCeil,
+                          uint32_t nSrcStride,
+                          uint32_t kSrcStride,
+                          uint32_t nDstStride,
+                          uint32_t kDstStride)
+    {
+        AscendC::LoadData(
+            l0Tensor,
+            l1Tensor,
+            AscendC::LoadData2dParams(0,                                                           // baseIdx
+                                      static_cast<uint16_t>(kPartCeil * nTileCeil / FRACTAL_SIZE), // repeat
+                                      1,                                                           // srcStride
+                                      0,                                                           // sid
+                                      0,                                                           // dstStride
+                                      false,                                                       // transpose
+                                      0));                                                         // addr_cal_mode_t
+    };
+};
+
+#endif // L1_TO_L0_ITERATOR_H

csrc/common/include/kernel/l1_to_ub_iterator.h

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file l1_to_ub_iterator.h
+ * \brief
+ */
+
+#ifndef L1_TO_UB_ITERATOR_H
+#define L1_TO_UB_ITERATOR_H
+
+#include "iterator.h"
+
+/////////////////////////////////////////////////////
+// l1_to_ub
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DataType>
+struct l1_to_ub {
+    __aicore__ l1_to_ub(AscendC::LocalTensor<DataType> ubTensor,
+                        AscendC::LocalTensor<DataType> l1Tensor,
+                        uint16_t nBurst,
+                        uint16_t lenBurst,
+                        uint16_t srcStride,
+                        uint16_t dstStride)
+    {
+        AscendC::DataCopy(ubTensor, l1Tensor, AscendC::DataCopyParams(nBurst, lenBurst, srcStride, dstStride));
+    };
+};
+
+/////////////////////////////////////////////////////
+// ub_to_l1
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DataType>
+struct ub_to_l1 {
+    __aicore__ ub_to_l1(AscendC::LocalTensor<DataType> l1Tensor,
+                        AscendC::LocalTensor<DataType> ubTensor,
+                        uint16_t nBurst,
+                        uint16_t lenBurst,
+                        uint16_t srcStride,
+                        uint16_t dstStride)
+    {
+        AscendC::DataCopy(l1Tensor, ubTensor, AscendC::DataCopyParams(nBurst, lenBurst, srcStride, dstStride));
+    };
+};
+#endif // L1_TO_UB_ITERATOR_H

csrc/common/include/kernel/layout.h

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file layout.h
+ * \brief
+ */
+
+#ifndef INCLUDE_LAYOUT_H
+#define INCLUDE_LAYOUT_H
+
+enum class DataFormatT { 
+    ND = 0,
+    NZ,
+    ZN,
+    ZZ,
+    NN,
+    VECTOR
+}; 
+
+#endif // INCLUDE_LAYOUT_H

csrc/common/include/kernel/mem.h

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file mem.h
+ * \brief
+ */
+
+#ifndef INCLUDE_MEM_H
+#define INCLUDE_MEM_H
+
+#include "hardware.h"
+#include "kernel_event.h"
+#include "kernel_tensor.h"
+ 
+enum class BufferType { ASCEND_UB, ASCEND_CB, ASCEND_L0A, ASCEND_L0B, ASCEND_L0C, ASCEND_MAX };
+
+template <BufferType BufferType_>
+__aicore__ constexpr AscendC::TPosition GetPosition()
+{
+    if constexpr (BufferType_ == BufferType::ASCEND_UB) {
+        return AscendC::TPosition::VECIN;
+    } else if constexpr (BufferType_ == BufferType::ASCEND_CB) {
+        return AscendC::TPosition::A1;
+    } else if constexpr (BufferType_ == BufferType::ASCEND_L0A) {
+        return AscendC::TPosition::A2;
+    } else if constexpr (BufferType_ == BufferType::ASCEND_L0B) {
+        return AscendC::TPosition::B2;
+    } else if constexpr (BufferType_ == BufferType::ASCEND_L0C) {
+        return AscendC::TPosition::CO1;
+    }
+    return AscendC::TPosition::GM;
+}
+
+template <ArchType ArchTag>
+struct AsdopsBuffer {
+public:
+    __aicore__ AsdopsBuffer()
+    {
+        constexpr uint32_t bufferSize[(uint32_t)BufferType::ASCEND_MAX] = {HardwareInfo<ArchTag>::ubSize,
+                                                                        HardwareInfo<ArchTag>::l1Size,
+                                                                        HardwareInfo<ArchTag>::l0ASize,
+                                                                        HardwareInfo<ArchTag>::l0BSize,
+                                                                        HardwareInfo<ArchTag>::l0CSize};
+#ifdef __DAV_C220_VEC__
+        tensor[(uint32_t)BufferType::ASCEND_UB] = AscendC::LocalTensor<uint8_t>(AscendC::TPosition::VECIN, 0, bufferSize[(uint32_t)BufferType::ASCEND_UB]);
+#elif __DAV_C220_CUBE__
+        tensor[(uint32_t)BufferType::ASCEND_CB] = AscendC::LocalTensor<uint8_t>(AscendC::TPosition::A1, 0, bufferSize[(uint32_t)BufferType::ASCEND_CB]);
+        tensor[(uint32_t)BufferType::ASCEND_L0A] = AscendC::LocalTensor<uint8_t>(AscendC::TPosition::A2, 0, bufferSize[(uint32_t)BufferType::ASCEND_L0A]);
+        tensor[(uint32_t)BufferType::ASCEND_L0B] = AscendC::LocalTensor<uint8_t>(AscendC::TPosition::B2, 0, bufferSize[(uint32_t)BufferType::ASCEND_L0B]);
+        tensor[(uint32_t)BufferType::ASCEND_L0C] = AscendC::LocalTensor<uint8_t>(AscendC::TPosition::CO1, 0, bufferSize[(uint32_t)BufferType::ASCEND_L0C]);
+#else
+#ifndef __clang__
+        tensor[(uint32_t)BufferType::ASCEND_UB] = AscendC::LocalTensor<uint8_t>(AscendC::TPosition::VECIN, 0, bufferSize[(uint32_t)BufferType::ASCEND_UB]);
+        tensor[(uint32_t)BufferType::ASCEND_CB] = AscendC::LocalTensor<uint8_t>(AscendC::TPosition::A1, 0, bufferSize[(uint32_t)BufferType::ASCEND_CB]);
+        tensor[(uint32_t)BufferType::ASCEND_L0A] = AscendC::LocalTensor<uint8_t>(AscendC::TPosition::A2, 0, bufferSize[(uint32_t)BufferType::ASCEND_L0A]);
+        tensor[(uint32_t)BufferType::ASCEND_L0B] = AscendC::LocalTensor<uint8_t>(AscendC::TPosition::B2, 0, bufferSize[(uint32_t)BufferType::ASCEND_L0B]);
+        tensor[(uint32_t)BufferType::ASCEND_L0C] = AscendC::LocalTensor<uint8_t>(AscendC::TPosition::CO1, 0, bufferSize[(uint32_t)BufferType::ASCEND_L0C]);
+#endif
+#endif
+    };
+
+    template <BufferType BufferType_, typename DstDataType = half>
+    __aicore__ AscendC::LocalTensor<DstDataType> GetBuffer(const uint32_t offset) const
+    {
+        return tensor[(uint32_t)BufferType_][offset].template ReinterpretCast<DstDataType>();
+    }
+
+public:
+    AscendC::LocalTensor<uint8_t> tensor[(uint32_t)BufferType::ASCEND_MAX];
+};
+#endif

csrc/common/include/kernel/mma.h

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file mma.h
+ * \brief
+ */
+
+#ifndef INCLUDE_MMA_H
+#define INCLUDE_MMA_H
+
+#include "hardware.h"
+#include "kernel_tensor.h"
+
+template <ArchType ArchTag, typename ElementA, typename ElementB, typename AccDTypeC, bool IsTransposeA>
+struct mmad {
+    __aicore__ mmad(AscendC::LocalTensor<AccDTypeC> l0cTensor,
+                    AscendC::LocalTensor<ElementA> l0aTensor,
+                    AscendC::LocalTensor<ElementB> l0bTensor,
+                    uint32_t mTileActual,
+                    uint32_t nTileActual,
+                    uint32_t kPartActual,
+                    bool initC) {};
+
+    __aicore__ mmad(AscendC::LocalTensor<AccDTypeC> l0cTensor,
+                    AscendC::LocalTensor<ElementA> l0aTensor,
+                    AscendC::LocalTensor<ElementB> l0bTensor,
+                    uint64_t biasBt,
+                    uint32_t mTileActual,
+                    uint32_t nTileActual,
+                    uint32_t kPartActual,
+                    bool initC) {};
+};
+
+// Partial specialization for V220, int8_t, not_vector_A, not TransposeA
+template <ArchType ArchTag, typename AccDTypeC, typename ElementA, typename ElementB>
+struct mmad<ArchTag, ElementA, ElementB, AccDTypeC, false> {
+    __aicore__ mmad(AscendC::LocalTensor<AccDTypeC> l0cTensor,
+                    AscendC::LocalTensor<ElementA> l0aTensor,
+                    AscendC::LocalTensor<ElementB> l0bTensor,
+                    uint32_t mTileActual,
+                    uint32_t nTileActual,
+                    uint32_t kPartActual,
+                    bool initC)
+    {
+        AscendC::Mmad(l0cTensor,
+                      l0aTensor,
+                      l0bTensor,
+                      AscendC::MmadParams(mTileActual, nTileActual, kPartActual, 0, false, initC));
+    };
+
+    __aicore__ mmad(AscendC::LocalTensor<AccDTypeC> l0cTensor,
+                    AscendC::LocalTensor<ElementA> l0aTensor,
+                    AscendC::LocalTensor<ElementB> l0bTensor,
+                    uint64_t biasBt,
+                    uint32_t mTileActual,
+                    uint32_t nTileActual,
+                    uint32_t kPartActual,
+                    bool initC)
+    {
+        AscendC::LocalTensor<ElementA> biasTensor;
+        biasTensor.InitBuffer(biasBt, mTileActual);
+        biasTensor.address_.logicPos = static_cast<uint8_t>(AscendC::TPosition::C2);
+        AscendC::Mmad(l0cTensor,
+                      l0aTensor,
+                      l0bTensor,
+                      biasTensor,
+                      AscendC::MmadParams(mTileActual, nTileActual, kPartActual, 0, false, initC));
+    };
+};
+
+#endif

csrc/common/include/kernel/pse.h

@@ -0,0 +1,483 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file pse.h
+ * \brief
+ */
+
+#ifndef FLASH_ATTENTION_SCORE_PSE_H
+#define FLASH_ATTENTION_SCORE_PSE_H
+
+#include "kernel_operator.h"
+#include "util.h"
+
+constexpr static int64_t pseS1S2 = 0;
+constexpr static int64_t pse1S2 = 1;
+constexpr static int64_t pseSlopeBn = 2;
+constexpr static int64_t pseSlopeN = 3;
+
+constexpr static uint8_t pseEncodeALibiS2Full = 0x11;
+
+enum class PseTypeEnum {
+    PSE_OUTER_MUL_ADD_TYPE = 0, // default
+    PSE_OUTER_ADD_MUL_TYPE,
+    PSE_INNER_MUL_ADD_TYPE,
+    PSE_INNER_MUL_ADD_SQRT_TYPE,
+    PSE_INVALID_TYPE
+};
+
+struct PseInfo {
+    int64_t blockCount;
+    int64_t bSSOffset; // boidx * s1 * s2
+    int64_t boIdx;
+    int64_t gSize;
+    int64_t goIdx;
+    int64_t loopIdx;
+    int64_t n2G;
+    int64_t n2oIdx;
+    int64_t pseBSize;
+    int64_t pseS1Size;        // for alibi
+    int64_t pseS2ComputeSize; // for alibi, do not need assignment
+    int64_t pseS2Size;        // for alibi
+    uint32_t pseShapeType;
+    int64_t readS2Size; // for alibi, do not need assignment
+    int64_t s1BaseSize;
+    int64_t s1Size;
+    int64_t s1oIdx;
+    int64_t s2AlignedSize;
+    int64_t s2BaseNratioSize;
+    int64_t s2LoopCount;
+    int64_t s2RealSize;
+    int64_t s2Size;
+    int64_t s2SizeAcc; // accumulated sum of s2 size
+    int64_t s2StartIdx;
+    int64_t vec1S1BaseSize;
+    int64_t vec1S1RealSize;
+    uint32_t pseEncodeType; // for distinguish alibi
+    uint32_t pseType; // 0: outer, mul-add   1:outer, add-mul   2:inner, mul-add   3:inner, mul-add-sqrt
+    int64_t pseAlibiBaseS1;
+    int64_t pseAlibiBaseS2;
+    int64_t qStartIdx;
+    int64_t kvStartIdx;
+    int64_t vecCoreOffset = 0;
+    bool needCast;
+    bool align8 = false;
+    bool pseEndogenous = false;
+};
+
+template <typename INPUT_T, bool hasPse>
+__aicore__ inline void DataCopyInCommon(LocalTensor<INPUT_T> &dstTensor, GlobalTensor<INPUT_T> &srcTensor, int64_t offset,
+                                  int64_t s1Size, int64_t s2Size, int64_t actualS2Len, int32_t dtypeSize,
+                                  int32_t alignedS2Size)
+{
+    if constexpr (hasPse == true) {
+        uint32_t shapeArray[] = {static_cast<uint32_t>(s1Size), static_cast<uint32_t>(alignedS2Size)};
+        dstTensor.SetShapeInfo(ShapeInfo(2, shapeArray, DataFormat::ND));
+        dstTensor.SetSize(s1Size * alignedS2Size);
+        DataCopyParams dataCopyParams;
+        dataCopyParams.blockCount = s1Size;
+        dataCopyParams.blockLen = CeilDiv(s2Size * dtypeSize, blockBytes); // 单位32B
+        dataCopyParams.dstStride = alignedS2Size * dtypeSize / blockBytes - dataCopyParams.blockLen;                                      // gap
+        if (actualS2Len * dtypeSize % blockBytes == 0) {
+            dataCopyParams.srcStride =
+                (actualS2Len * dtypeSize - dataCopyParams.blockLen * blockBytes) / blockBytes; // srcGap
+            DataCopy(dstTensor, srcTensor[offset], dataCopyParams);
+        } else {
+            dataCopyParams.blockLen = s2Size * dtypeSize; // 单位Byte
+            dataCopyParams.srcStride = (actualS2Len * dtypeSize - dataCopyParams.blockLen);
+            dataCopyParams.dstStride = (alignedS2Size - s2Size) * dtypeSize / blockBytes;
+            DataCopyPadParams dataCopyPadParams;
+            dataCopyPadParams.isPad = false;
+            DataCopyPad(dstTensor, srcTensor[offset], dataCopyParams, dataCopyPadParams);
+        }
+    }
+}
+
+template <typename INPUT_T, bool hasPse>
+__aicore__ inline void DataCopyIn(LocalTensor<INPUT_T> &dstTensor, GlobalTensor<INPUT_T> &srcTensor, int64_t offset,
+                                  int64_t s1Size, int64_t s2Size, int64_t actualS2Len, int64_t alignedSize = 16)
+{
+    if constexpr (hasPse == true) {
+        int32_t dtypeSize = sizeof(INPUT_T);
+        int32_t alignedS2Size = CeilDiv(s2Size, alignedSize) * alignedSize;
+        DataCopyInCommon<INPUT_T, hasPse>(dstTensor, srcTensor, offset, s1Size, s2Size,
+            actualS2Len, dtypeSize, alignedS2Size);
+    }
+}
+
+template <typename INPUT_T, bool hasPse>
+__aicore__ inline void DataCopyInAlign8(LocalTensor<INPUT_T> &dstTensor, GlobalTensor<INPUT_T> &srcTensor, int64_t offset,
+                                  int64_t s1Size, int64_t s2Size, int64_t actualS2Len)
+{
+    if constexpr (hasPse == true) {
+        int32_t dtypeSize = sizeof(INPUT_T);
+        if (dtypeSize == 0){
+            return;
+        }
+        int32_t alignedS2Size = CeilDiv(s2Size, 32 / dtypeSize) * (32 / dtypeSize);
+        DataCopyInCommon<INPUT_T, hasPse>(dstTensor, srcTensor, offset, s1Size, s2Size,
+            actualS2Len, dtypeSize, alignedS2Size);
+    }
+}
+
+/*
+dst = BroadcastAdd(src0, src1)
+src0 shape: (s1, s2)
+src1 shape: (1, s2)
+dst  shape: (s1, s2)
+*/
+template <typename T, bool hasPse>
+__aicore__ inline void BroadcastAdd(const LocalTensor<T> &src0Tensor, const LocalTensor<T> &src1Tensor,
+                                    int64_t src0Offset, int32_t src1Size, int32_t repeatTimes)
+{
+    if constexpr (hasPse == true) {
+        /* Total data number of single step should be smaller than 256bytes.
+         * If larger, we need to do add multiple times. */
+        int32_t innerLoop = src1Size / repeatMaxSize;   // s2轴整块计算次数
+        int32_t innerRemain = src1Size % repeatMaxSize; // s2轴尾块计算量
+        BinaryRepeatParams binaryRepeatParams;
+        binaryRepeatParams.src0BlkStride = 1;
+        binaryRepeatParams.src0RepStride = src1Size / blockSize;
+        binaryRepeatParams.src1BlkStride = 1;
+        binaryRepeatParams.src1RepStride = 0;
+        binaryRepeatParams.dstRepStride = binaryRepeatParams.src0RepStride;
+        binaryRepeatParams.blockNumber = binaryRepeatParams.src0RepStride;
+
+        for (int32_t j = 0; j < innerLoop; j++) {
+            auto innerOffset = j * repeatMaxSize;
+            auto ubOffset = src0Offset + innerOffset;
+            Add(src0Tensor[ubOffset], src0Tensor[ubOffset], src1Tensor[innerOffset], repeatMaxSize, repeatTimes,
+                binaryRepeatParams);
+        }
+        if (innerRemain > 0) {
+            auto innerOffset = innerLoop * repeatMaxSize;
+            auto ubOffset = src0Offset + innerOffset;
+            Add(src0Tensor[ubOffset], src0Tensor[ubOffset], src1Tensor[innerOffset], innerRemain, repeatTimes,
+                binaryRepeatParams);
+        }
+    }
+}
+
+template <typename T, bool hasPse>
+__aicore__ inline void PseBroadcastAdd(int32_t s1Size, int32_t s2Size, int32_t computeSize, const LocalTensor<T> &pseUb,
+                                       const LocalTensor<T> &dstTensor, uint32_t pseShapeType)
+{
+    if constexpr (hasPse == true) {
+        if (pseShapeType == pseS1S2 || pseShapeType == pseSlopeBn || pseShapeType == pseSlopeN) {
+            Add(dstTensor, dstTensor, pseUb, computeSize);
+        } else {
+            /* Total repeated times should be <= repeatMaxTimes. If larger,
+             * we need to do multiple inner loops. */
+            int32_t s1OuterLoop = s1Size / repeatMaxTimes;
+            int32_t s1OuterRemain = s1Size % repeatMaxTimes;
+            for (int32_t s1OuterIdx = 0; s1OuterIdx < s1OuterLoop; s1OuterIdx++) {
+                int32_t s1OuterOffset = s1OuterIdx * repeatMaxTimes * s2Size;
+                BroadcastAdd<T, hasPse>(dstTensor, pseUb, s1OuterOffset, s2Size, repeatMaxTimes);
+            }
+            if (s1OuterRemain > 0) {
+                int32_t s1OuterOffset = s1OuterLoop * repeatMaxTimes * s2Size;
+                BroadcastAdd<T, hasPse>(dstTensor, pseUb, s1OuterOffset, s2Size, s1OuterRemain);
+            }
+        }
+    }
+}
+template <bool hasPse> __aicore__ inline int64_t PseComputeOffset(PseInfo &pseInfo)
+{
+    if constexpr (hasPse == true) {
+        int64_t bOffset = 0;
+        int64_t n2Offset = 0;
+        int64_t s1Offset = 0;
+        int64_t s2Offset = pseInfo.s2StartIdx + pseInfo.s2LoopCount * pseInfo.s2BaseNratioSize;
+        int64_t gOffset = 0;
+        if (pseInfo.pseShapeType == pseS1S2) {
+            // b, n2, g, s1, s2
+            bOffset = pseInfo.bSSOffset * pseInfo.n2G;
+            n2Offset = pseInfo.n2oIdx * pseInfo.gSize * pseInfo.s1Size * pseInfo.s2Size;
+            gOffset = pseInfo.goIdx * pseInfo.s1Size * pseInfo.s2Size;
+            s1Offset = (pseInfo.s1oIdx * pseInfo.s1BaseSize + pseInfo.vecCoreOffset +
+                       pseInfo.loopIdx * pseInfo.vec1S1BaseSize) * pseInfo.s2Size;
+        } else if (pseInfo.pseShapeType == pse1S2) {
+            // b, n2, g, 1, s2
+            bOffset = pseInfo.s2SizeAcc * pseInfo.n2G;
+            n2Offset = pseInfo.n2oIdx * pseInfo.gSize * pseInfo.s2Size;
+            gOffset = pseInfo.goIdx * pseInfo.s2Size;
+        }
+        if (pseInfo.pseBSize == 1) {
+            bOffset = 0;
+        }
+        return bOffset + n2Offset + gOffset + s1Offset + s2Offset;
+    } else {
+        return 0;
+    }
+}
+
+template <LayOutTypeEnum layOutType, bool hasPse> __aicore__ inline int64_t PseAlibiComputeOffset(PseInfo &pseInfo)
+{
+    if constexpr (hasPse == true) {
+        int64_t bOffset = (pseInfo.boIdx % pseInfo.pseBSize) * pseInfo.n2G * pseInfo.pseS2Size * pseInfo.pseS1Size;
+        int64_t n2Offset = pseInfo.n2oIdx * pseInfo.gSize * pseInfo.pseS2Size * pseInfo.pseS1Size;
+        int64_t gOffset = pseInfo.goIdx * pseInfo.pseS2Size * pseInfo.pseS1Size;
+        int64_t row = pseInfo.s1oIdx * pseInfo.s1BaseSize + pseInfo.vecCoreOffset +
+                      pseInfo.loopIdx * pseInfo.vec1S1BaseSize;
+        int64_t column = pseInfo.s2StartIdx + pseInfo.s2LoopCount * pseInfo.s2BaseNratioSize;
+        int64_t m = 0;
+        int64_t k = 0;
+        if constexpr (layOutType != LayOutTypeEnum::LAYOUT_TND) {
+            int64_t threshold = pseInfo.s1Size - pseInfo.pseS1Size;
+            if (row >= threshold) {
+                m = row - threshold;
+                k = column;
+            } else {
+                m = row % pseInfo.pseS1Size;
+                k = pseInfo.pseS2Size - (row - column) - (pseInfo.pseS1Size - m);
+            }
+        } else {
+            int64_t threshold = pseInfo.pseS2Size - pseInfo.pseS1Size;
+            int64_t posVal = row - column - threshold;
+            if (threshold >= 0) {
+                if (posVal >= 0) {
+                    m = posVal;
+                    k = 0;
+                } else {
+                    m = 0;
+                    k = -posVal;
+                }
+            } else {
+                m = posVal;
+                k = 0;
+            }
+        }
+        int64_t s1Offset = m * pseInfo.pseS2Size;
+        int64_t s2Offset = k;
+        pseInfo.readS2Size = Min(pseInfo.s2AlignedSize, pseInfo.pseS2Size - k);
+        pseInfo.pseS2ComputeSize = Align(pseInfo.readS2Size);
+
+        return bOffset + n2Offset + gOffset + s1Offset + s2Offset;
+    } else {
+        return 0;
+    }
+}
+
+template <bool hasPse> __aicore__ inline bool NeedPseAlibiCompute(PseInfo &pseInfo)
+{
+    if constexpr (hasPse == true) {
+        // Alibi编码只计算下三角
+        if (pseInfo.s1oIdx * pseInfo.s1BaseSize + pseInfo.vecCoreOffset +
+            (pseInfo.loopIdx + 1) * pseInfo.vec1S1BaseSize <=
+            pseInfo.s2StartIdx + pseInfo.s2LoopCount * pseInfo.s2BaseNratioSize) {
+            return false;
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <typename INPUT_T, typename T, LayOutTypeEnum layOutType, bool hasPse>
+__aicore__ inline void PseAlibiCopyIn(LocalTensor<T> &dstTensor, LocalTensor<INPUT_T> &tmpTensor,
+                                      GlobalTensor<INPUT_T> &srcTensor, PseInfo &pseInfo, int64_t alignedSize = 16)
+{
+    if constexpr (hasPse == true) {
+        if (!NeedPseAlibiCompute<hasPse>(pseInfo)) {
+            return;
+        }
+        int64_t offset = PseAlibiComputeOffset<layOutType, hasPse>(pseInfo);
+        if constexpr (IsSameType<INPUT_T, T>::value) {
+            if (!pseInfo.align8){
+                DataCopyIn<INPUT_T, hasPse>(dstTensor, srcTensor, offset, pseInfo.vec1S1RealSize, pseInfo.readS2Size,
+                                        pseInfo.pseS2Size, alignedSize);
+            } else {
+                DataCopyInAlign8<INPUT_T, hasPse>(dstTensor, srcTensor, offset, pseInfo.vec1S1RealSize,
+                        pseInfo.readS2Size, pseInfo.pseS2Size);
+            }
+            return;
+        }
+
+        DataCopyIn<INPUT_T, hasPse>(tmpTensor, srcTensor, offset, pseInfo.vec1S1RealSize, pseInfo.readS2Size,
+                                    pseInfo.pseS2Size, alignedSize);
+        if (pseInfo.needCast) {
+            event_t eventIdMte2ToV = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::MTE2_V));
+            SetFlag<HardEvent::MTE2_V>(eventIdMte2ToV);
+            WaitFlag<HardEvent::MTE2_V>(eventIdMte2ToV);
+            Cast(dstTensor, tmpTensor, RoundMode::CAST_NONE, pseInfo.vec1S1RealSize * pseInfo.pseS2ComputeSize);
+        }
+        return;
+    }
+}
+
+template <typename T, bool hasPse>
+__aicore__ inline void PseSlopeCopyIn(LocalTensor<T> &dstTensor, LocalTensor<half> &helpTensor,
+                                      __gm__ uint8_t *pseSlope, GlobalTensor<half> &alibiGm, PseInfo &pseInfo,
+                                      int64_t alignedSize = 16) {
+    if constexpr (hasPse == true) {
+        int64_t bOffset = 0;
+        int64_t n2Offset = pseInfo.n2oIdx * pseInfo.gSize;
+        int64_t gOffset = pseInfo.goIdx;
+
+        if (pseInfo.pseShapeType == pseSlopeBn) {
+            bOffset = pseInfo.boIdx * pseInfo.n2G;
+        }
+        int64_t offset = bOffset + n2Offset + gOffset;
+
+        DataCopyIn<half, hasPse>(helpTensor, alibiGm, 0, pseInfo.vec1S1RealSize,
+                                 pseInfo.s2RealSize, pseInfo.pseAlibiBaseS2, alignedSize);
+        event_t eventIdMte2ToV = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::MTE2_V));
+        SetFlag<HardEvent::MTE2_V>(eventIdMte2ToV);
+        WaitFlag<HardEvent::MTE2_V>(eventIdMte2ToV);
+
+        if (pseInfo.needCast) {
+            int64_t computeSize = pseInfo.vec1S1RealSize * pseInfo.s2AlignedSize;
+            Cast(dstTensor, helpTensor, RoundMode::CAST_NONE, computeSize);
+            AscendC::PipeBarrier<PIPE_V>();
+
+            int64_t s1Offset = pseInfo.s1oIdx * pseInfo.s1BaseSize + pseInfo.vecCoreOffset +
+                               pseInfo.loopIdx * pseInfo.vec1S1BaseSize;
+            int64_t s2Offset = pseInfo.s2StartIdx + pseInfo.s2LoopCount * pseInfo.s2BaseNratioSize;
+
+            float posShift = float(s2Offset + pseInfo.kvStartIdx - s1Offset - pseInfo.qStartIdx);
+
+            Adds(dstTensor, dstTensor, posShift, computeSize);
+            AscendC::PipeBarrier<PIPE_V>();
+            Abs(dstTensor, dstTensor, computeSize);
+            AscendC::PipeBarrier<PIPE_V>();
+            float slopes = ((__gm__ T *)pseSlope)[offset] * -1;
+            if (pseInfo.pseType == (uint32_t)PseTypeEnum::PSE_INNER_MUL_ADD_SQRT_TYPE) {
+                Sqrt(dstTensor, dstTensor, computeSize);
+                AscendC::PipeBarrier<PIPE_V>();
+            }
+            Muls(dstTensor, dstTensor, slopes, computeSize);
+            AscendC::PipeBarrier<PIPE_V>();
+        }
+    }
+}
+
+template <typename T, bool hasPse>
+__aicore__ inline void PseSlopeCast(LocalTensor<T> &dstTensor, LocalTensor<half> &helpTensor,
+                                    __gm__ uint8_t *pseSlope, PseInfo &pseInfo) {
+    if constexpr (hasPse == true) {
+        int64_t bOffset = 0;
+        int64_t n2Offset = pseInfo.n2oIdx * pseInfo.gSize;
+        int64_t gOffset = pseInfo.goIdx;
+
+        if (pseInfo.pseShapeType == pseSlopeBn) {
+            bOffset = pseInfo.boIdx * pseInfo.n2G;
+        }
+        int64_t offset = bOffset + n2Offset + gOffset;
+        int64_t computeSize = pseInfo.vec1S1RealSize * pseInfo.s2AlignedSize;
+        Cast(dstTensor, helpTensor, RoundMode::CAST_NONE, computeSize);
+        AscendC::PipeBarrier<PIPE_V>();
+
+        int64_t s1Offset = pseInfo.s1oIdx * pseInfo.s1BaseSize + pseInfo.vecCoreOffset +
+                           pseInfo.loopIdx * pseInfo.vec1S1BaseSize;
+        int64_t s2Offset = pseInfo.s2StartIdx + pseInfo.s2LoopCount * pseInfo.s2BaseNratioSize;
+
+        float posShift = float(s2Offset + pseInfo.kvStartIdx - s1Offset - pseInfo.qStartIdx);
+
+        Adds(dstTensor, dstTensor, posShift, computeSize);
+        AscendC::PipeBarrier<PIPE_V>();
+        Abs(dstTensor, dstTensor, computeSize);
+        AscendC::PipeBarrier<PIPE_V>();
+        float slopes = ((__gm__ T *)pseSlope)[offset] * -1;
+        if (pseInfo.pseType == (uint32_t)PseTypeEnum::PSE_INNER_MUL_ADD_SQRT_TYPE) {
+            Sqrt(dstTensor, dstTensor, computeSize);
+            AscendC::PipeBarrier<PIPE_V>();
+        }
+        Muls(dstTensor, dstTensor, slopes, computeSize);
+        AscendC::PipeBarrier<PIPE_V>();
+    }
+}
+
+template <typename INPUT_T, typename T, LayOutTypeEnum layOutType, bool hasPse>
+__aicore__ inline void PseCopyIn(LocalTensor<T> &dstTensor, LocalTensor<INPUT_T> &tmpTensor,
+                                 GlobalTensor<INPUT_T> &srcTensor, PseInfo &pseInfo, int64_t alignedSize = 16)
+{
+    if constexpr (hasPse == true) {
+        if (pseInfo.pseEncodeType == pseEncodeALibiS2Full) {
+            return PseAlibiCopyIn<INPUT_T, T, layOutType, hasPse>(dstTensor, tmpTensor, srcTensor, pseInfo, alignedSize);
+        }
+        int64_t offset = PseComputeOffset<hasPse>(pseInfo);
+        int64_t s1Size = pseInfo.pseShapeType == pse1S2 ? (pseInfo.blockCount == 0 ? 1 : pseInfo.blockCount) :
+                                                          pseInfo.vec1S1RealSize;
+
+        if constexpr (IsSameType<INPUT_T, T>::value) {
+            if (!pseInfo.align8){
+                DataCopyIn<INPUT_T, hasPse>(dstTensor, srcTensor, offset, s1Size, pseInfo.s2RealSize,
+                                            pseInfo.s2Size, alignedSize);
+            } else {
+                DataCopyInAlign8<INPUT_T, hasPse>(dstTensor, srcTensor, offset, s1Size, pseInfo.s2RealSize, pseInfo.s2Size);
+            }
+            return;
+        }
+        DataCopyIn<INPUT_T, hasPse>(tmpTensor, srcTensor, offset, s1Size, pseInfo.s2RealSize, pseInfo.s2Size,
+                                    alignedSize);
+        if (pseInfo.needCast) {
+            event_t eventIdMte2ToV = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::MTE2_V));
+            SetFlag<HardEvent::MTE2_V>(eventIdMte2ToV);
+            WaitFlag<HardEvent::MTE2_V>(eventIdMte2ToV);
+            Cast(dstTensor, tmpTensor, RoundMode::CAST_NONE, s1Size * pseInfo.s2AlignedSize);
+        }
+        return;
+    }
+}
+
+template <typename T, bool hasPse>
+__aicore__ inline void PseAlibiCompute(LocalTensor<T> &dstTensor, LocalTensor<T> &pseTensor, PseInfo &pseInfo)
+{
+    if constexpr (hasPse == true) {
+        if (!NeedPseAlibiCompute<hasPse>(pseInfo)) {
+            return;
+        }
+        Add(dstTensor, dstTensor, pseTensor, pseInfo.vec1S1RealSize * pseInfo.pseS2ComputeSize);
+        return;
+    }
+}
+
+template <typename T, bool hasPse>
+__aicore__ inline void PseCompute(LocalTensor<T> &dstTensor, LocalTensor<T> &pseTensor, PseInfo &pseInfo)
+{
+    if constexpr (hasPse == true) {
+        if (pseInfo.pseEncodeType == pseEncodeALibiS2Full) {
+            return PseAlibiCompute<T, hasPse>(dstTensor, pseTensor, pseInfo);
+        }
+        int64_t computeSize = (pseInfo.pseShapeType == pseS1S2 || pseInfo.pseShapeType == pseSlopeBn ||
+                               pseInfo.pseShapeType == pseSlopeN)
+                              ? pseInfo.vec1S1RealSize * pseInfo.s2AlignedSize
+                              : pseInfo.s2AlignedSize;
+        PseBroadcastAdd<T, hasPse>(pseInfo.vec1S1RealSize, pseInfo.s2AlignedSize, computeSize, pseTensor,
+                                   dstTensor, pseInfo.pseShapeType);
+        return;
+    }
+}
+
+template <bool hasPse>
+__aicore__ inline void PseInnerAlibiCreate(GlobalTensor<half> &dstTensor, LocalTensor<half> &helpTensor, PseInfo &pseInfo) {
+    if constexpr (hasPse == true) {
+        if (pseInfo.pseType != (uint32_t)PseTypeEnum::PSE_INNER_MUL_ADD_TYPE && pseInfo.pseType != (uint32_t)PseTypeEnum::PSE_INNER_MUL_ADD_SQRT_TYPE) {
+            return;
+        }
+        event_t eventIdMte3ToV = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::MTE3_V));
+        event_t eventIdMte3ToS = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::MTE3_S));
+        event_t eventIdVToMte3 = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::V_MTE3));
+        float tmpValue = -1.0;
+
+        for (int64_t i = 0; i < pseInfo.pseAlibiBaseS1; i++) {
+            CreateVecIndex(helpTensor, (half)(i * tmpValue), pseInfo.pseAlibiBaseS2);
+            SetFlag<HardEvent::V_MTE3>(eventIdVToMte3);
+            WaitFlag<HardEvent::V_MTE3>(eventIdVToMte3);
+            DataCopy(dstTensor[i * pseInfo.pseAlibiBaseS2], helpTensor, pseInfo.pseAlibiBaseS2);
+            SetFlag<HardEvent::MTE3_V>(eventIdMte3ToV);
+            WaitFlag<HardEvent::MTE3_V>(eventIdMte3ToV);
+            SetFlag<HardEvent::MTE3_S>(eventIdMte3ToS);
+            WaitFlag<HardEvent::MTE3_S>(eventIdMte3ToS);
+        }
+    }
+}
+#endif

csrc/common/include/kernel/simd.h

@@ -0,0 +1,433 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file simd.h
+ * \brief
+ */
+
+#ifndef INCLUDE_SIMD_H
+#define INCLUDE_SIMD_H
+
+#ifdef __CCE_KT_TEST__
+#define __bf16 bfloat16_t
+#endif
+
+#include "hardware.h"
+#include "kernel_operator.h"
+
+/////////////////////////////////////////////////////
+// vadd
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void add_v(AscendC::LocalTensor<DType> dst,
+                             AscendC::LocalTensor<DType> src0,
+                             AscendC::LocalTensor<DType> src1,
+                             uint8_t repeat,
+                             uint8_t dstBlockStride,
+                             uint8_t src0BlockStride,
+                             uint8_t src1BlockStride,
+                             uint8_t dstRepeatStride,
+                             uint8_t src0RepeatStride,
+                             uint8_t src1RepeatStride)
+{
+    AscendC::Add<DType, false>(
+        dst,
+        src0,
+        src1,
+        (uint64_t)0,
+        repeat,
+        AscendC::BinaryRepeatParams(
+            dstBlockStride, src0BlockStride, src1BlockStride, dstRepeatStride, src0RepeatStride, src1RepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vadds
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void adds_v(AscendC::LocalTensor<DType> dst,
+                              AscendC::LocalTensor<DType> src,
+                              DType scalarValue,
+                              uint8_t repeat,
+                              uint8_t dstBlockStride,
+                              uint8_t srcBlockStride,
+                              uint8_t dstRepeatStride,
+                              uint8_t srcRepeatStride)
+{
+    AscendC::Adds<DType, false>(
+        dst,
+        src,
+        scalarValue,
+        (uint64_t)0,
+        repeat,
+        AscendC::UnaryRepeatParams(dstBlockStride, srcBlockStride, dstRepeatStride, srcRepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vcadd
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void cadd_v(AscendC::LocalTensor<DType> dst,
+                              AscendC::LocalTensor<DType> src,
+                              uint8_t repeat,
+                              uint16_t dstRepeatStride,
+                              uint16_t srcBlockStride,
+                              uint16_t srcRepeatStride)
+{
+    AscendC::RepeatReduceSum<DType, false>(dst, src, repeat, 0, 0, srcBlockStride, dstRepeatStride, srcRepeatStride);
+}
+/////////////////////////////////////////////////////
+// vbrcb
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void brcb_v(AscendC::LocalTensor<DType> dst,
+                              AscendC::LocalTensor<DType> src,
+                              uint16_t dstBlockStride,
+                              uint16_t dstRepeatStride,
+                              uint8_t repeat)
+{
+    AscendC::Brcb(dst, src, repeat, AscendC::BrcbRepeatParams(dstBlockStride, dstRepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vcmax
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType, AscendC::ReduceOrder OrderType>
+__aicore__ inline void cmax_v(AscendC::LocalTensor<DType> dst,
+                              AscendC::LocalTensor<DType> src,
+                              uint8_t repeat,
+                              uint16_t dstRepeatStride,
+                              uint16_t srcBlockStride,
+                              uint16_t srcRepeatStride)
+{
+#if defined(__DAV_C220_VEC__)
+    AscendC::WholeReduceMax<DType, false>(
+        dst, src, (int32_t)0, repeat, dstRepeatStride, srcBlockStride, srcRepeatStride, OrderType);
+#else
+    AscendC::WholeReduceMax<DType, false>(
+        dst, src, (int32_t)0, repeat, dstRepeatStride, srcBlockStride, srcRepeatStride);
+#endif
+}
+
+/////////////////////////////////////////////////////
+// vconv
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DTypeIn, typename DTypeOut>
+__aicore__ inline void conv_v(AscendC::LocalTensor<DTypeOut> dst,
+                              AscendC::LocalTensor<DTypeIn> src,
+                              uint8_t repeat,
+                              uint16_t dstBlockStride,
+                              uint16_t srcBlockStride,
+                              uint16_t dstRepeatStride,
+                              uint16_t srcRepeatStride)
+{
+    if constexpr (std::is_same<DTypeIn, float>::value && std::is_same<DTypeOut, __bf16>::value) {
+        AscendC::Cast<DTypeOut, DTypeIn, false>(
+            dst,
+            src,
+            AscendC::RoundMode::CAST_RINT,
+            (uint64_t)0,
+            repeat,
+            AscendC::UnaryRepeatParams(dstBlockStride, srcBlockStride, dstRepeatStride, srcRepeatStride));
+    } else {
+        AscendC::Cast<DTypeOut, DTypeIn, false>(
+            dst,
+            src,
+            AscendC::RoundMode::CAST_NONE,
+            (uint64_t)0,
+            repeat,
+            AscendC::UnaryRepeatParams(dstBlockStride, srcBlockStride, dstRepeatStride, srcRepeatStride));
+    }
+}
+
+/////////////////////////////////////////////////////
+// vconv_f322bf16r
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DTypeIn, typename DTypeOut>
+__aicore__ inline void convr_v(AscendC::LocalTensor<DTypeOut> dst,
+                               AscendC::LocalTensor<DTypeIn> src,
+                               uint8_t repeat,
+                               uint16_t dstBlockStride,
+                               uint16_t srcBlockStride,
+                               uint16_t dstRepeatStride,
+                               uint16_t srcRepeatStride)
+{
+    AscendC::Cast<DTypeOut, DTypeIn, false>(
+        dst,
+        src,
+        AscendC::RoundMode::CAST_RINT,
+        (uint64_t)0,
+        repeat,
+        AscendC::UnaryRepeatParams(dstBlockStride, srcBlockStride, dstRepeatStride, srcRepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vdiv
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void div_v(AscendC::LocalTensor<DType> dst,
+                             AscendC::LocalTensor<DType> src0,
+                             AscendC::LocalTensor<DType> src1,
+                             uint8_t repeat,
+                             uint8_t dstBlockStride,
+                             uint8_t src0BlockStride,
+                             uint8_t src1BlockStride,
+                             uint8_t dstRepeatStride,
+                             uint8_t src0RepeatStride,
+                             uint8_t src1RepeatStride)
+{
+    AscendC::Div<DType, false>(
+        dst,
+        src0,
+        src1,
+        (uint64_t)0,
+        repeat,
+        AscendC::BinaryRepeatParams(
+            dstBlockStride, src0BlockStride, src1BlockStride, dstRepeatStride, src0RepeatStride, src1RepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vexp
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void exp_v(AscendC::LocalTensor<DType> dst,
+                             AscendC::LocalTensor<DType> src,
+                             uint8_t repeat,
+                             uint16_t dstBlockStride,
+                             uint16_t srcBlockStride,
+                             uint16_t dstRepeatStride,
+                             uint16_t srcRepeatStride)
+{
+    AscendC::Exp<DType, false>(
+        dst,
+        src,
+        (uint64_t)0,
+        repeat,
+        AscendC::UnaryRepeatParams(dstBlockStride, srcBlockStride, dstRepeatStride, srcRepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vmax
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void max_v(AscendC::LocalTensor<DType> dst,
+                             AscendC::LocalTensor<DType> src0,
+                             AscendC::LocalTensor<DType> src1,
+                             uint8_t repeat,
+                             uint8_t dstBlockStride,
+                             uint8_t src0BlockStride,
+                             uint8_t src1BlockStride,
+                             uint8_t dstRepeatStride,
+                             uint8_t src0RepeatStride,
+                             uint8_t src1RepeatStride)
+{
+    AscendC::Max<DType, false>(
+        dst,
+        src0,
+        src1,
+        (uint64_t)0,
+        repeat,
+        AscendC::BinaryRepeatParams(
+            dstBlockStride, src0BlockStride, src1BlockStride, dstRepeatStride, src0RepeatStride, src1RepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vmul
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void mul_v(AscendC::LocalTensor<DType> dst,
+                             AscendC::LocalTensor<DType> src0,
+                             AscendC::LocalTensor<DType> src1,
+                             uint8_t repeat,
+                             uint8_t dstBlockStride,
+                             uint8_t src0BlockStride,
+                             uint8_t src1BlockStride,
+                             uint8_t dstRepeatStride,
+                             uint8_t src0RepeatStride,
+                             uint8_t src1RepeatStride)
+{
+    AscendC::Mul<DType, false>(
+        dst,
+        src0,
+        src1,
+        (uint64_t)0,
+        repeat,
+        AscendC::BinaryRepeatParams(
+            dstBlockStride, src0BlockStride, src1BlockStride, dstRepeatStride, src0RepeatStride, src1RepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vmuls
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void muls_v(AscendC::LocalTensor<DType> dst,
+                              AscendC::LocalTensor<DType> src0,
+                              DType src1,
+                              uint8_t repeat,
+                              uint16_t dstBlockStride,
+                              uint16_t srcBlockStride,
+                              uint16_t dstRepeatStride,
+                              uint16_t srcRepeatStride)
+{
+    AscendC::Muls<DType, false>(
+        dst,
+        src0,
+        src1,
+        (uint64_t)0,
+        repeat,
+        AscendC::UnaryRepeatParams(dstBlockStride, srcBlockStride, dstRepeatStride, srcRepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vsub
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void sub_v(AscendC::LocalTensor<DType> dst,
+                             AscendC::LocalTensor<DType> src0,
+                             AscendC::LocalTensor<DType> src1,
+                             uint8_t repeat,
+                             uint8_t dstBlockStride,
+                             uint8_t src0BlockStride,
+                             uint8_t src1BlockStride,
+                             uint8_t dstRepeatStride,
+                             uint8_t src0RepeatStride,
+                             uint8_t src1RepeatStride)
+{
+    AscendC::Sub<DType, false>(
+        dst,
+        src0,
+        src1,
+        (uint64_t)0,
+        repeat,
+        AscendC::BinaryRepeatParams(
+            dstBlockStride, src0BlockStride, src1BlockStride, dstRepeatStride, src0RepeatStride, src1RepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vmaxs
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void maxs_v(AscendC::LocalTensor<DType> dst,
+                              AscendC::LocalTensor<DType> src0,
+                              DType src1,
+                              uint8_t repeat,
+                              uint16_t dstBlockStride,
+                              uint16_t srcBlockStride,
+                              uint16_t dstRepeatStride,
+                              uint16_t srcRepeatStride)
+{
+    AscendC::Maxs<DType, false>(
+        dst,
+        src0,
+        src1,
+        (uint64_t)0,
+        repeat,
+        AscendC::UnaryRepeatParams(dstBlockStride, srcBlockStride, dstRepeatStride, srcRepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vmins
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void mins_v(AscendC::LocalTensor<DType> dst,
+                              AscendC::LocalTensor<DType> src0,
+                              DType src1,
+                              uint8_t repeat,
+                              uint16_t dstBlockStride,
+                              uint16_t srcBlockStride,
+                              uint16_t dstRepeatStride,
+                              uint16_t srcRepeatStride)
+{
+    AscendC::Mins<DType, false>(
+        dst,
+        src0,
+        src1,
+        (uint64_t)0,
+        repeat,
+        AscendC::UnaryRepeatParams(dstBlockStride, srcBlockStride, dstRepeatStride, srcRepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vsqrt
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void sqrt_v(AscendC::LocalTensor<DType> dst,
+                              AscendC::LocalTensor<DType> src,
+                              uint8_t repeat,
+                              uint16_t dstBlockStride,
+                              uint16_t srcBlockStride,
+                              uint16_t dstRepeatStride,
+                              uint16_t srcRepeatStride)
+{
+    AscendC::Sqrt<DType, false>(
+        dst,
+        src,
+        (uint64_t)0,
+        repeat,
+        AscendC::UnaryRepeatParams(dstBlockStride, srcBlockStride, dstRepeatStride, srcRepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vln
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void ln_v(AscendC::LocalTensor<DType> dst,
+                            AscendC::LocalTensor<DType> src,
+                            uint8_t repeat,
+                            uint16_t dstBlockStride,
+                            uint16_t srcBlockStride,
+                            uint16_t dstRepeatStride,
+                            uint16_t srcRepeatStride)
+{
+    AscendC::Ln<DType, false>(
+        dst,
+        src,
+        (uint64_t)0,
+        repeat,
+        AscendC::UnaryRepeatParams(dstBlockStride, srcBlockStride, dstRepeatStride, srcRepeatStride));
+}
+
+/////////////////////////////////////////////////////
+// vtranspose
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void tranpose_v(AscendC::LocalTensor<DType> dst, AscendC::LocalTensor<DType> src)
+{
+    AscendC::Transpose(dst, src);
+}
+
+/////////////////////////////////////////////////////
+// vcgmax
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void cgmax_v(AscendC::LocalTensor<DType> dst,
+                               AscendC::LocalTensor<DType> src,
+                               const int32_t repeat,
+                               const int32_t dstRepStride,
+                               const int32_t srcBlkStride,
+                               const int32_t srcRepStride)
+{
+    AscendC::BlockReduceMax<DType, false>(dst, src, repeat, 0, dstRepStride, srcBlkStride, srcRepStride);
+}
+
+/////////////////////////////////////////////////////
+// vcgadd
+/////////////////////////////////////////////////////
+template <ArchType ArchTag, typename DType>
+__aicore__ inline void cgadd_v(AscendC::LocalTensor<DType> dst,
+                               AscendC::LocalTensor<DType> src,
+                               const int32_t repeat,
+                               const int32_t dstRepStride,
+                               const int32_t srcBlkStride,
+                               const int32_t srcRepStride)
+{
+    AscendC::BlockReduceSum<DType, false>(dst, src, repeat, 0, dstRepStride, srcBlkStride, srcRepStride);
+}
+#endif

csrc/common/include/kernel/util.h

@@ -0,0 +1,159 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file util.h
+ * \brief
+ */
+
+#ifndef FLASH_ATTENTION_UTIL_H
+#define FLASH_ATTENTION_UTIL_H
+
+constexpr int32_t blockBytes = 32;
+constexpr int32_t byteBitRatio = 8;
+constexpr int64_t prefixAttenMaskDownHeight = 1024;
+constexpr static int32_t blockSize = blockBytes / 4; // 4 means sizeof(T)
+constexpr static int32_t repeatMaxBytes = 256;
+constexpr static int32_t repeatMaxTimes = 255;
+constexpr static int32_t repeatMaxSize = repeatMaxBytes / 4; // 4 means sizeof(T)
+
+using AscendC::LocalTensor;
+using AscendC::GlobalTensor;
+using AscendC::DataFormat;
+using AscendC::ShapeInfo;
+using AscendC::DataCopyParams;
+using AscendC::DataCopyExtParams;
+using AscendC::DataCopyPadParams;
+using AscendC::DataCopyPadExtParams;
+using AscendC::BinaryRepeatParams;
+using AscendC::IsSameType;
+using AscendC::HardEvent;
+using AscendC::SetFlag;
+using AscendC::WaitFlag;
+
+enum class LayOutTypeEnum { None = 0, LAYOUT_BSH = 1, LAYOUT_SBH = 2, LAYOUT_BNSD = 3, LAYOUT_TND = 4, LAYOUT_NTD_TND = 5};
+
+namespace math {
+template <typename T> __aicore__ inline T Ceil(T a, T b)
+{
+    if (b == 0) {
+        return 0;
+    }
+    return (a + b - 1) / b;
+}
+
+template <typename T> __aicore__ inline T Align(T a, T b)
+{
+    if (b == 0) {
+        return 0;
+    }
+    return (a + b - 1) / b * b;
+}
+}
+
+template <typename T1, typename T2>
+__aicore__ inline T1 CeilDiv(T1 a, T2 b)
+{
+    if (b == 0) {
+        return 0;
+    }
+    return (a + b - 1) / b;
+}
+
+template <typename T1, typename T2>
+__aicore__ inline T1 Max(T1 a, T2 b)
+{
+    return (a > b) ? (a) : (b);
+}
+
+template <typename T1, typename T2>
+__aicore__ inline T1 Min(T1 a, T2 b)
+{
+    return (a > b) ? (b) : (a);
+}
+
+__aicore__ inline void BoolCopyIn(LocalTensor<uint8_t> &dstTensor, GlobalTensor<uint8_t> &srcTensor,
+    int64_t srcOffset, uint32_t s1Size, uint32_t s2Size, int64_t totalS2Size, int64_t alignedSize = blockBytes)
+{
+    uint32_t alignedS2Size = CeilDiv(s2Size, alignedSize) * alignedSize;
+    uint32_t shapeArray[] = {s1Size, alignedS2Size};
+    dstTensor.SetShapeInfo(ShapeInfo(2, shapeArray, DataFormat::ND));
+    dstTensor.SetSize(s1Size * alignedS2Size);
+    DataCopyParams dataCopyParams;
+    dataCopyParams.blockCount = s1Size;
+    dataCopyParams.dstStride = 0;
+    if (totalS2Size == blockBytes && alignedSize == 64) { // totalS2Size < 64 && totalS2Size % blockBytes == 0
+        dataCopyParams.dstStride = 1;
+        alignedSize = blockBytes;
+        alignedS2Size = CeilDiv(s2Size, blockBytes) * blockBytes;
+    }
+    if (likely(totalS2Size - s2Size <= UINT16_MAX)) {
+        if (totalS2Size % alignedSize == 0) {
+            dataCopyParams.blockLen = alignedS2Size / blockBytes;
+            dataCopyParams.srcStride = (totalS2Size - alignedS2Size) / blockBytes;
+            DataCopy(dstTensor, srcTensor[srcOffset], dataCopyParams);
+        } else {
+            dataCopyParams.blockLen = s2Size;
+            dataCopyParams.srcStride = totalS2Size - s2Size;
+            DataCopyPadParams dataCopyPadParams;
+            dataCopyPadParams.isPad = true;
+            dataCopyPadParams.rightPadding = Min(alignedS2Size - s2Size, blockBytes);
+            dataCopyPadParams.paddingValue = 1;
+            DataCopyPad(dstTensor, srcTensor[srcOffset], dataCopyParams, dataCopyPadParams);
+        }
+    } else {
+        DataCopyExtParams extParams;
+        extParams.blockCount = s1Size;
+        extParams.dstStride = 0;
+        extParams.blockLen = s2Size;
+        extParams.srcStride = totalS2Size - s2Size;
+        DataCopyPadExtParams<uint8_t> dataCopyPadParams;
+        dataCopyPadParams.isPad = true;
+        dataCopyPadParams.rightPadding = Min(alignedS2Size - s2Size, blockBytes);
+        dataCopyPadParams.paddingValue = 1;
+        DataCopyPad(dstTensor, srcTensor[srcOffset], extParams, dataCopyPadParams);
+    }
+}
+
+__aicore__ inline void Bit2Int8CopyIn(LocalTensor<uint8_t> &dstTensor, GlobalTensor<uint8_t> &srcTensor,
+    int64_t srcOffset, uint32_t batchSize, uint32_t s1BaseSize, uint32_t s2BaseSize, int64_t s2TotalSize,
+    int64_t alignedSize = blockBytes)
+{
+    uint32_t alignedS2Size = CeilDiv(s2BaseSize / byteBitRatio, alignedSize) * alignedSize;
+    uint32_t shapeArray[] = {batchSize * s1BaseSize, alignedS2Size};
+    dstTensor.SetShapeInfo(ShapeInfo(2, shapeArray, DataFormat::ND));
+    dstTensor.SetSize(batchSize * s1BaseSize * alignedS2Size);
+    DataCopyParams dataCopyParams;
+    dataCopyParams.blockCount = batchSize * s1BaseSize;
+    dataCopyParams.blockLen = CeilDiv(s2BaseSize / byteBitRatio, blockBytes);
+    dataCopyParams.dstStride = 0;
+    if (s2TotalSize / byteBitRatio % alignedSize == 0 && s2BaseSize / byteBitRatio % alignedSize == 0) {
+        dataCopyParams.srcStride =
+            (s2TotalSize / byteBitRatio - dataCopyParams.blockLen * blockBytes) / blockBytes;
+        DataCopy(dstTensor, srcTensor[srcOffset / byteBitRatio], dataCopyParams);
+    } else {
+        dataCopyParams.blockLen = CeilDiv(s2BaseSize , byteBitRatio);
+        dataCopyParams.srcStride = (s2TotalSize  - s2BaseSize) / byteBitRatio;
+        DataCopyPadParams dataCopyPadParams;
+        dataCopyPadParams.isPad = true;
+        dataCopyPadParams.rightPadding = 0;
+        dataCopyPadParams.paddingValue = 0;
+        DataCopyPad(dstTensor, srcTensor[srcOffset / byteBitRatio], dataCopyParams, dataCopyPadParams);
+    }
+}
+
+__aicore__ inline int32_t Align(int32_t shape)
+{
+    int32_t alignFactor = 16;
+    int32_t alignedSize = CeilDiv<int32_t, int32_t>(shape, alignFactor) * alignFactor;
+    return alignedSize;
+}
+
+#endif // FLASH_ATTENTION_UTIL_H

csrc/common/include/op_graph/op_transformer_proto_extend.h

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file op_transformer_proto_extend.h
+ * \brief
+ */
+#ifndef OPS_OP_MATH_PROTO_EXTEND_H_
+#define OPS_OP_MATH_PROTO_EXTEND_H_
+
+#include "graph/operator_reg.h"
+
+namespace ge {
+/**
+* @brief swin_transformer model specific structure.Operator only supports swin_transformer.
+
+* @par Inputs:
+* Three inputs, including:
+* @li x: An ND Tensor. Must be one of the following types: float16, float, bfloat16,
+         the shape should be (B*W, N, S1, S2) or (B, W, N, S1, S2).
+* @li atten_mask: An ND Tensor. Must be one of the following types: float16, float, bfloat16,
+                  the shape should be (W, S1, S2) or (W, 1, S1, S2) or (1, W, 1, S1, S2)
+* @li relative_pos_bias: An ND Tensor. Must be one of the following types: float16, float, bfloat16.
+                         the shape sholud be (N, S1, S2) or (1, N, S1, S2) or (1, 1, N, S1, S2)
+
+* @par Attributes:
+* @li scale_value: A optional attribute, the type is float. Defaults to 1.0.
+* @li inner_precision_mode: A optional attribute, the type is int. Defaults to 0, reserved field.
+
+* @par Outputs:
+* One output, including:
+* @li y: An ND Tensor. Must be one of the following types: float16, float, bfloat16,
+         the shape should be same with x.
+*/
+REG_OP(MaskedSoftmaxWithRelPosBias)
+    .INPUT(x, TensorType({DT_FLOAT16, DT_BFLOAT16, DT_FLOAT}))
+    .OPTIONAL_INPUT(atten_mask, TensorType({DT_FLOAT16, DT_BFLOAT16, DT_FLOAT}))
+    .INPUT(relative_pos_bias, TensorType({DT_FLOAT16, DT_BFLOAT16, DT_FLOAT}))
+    .OUTPUT(y, TensorType({DT_FLOAT16, DT_BFLOAT16, DT_FLOAT}))
+    .ATTR(scale_value, Float, 1.0)
+    .ATTR(inner_precision_mode, Int, 0)
+    .OP_END_FACTORY_REG(MaskedSoftmaxWithRelPosBias)
+
+/**
+* @brief AttentionScore's forward calculation.
+
+* @par Inputs:
+* six inputs, including:
+* @li query: A matrix Tensor. The type only support float16. Enter a 4D Tensor.
+* @li key: A matrix Tensor. The type only support float16. Enter a 4D Tensor.
+* @li value: A matrix Tensor. The type only support float16. Enter a 4D Tensor.
+* @li padding_mask: A matrix Tensor. The type only support float16. Enter a 4D Tensor.
+* @li scale: A scalar. The type only support float16. Enter a 4D Tensor.
+* @li drop_mask: A matrix Tensor. An optional input parameter. The type only support uint8. Enter a 4D Tensor.
+
+* @par Attributes:
+* @li keep_prob: A float. The keep probability of dropout. Default: 1.0.
+* @li query_transpose: A bool. If True, changes the shape of "query" from [B, N, S, D] to [B, N, D, S].
+* Default: false.
+* @li key_transpose: A bool. If True, changes the shape of "key" from [B, N, S, D] to [B, N, D, S].
+* Default: false.
+* @li bmm_score_transpose_a: A bool. If True, changes the shape of "mid_data" from [B, N, S, D] to [B, N, D, S].
+* Default: false.
+* @li bmm_score_transpose_b: A bool. If True, changes the shape of "value" from [B, N, S, D] to [B, N, D, S].
+* Default: false.
+* @li softmax_axes: A list of int. The dimension softmax would be performed on. Defaults to "[-1]".
+
+* @par Outputs:
+* attention_score: The result matrix Tensor. The type only support float16. The output shape is the same as query.
+* softmax_output: The result matrix Tensor. The type only support float16. The output shape is the same as query.
+
+* @par Restrictions:
+* Warning: THIS FUNCTION IS EXPERIMENTAL. Please do not use.
+*/
+REG_OP(AttentionScore)
+    .INPUT(query, TensorType({DT_FLOAT16}))
+    .INPUT(key, TensorType({DT_FLOAT16}))
+    .INPUT(value, TensorType({DT_FLOAT16}))
+    .INPUT(padding_mask, TensorType({DT_FLOAT16}))
+    .INPUT(scale, TensorType({DT_FLOAT16}))
+    .OPTIONAL_INPUT(drop_mask, TensorType({DT_INT8}))
+    .OUTPUT(attention_score, TensorType({DT_FLOAT16}))
+    .OUTPUT(softmax_output, TensorType({DT_FLOAT16}))
+    .ATTR(keep_prob, Float, 1.0)
+    .ATTR(query_transpose, Bool, false)
+    .ATTR(key_transpose, Bool, false)
+    .ATTR(bmm_score_transpose_a, Bool, false)
+    .ATTR(bmm_score_transpose_b, Bool, false)
+    .ATTR(softmax_axes, ListInt, {-1})
+    .OP_END_FACTORY_REG(AttentionScore)
+}
+
+#endif

csrc/common/include/static/op_resource.h

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file op_resource.h
+ * \brief
+ */
+#ifndef COMMON_NN_OP_RESOURCE_H
+#define COMMON_NN_OP_RESOURCE_H
+
+#define EXTERN_OP_RESOURCE(kernelName)                        \
+namespace l0op {                                                \
+    extern void * kernelName##TilingRegisterResource();                 \
+    extern void * kernelName##InferShapeRegisterResource();             \
+    extern void * kernelName##TuningRegisterResource();             \
+    extern const OP_BINARY_RES& kernelName##KernelResource();                 \
+    extern const OP_RUNTIME_KB_RES& kernelName##TuningResource();             \
+    [[maybe_unused]] uint32_t kernelName##_kernelName_Be_Defined_Multi_Times___;  \
+}
+
+#define AUTO_GEN_OP_RESOURCE(kernelName)    {{ #kernelName,                     \
+    {{l0op::kernelName##TilingRegisterResource(), l0op::kernelName##InferShapeRegisterResource(), l0op::kernelName##TuningRegisterResource()},  \
+      l0op::kernelName##KernelResource(), l0op::kernelName##TuningResource()}}} \
+
+#endif  // COMMON_NN_OP_RESOURCE_H

csrc/common/include/static/static_space.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file static_space.h
+ * \brief
+ */
+#ifndef CANN_OPS_STATIC_SPACE_H_
+#define CANN_OPS_STATIC_SPACE_H_
+#include "base/registry/op_impl_space_registry_v2.h"
+
+class StaticSpaceInitializer {
+public:
+    static StaticSpaceInitializer& GetInstance() {
+        static StaticSpaceInitializer instance;
+        return instance;
+    }
+private:
+    StaticSpaceInitializer () {
+        auto space_registry = gert::DefaultOpImplSpaceRegistryV2::GetInstance().GetSpaceRegistry();
+        if (space_registry == nullptr) {
+            space_registry = std::make_shared<gert::OpImplSpaceRegistryV2>();
+            gert::DefaultOpImplSpaceRegistryV2::GetInstance().SetSpaceRegistry(space_registry);
+        }
+    }
+};
+#endif

csrc/common/include/tiling_base/data_copy_transpose_tiling.h

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file data_copy_transpose_tiling.h
+ * \brief
+ */
+
+#pragma once
+
+#include <vector>
+#include <graph/tensor.h>
+#include "data_copy_transpose_tiling_def.h"
+
+namespace optiling {
+
+inline void GetDataCopyTransposeTiling(const ge::Shape &dstShape, const ge::Shape &srcShape, const uint32_t typeSize,
+                                       optiling::CopyTransposeTiling &tiling)
+{
+    constexpr int64_t B_INDEX = 0;
+    constexpr int64_t N_INDEX = 1;
+    constexpr int64_t S_INDEX = 2;
+    constexpr int64_t H_INDEX = 3;
+    std::vector<int64_t> dstShapeInfo = dstShape.GetDims();
+    std::vector<int64_t> srcShapeInfo = srcShape.GetDims();
+
+    tiling.set_dstShapeB(dstShapeInfo[B_INDEX]);
+    tiling.set_dstShapeN(dstShapeInfo[N_INDEX]);
+    tiling.set_dstShapeS(dstShapeInfo[S_INDEX]);
+    tiling.set_dstShapeH(dstShapeInfo[H_INDEX]);
+    tiling.set_dstShapeHN(tiling.get_dstShapeH() / tiling.get_dstShapeN());
+
+    tiling.set_srcShapeB(srcShapeInfo[B_INDEX]);
+    tiling.set_srcShapeN(srcShapeInfo[N_INDEX]);
+    tiling.set_srcShapeS(srcShapeInfo[S_INDEX]);
+    tiling.set_srcShapeHN(srcShapeInfo[H_INDEX]);
+    tiling.set_originalShapeNLen(tiling.get_srcShapeHN() * typeSize);
+    tiling.set_shapeSHValue(tiling.get_dstShapeS() * tiling.get_dstShapeH());
+    tiling.set_shapeNsValue(tiling.get_dstShapeN() * tiling.get_dstShapeS());
+    tiling.set_shapeNsnValue(tiling.get_dstShapeN() * tiling.get_srcShapeS() * tiling.get_srcShapeN());
+    tiling.set_shapeBHValue(tiling.get_dstShapeB() * tiling.get_dstShapeH());
+}
+
+} // namespace optiling

csrc/common/include/tiling_base/data_copy_transpose_tiling_def.h

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file data_copy_transpose_tiling_def.h
+ * \brief
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <register/tilingdata_base.h>
+
+namespace optiling {
+
+BEGIN_TILING_DATA_DEF(CopyTransposeTiling)
+TILING_DATA_FIELD_DEF(uint32_t, dstShapeB);
+TILING_DATA_FIELD_DEF(uint32_t, dstShapeN);
+TILING_DATA_FIELD_DEF(uint32_t, dstShapeS);
+TILING_DATA_FIELD_DEF(uint32_t, dstShapeHN);
+TILING_DATA_FIELD_DEF(uint32_t, dstShapeH);
+TILING_DATA_FIELD_DEF(uint32_t, srcShapeB);
+TILING_DATA_FIELD_DEF(uint32_t, srcShapeN);
+TILING_DATA_FIELD_DEF(uint32_t, srcShapeS);
+TILING_DATA_FIELD_DEF(uint32_t, srcShapeHN);
+TILING_DATA_FIELD_DEF(uint32_t, originalShapeNLen);
+TILING_DATA_FIELD_DEF(uint32_t, shapeSHValue);
+TILING_DATA_FIELD_DEF(uint32_t, shapeNsValue);
+TILING_DATA_FIELD_DEF(uint32_t, shapeNsnValue);
+TILING_DATA_FIELD_DEF(uint32_t, invalidParamCopyTransposeTiling);
+TILING_DATA_FIELD_DEF(uint32_t, shapeBHValue);
+TILING_DATA_FIELD_DEF(uint32_t, paramsAlign);
+END_TILING_DATA_DEF;
+REGISTER_TILING_DATA_CLASS(CopyTransposeTilingOp, CopyTransposeTiling)
+
+} // namespace optiling

csrc/common/include/tiling_base/error_log.h

@@ -0,0 +1,73 @@
+#ifndef OPS_BUILT_IN_OP_TILING_ERROR_LOG_H_
+#define OPS_BUILT_IN_OP_TILING_ERROR_LOG_H_
+
+#include <cstdio>
+#include <string>
+
+#include "tiling_base/tiling_util.h"
+#include "toolchain/slog.h"
+
+#define OP_LOGI(opname, ...)
+#define OP_LOGD(opname, ...)
+
+#define OP_LOGW(opname, ...)       \
+    do {                           \
+        (void)(opname);            \
+        std::printf("[WARN] ");    \
+        std::printf(__VA_ARGS__);  \
+        std::printf("\n");        \
+    } while (0)
+
+#define OP_LOGE_WITHOUT_REPORT(opname, ...) \
+    do {                                    \
+        (void)(opname);                     \
+        std::printf("[ERRORx] ");           \
+        std::printf(__VA_ARGS__);           \
+        std::printf("\n");                 \
+    } while (0)
+
+#define OP_LOGE(opname, ...)       \
+    do {                           \
+        (void)(opname);            \
+        std::printf("[ERROR] ");   \
+        std::printf(__VA_ARGS__);  \
+        std::printf("\n");        \
+    } while (0)
+
+namespace optiling {
+
+#define VECTOR_INNER_ERR_REPORT_TILIING(op_name, err_msg, ...)   \
+    do {                                                         \
+        OP_LOGE_WITHOUT_REPORT(op_name, err_msg, ##__VA_ARGS__); \
+    } while (0)
+
+#define OP_CHECK_IF(cond, log_func, expr) \
+    do {                                  \
+        if (cond) {                       \
+            log_func;                     \
+            expr;                         \
+        }                                 \
+    } while (0)
+
+#define OP_TILING_CHECK(cond, log_func, expr) \
+    do {                                      \
+        if (cond) {                           \
+            log_func;                         \
+            expr;                             \
+        }                                     \
+    } while (0)
+
+#define OP_CHECK_NULL_WITH_CONTEXT(context, ptr)                 \
+    do {                                                         \
+        if ((ptr) == nullptr) {                                  \
+            OP_LOGE(context->GetNodeType(), "%s is null", #ptr); \
+            return ge::GRAPH_FAILED;                             \
+        }                                                        \
+    } while (0)
+
+} // namespace optiling
+
+using Ops::Transformer::CeilAlign;
+using Ops::Transformer::CeilDiv;
+
+#endif // OPS_BUILT_IN_OP_TILING_ERROR_LOG_H_

csrc/common/include/tiling_base/tiling_base.h

@@ -0,0 +1,256 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file tiling_base.h
+ * \brief
+ */
+
+#pragma once
+
+#include <sstream>
+#include <exe_graph/runtime/tiling_context.h>
+#include <graph/utils/type_utils.h>
+#include "tiling/platform/platform_ascendc.h"
+#include "tiling_base/error_log.h"
+
+#ifdef ASCENDC_OP_TEST
+#define ASCENDC_EXTERN_C extern "C"
+#else
+#define ASCENDC_EXTERN_C
+#endif
+
+namespace Ops {
+namespace Transformer {
+namespace OpTiling {
+
+struct AiCoreParams {
+    uint64_t ubSize = 0;
+    uint64_t blockDim = 0;
+    uint64_t aicNum = 0;
+    uint64_t l1Size = 0;
+    uint64_t l0aSize = 0;
+    uint64_t l0bSize = 0;
+    uint64_t l0cSize = 0;
+};
+
+struct CompileInfoCommon {
+    uint32_t aivNum;
+    uint32_t aicNum;
+    uint64_t ubSize;
+    uint64_t l1Size;
+    uint64_t l0aSize;
+    uint64_t l0bSize;
+    uint64_t l0cSize;
+    uint64_t l2CacheSize;
+    int64_t coreNum;
+    int32_t socVersion;
+    uint32_t rsvd;
+};
+
+struct FlashAttentionScoreGradCompileInfo {
+    uint32_t aivNum;
+    uint32_t aicNum;
+    uint64_t ubSize;
+    uint64_t l1Size;
+    uint64_t l0aSize;
+    uint64_t l0bSize;
+    uint64_t l0cSize;
+    uint64_t l2CacheSize;
+    int64_t coreNum;
+    platform_ascendc::SocVersion socVersion;
+};
+
+struct FACompileInfoCommon {
+    uint32_t aivNum;
+    uint32_t aicNum;
+    uint64_t ubSize;
+    uint64_t l1Size;
+    uint64_t l0aSize;
+    uint64_t l0bSize;
+    uint64_t l0cSize;
+    uint64_t l2CacheSize;
+    int64_t coreNum;
+    int32_t socVersion;
+    uint32_t rsvd;
+};
+
+class TilingBaseClass {
+public:
+    explicit TilingBaseClass(gert::TilingContext* context) : context_(context)
+    {}
+
+    virtual ~TilingBaseClass() = default;
+
+    // Tiling执行框架
+    //     1、GRAPH_SUCCESS: 成功，并且不需要继续执行后续Tiling类的实现
+    //     2、GRAPH_FAILED: 失败，中止整个Tiling流程
+    //     3、GRAPH_PARAM_INVALID: 本类不支持，需要继续往下执行其他Tiling类的实现
+    ge::graphStatus DoTiling()
+    {
+        auto ret = GetShapeAttrsInfo();
+        if (ret != ge::GRAPH_SUCCESS) {
+            return ret;
+        }
+        ret = GetPlatformInfo();
+        if (ret != ge::GRAPH_SUCCESS) {
+            return ret;
+        }
+        if (!IsCapable()) {
+            return ge::GRAPH_PARAM_INVALID;
+        }
+        ret = DoOpTiling();
+        if (ret != ge::GRAPH_SUCCESS) {
+            return ret;
+        }
+        ret = DoLibApiTiling();
+        if (ret != ge::GRAPH_SUCCESS) {
+            return ret;
+        }
+        ret = GetWorkspaceSize();
+        if (ret != ge::GRAPH_SUCCESS) {
+            return ret;
+        }
+        ret = PostTiling();
+        if (ret != ge::GRAPH_SUCCESS) {
+            return ret;
+        }
+        context_->SetTilingKey(GetTilingKey());
+        DumpTilingInfo();
+        return ge::GRAPH_SUCCESS;
+    }
+
+    // 更新 context
+    virtual void Reset(gert::TilingContext* context)
+    {
+        context_ = context;
+    }
+
+protected:
+    virtual bool IsCapable() = 0;
+    // 1、获取平台信息比如CoreNum、UB/L1/L0C资源大小
+    virtual ge::graphStatus GetPlatformInfo() = 0;
+    // 2、获取INPUT/OUTPUT/ATTR信息
+    virtual ge::graphStatus GetShapeAttrsInfo() = 0;
+    // 3、计算数据切分TilingData
+    virtual ge::graphStatus DoOpTiling() = 0;
+    // 4、计算高阶API的TilingData
+    virtual ge::graphStatus DoLibApiTiling() = 0;
+    // 5、计算TilingKey
+    [[nodiscard]] virtual uint64_t GetTilingKey() const = 0;
+    // 6、计算Workspace 大小
+    virtual ge::graphStatus GetWorkspaceSize() = 0;
+    // 7、保存Tiling数据
+    virtual ge::graphStatus PostTiling() = 0;
+    // 8、Dump Tiling数据
+    virtual void DumpTilingInfo()
+    {
+        int32_t enable = CheckLogLevel(static_cast<int32_t>(OP), DLOG_DEBUG);
+        if (enable != 1) {
+            return;
+        }
+        auto buf = (uint32_t*)context_->GetRawTilingData()->GetData();
+        auto bufLen = context_->GetRawTilingData()->GetDataSize();
+        std::ostringstream oss;
+        oss << "Start to dump tiling info. tilingkey:" << context_->GetTilingKey() << ", tiling data size:" << bufLen
+            << ", content:";
+        for (size_t i = 0; i < bufLen / sizeof(uint32_t); i++) {
+            oss << *(buf + i) << ",";
+            if (oss.str().length() > 640) { // Split according to 640 to avoid truncation
+                OP_LOGD(context_, "%s", oss.str().c_str());
+                oss.str("");
+            }
+        }
+        OP_LOGD(context_, "%s", oss.str().c_str());
+    }
+
+    static uint32_t CalcTschBlockDim(uint32_t sliceNum, uint32_t aicCoreNum, uint32_t aivCoreNum)
+    {
+        uint32_t ration;
+        if (aicCoreNum == 0 || aivCoreNum == 0 || aicCoreNum > aivCoreNum) {
+            return sliceNum;
+        }
+        ration = aivCoreNum / aicCoreNum;
+        return (sliceNum + (ration - 1)) / ration;
+    }
+
+    template <typename T>
+    [[nodiscard]] std::string GetShapeDebugStr(const T& shape) const
+    {
+        std::ostringstream oss;
+        oss << "[";
+        if (shape.GetDimNum() > 0) {
+            for (size_t i = 0; i < shape.GetDimNum() - 1; ++i) {
+                oss << shape.GetDim(i) << ", ";
+            }
+            oss << shape.GetDim(shape.GetDimNum() - 1);
+        }
+        oss << "]";
+        return oss.str();
+    }
+
+    [[nodiscard]] std::string GetTensorDebugStr(
+        const gert::StorageShape* shape, const gert::CompileTimeTensorDesc* tensor)
+    {
+        if (shape == nullptr || tensor == nullptr) {
+            return "nil ";
+        }
+        std::ostringstream oss;
+        oss << "(dtype: " << ge::TypeUtils::DataTypeToSerialString(tensor->GetDataType()) << "),";
+        oss << "(shape:" << GetShapeDebugStr(shape->GetStorageShape()) << "),";
+        oss << "(ori_shape:" << GetShapeDebugStr(shape->GetOriginShape()) << "),";
+        oss << "(format: "
+            << ge::TypeUtils::FormatToSerialString(
+                   static_cast<ge::Format>(ge::GetPrimaryFormat(tensor->GetStorageFormat())))
+            << "),";
+        oss << "(ori_format: " << ge::TypeUtils::FormatToSerialString(tensor->GetOriginFormat()) << ") ";
+        return oss.str();
+    }
+
+    [[nodiscard]] std::string GetTilingContextDebugStr()
+    {
+        std::ostringstream oss;
+        for (size_t i = 0; i < context_->GetComputeNodeInfo()->GetInputsNum(); ++i) {
+            oss << "input" << i << ": ";
+            oss << GetTensorDebugStr(context_->GetInputShape(i), context_->GetInputDesc(i));
+        }
+
+        for (size_t i = 0; i < context_->GetComputeNodeInfo()->GetOutputsNum(); ++i) {
+            oss << "output" << i << ": ";
+            oss << GetTensorDebugStr(context_->GetOutputShape(i), context_->GetOutputDesc(i));
+        }
+        return oss.str();
+    }
+
+    [[nodiscard]] std::string GetTilingDataDebugStr() const
+    {
+        auto rawTilingData = context_->GetRawTilingData();
+        auto rawTilingDataSize = rawTilingData->GetDataSize();
+        auto data = reinterpret_cast<const int32_t*>(rawTilingData->GetData());
+        size_t len = rawTilingDataSize / sizeof(int32_t);
+        std::ostringstream oss;
+        for (size_t i = 0; i < len; i++) {
+            oss << data[i] << ", ";
+        }
+        return oss.str();
+    }
+
+protected:
+    gert::TilingContext* context_ = nullptr;
+    std::unique_ptr<platform_ascendc::PlatformAscendC> ascendcPlatform_{nullptr};
+    uint32_t blockDim_{0};
+    uint64_t workspaceSize_{0};
+    uint64_t tilingKey_{0};
+    AiCoreParams aicoreParams_;
+};
+
+} // namespace OpTiling
+} // namespace Transformer
+} // namespace Ops

csrc/common/include/tiling_base/tiling_key.h

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file tiling_key.h
+ * \brief
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace Ops {
+namespace Transformer {
+namespace OpTiling {
+constexpr uint64_t RecursiveSum()
+{
+    return 0;
+}
+
+constexpr uint64_t kBase = 10; // 10进制进位基数
+template <typename T, typename... Args> constexpr uint64_t RecursiveSum(T templateId, Args... templateIds)
+{
+    return static_cast<uint64_t>(templateId) + kBase * RecursiveSum(templateIds...);
+}
+
+// TilingKey 的生成规则：
+// FlashAttentionScore/FlashAttentionScoreGrad 十进制位组装tiling key，包含以下关键参数，从低位到高位依次是：Ub0, Ub1,
+// Block, DataType, Format, Sparse, 特化模板 Ub0、Ub1:
+//     表示Ub核内切分的轴，使用枚举AxisEnum表示，因为我们允许最多切分两根轴，所以存在UB0和UB1，如果没有UB核内切分，
+//     那么填AXIS_NONE。UB0和UB1各占一个十进制位;
+//     Block: 表示UB用来分核的轴，使用枚举AxisEnum表示，占一个十进制位;
+//     DataType: 表示当前tiling key支持的输入输出的数据类型，使用枚举SupportedDtype来表示，占一个十进制位
+//     Format: 表示当前tiling key支持的Format, 使用枚举InputLayout表示，占一个十进制位
+//     Sparse: 表示当前tiling key是否支持Sparse，使用枚举SparseCapability表示，占一个十进制位
+//     其余特化场景，定义自己的位域和值
+// usage: get tilingKey from inputted types
+//     uint64_t tilingKey = GET_FLASHATTENTION_TILINGKEY(AxisEnum::AXIS_S1, AxisEnum::AXIS_S2, AxisEnum::AXIS_N2,
+//                                     SupportedDtype::FLOAT32, InputLayout::BSH, SparseCapability::SUPPORT_ALL)
+
+constexpr uint64_t TILINGKEYOFFSET = uint64_t(10000000000000000000UL); // 10^19
+template <typename... Args> constexpr uint64_t GET_TILINGKEY(Args... templateIds)
+{
+    return TILINGKEYOFFSET + RecursiveSum(templateIds...);
+}
+
+// usage: get tilingKey from inputted types
+//     uint64_t tilingKey = TILINGKEY(S2, S1, N2, FLOAT32, BSND, ALL)
+
+#define TILINGKEY(ub2, ub1, block, dtype, layout, sparse)                                                              \
+    (GET_TILINGKEY(AxisEnum::ub2, AxisEnum::ub1, AxisEnum::block, DtypeEnum::dtype, LayoutEnum::layout,                \
+                   SparseEnum::sparse))
+
+} // namespace Optiling
+} // namespace Transformer
+} // namespace Ops

csrc/common/include/tiling_base/tiling_templates_registry.h

@@ -0,0 +1,350 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file tiling_templates_registry.h
+ * \brief
+ */
+
+#pragma once
+
+#include <map>
+#include <string>
+#include <memory>
+#include "exe_graph/runtime/tiling_context.h"
+#include "tiling_base/tiling_base.h"
+#include "tiling_base/error_log.h"
+
+namespace Ops {
+namespace Transformer {
+namespace OpTiling {
+
+template <typename T>
+std::unique_ptr<TilingBaseClass> TILING_CLASS(gert::TilingContext* context)
+{
+    return std::unique_ptr<T>(new (std::nothrow) T(context));
+}
+
+using TilingClassCase = std::unique_ptr<TilingBaseClass> (*)(gert::TilingContext*);
+
+class TilingCases {
+public:
+    explicit TilingCases(std::string op_type) : op_type_(std::move(op_type))
+    {}
+
+    template <typename T>
+    void AddTiling(int32_t priority)
+    {
+        OP_CHECK_IF(
+            cases_.find(priority) != cases_.end(), OP_LOGE(op_type_, "There are duplicate registrations."), return);
+        cases_[priority] = TILING_CLASS<T>;
+        OP_CHECK_IF(
+            cases_[priority] == nullptr,
+            OP_LOGE(op_type_, "Register op tiling func failed, please check the class name."), return);
+    }
+
+    const std::map<int32_t, TilingClassCase>& GetTilingCases()
+    {
+        return cases_;
+    }
+
+private:
+    std::map<int32_t, TilingClassCase> cases_;
+    const std::string op_type_;
+};
+
+// --------------------------------Interfacce with soc version --------------------------------
+class TilingRegistryNew {
+public:
+    TilingRegistryNew() = default;
+
+#ifdef ASCENDC_OP_TEST
+    static TilingRegistryNew& GetInstance();
+#else
+    static TilingRegistryNew& GetInstance()
+    {
+        static TilingRegistryNew registry_impl_;
+        return registry_impl_;
+    }
+#endif
+
+    std::shared_ptr<TilingCases> RegisterOp(const std::string& op_type, int32_t soc_version)
+    {
+        auto soc_iter = registry_map_.find(soc_version);
+        if (soc_iter == registry_map_.end()) {
+            std::map<std::string, std::shared_ptr<TilingCases>> op_type_map;
+            op_type_map[op_type] = std::shared_ptr<TilingCases>(new (std::nothrow) TilingCases(op_type));
+            registry_map_[soc_version] = op_type_map;
+        } else {
+            if (soc_iter->second.find(op_type) == soc_iter->second.end()) {
+                soc_iter->second[op_type] = std::shared_ptr<TilingCases>(new (std::nothrow) TilingCases(op_type));
+            }
+        }
+
+        OP_CHECK_IF(
+            registry_map_[soc_version][op_type] == nullptr,
+            OP_LOGE(op_type, "Register tiling func failed, please check the class name."), return nullptr);
+        return registry_map_[soc_version][op_type];
+    }
+
+    ge::graphStatus DoTilingImpl(gert::TilingContext* context)
+    {
+        int32_t soc_version = (int32_t)platform_ascendc::SocVersion::RESERVED_VERSION;
+        const char* op_type = context->GetNodeType();
+        fe::PlatFormInfos* platformInfoPtr = context->GetPlatformInfo();
+        if (platformInfoPtr == nullptr) {
+            auto compileInfoPtr = static_cast<const CompileInfoCommon*>(context->GetCompileInfo());
+            OP_CHECK_IF(
+                compileInfoPtr == nullptr, OP_LOGE(op_type, "compileInfoPtr is null."), return ge::GRAPH_FAILED);
+            soc_version = compileInfoPtr->socVersion;
+            OP_LOGD(context, "soc version in compileInfo is %d", soc_version);
+        } else {
+            auto ascendcPlatform = platform_ascendc::PlatformAscendC(platformInfoPtr);
+            soc_version = static_cast<int32_t>(ascendcPlatform.GetSocVersion());
+            OP_LOGD(context, "soc version is %d", soc_version);
+            if (soc_version == (int32_t)platform_ascendc::SocVersion::RESERVED_VERSION) {
+                OP_LOGE(op_type, "Do op tiling failed, cannot find soc version.");
+                return ge::GRAPH_FAILED;
+            }
+        }
+        auto tilingTemplateRegistryMap = GetTilingTemplates(op_type, soc_version);
+        for (auto it = tilingTemplateRegistryMap.begin(); it != tilingTemplateRegistryMap.end(); ++it) {
+            auto tilingTemplate = it->second(context);
+            if (tilingTemplate != nullptr) {
+                ge::graphStatus status = tilingTemplate->DoTiling();
+                if (status != ge::GRAPH_PARAM_INVALID) {
+                    OP_LOGD(context, "Do general op tiling success priority=%d", it->first);
+                    return status;
+                }
+                OP_LOGD(context, "Ignore general op tiling priority=%d", it->first);
+            }
+        }
+        OP_LOGE(op_type, "Do op tiling failed, no valid template is found.");
+        return ge::GRAPH_FAILED;
+    }
+
+    ge::graphStatus DoTilingImpl(gert::TilingContext* context, const std::vector<int32_t>& priorities)
+    {
+        int32_t soc_version;
+        const char* op_type = context->GetNodeType();
+        auto platformInfoPtr = context->GetPlatformInfo();
+        if (platformInfoPtr == nullptr) {
+            auto compileInfoPtr = reinterpret_cast<const CompileInfoCommon*>(context->GetCompileInfo());
+            OP_CHECK_IF(
+                compileInfoPtr == nullptr, OP_LOGE(op_type, "compileInfoPtr is null."), return ge::GRAPH_FAILED);
+            soc_version = compileInfoPtr->socVersion;
+            OP_LOGD(context, "soc version in compileInfo is %d", soc_version);
+        } else {
+            auto ascendcPlatform = platform_ascendc::PlatformAscendC(platformInfoPtr);
+            soc_version = static_cast<int32_t>(ascendcPlatform.GetSocVersion());
+            OP_LOGD(context, "soc version is %d", soc_version);
+        }
+
+        auto tilingTemplateRegistryMap = GetTilingTemplates(op_type, soc_version);
+        for (auto priority_id : priorities) {
+            auto tilingCaseIter = tilingTemplateRegistryMap.find(priority_id);
+            if (tilingCaseIter != tilingTemplateRegistryMap.end()) {
+                auto templateFunc = tilingCaseIter->second(context);
+                if (templateFunc != nullptr) {
+                    ge::graphStatus status = templateFunc->DoTiling();
+                    if (status == ge::GRAPH_SUCCESS) {
+                        OP_LOGD(context, "Do general op tiling success priority=%d", priority_id);
+                        return status;
+                    }
+                    OP_LOGD(context, "Ignore general op tiling priority=%d", priority_id);
+                }
+            }
+        }
+        return ge::GRAPH_FAILED;
+    }
+
+    const std::map<int32_t, TilingClassCase>& GetTilingTemplates(const std::string& op_type, int32_t soc_version)
+    {
+        auto soc_iter = registry_map_.find(soc_version);
+        OP_CHECK_IF(
+            soc_iter == registry_map_.end(),
+            OP_LOGE(op_type, "Get op tiling func failed, please check the soc version %d", soc_version),
+            return empty_tiling_case_);
+        auto op_iter = soc_iter->second.find(op_type);
+        OP_CHECK_IF(
+            op_iter == soc_iter->second.end(), OP_LOGE(op_type, "Get op tiling func failed, please check the op name."),
+            return empty_tiling_case_);
+        return op_iter->second->GetTilingCases();
+    }
+
+private:
+    std::map<int32_t, std::map<std::string, std::shared_ptr<TilingCases>>> registry_map_; // key is socversion
+    const std::map<int32_t, TilingClassCase> empty_tiling_case_{};
+};
+
+class RegisterNew {
+public:
+    explicit RegisterNew(std::string op_type) : op_type_(std::move(op_type))
+    {}
+
+    template <typename T>
+    RegisterNew& tiling(int32_t priority, int32_t soc_version)
+    {
+        auto tilingCases = TilingRegistryNew::GetInstance().RegisterOp(op_type_, soc_version);
+        OP_CHECK_IF(
+            tilingCases == nullptr, OP_LOGE(op_type_, "Register op tiling failed, please the op name."), return *this);
+        tilingCases->AddTiling<T>(priority);
+        return *this;
+    }
+
+    template <typename T>
+    RegisterNew& tiling(int32_t priority, const std::vector<int32_t>& soc_versions)
+    {
+        for (int32_t soc_version : soc_versions) {
+            auto tilingCases = TilingRegistryNew::GetInstance().RegisterOp(op_type_, soc_version);
+            OP_CHECK_IF(
+                tilingCases == nullptr, OP_LOGE(op_type_, "Register op tiling failed, please the op name."),
+                return *this);
+            tilingCases->AddTiling<T>(priority);
+        }
+        return *this;
+    }
+
+private:
+    const std::string op_type_;
+};
+
+// --------------------------------Interfacce without soc version --------------------------------
+class TilingRegistry {
+public:
+    TilingRegistry() = default;
+
+#ifdef ASCENDC_OP_TEST
+    static TilingRegistry& GetInstance();
+#else
+    static TilingRegistry& GetInstance()
+    {
+        static TilingRegistry registry_impl_;
+        return registry_impl_;
+    }
+#endif
+
+    std::shared_ptr<TilingCases> RegisterOp(const std::string& op_type)
+    {
+        if (registry_map_.find(op_type) == registry_map_.end()) {
+            registry_map_[op_type] = std::shared_ptr<TilingCases>(new (std::nothrow) TilingCases(op_type));
+        }
+        OP_CHECK_IF(
+            registry_map_[op_type] == nullptr,
+            OP_LOGE(op_type, "Register tiling func failed, please check the class name."), return nullptr);
+        return registry_map_[op_type];
+    }
+
+    ge::graphStatus DoTilingImpl(gert::TilingContext* context)
+    {
+        const char* op_type = context->GetNodeType();
+        auto tilingTemplateRegistryMap = GetTilingTemplates(op_type);
+        for (auto it = tilingTemplateRegistryMap.begin(); it != tilingTemplateRegistryMap.end(); ++it) {
+            auto tilingTemplate = it->second(context);
+            if (tilingTemplate != nullptr) {
+                ge::graphStatus status = tilingTemplate->DoTiling();
+                if (status != ge::GRAPH_PARAM_INVALID) {
+                    OP_LOGD(context, "Do general op tiling success priority=%d", it->first);
+                    return status;
+                }
+                OP_LOGD(context, "Ignore general op tiling priority=%d", it->first);
+            }
+        }
+        OP_LOGE(op_type, "Do op tiling failed, no valid template is found.");
+        return ge::GRAPH_FAILED;
+    }
+
+    ge::graphStatus DoTilingImpl(gert::TilingContext* context, const std::vector<int32_t>& priorities)
+    {
+        const char* op_type = context->GetNodeType();
+        auto tilingTemplateRegistryMap = GetTilingTemplates(op_type);
+        for (auto priorityId : priorities) {
+            auto templateFunc = tilingTemplateRegistryMap[priorityId](context);
+            if (templateFunc != nullptr) {
+                ge::graphStatus status = templateFunc->DoTiling();
+                if (status == ge::GRAPH_SUCCESS) {
+                    OP_LOGD(context, "Do general op tiling success priority=%d", priorityId);
+                    return status;
+                }
+                if (status != ge::GRAPH_PARAM_INVALID) {
+                    OP_LOGD(context, "Do op tiling failed");
+                    return status;
+                }
+                OP_LOGD(context, "Ignore general op tiling priority=%d", priorityId);
+            }
+        }
+        OP_LOGE(op_type, "Do op tiling failed, no valid template is found.");
+        return ge::GRAPH_FAILED;
+    }
+
+    const std::map<int32_t, TilingClassCase>& GetTilingTemplates(const std::string& op_type)
+    {
+        OP_CHECK_IF(
+            registry_map_.find(op_type) == registry_map_.end(),
+            OP_LOGE(op_type, "Get op tiling func failed, please check the op name."), return empty_tiling_case_);
+        return registry_map_[op_type]->GetTilingCases();
+    }
+
+private:
+    std::map<std::string, std::shared_ptr<TilingCases>> registry_map_;
+    const std::map<int32_t, TilingClassCase> empty_tiling_case_;
+};
+
+class Register {
+public:
+    explicit Register(std::string op_type) : op_type_(std::move(op_type))
+    {}
+
+    template <typename T>
+    Register& tiling(int32_t priority)
+    {
+        auto tilingCases = TilingRegistry::GetInstance().RegisterOp(op_type_);
+        OP_CHECK_IF(
+            tilingCases == nullptr, OP_LOGE(op_type_, "Register op tiling failed, please the op name."), return *this);
+        tilingCases->AddTiling<T>(priority);
+        return *this;
+    }
+
+private:
+    const std::string op_type_;
+};
+} // namespace OpTiling
+} // namespace Transformer
+} // namespace Ops
+
+// op_type: 算子名称， class_name: 注册的 tiling 类, soc_version：芯片版本号
+// priority: tiling 类的优先级, 越小表示优先级越高, 即会优先选择这个tiling类
+#define REGISTER_TILING_TEMPLATE_WITH_SOCVERSION(op_type, class_name, soc_versions, priority)    \
+    [[maybe_unused]] uint32_t op_impl_register_template_##op_type##_##class_name##priority;      \
+    static Ops::Transformer::OpTiling::RegisterNew VAR_UNUSED##op_type##class_name##priority_register = \
+        Ops::Transformer::OpTiling::RegisterNew(#op_type).tiling<class_name>(priority, soc_versions)
+
+// op_type: 算子名称， class_name: 注册的 tiling 类,
+// priority: tiling 类的优先级, 越小表示优先级越高, 即被选中的概率越大
+#define REGISTER_TILING_TEMPLATE(op_type, class_name, priority)                                \
+    static Ops::Transformer::OpTiling::Register VAR_UNUSED##op_type_##class_name##priority_register = \
+        Ops::Transformer::OpTiling::Register(op_type).tiling<class_name>(priority)
+
+// op_type: 算子名称， class_name: 注册的 tiling 类,
+// soc_version: soc版本，用于区分不同的soc
+// priority: tiling 类的优先级, 越小表示优先级越高, 即会优先选择这个tiling类
+#define REGISTER_TILING_TEMPLATE_NEW(op_type, class_name, soc_version, priority)                 \
+    [[maybe_unused]] uint32_t op_impl_register_template_##op_type##_##class_name##priority;      \
+    static Ops::Transformer::OpTiling::RegisterNew VAR_UNUSED##op_type##class_name##priority_register = \
+        Ops::Transformer::OpTiling::RegisterNew(#op_type).tiling<class_name>(priority, soc_version)
+
+// op_type: 算子名称， class_name: 注册的 tiling 类,
+// priority: tiling 类的优先级, 越小表示优先级越高, 即被选中的概率越大
+// 取代 REGISTER_TILING_TEMPLATE , 传入的op_type如果是字符串常量，需要去掉引号
+#define REGISTER_OPS_TILING_TEMPLATE(op_type, class_name, priority)                       \
+    [[maybe_unused]] uint32_t op_impl_register_template_##op_type##_##class_name##priority;      \
+    static Ops::Transformer::OpTiling::Register                                                  \
+        __attribute__((unused)) tiling_##op_type##_##class_name##_##priority##_register = \
+            Ops::Transformer::OpTiling::Register(#op_type).tiling<class_name>(priority)

csrc/common/include/tiling_base/tiling_type.h

@@ -0,0 +1,139 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file tiling_type.h
+ * \brief
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace optiling {
+
+enum class AxisEnum {
+    B = 0,
+    N2 = 1,
+    G = 2,
+    S1 = 3,
+    S2 = 4,
+    D = 5,
+    NONE = 9,
+};
+
+enum class DtypeEnum {
+    FLOAT16 = 0,
+    FLOAT32 = 1,
+    BFLOAT16 = 2,
+    FLOAT16_PRECISION = 3,
+};
+
+enum class PerformanceOrientedEnum {
+    BIG_BUFFER = 1,
+    BIG_DOUBLE_BUFFER = 2,
+};
+
+enum class MatmulConfig {
+    NULL_CONFIG = 0,
+    NORMAL_CONFIG = 1,
+    MDL_CONFIG = 2
+};
+
+enum class PseConfig {
+    NO_PSE = 0,
+    EXIST_PSE = 1
+};
+
+enum class AttenMaskConfig {
+    NO_ATTEN_MASK = 0,
+    EXIST_ATTEN_MASK = 1
+};
+
+enum class DropOutConfig {
+    NO_DROP_OUT = 0,
+    EXIST_DROP_OUT = 1
+};
+
+enum class CubeFormatEnum {
+    ND = 0,
+    NZ = 1
+};
+enum class LayoutEnum {
+    BSND = 0,
+    SBND = 1,
+    BNSD = 2,
+    TND = 3,
+    NTD_TND = 4
+};
+
+enum class CubeInputSourceEnum {
+    GM = 0,
+    L1 = 1
+};
+
+enum class OptionEnum {
+    DISABLE = 0,
+    ENABLE = 1
+};
+
+enum class SparseEnum {
+    ALL = 0,
+    NONE = 1,
+    ANY = 2,
+    CAUSAL = 3,
+    BAND = 4,
+    PREFIX = 5,
+    BAND_COMPRESS = 6,
+    RIGHT_DOWN_CAUSAL = 7,
+    RIGHT_DOWN_CAUSAL_BAND = 8,
+    BAND_LEFT_UP_CAUSAL = 9
+};
+
+constexpr uint64_t RecursiveSum()
+{
+    return 0;
+}
+
+constexpr int64_t base10Multiplier = 10;
+
+template <typename T, typename... Args> constexpr uint64_t RecursiveSum(T templateId, Args... templateIds)
+{
+    return static_cast<uint64_t>(templateId) + base10Multiplier * RecursiveSum(templateIds...);
+}
+
+// TilingKey 的生成规则：
+// FlashAttentionScore/FlashAttentionScoreGrad 十进制位组装tiling key，包含以下关键参数，从低位到高位依次是：Ub0, Ub1,
+// Block, DataType, Format, Sparse, 特化模板 Ub0、Ub1:
+//     表示Ub核内切分的轴，使用枚举AxisEnum表示，因为我们允许最多切分两根轴，所以存在UB0和UB1，如果没有UB核内切分，
+//     那么填AXIS_NONE。UB0和UB1各占一个十进制位;
+//     Block: 表示UB用来分核的轴，使用枚举AxisEnum表示，占一个十进制位;
+//     DataType: 表示当前tiling key支持的输入输出的数据类型，使用枚举SupportedDtype来表示，占一个十进制位
+//     Format: 表示当前tiling key支持的Format, 使用枚举InputLayout表示，占一个十进制位
+//     Sparse: 表示当前tiling key是否支持Sparse，使用枚举SparseCapability表示，占一个十进制位
+//     其余特化场景，定义自己的位域和值
+// usage: get tilingKey from inputted types
+//     uint64_t tilingKey = GET_FLASHATTENTION_TILINGKEY(AxisEnum::AXIS_S1, AxisEnum::AXIS_S2, AxisEnum::AXIS_N2,
+//                                     SupportedDtype::FLOAT32, InputLayout::BSH, SparseCapability::SUPPORT_ALL)
+
+constexpr uint64_t TILINGKEYOFFSET = uint64_t(10000000000000000000UL); // 10^19
+template <typename... Args> constexpr uint64_t GET_TILINGKEY(Args... templateIds)
+{
+    return TILINGKEYOFFSET + RecursiveSum(templateIds...);
+}
+
+// usage: get tilingKey from inputted types
+//     uint64_t tilingKey = TILINGKEY(S2, S1, N2, FLOAT32, BSND, ALL)
+
+#define TILINGKEY(ub2, ub1, block, dtype, layout, sparse)                                                              \
+    (GET_TILINGKEY(AxisEnum::ub2, AxisEnum::ub1, AxisEnum::block, DtypeEnum::dtype, LayoutEnum::layout,                \
+                   SparseEnum::sparse))
+
+} // namespace optiling

csrc/common/include/tiling_base/tiling_util.h

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file tiling_util.h
+ * \brief
+ */
+
+#pragma once
+
+#include "register/op_impl_registry.h"
+
+namespace Ops {
+namespace Transformer {
+
+template <typename T>
+T CeilAlign(T a, T b)
+{
+    return (a + b - 1) / b * b;
+}
+
+template <typename T>
+T CeilDiv(T a, T b)
+{
+    if (b == 0) {
+        return a;
+    }
+    return (a + b - 1) / b;
+}
+
+namespace OpTiling {
+bool IsRegbaseSocVersion(const gert::TilingParseContext* context);
+
+bool IsRegbaseSocVersion(const gert::TilingContext* context);
+
+const gert::Shape& EnsureNotScalar(const gert::Shape& inShape);
+} // namespace OpTiling
+} // namespace Transformer
+} // namespace Ops

csrc/common/include/tiling_sink/device_op_impl_registry_impl.h

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file device_op_impl_registry_impl.h
+ * \brief
+ */
+
+#ifndef OP_TILING_DEVICE_OP_IMPL_REGISTRY_IMPL_H
+#define OP_TILING_DEVICE_OP_IMPL_REGISTRY_IMPL_H
+
+#include <string>
+#include <map>
+#include "register/device_op_impl_registry.h"
+
+namespace optiling {
+class DeviceOpImplRegistry {
+ public:
+  static DeviceOpImplRegistry& GetSingleton();
+  void RegisterSinkTiling(std::string &opType, SinkTilingFunc& func);
+  SinkTilingFunc GetSinkTilingFunc(std::string &opType);
+
+ private:
+  DeviceOpImplRegistry() = default;
+  ~DeviceOpImplRegistry() = default;
+
+ private:
+  std::map<std::string, SinkTilingFunc> sinkTilingFuncsMap_;
+};
+
+class DeviceOpImplRegisterImpl {
+ public:
+  DeviceOpImplRegisterImpl() = default;
+  ~DeviceOpImplRegisterImpl();
+  std::string& GetOpType();
+
+ private:
+  std::string opType_ = "";
+};
+}  // namespace optiling
+
+#endif

csrc/common/include/tiling_sink/tiling_aicpu_task.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ */
+
+/*!
+ * \file tiling_aicpu_task.h
+ * \brief
+ */
+
+#ifndef TILING_SINK_TILING_AICPU_TASK_H_
+#define TILING_SINK_TILING_AICPU_TASK_H_
+#include "exe_graph/runtime/tiling_context.h"
+
+namespace tilingsink {
+struct TilingAicpuTask {
+  gert::TilingContext *tilingContext;
+  const char *opType;
+  uint64_t notifyAddr;
+  uint64_t workspaceAddr;
+  uint64_t workspaceSize;
+};
+}  // namespace optiling
+
+#endif