init v0.23.0

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

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/CMakeLists.txt

@@ -0,0 +1,31 @@
+# -----------------------------------------------------------------------------------------------------------
+# 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.
+# -----------------------------------------------------------------------------------------------------------
+add_op_to_compiled_list()
+
+if (BUILD_OPEN_PROJECT)
+    target_sources(op_host_aclnnExc PRIVATE
+        grouped_matmul_swiglu_quant_v2_def.cpp
+    )
+endif()
+
+add_ops_compile_options(
+    OP_NAME GroupedMatmulSwigluQuantV2
+    OPTIONS
+        --cce-auto-sync=off
+        -Wno-deprecated-declarations
+)
+
+if (NOT BUILD_OPS_RTY_KERNEL)
+    add_modules_sources(OPTYPE grouped_matmul_swiglu_quant_v2 ACLNNTYPE aclnn_exclude)
+    target_include_directories(${OPHOST_NAME}_tiling_obj PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+endif()
+

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/grouped_matmul_swiglu_quant_v2_base_tiling.cpp

@@ -0,0 +1,507 @@
+/**
+ * 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 grouped_matmul_swiglu_quant_v2_base_tiling.cpp
+ * \brief
+ */
+#include "grouped_matmul_swiglu_quant_v2_base_tiling.h"
+#include "util/math_util.h"
+#include "err/ops_err.h"
+
+using namespace matmul_tiling;
+
+namespace optiling {
+namespace GroupedMatmulSwigluQuantV2Tiling {
+
+constexpr int64_t ND_WEIGHT_MULTI_TENSOR_DIM = 2;
+constexpr int64_t NZ_WEIGHT_MULTI_TENSOR_DIM = 4;
+constexpr float EFFECTIVE_TASK_RATIO = 0.95f;
+constexpr int32_t MIN_BASE_M = 16;
+
+template <typename T>
+static inline auto AlignUp(T a, T base) -> T
+{
+    if (base == 0) {
+        return 0;
+    }
+    return (a + base - 1) / base * base;
+}
+
+template <typename T1, typename T2>
+auto CeilDiv(T1 a, T2 b) -> T1
+{
+    if (b == 0) {
+        return 0;
+    }
+    return (a + b - 1) / b;
+}
+
+
+static inline uint32_t SixteenAlign(uint32_t a, bool up = false)
+{
+    if (up) {
+        a += 15U;
+    }
+    return a & ~15U;
+}
+
+int64_t GroupedMatmulSwigluQuantV2BaseTiling::CalMaxRowInUbA8W4(const uint64_t ubSize, const uint64_t n) const
+{
+    const uint64_t ALIGNMENT = 8;
+    const float WEIGHT_FACTOR = isA4W4_ ? 4.5f : 8.5f;
+    const uint64_t ALIGNMENT_TERM_FACTOR = 4;
+    const uint64_t LINEAR_TERM_FACTOR = 6;
+    const uint64_t CONSTANT_TERM = 64;
+    const int64_t MIN_ROW_THRESHOLD = 1;
+
+    // A8W4 表达式：8.5 * row * n + 4 * alignUp(row, 8) + 6n + 64 <= ubSize
+    // A4W4 表达式：4.5 * row * n + 4 * alignUp(row, 8) + 6n + 64 <= ubSize
+
+    // 忽略对齐项的初始估计
+    int64_t maxRowEstimate =
+        (ubSize - CONSTANT_TERM - LINEAR_TERM_FACTOR * n) / static_cast<int64_t>(WEIGHT_FACTOR * n);
+
+    // 考虑对齐影响
+    uint64_t alignedRow = (maxRowEstimate + ALIGNMENT - 1) / ALIGNMENT * ALIGNMENT;
+    uint64_t totalSize = static_cast<uint64_t>(WEIGHT_FACTOR * maxRowEstimate * n) +
+                         ALIGNMENT_TERM_FACTOR * alignedRow + LINEAR_TERM_FACTOR * n + CONSTANT_TERM;
+
+    // 如果超过UB大小，逐步减少row直到满足条件
+    while (totalSize > ubSize && maxRowEstimate > 0) {
+        maxRowEstimate--;
+        alignedRow = (maxRowEstimate + ALIGNMENT - 1) / ALIGNMENT * ALIGNMENT;
+        totalSize = static_cast<uint64_t>(WEIGHT_FACTOR * maxRowEstimate * n) + ALIGNMENT_TERM_FACTOR * alignedRow +
+                    LINEAR_TERM_FACTOR * n + CONSTANT_TERM;
+    }
+
+    if (maxRowEstimate < MIN_ROW_THRESHOLD) {
+        OP_LOGE(context_->GetNodeName(), "GMM_SWIGLU_QUANT TILING: No valid row found for n = %lu, ubSize = %lu\n", n,
+                ubSize);
+        return 0;
+    }
+    return maxRowEstimate;
+}
+
+int64_t GroupedMatmulSwigluQuantV2BaseTiling::CalMaxRowInUb(const uint64_t ubSize, const uint64_t n) const
+{
+    uint64_t tmpBufSize = (n / SWIGLU_REDUCE_FACTOR) * FP32_DTYPE_SIZE;
+    uint64_t perchannleBufSize = n * FP32_DTYPE_SIZE * DOUBLE_BUFFER;
+    uint64_t reduceMaxResBufSize = BLOCK_BYTE;
+    uint64_t reduceMaxTmpBufSize = BLOCK_BYTE;
+    const uint64_t CONSTANT_TERM = 64;
+    int64_t remainUbSize = ubSize - tmpBufSize - perchannleBufSize - reduceMaxResBufSize - reduceMaxTmpBufSize;
+    int64_t maxRowInUb =
+        remainUbSize / (n * INT32_DTYPE_SIZE + n / SWIGLU_REDUCE_FACTOR + FP32_DTYPE_SIZE) / DOUBLE_BUFFER;
+    int64_t curUb = DOUBLE_BUFFER * (maxRowInUb * (INT32_DTYPE_SIZE * n + n / SWIGLU_REDUCE_FACTOR) +
+                                     AlignUp(maxRowInUb, FP32_BLOCK_SIZE) * FP32_DTYPE_SIZE);
+    if (curUb > remainUbSize) {
+        // 64 : make sure ub does not excceed maxUbSize after align up to 8
+        maxRowInUb = (remainUbSize - CONSTANT_TERM) /
+                     (n * INT32_DTYPE_SIZE + n / SWIGLU_REDUCE_FACTOR + FP32_DTYPE_SIZE) / DOUBLE_BUFFER;
+    }
+    if (maxRowInUb < 1) {
+        // when n > (ubSize - 72) / 19 = 10330, maxRowInUb < 1
+        OP_LOGE(context_->GetNodeName(), "GMM_SWIGLU_QUANT TILING: n should not be greater than 10240, now is %lu\n",
+                n);
+    }
+    return maxRowInUb;
+}
+
+bool GroupedMatmulSwigluQuantV2BaseTiling::IsCapable()
+{
+    auto weightDesc = context_->GetInputDesc(WEIGHT_INDEX);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, weightDesc);
+    ge::DataType weightDType = weightDesc->GetDataType();
+    if (weightDType != ge::DataType::DT_INT4) {
+        return false;
+    }
+
+    auto wTensor = context_->GetDynamicInputTensor(WEIGHT_INDEX, 0);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, wTensor);
+    if (!(wTensor->GetStorageShape().GetDimNum() == ND_WEIGHT_DIM_LIMIT ||
+          wTensor->GetStorageShape().GetDimNum() == ND_WEIGHT_MULTI_TENSOR_DIM ||
+          wTensor->GetStorageShape().GetDimNum() == NZ_WEIGHT_DIM_LIMIT ||
+          wTensor->GetStorageShape().GetDimNum() == NZ_WEIGHT_MULTI_TENSOR_DIM)) {
+        return false;
+    }
+
+    return true;
+}
+
+ge::graphStatus GroupedMatmulSwigluQuantV2BaseTiling::ParseInputAndAttr()
+{
+    auto xDesc = context_->GetInputDesc(X_INDEX);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, xDesc);
+    auto weightDesc = context_->GetInputDesc(WEIGHT_INDEX);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, weightDesc);
+    auto wTensor = context_->GetDynamicInputTensor(WEIGHT_INDEX, 0);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, wTensor);
+    auto xTensor = context_->GetDynamicInputTensor(X_INDEX, 0);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, xTensor);
+    auto wScaleTensor = context_->GetDynamicInputTensor(WEIGHT_SCALE_INDEX, 0);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, wScaleTensor);
+    auto groupListTensor = context_->GetDynamicInputTensor(GROUPLIST_INDEX, 0);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, groupListTensor);
+
+    auto wDimNum = wTensor->GetStorageShape().GetDimNum();
+    if (wDimNum == ND_WEIGHT_DIM_LIMIT || wDimNum == NZ_WEIGHT_DIM_LIMIT) {
+        isSingleTensor_ = 1;
+    } else {
+        isSingleTensor_ = 0;
+    }
+
+    auto attr = context_->GetAttrs();
+    OP_CHECK_NULL_WITH_CONTEXT(context_, attr); // check attr is not null
+    const int64_t *dequantModePtr = attr->GetAttrPointer<int64_t>(ATTR_INDEX_DEQUANT_MODE);
+    auto dequantMode = dequantModePtr != nullptr ? *dequantModePtr : 0;
+    OP_CHECK_IF(!(dequantMode == 0 || dequantMode == 1),
+                OP_LOGE(context_->GetNodeName(), "dequantMode must be 0 or 1, but actual value is %ld.", dequantMode),
+                return ge::GRAPH_FAILED);
+
+    const auto swigluLimtPtr = attr->GetAttrPointer<double>(ATTR_INDEX_SWIGLU_LIMIT);
+    double swigluLimt_ = swigluLimtPtr != nullptr ? *swigluLimtPtr : 0.0f;
+    OP_CHECK_IF(!(swigluLimt_ >= 0.0),
+                OP_LOGE(context_->GetNodeName(), "swigluLimit must be non-negative, but actual value is %f.",
+                        swigluLimt_),
+                return ge::GRAPH_FAILED);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_swigluLimit(swigluLimt_);
+    const int64_t *groupListTypePtr = attr->GetAttrPointer<int64_t>(ATTR_INDEX_GROUPLIST_TYPE);
+    groupListType_ = groupListTypePtr != nullptr ? *groupListTypePtr : 0;
+    OP_CHECK_IF(
+        !(groupListType_ == 0 || groupListType_ == 1),
+        OP_LOGE(context_->GetNodeName(), "GroupListType must be 0 or 1, but actual value is %ld.", groupListType_),
+        return ge::GRAPH_FAILED);
+
+    ge::DataType xDType = xDesc->GetDataType();
+    ge::DataType weightDType = weightDesc->GetDataType();
+
+    isA8W4MSD_ = (xDType == ge::DataType::DT_INT8 && weightDType == ge::DataType::DT_INT4);
+    isA4W4_ = (xDType == ge::DataType::DT_INT4 && weightDType == ge::DataType::DT_INT4);
+    if (isA4W4_) {
+        auto smoothScaleTensor = context_->GetDynamicInputTensor(SMOOTH_SCALE_INDEX, 0);
+        if (smoothScaleTensor == nullptr) {
+            smoothScaleDimNum_ = 0;
+        } else {
+            smoothScaleDimNum_ = smoothScaleTensor->GetStorageShape().GetDimNum();
+        }
+    }
+
+    auto compileInfoPtr = context_->GetCompileInfo<GMMSwigluV2CompileInfo>();
+    OP_CHECK_IF(compileInfoPtr == nullptr, OP_LOGE(context_->GetNodeName(), "CompileInfo is nullptr"),
+                return ge::GRAPH_FAILED);
+
+    m_ = xTensor->GetStorageShape().GetDim(0);
+    k_ = xTensor->GetStorageShape().GetDim(1);
+    auto wScaleDimNum = wScaleTensor->GetStorageShape().GetDimNum();
+    isWeightTrans_ = false;
+    if (wTensor->GetStorageShape().GetDimNum() == NZ_WEIGHT_DIM_LIMIT || wTensor->GetStorageShape().GetDimNum() == NZ_WEIGHT_MULTI_TENSOR_DIM) {
+        isNz_ = true;
+    }
+    const auto tuningConfigPtr = attr->GetAttrPointer<gert::ContinuousVector>(ATTR_INDEX_TUNING_CONFIG);
+    tuningConfig_ = tuningConfigPtr != nullptr && tuningConfigPtr->GetSize() > 1?
+                    (reinterpret_cast<const int64_t*>(tuningConfigPtr->GetData()))[0] : 0;
+
+    if (isA4W4_) {
+        n_ = wScaleTensor->GetStorageShape().GetDim(wScaleDimNum - DIM_1);
+    } else {
+        if (wTensor->GetStorageShape().GetDimNum() == ND_WEIGHT_DIM_LIMIT) {
+            // ND SingleTensor [E, K, N]
+            n_ = wTensor->GetStorageShape().GetDim(DIM_2);
+        } else if (wTensor->GetStorageShape().GetDimNum() == NZ_WEIGHT_DIM_LIMIT) {
+            // NZ SingleTensor [E, N // 64, K // 16, 16, 64]
+            n_ = wTensor->GetStorageShape().GetDim(DIM_1) * wTensor->GetStorageShape().GetDim(DIM_4);
+        } else if (wTensor->GetStorageShape().GetDimNum() == ND_WEIGHT_MULTI_TENSOR_DIM) {
+            // ND MultiTensor [K, N]
+            n_ = wTensor->GetStorageShape().GetDim(DIM_1);
+        } else if (wTensor->GetStorageShape().GetDimNum() == NZ_WEIGHT_MULTI_TENSOR_DIM) {
+            // NZ MultiTensor [N // 64, K // 16, 16, 64]
+            n_ = wTensor->GetStorageShape().GetDim(DIM_0) * wTensor->GetStorageShape().GetDim(DIM_3);
+        }
+    }
+
+    isWeightTrans_ = *attr->GetAttrPointer<int64_t>(ATTR_INDEX_TRANSPOSE_WEIGHT);
+
+    if (dequantMode == 1) { // perGroup量化模式：单tensor场景[E, KGroupCount, N]，多tensor场景[KGroupCount, N]
+        quantGroupNum_ = wScaleTensor->GetStorageShape().GetDim(wScaleDimNum - DIM_2);
+    } else { // perChannel量化模式
+        quantGroupNum_ = 1;
+    }
+
+    groupNum_ = groupListTensor->GetStorageShape().GetDim(0);
+
+    if (isA8W4MSD_ || isA4W4_) {
+        maxProcessRowNum_ = CalMaxRowInUbA8W4(compileInfoPtr->ubSize_, n_);
+    } else {
+        maxProcessRowNum_ = CalMaxRowInUb(compileInfoPtr->ubSize_, n_);
+    }
+
+    blockDim_ = compileInfoPtr->aicNum_;
+    return ge::GRAPH_SUCCESS;
+}
+
+int32_t GroupedMatmulSwigluQuantV2BaseTiling::FindBestSingleN(const uint32_t &aicNum, int64_t baseM, int64_t baseN) const
+{
+    uint64_t quantGroupNum = quantGroupNum_;
+    if (n_ < baseN || tuningConfig_ <= 0 || !(quantGroupNum == 1)) {
+        return baseN;
+    }
+    int32_t mDim = CeilDiv(tuningConfig_, baseM);
+    int32_t nDim = CeilDiv(n_, baseN);
+    int32_t taskNum = mDim * nDim * static_cast<int32_t>(groupNum_);
+    int32_t taskNumPerCore = CeilDiv(taskNum, aicNum);
+    // 每个核只需要做1个基本块的时候，任务量太少，无需处理
+    if (taskNumPerCore <= 1) {
+        return baseN;
+    }
+    int32_t curNDim = 0;
+    int32_t curTaskNum = 0;
+    int32_t bestSingleN = baseN;
+    float ratio = 0;
+    for (uint32_t i = 1; i <= aicNum; ++i) {
+        if (isNz_) {
+            bestSingleN = CeilDiv(static_cast<int32_t>(n_), i);
+            if (bestSingleN != n_ && bestSingleN % baseN != 0) {
+                continue;
+            }
+        } else {
+            // 暂时只NZ格式开启动态分块
+            return baseN;
+        }
+        curNDim = CeilDiv(n_, bestSingleN);
+        curTaskNum = mDim * curNDim * static_cast<int32_t>(groupNum_);
+        ratio = static_cast<float>(curTaskNum) / AlignUp(static_cast<uint32_t>(curTaskNum), aicNum);
+        if (ratio >= EFFECTIVE_TASK_RATIO) {
+            return bestSingleN;
+        }
+    }
+    return baseN;
+}
+
+bool GroupedMatmulSwigluQuantV2BaseTiling::TryFullLoadA(int32_t baseM, int64_t baseN, int64_t baseK, uint64_t l1Size)
+{
+    // 暂时只支持A4W4
+    float sizeofweightDtype = 0.5f;
+    float sizeofxDtype = 0.5f;
+    auto matBl1Size = static_cast<int32_t>(tilingData_.mmTilingData.get_depthB1() * baseN * baseK * sizeofweightDtype);
+    auto remainL1Size = l1Size - matBl1Size - 8 * baseN;
+    int32_t newDepthA1 = CeilDiv(k_, baseK);
+    if (static_cast<int32_t>(newDepthA1 * baseM * baseK * sizeofxDtype) < static_cast<int32_t>(remainL1Size)) {
+        tilingData_.mmTilingData.set_stepKa(newDepthA1);
+        tilingData_.mmTilingData.set_depthA1(newDepthA1);
+        return true;
+    }
+    return false;
+}
+
+
+ge::graphStatus GroupedMatmulSwigluQuantV2BaseTiling::DynamicTilingSingleN(gert::TilingContext *context, const uint32_t &aicNum,
+                                                int64_t baseM, int64_t baseN, int64_t baseK)
+{
+    //get info
+    auto platformInfoPtr = context->GetPlatformInfo();
+    OP_CHECK_NULL_WITH_CONTEXT(context, platformInfoPtr);
+    auto ascendcPlatform = platform_ascendc::PlatformAscendC(platformInfoPtr);
+    uint64_t l1Size = 0;
+    ascendcPlatform.GetCoreMemSize(platform_ascendc::CoreMemType::L1, l1Size);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_singleN(0);
+
+    if (n_ < baseN || tuningConfig_ <= 0 || !isA4W4_) {
+        return ge::GRAPH_SUCCESS;
+    }
+    int32_t bestSingleN = FindBestSingleN(aicNum, baseM, baseN);
+    if (bestSingleN == baseN) { // 没找到更优的singleN
+        return ge::GRAPH_SUCCESS;
+    }
+    tilingData_.gmmSwigluQuantV2BaseParams.set_singleN(bestSingleN);
+    // 先不改看看baseM能否全载左矩阵
+    if (TryFullLoadA(baseM, baseN, baseK, l1Size)) {
+        return ge::GRAPH_SUCCESS;
+    }
+    // 可以尝试减小baseM来全载左矩阵
+    int32_t newBaseM = static_cast<int32_t>(SixteenAlign(tuningConfig_, true));
+    // 防止不均匀情况
+    newBaseM += MIN_BASE_M;
+    // 再看看能否全载左矩阵
+    if (newBaseM < baseM && TryFullLoadA(newBaseM, baseN, baseK, l1Size)) {
+        tilingData_.mmTilingData.set_baseM(newBaseM);
+        return ge::GRAPH_SUCCESS;
+    }
+    return ge::GRAPH_SUCCESS;
+}
+
+ge::graphStatus GroupedMatmulSwigluQuantV2BaseTiling::DoOpTiling()
+{
+    OP_LOGD(context_->GetNodeName(), "Begin Run GMM Swiglu Tiling .");
+
+    if (ParseInputAndAttr() != ge::GRAPH_SUCCESS) {
+        return ge::GRAPH_FAILED;
+    }
+
+    auto ascendcPlatform = platform_ascendc::PlatformAscendC(context_->GetPlatformInfo());
+    MatmulApiTiling tiling(ascendcPlatform);
+    tiling.SetAType(TPosition::GM, CubeFormat::ND, matmul_tiling::DataType::DT_INT4);
+    tiling.SetBType(TPosition::GM, CubeFormat::NZ, matmul_tiling::DataType::DT_INT4);
+    tiling.SetCType(TPosition::GM, CubeFormat::ND, matmul_tiling::DataType::DT_FLOAT16);
+    tiling.SetBias(false);
+    tiling.SetShape(A8W4_BASEM, A8W4_BASEN, k_);
+    tiling.SetFixSplit(A8W4_BASEM, A8W4_BASEN, A8W4_BASEK);
+    tiling.SetOrgShape(m_, n_, k_);
+    tiling.SetBufferSpace(-1, -1, -1);
+    OP_CHECK_IF(tiling.GetTiling(tilingData_.mmTilingData) == -1,
+                OPS_REPORT_VECTOR_INNER_ERR(context_->GetNodeName(),
+                                            "grouped_matmul_swiglu_quant_base_tiling, get tiling failed"),
+                return ge::GRAPH_FAILED);
+    if (isA8W4MSD_ || isA4W4_) {
+        tilingData_.mmTilingData.set_baseM(A8W4_BASEM);
+        tilingData_.mmTilingData.set_baseN(A8W4_BASEN);
+        tilingData_.mmTilingData.set_baseK(A8W4_BASEK);
+        tilingData_.mmTilingData.set_dbL0B(DOUBLE_BUFFER);
+        tilingData_.mmTilingData.set_stepKa(NUM_FOUR);
+        tilingData_.mmTilingData.set_stepKb(NUM_FOUR);
+        tilingData_.mmTilingData.set_depthA1(NUM_EIGHT);
+        tilingData_.mmTilingData.set_depthB1(NUM_EIGHT);
+        tilingData_.mmTilingData.set_stepM(1);
+        tilingData_.mmTilingData.set_stepN(1);
+
+    }
+
+    usrWorkspaceLimit_ = USER_WORKSPACE_LIMIT;
+    mLimit_ = 0;
+    if (isA8W4MSD_) {
+        mLimit_ =
+            ((usrWorkspaceLimit_ / DOUBLE_WORKSPACE_SPLIT) / (k_ * sizeof(int8_t) + DOUBLE_ROW * n_ * SIZE_OF_HALF_2));
+    } else if (isA4W4_) {
+        mLimit_ = ((usrWorkspaceLimit_ / DOUBLE_WORKSPACE_SPLIT) / (n_ * SIZE_OF_HALF_2));
+    } else {
+        mLimit_ = ((usrWorkspaceLimit_ / DOUBLE_WORKSPACE_SPLIT) / INT32_DTYPE_SIZE) / n_;
+    }
+
+    OP_CHECK_IF(mLimit_ <= 0,
+                OPS_REPORT_VECTOR_INNER_ERR(context_->GetNodeName(), "mLimit_ is %ld must over then 0.", mLimit_),
+                return ge::GRAPH_FAILED);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_mLimit(mLimit_);
+
+    DynamicTilingSingleN(context_, blockDim_, A8W4_BASEM, A8W4_BASEN, A8W4_BASEK);
+
+    if (isA8W4MSD_) {
+        int workSpaceMTemp = mLimit_ * DOUBLE_WORKSPACE_SPLIT;
+        tilingData_.gmmSwigluQuantV2BaseParams.set_workSpaceOffset1(workSpaceMTemp * k_ * sizeof(int8_t));
+        tilingData_.gmmSwigluQuantV2BaseParams.set_workSpaceOffset2(DOUBLE_ROW * workSpaceMTemp * n_ * SIZE_OF_HALF_2);
+        workspaceSize_ =
+            SYS_WORKSPACE_SIZE +                     // 系统预留16MB
+            (workSpaceMTemp * k_ * sizeof(int8_t)) + // 第一阶段 预处理左矩阵 (mLimit_, K) * int8 * 2(double WorkSpace)
+            (DOUBLE_ROW * workSpaceMTemp * n_ *
+             SIZE_OF_HALF_2); // 第二阶段 矩阵乘结果 (2 * mLimit_, N) * fp16 * 2(double WorkSpace)
+    } else if (isA4W4_) {
+        int workSpaceMTemp = mLimit_ * DOUBLE_WORKSPACE_SPLIT;
+        tilingData_.gmmSwigluQuantV2BaseParams.set_workSpaceOffset1(mLimit_ * n_ * SIZE_OF_HALF_2);
+        tilingData_.gmmSwigluQuantV2BaseParams.set_workSpaceOffset2(0);
+        workspaceSize_ = SYS_WORKSPACE_SIZE + (workSpaceMTemp * n_ * SIZE_OF_HALF_2);
+    } else {
+        int workSpaceMTemp = (mLimit_ * DOUBLE_WORKSPACE_SPLIT > m_ ? m_ : mLimit_ * DOUBLE_WORKSPACE_SPLIT);
+        tilingData_.gmmSwigluQuantV2BaseParams.set_workSpaceOffset1(0);
+        tilingData_.gmmSwigluQuantV2BaseParams.set_workSpaceOffset2(0);
+        workspaceSize_ = SYS_WORKSPACE_SIZE + (workSpaceMTemp * n_ * sizeof(int32_t));
+    }
+
+    isSplitWorkSpace_ = m_ > mLimit_ * DOUBLE_WORKSPACE_SPLIT;
+    SetTilingKeyAndScheMode();
+    FillTilingData();
+    PrintTilingData();
+    OP_LOGD(context_->GetNodeName(), "End Run GMM Swiglu Tiling.");
+    return ge::GRAPH_SUCCESS;
+}
+
+uint64_t GroupedMatmulSwigluQuantV2BaseTiling::GetTilingKey() const
+{
+    return tilingKey_;
+}
+
+void GroupedMatmulSwigluQuantV2BaseTiling::FillTilingData()
+{
+    tilingData_.gmmSwigluQuantV2BaseParams.set_groupNum(groupNum_);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_coreNum(blockDim_);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_K(k_);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_N(n_);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_M(m_);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_baseM(A8W4_BASEM);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_baseN(A8W4_BASEN);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_quantGroupNum(quantGroupNum_);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_isSingleTensor(isSingleTensor_);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_groupListType(groupListType_);
+    tilingData_.gmmSwigluQuantV2BaseParams.set_smoothScaleDimNum(smoothScaleDimNum_);
+    tilingData_.gmmSwigluQuantV2.set_maxProcessRowNum(maxProcessRowNum_);
+    tilingData_.gmmSwigluQuantV2.set_groupListLen(groupNum_);
+    tilingData_.gmmSwigluQuantV2.set_tokenLen(n_);
+}
+
+void GroupedMatmulSwigluQuantV2BaseTiling::PrintTilingData()
+{
+    OP_LOGD(context_->GetNodeName(), "grouped_matmul_swiglu_quant_base_tiling.");
+    OP_LOGD(context_->GetNodeName(), "groupNum:      %ld", tilingData_.gmmSwigluQuantV2BaseParams.get_groupNum());
+    OP_LOGD(context_->GetNodeName(), "coreNum:       %ld", tilingData_.gmmSwigluQuantV2BaseParams.get_coreNum());
+    OP_LOGD(context_->GetNodeName(), "M:             %ld", tilingData_.gmmSwigluQuantV2BaseParams.get_M());
+    OP_LOGD(context_->GetNodeName(), "K:             %ld", tilingData_.gmmSwigluQuantV2BaseParams.get_K());
+    OP_LOGD(context_->GetNodeName(), "N:             %ld", tilingData_.gmmSwigluQuantV2BaseParams.get_N());
+    OP_LOGD(context_->GetNodeName(), "baseM:         %ld", tilingData_.gmmSwigluQuantV2BaseParams.get_baseM());
+    OP_LOGD(context_->GetNodeName(), "baseN:         %ld", tilingData_.gmmSwigluQuantV2BaseParams.get_baseN());
+    OP_LOGD(context_->GetNodeName(), "mLimit:        %ld", tilingData_.gmmSwigluQuantV2BaseParams.get_mLimit());
+    OP_LOGD(context_->GetNodeName(), "quantGroupNum: %ld", tilingData_.gmmSwigluQuantV2BaseParams.get_quantGroupNum());
+    OP_LOGD(context_->GetNodeName(), "isSingleTensor:%ld", tilingData_.gmmSwigluQuantV2BaseParams.get_isSingleTensor());
+    OP_LOGD(context_->GetNodeName(), "groupListType: %ld", tilingData_.gmmSwigluQuantV2BaseParams.get_groupListType());
+    OP_LOGD(context_->GetNodeName(), "get_swigluLimit: %ld", tilingData_.gmmSwigluQuantV2BaseParams.get_swigluLimit());
+    OP_LOGD(context_->GetNodeName(), "smoothScaleDimNum: %ld",
+            tilingData_.gmmSwigluQuantV2BaseParams.get_smoothScaleDimNum());
+    OP_LOGD(context_->GetNodeName(), "maxProcessRowNum:      %ld", tilingData_.gmmSwigluQuantV2.get_maxProcessRowNum());
+    OP_LOGD(context_->GetNodeName(), "groupListLen:          %ld", tilingData_.gmmSwigluQuantV2.get_groupListLen());
+    OP_LOGD(context_->GetNodeName(), "tokenLen:              %ld", tilingData_.gmmSwigluQuantV2.get_tokenLen());
+    OP_LOGD(context_->GetNodeName(), "USER_WORKSPACE_LIMIT:  %ld", usrWorkspaceLimit_);
+    OP_LOGD(context_->GetNodeName(), "workspaceSizes:        %lu", workspaceSize_);
+    OP_LOGD(context_->GetNodeName(), "isSplitWorkSpace:      %s", isSplitWorkSpace_ ? "true" : "false");
+}
+
+void GroupedMatmulSwigluQuantV2BaseTiling::SetTilingKeyAndScheMode()
+{
+    if (isA8W4MSD_) { // A8W4 MSD tiling_key
+        tilingKey_ = A8W4_MSD_TILING_KEY_MODE;
+        context_->SetScheduleMode(BATCH_MODE_SCHEDULE);
+    } else if (isA4W4_ && !isWeightTrans_) {
+        tilingKey_ = A4W4_WEIGHT_NOTRANS_TILING_KEY_MODE;
+        context_->SetScheduleMode(BATCH_MODE_SCHEDULE);
+    } else if (isA4W4_ && isWeightTrans_) {
+        tilingKey_ = A4W4_WEIGHT_TRANS_TILING_KEY_MODE;
+        context_->SetScheduleMode(BATCH_MODE_SCHEDULE);
+    } else if (isSplitWorkSpace_) {
+        tilingKey_ = SPLITWORKSPACE_TILING_KEY_MODE;
+        context_->SetScheduleMode(BATCH_MODE_SCHEDULE);
+    } else {
+        tilingKey_ = COMMON_TILING_KEY_MODE;
+        context_->SetScheduleMode(BATCH_MODE_SCHEDULE);
+    }
+}
+
+ge::graphStatus GroupedMatmulSwigluQuantV2BaseTiling::PostTiling()
+{
+    OP_CHECK_NULL_WITH_CONTEXT(context_, context_->GetRawTilingData());
+    tilingData_.SaveToBuffer(context_->GetRawTilingData()->GetData(), context_->GetRawTilingData()->GetCapacity());
+    context_->GetRawTilingData()->SetDataSize(tilingData_.GetDataSize());
+    context_->SetBlockDim(blockDim_);
+
+    size_t *workspaces = context_->GetWorkspaceSizes(1); // set workspace
+    OP_CHECK_IF(workspaces == nullptr, OPS_REPORT_CUBE_INNER_ERR(context_->GetNodeName(), "workspaces is null"),
+                return ge::GRAPH_FAILED);
+    workspaces[0] = workspaceSize_;
+
+    return ge::GRAPH_SUCCESS;
+}
+
+} // namespace GroupedMatmulSwigluQuantV2Tiling
+} // namespace optiling

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/grouped_matmul_swiglu_quant_v2_base_tiling.h

@@ -0,0 +1,77 @@
+/**
+ * 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 grouped_matmul_swiglu_quant_v2_base_tiling.h
+ * \brief
+ */
+#ifndef __OP_HOST_OP_TILING_GROUPED_MATMUL_SWIGLU_QUANT_V2_BASE_TILING_H__
+#define __OP_HOST_OP_TILING_GROUPED_MATMUL_SWIGLU_QUANT_V2_BASE_TILING_H__
+
+#include "grouped_matmul_swiglu_quant_v2_tiling.h"
+#include "tiling_base/tiling_base.h"
+#include "err/ops_err.h"
+
+namespace optiling {
+namespace GroupedMatmulSwigluQuantV2Tiling {
+
+class GroupedMatmulSwigluQuantV2BaseTiling : public GroupedMatmulSwigluQuantV2Tiling {
+public:
+    explicit GroupedMatmulSwigluQuantV2BaseTiling(gert::TilingContext* context) : GroupedMatmulSwigluQuantV2Tiling(context) {};
+
+    ~GroupedMatmulSwigluQuantV2BaseTiling() override = default;
+
+protected:
+    bool IsCapable() override;
+
+    ge::graphStatus DoOpTiling() override;
+
+    uint64_t GetTilingKey() const override;
+
+    ge::graphStatus PostTiling() override;
+
+    void FillTilingData() override;
+    void PrintTilingData() override;
+    void SetTilingKeyAndScheMode(void);
+    ge::graphStatus ParseInputAndAttr();
+    int64_t CalMaxRowInUbA8W4(const uint64_t ubSize, const uint64_t n) const;
+    int64_t CalMaxRowInUb(const uint64_t ubSize, const uint64_t n) const;
+    int32_t FindBestSingleN(const uint32_t &aicNum, int64_t baseM, int64_t baseN) const;
+    bool TryFullLoadA(int32_t baseM, int64_t baseN, int64_t baseK, uint64_t l1Size);
+    ge::graphStatus DynamicTilingSingleN(gert::TilingContext *context, const uint32_t &aicNum,
+                    int64_t baseM, int64_t baseN, int64_t baseK);
+
+private:
+    GMMSwigluQuantV2TilingData tilingData_;
+    int64_t k_ = 0;
+    int64_t m_ = 0;
+    int64_t n_ = 0;
+    int64_t quantGroupNum_ = 0;
+    int64_t mLimit_ = 0;
+    int64_t blockDim_ = 0;
+    int64_t maxProcessRowNum_ = 0;
+    int64_t groupNum_ = 0;
+    int64_t isSingleTensor_ = 1;
+    int64_t groupListType_ = 0;
+    int64_t smoothScaleDimNum_ = 0;
+    int64_t usrWorkspaceLimit_ = 0;
+    uint64_t workspaceSize_ = 0;
+    int64_t tuningConfig_ = 0;
+    float swigluLimtPtr_ = 0.0f;
+    bool isA8W4MSD_ = false;
+    bool isA4W4_ = false;
+    bool isNz_ = false;
+    bool isWeightTrans_ = false;
+    bool isSplitWorkSpace_ = false;
+};
+
+}
+}
+#endif // __OP_HOST_OP_TILING_GROUPED_MATMUL_SWIGLU_QUANT_V2_BASE_TILING_H__

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/grouped_matmul_swiglu_quant_v2_def.cpp

@@ -0,0 +1,261 @@
+/**
+ * Copyright (c) 2026 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 grouped_matmul_swiglu_quant_v2_def.cpp
+ * \brief
+ */
+
+#include "register/op_def_registry.h"
+
+namespace ops {
+class GroupedMatmulSwigluQuantV2 : public OpDef {
+public:
+    explicit GroupedMatmulSwigluQuantV2(const char *name) : OpDef(name)
+    {
+        this->Input("x")
+            .ParamType(REQUIRED)
+            .DataType({ge::DT_INT8, ge::DT_INT8, ge::DT_INT8, ge::DT_INT8, ge::DT_INT8, ge::DT_INT4, ge::DT_INT4})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND});
+        this->Input("x_scale")
+            .ParamType(REQUIRED)
+            .DataType({ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND});
+        this->Input("group_list")
+            .ParamType(REQUIRED)
+            .DataType({ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND});
+        this->Input("weight")
+            .ParamType(DYNAMIC)
+            .DataType({ge::DT_INT8, ge::DT_INT8, ge::DT_INT8, ge::DT_INT4, ge::DT_INT4, ge::DT_INT4, ge::DT_INT4})
+            .Format({ge::FORMAT_FRACTAL_NZ, ge::FORMAT_FRACTAL_NZ, ge::FORMAT_FRACTAL_NZ, ge::FORMAT_ND,
+                     ge::FORMAT_FRACTAL_NZ, ge::FORMAT_FRACTAL_NZ, ge::FORMAT_ND});
+        this->Input("weight_scale")
+            .ParamType(DYNAMIC)
+            .DataType({ge::DT_FLOAT, ge::DT_BF16, ge::DT_FLOAT16, ge::DT_UINT64, ge::DT_UINT64, ge::DT_UINT64, ge::DT_UINT64})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND});
+        this->Input("weight_assist_matrix")
+            .ParamType(DYNAMIC)
+            .DataType({ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND});
+        this->Input("bias")
+            .ParamType(OPTIONAL)
+            .DataType({ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND});
+        this->Input("smooth_scale")
+            .ParamType(OPTIONAL)
+            .DataType({ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND});
+
+        this->Output("y")
+            .ParamType(REQUIRED)
+            .DataType({ge::DT_INT8, ge::DT_INT8, ge::DT_INT8, ge::DT_INT8, ge::DT_INT8, ge::DT_INT8, ge::DT_INT8})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND});
+        this->Output("y_scale")
+            .ParamType(REQUIRED)
+            .DataType({ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND});
+
+        this->Attr("dequant_mode").AttrType(OPTIONAL).Int(0);
+        this->Attr("dequant_dtype").AttrType(OPTIONAL).Int(0);
+        this->Attr("quant_mode").AttrType(OPTIONAL).Int(0);
+        this->Attr("quant_dtype").AttrType(OPTIONAL).Int(0);
+        this->Attr("transpose_weight").AttrType(OPTIONAL).Bool(0);
+        this->Attr("group_list_type").AttrType(OPTIONAL).Int(0);
+        this->Attr("tuning_config").AttrType(OPTIONAL).ListInt({0});
+        this->Attr("swiglu_limit").AttrType(OPTIONAL).Float(0.0f);
+
+        OpAICoreConfig aicore_config;
+        aicore_config.DynamicCompileStaticFlag(true)
+            .DynamicFormatFlag(true)
+            .DynamicRankSupportFlag(true)
+            .DynamicShapeSupportFlag(true)
+            .NeedCheckSupportFlag(false)
+            .PrecisionReduceFlag(true);
+
+        this->AICore().AddConfig("ascend910b", aicore_config);
+        this->AICore().AddConfig("ascend910_93", aicore_config);
+
+        OpAICoreConfig config950;
+        config950.Input("x")
+            .ParamType(REQUIRED)
+            .DataType({ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN,
+                       ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN,
+                       ge::DT_FLOAT4_E2M1,
+                       ge::DT_FLOAT4_E2M1,
+                       ge::DT_FLOAT4_E2M1,
+                       ge::DT_INT8,          ge::DT_INT8,          ge::DT_INT8,          ge::DT_HIFLOAT8,
+                       ge::DT_HIFLOAT8,      ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN,
+                       ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E5M2,
+                       ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN,
+                       ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E5M2,
+                       ge::DT_FLOAT8_E5M2})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND});
+        config950.Input("x_scale")
+            .ParamType(REQUIRED)
+            .DataType(
+                {ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0,
+                 ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0,
+                 ge::DT_FLOAT8_E8M0, ge::DT_FLOAT,
+                 ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,
+                 ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,
+                 ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,
+                 ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND});
+        config950.Input("group_list")
+            .ParamType(REQUIRED)
+            .DataType({ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64,
+                       ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64,
+                       ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64,
+                       ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64,
+                       ge::DT_INT64, ge::DT_INT64, ge::DT_INT64, ge::DT_INT64})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND});
+        config950.Input("weight")
+            .ParamType(DYNAMIC)
+            .DataType({ge::DT_FLOAT8_E5M2, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,
+                       ge::DT_FLOAT8_E5M2, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,
+                       ge::DT_FLOAT4_E2M1,
+                       ge::DT_FLOAT4_E2M1,
+                       ge::DT_FLOAT4_E2M1,
+                       ge::DT_INT8,        ge::DT_INT8,          ge::DT_INT8,          ge::DT_HIFLOAT8,
+                       ge::DT_HIFLOAT8,    ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,
+                       ge::DT_FLOAT8_E5M2, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,
+                       ge::DT_FLOAT8_E5M2, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,
+                       ge::DT_FLOAT8_E5M2, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,
+                       ge::DT_FLOAT8_E5M2})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND});
+        config950.Input("weight_scale")
+            .ParamType(DYNAMIC)
+            .DataType(
+                {ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0,
+                 ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0,
+                 ge::DT_FLOAT8_E8M0, ge::DT_BF16,
+                 ge::DT_FLOAT,       ge::DT_FLOAT16,     ge::DT_BF16,        ge::DT_FLOAT,       ge::DT_BF16,
+                 ge::DT_BF16,        ge::DT_BF16,        ge::DT_BF16,        ge::DT_BF16,        ge::DT_BF16,
+                 ge::DT_BF16,        ge::DT_BF16,        ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,
+                 ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT})
+            .Format({
+                ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND});
+        config950.Input("weight_assist_matrix")
+            .ParamType(DYNAMIC)
+            .DataType({ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND});
+        config950.Input("bias")
+            .ParamType(OPTIONAL)
+            .DataType({ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND});
+        config950.Input("smooth_scale")
+            .ParamType(OPTIONAL)
+            .DataType({ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT,
+                       ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT, ge::DT_FLOAT})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND});
+
+        config950.Output("y")
+            .ParamType(REQUIRED)
+            .DataType({ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E5M2,
+                       ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E4M3FN,
+                       ge::DT_FLOAT8_E5M2,
+                       ge::DT_FLOAT8_E4M3FN,
+                       ge::DT_FLOAT4_E2M1,
+                       ge::DT_INT8,          ge::DT_INT8,          ge::DT_INT8,          ge::DT_HIFLOAT8,
+                       ge::DT_HIFLOAT8,      ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN,
+                       ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN,
+                       ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN,
+                       ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN, ge::DT_FLOAT8_E5M2,   ge::DT_FLOAT8_E4M3FN,
+                       ge::DT_FLOAT8_E5M2})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND});
+        config950.Output("y_scale")
+            .ParamType(REQUIRED)
+            .DataType(
+                {ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0,
+                 ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0, ge::DT_FLOAT8_E8M0,
+                 ge::DT_FLOAT8_E8M0, ge::DT_FLOAT,
+                 ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,
+                 ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,
+                 ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,
+                 ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT,       ge::DT_FLOAT})
+            .Format({ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND, ge::FORMAT_ND,
+                     ge::FORMAT_ND, ge::FORMAT_ND});
+
+        config950.DynamicCompileStaticFlag(true)
+            .DynamicFormatFlag(true)
+            .DynamicRankSupportFlag(true)
+            .DynamicShapeSupportFlag(true)
+            .NeedCheckSupportFlag(false)
+            .PrecisionReduceFlag(true)
+            .ExtendCfgInfo("prebuildPattern.value", "Opaque")
+            .ExtendCfgInfo("coreType.value", "AiCore")
+            .ExtendCfgInfo("aclnnSupport.value", "support_aclnn")
+            .ExtendCfgInfo("opFile.value","grouped_matmul_swiglu_quant_v2_apt");
+        this->AICore().AddConfig("ascend950", config950);
+    }
+};
+
+OP_ADD(GroupedMatmulSwigluQuantV2);
+} // namespace ops

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/grouped_matmul_swiglu_quant_v2_fusion_tiling.cpp

@@ -0,0 +1,204 @@
+/**
+ * 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 grouped_matmul_swiglu_quant_v2_fusion_tiling.cpp
+ * \brief
+ */
+#include "grouped_matmul_swiglu_quant_v2_fusion_tiling.h"
+#include "util/math_util.h"
+#include "err/ops_err.h"
+
+namespace optiling {
+namespace GroupedMatmulSwigluQuantV2Tiling {
+
+constexpr int64_t BASE_M = 128;
+constexpr int64_t BASE_K = 128;
+constexpr int64_t BASE_N = 256;
+constexpr int64_t UB_Y_FACTOR = 2;
+constexpr int64_t EXTEND_WORKSPACE_SIZE = (20 * 1024 * 1024);
+constexpr int64_t NZ_WEIGHT_SINGLE_TENSOR_DIM = 5;   // single: [E, N/32, K/16, 16, 32]
+constexpr int64_t NZ_WEIGHT_MULTI_TENSOR_DIM = 4;    // multi: each [N/32, K/16, 16, 32]
+constexpr int64_t MIN_UB_FACTOR_DIM_X_N = 4600;
+constexpr int64_t MID_UB_FACTOR_DIM_X_N = 8192;
+
+using namespace matmul_tiling;
+
+bool GroupedMatmulSwigluQuantV2FusionTiling::IsCapable()
+{
+    auto weightDesc = context_->GetInputDesc(WEIGHT_INDEX);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, weightDesc);
+    ge::DataType weightDType = weightDesc->GetDataType();
+    if (weightDType != ge::DataType::DT_INT8) {
+        return false;
+    }
+
+    auto wTensor = context_->GetDynamicInputTensor(WEIGHT_INDEX, 0);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, wTensor);
+    if (!(wTensor->GetStorageShape().GetDimNum() == NZ_WEIGHT_DIM_LIMIT ||
+          wTensor->GetStorageShape().GetDimNum() == NZ_WEIGHT_MULTI_TENSOR_DIM)) {
+        return false;
+    }
+    return true;
+}
+
+ge::graphStatus GroupedMatmulSwigluQuantV2FusionTiling::ParseInputAndAttr()
+{
+    auto xTensor = context_->GetDynamicInputTensor(X_INDEX, 0);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, xTensor);
+    auto wTensor = context_->GetDynamicInputTensor(WEIGHT_INDEX, 0);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, wTensor);
+    auto groupListTensor = context_->GetDynamicInputTensor(GROUPLIST_INDEX, 0);
+    OP_CHECK_NULL_WITH_CONTEXT(context_, groupListTensor);
+    groupNum_ = groupListTensor->GetStorageShape().GetDim(0);
+    auto wDimNum = wTensor->GetStorageShape().GetDimNum();
+    if (wDimNum == NZ_WEIGHT_DIM_LIMIT) {
+        isSingleTensor_ = 1;
+    } else {
+        isSingleTensor_ = 0;  // multi tensor: 4D per weight [N/32, K/16, 16, 32]
+    }
+    auto attr = context_->GetAttrs();
+    OP_CHECK_NULL_WITH_CONTEXT(context_, attr); // check attr is not null
+    const int64_t *groupListTypePtr = attr->GetAttrPointer<int64_t>(ATTR_INDEX_GROUPLIST_TYPE);
+    groupListType_ = groupListTypePtr != nullptr ? *groupListTypePtr : 0;
+    OP_CHECK_IF(!(groupListType_ == 0 || groupListType_ == 1),
+        OP_LOGE(context_->GetNodeName(), "GroupListType must be 0 or 1, but actual value is %ld.", groupListType_),
+        return ge::GRAPH_FAILED);
+
+    const auto swigluLimtPtr = attr->GetAttrPointer<double>(ATTR_INDEX_SWIGLU_LIMIT);
+    double swigluLimt_ = swigluLimtPtr != nullptr ? *swigluLimtPtr : 0.0f;
+    OP_CHECK_IF(!(swigluLimt_ >= 0.0),
+        OP_LOGE(context_->GetNodeName(), "swigluLimit must be non-negative, but actual value is %f.",
+                swigluLimt_),
+        return ge::GRAPH_FAILED);
+    tilingData_.set_swigluLimit(swigluLimt_);
+    m_ = xTensor->GetStorageShape().GetDim(0);
+    k_ = xTensor->GetStorageShape().GetDim(1);
+    if (wDimNum == NZ_WEIGHT_DIM_LIMIT) {
+        n_ = wTensor->GetStorageShape().GetDim(DIM_1) * wTensor->GetStorageShape().GetDim(DIM_4);
+    } else {
+        // 4D multi tensor: [N/32, K/16, 16, 32] -> N = dim0 * dim3
+        n_ = wTensor->GetStorageShape().GetDim(0) * wTensor->GetStorageShape().GetDim(3);
+    }
+    if (n_ < MIN_UB_FACTOR_DIM_X_N) {
+        ubFactorDimx_ = 0x4;
+    } else if (n_ >= MIN_UB_FACTOR_DIM_X_N && n_ < MID_UB_FACTOR_DIM_X_N) {
+        ubFactorDimx_ = 0x2;
+    } else {
+        ubFactorDimx_ = 1;
+    }
+
+    auto platformInfo = context_->GetPlatformInfo();
+    if (platformInfo == nullptr) {
+        auto compileInfoPtr = context_->GetCompileInfo<GMMSwigluV2CompileInfo>();
+        OP_CHECK_IF(compileInfoPtr == nullptr, OP_LOGE(context_->GetNodeName(), "CompileInfo is nullptr"),
+                    return ge::GRAPH_FAILED);
+        aicCoreNum_ = compileInfoPtr->aicNum_;
+        aivCoreNum_ = compileInfoPtr->aivNum_;
+    } else {
+        auto ascendcPlatform = platform_ascendc::PlatformAscendC(platformInfo);
+        aicCoreNum_ = ascendcPlatform.GetCoreNumAic();
+        aivCoreNum_ = ascendcPlatform.GetCoreNumAiv();
+    }
+
+    return ge::GRAPH_SUCCESS;
+}
+
+ge::graphStatus GroupedMatmulSwigluQuantV2FusionTiling::DoOpTiling()
+{
+    OP_LOGD(context_->GetNodeName(), "Begin Run GMM Swiglu Fusion Tiling.");
+
+    if (ParseInputAndAttr() != ge::GRAPH_SUCCESS) {
+        return ge::GRAPH_FAILED;
+    }
+    auto ascendcPlatform = platform_ascendc::PlatformAscendC(context_->GetPlatformInfo());
+    MatmulApiTiling tiling(ascendcPlatform);
+    tiling.SetAType(TPosition::GM, CubeFormat::ND, matmul_tiling::DataType::DT_INT8);
+    tiling.SetBType(TPosition::GM, CubeFormat::NZ, matmul_tiling::DataType::DT_INT8);
+    tiling.SetCType(TPosition::GM, CubeFormat::ND, matmul_tiling::DataType::DT_INT32);
+    tiling.SetBias(false);
+    tiling.SetShape(m_, BASE_N, k_);
+    tiling.SetOrgShape(m_, n_, k_);
+    tiling.SetBufferSpace(-1, -1, -1);
+    OP_CHECK_IF(
+        tiling.GetTiling(tilingData_.matmulTiling) == -1,
+        OPS_REPORT_VECTOR_INNER_ERR(context_->GetNodeName(), "grouped_matmul_swiglu_quant_tiling, get tiling failed"),
+        return ge::GRAPH_FAILED);
+
+    workspaceSize_ = static_cast<int64_t>(m_) * static_cast<int64_t>(n_) * sizeof(int32_t) + EXTEND_WORKSPACE_SIZE;
+    tilingKey_ = A8W8_FUSION_KEY_MODE;
+    FillTilingData();
+    PrintTilingData();
+    return ge::GRAPH_SUCCESS;
+}
+
+uint64_t GroupedMatmulSwigluQuantV2FusionTiling::GetTilingKey() const
+{
+    return tilingKey_;
+}
+
+void GroupedMatmulSwigluQuantV2FusionTiling::PrintTilingData()
+{
+    OP_LOGD(context_->GetNodeName(), "cubeBlockDim: %d", tilingData_.get_cubeBlockDim());
+    OP_LOGD(context_->GetNodeName(), "vectorBlockDim: %d", tilingData_.get_vectorBlockDim());
+    OP_LOGD(context_->GetNodeName(), "K: %d", tilingData_.get_K());
+    OP_LOGD(context_->GetNodeName(), "M: %d", tilingData_.get_M());
+    OP_LOGD(context_->GetNodeName(), "N: %d", tilingData_.get_N());
+    OP_LOGD(context_->GetNodeName(), "ubFactorDimx: %d", tilingData_.get_ubFactorDimx());
+    OP_LOGD(context_->GetNodeName(), "ubFactorDimy: %d", tilingData_.get_ubFactorDimy());
+    OP_LOGD(context_->GetNodeName(), "groupListType: %ld", tilingData_.get_groupListType());
+    OP_LOGD(context_->GetNodeName(), "isSingleTensor: %d", tilingData_.get_isSingleTensor());
+}
+
+void GroupedMatmulSwigluQuantV2FusionTiling::FillTilingData()
+{
+    tilingData_.set_cubeBlockDim(aicCoreNum_);
+    tilingData_.set_vectorBlockDim(aivCoreNum_);
+    tilingData_.set_groupNum(groupNum_);
+    tilingData_.set_K(k_);
+    tilingData_.set_N(n_);
+    tilingData_.set_M(m_);
+    tilingData_.set_ubFactorDimx(ubFactorDimx_);
+    tilingData_.set_ubFactorDimy(n_ / UB_Y_FACTOR);
+    tilingData_.set_groupListType(groupListType_);
+    tilingData_.set_isSingleTensor(isSingleTensor_);
+
+    blockDim_ = aicCoreNum_;
+    tilingData_.matmulTiling.set_usedCoreNum(aicCoreNum_);
+    tilingData_.matmulTiling.set_shareMode(0);
+    tilingData_.matmulTiling.set_dbL0C(1);
+    tilingData_.matmulTiling.set_baseM(BASE_M);
+    tilingData_.matmulTiling.set_baseN(BASE_N);
+    tilingData_.matmulTiling.set_baseK(BASE_K);
+    tilingData_.matmulTiling.set_stepKa(0x4);  // 4: L1中左矩阵单次搬运基于baseK的4倍数据
+    tilingData_.matmulTiling.set_stepKb(0x4);  // 4: L1中右矩阵单次搬运基于baseK的4倍数据
+    tilingData_.matmulTiling.set_depthA1(0x8);  // 8: stepKa的两倍，开启double buffer
+    tilingData_.matmulTiling.set_depthB1(0x8);  // 8: stepKb的两倍，开启double buffer
+    tilingData_.matmulTiling.set_stepM(1);
+    tilingData_.matmulTiling.set_stepN(1);
+}
+
+ge::graphStatus GroupedMatmulSwigluQuantV2FusionTiling::PostTiling()
+{
+    OP_CHECK_NULL_WITH_CONTEXT(context_, context_->GetRawTilingData());
+    tilingData_.SaveToBuffer(context_->GetRawTilingData()->GetData(), context_->GetRawTilingData()->GetCapacity());
+    context_->SetBlockDim(blockDim_);
+    context_->GetRawTilingData()->SetDataSize(tilingData_.GetDataSize());
+
+    size_t *workspaces = context_->GetWorkspaceSizes(1); // set workspace
+    OP_CHECK_IF(workspaces == nullptr,
+                OPS_REPORT_CUBE_INNER_ERR(context_->GetNodeName(), "fusion tiling workspaces is null"),
+                return ge::GRAPH_FAILED);
+    workspaces[0] = workspaceSize_;
+
+    return ge::GRAPH_SUCCESS;
+}
+} // namespace GroupedMatmulSwigluQuantV2Tiling
+} // namespace optiling

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/grouped_matmul_swiglu_quant_v2_fusion_tiling.h

@@ -0,0 +1,59 @@
+/**
+ * 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 grouped_matmul_swiglu_quant_v2_fusion_tiling.h
+ * \brief
+ */
+#ifndef __OP_HOST_OP_TILING_GROUPED_MATMUL_SWIGLU_QUANT_V2_FUSION_TILING_H__
+#define __OP_HOST_OP_TILING_GROUPED_MATMUL_SWIGLU_QUANT_V2_FUSION_TILING_H__
+
+#include "grouped_matmul_swiglu_quant_v2_tiling.h"
+#include "tiling_base/tiling_base.h"
+#include "err/ops_err.h"
+
+namespace optiling {
+namespace GroupedMatmulSwigluQuantV2Tiling {
+
+class GroupedMatmulSwigluQuantV2FusionTiling : public GroupedMatmulSwigluQuantV2Tiling {
+public:
+    explicit GroupedMatmulSwigluQuantV2FusionTiling(gert::TilingContext* context) : GroupedMatmulSwigluQuantV2Tiling(context) {};
+
+    ~GroupedMatmulSwigluQuantV2FusionTiling() override = default;
+
+protected:
+    bool IsCapable() override;
+
+    ge::graphStatus DoOpTiling() override;
+
+    uint64_t GetTilingKey() const override;
+
+    ge::graphStatus PostTiling() override;
+    ge::graphStatus ParseInputAndAttr();
+    void FillTilingData() override;
+    void PrintTilingData() override;
+private:
+    GMMSwigluQuantV2TilingFusionData tilingData_;
+    uint64_t workspaceSize_;
+    uint32_t blockDim_;
+    int64_t k_;
+    int64_t m_;
+    int64_t n_;
+    int32_t groupNum_;
+    int32_t aicCoreNum_;
+    int32_t aivCoreNum_;
+    int64_t ubFactorDimx_;
+    int64_t groupListType_ = 0;
+    int8_t isSingleTensor_;
+};
+
+}
+}
+#endif // __OP_HOST_OP_TILING_GROUPED_MATMUL_SWIGLU_QUANT_V2_FUSION_TILING_H__

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/grouped_matmul_swiglu_quant_v2_host_utils.h

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2025-2026 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 grouped_matmul_swiglu_quant_v2_host_utils.h
+ * \brief
+ */
+
+#ifndef OP_HOST_GROUPED_MATMUL_SWIGLU_QUANT_V2_HOST_UTILS_H
+#define OP_HOST_GROUPED_MATMUL_SWIGLU_QUANT_V2_HOST_UTILS_H
+
+#include <map>
+
+namespace GroupedMatmulSwigluQuantParamsV2 {
+constexpr uint32_t X_INDEX = 0UL;
+constexpr uint32_t PER_TOKEN_SCALE_INDEX = 1UL;
+constexpr uint32_t GROUPLIST_INDEX = 2UL;
+constexpr uint32_t WEIGHT_INDEX = 3UL;
+constexpr uint32_t SCALE_INDEX = 4UL;
+constexpr uint32_t Y_DATA_INDEX = 0UL;
+constexpr uint32_t Y_SCALE_INDEX = 1UL;
+constexpr uint64_t TILING_KEY = 0UL;
+constexpr uint64_t ATTR_INDEX_DEQUANT_MODE = 0UL;
+constexpr uint32_t ATTR_INDEX_DEQUANT_DTYPE = 1UL;
+constexpr uint64_t ATTR_INDEX_QUANT_MODE = 2UL;
+constexpr uint32_t ATTR_INDEX_QUANT_DTYPE = 3UL;
+constexpr uint64_t ATTR_INDEX_TRANS_W = 4UL;
+constexpr uint32_t ATTR_INDEX_GROUP_LIST_TYPE = 5UL;
+constexpr size_t PRECHANNEL_WEIGHT_SCALE_DIM = 2UL;
+constexpr size_t PERTOKEN_X_SCALE_DIM = 1UL;
+constexpr size_t MX_WEIGHT_SCALE_DIM = 4UL;
+constexpr size_t MX_X_SCALE_DIM = 3UL;
+constexpr size_t MXQuantMode = 2UL;
+constexpr uint64_t B4_DATACOPY_MIN_NUM = 2;
+constexpr int32_t SPLIT_M = 0;
+constexpr uint64_t MXFP4_K_MIN_VALUE = 2UL;
+constexpr uint64_t MXFP4_N_MIN_VALUE = 4UL;
+} // namespace GroupedMatmulSwigluQuantParamsV2
+#endif

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/grouped_matmul_swiglu_quant_v2_infershape.cpp

@@ -0,0 +1,142 @@
+/**
+ * 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 grouped_matmul_swiglu_quant_proto.cpp
+ * \brief
+ */
+#include "register/op_impl_registry.h"
+#include "log/log.h"
+#include "platform/platform_info.h"
+#include "util/math_util.h"
+#include "graph/utils/type_utils.h"
+
+using namespace ge;
+namespace ops {
+const int64_t X_INDEX = 0;
+const int64_t WEIGHT_INDEX = 3;
+const int64_t WEIGHTSCALE_DIM_PERTOKEN = 2;
+const int64_t WEIGHTSCALE_INDEX = 4;
+const int64_t M_DIM_INDEX = 0;
+const int64_t DIM_LEN = 2;
+const int64_t SPLIT_RATIO = 2;
+const int64_t OUT_DIM_LEN = 3;
+const int64_t N_SPLIT_RATIO = 128;
+constexpr size_t GMMSQ_INDEX_ATTR_QUANT_DTYPE = 3UL;
+constexpr size_t GMMSQ_INDEX_ATTR_QUANT_MODE = 2UL;
+constexpr size_t QUANT_MODE_MX_TYPE = 2;
+constexpr size_t QUANT_MODE_PERTOKEN_TYPE = 0;
+constexpr int64_t DYNAMIC_GRAPH_FIRST_INFERSHAPE_DIM_VALUE = -1;
+
+static std::set<std::string> GmmDavidSupportSoc = {"Ascend950"};
+static const std::unordered_set<ge::DataType> DavidSupportedInputDtypes = {
+    ge::DataType::DT_FLOAT8_E5M2, ge::DataType::DT_FLOAT8_E4M3FN,
+    ge::DataType::DT_FLOAT4_E2M1, ge::DataType::DT_INT8, ge::DataType::DT_HIFLOAT8};
+bool  isSupportedInputDtypeForDavid(ge::DataType dtype)
+{
+    return DavidSupportedInputDtypes.find(dtype) != DavidSupportedInputDtypes.end();
+}
+
+static ge::graphStatus InferShape4GroupedMatmulSwigluQuantV2(gert::InferShapeContext *context)
+{
+    const gert::Shape *xShape = context->GetDynamicInputShape(X_INDEX, 0);
+    OP_CHECK_NULL_WITH_CONTEXT(context, xShape);
+    const gert::Shape *weightScaleShape = context->GetDynamicInputShape(WEIGHTSCALE_INDEX, 0);
+    OP_CHECK_NULL_WITH_CONTEXT(context, weightScaleShape);
+    int64_t m = xShape->GetDim(M_DIM_INDEX);
+    int64_t nDimIndex = weightScaleShape->GetDimNum() - 1;
+    auto outScaleShape = context->GetOutputShape(1);
+    OP_CHECK_NULL_WITH_CONTEXT(context, outScaleShape);
+    if (nDimIndex == OUT_DIM_LEN) {
+        auto attrs = context->GetAttrs();
+        OP_CHECK_NULL_WITH_CONTEXT(context, attrs);
+        const bool *transposeWeightPtr = attrs->GetBool(WEIGHTSCALE_INDEX);
+        const bool transposeWeight = (transposeWeightPtr != nullptr ? *transposeWeightPtr : false);
+        nDimIndex = transposeWeight ? weightScaleShape->GetDimNum() - OUT_DIM_LEN :
+                                        weightScaleShape->GetDimNum() - DIM_LEN;
+        int64_t dimValue = static_cast<int64_t>(weightScaleShape->GetDim(nDimIndex));
+        int64_t n = 0;
+        if (dimValue == DYNAMIC_GRAPH_FIRST_INFERSHAPE_DIM_VALUE) {
+            n = dimValue;
+        } else {
+            n = static_cast<int64_t>(Ops::Base::CeilDiv(weightScaleShape->GetDim(nDimIndex), N_SPLIT_RATIO));
+        }
+        outScaleShape->SetDimNum(OUT_DIM_LEN);
+        outScaleShape->SetDim(0, m);
+        outScaleShape->SetDim(1, n);
+        outScaleShape->SetDim(2, SPLIT_RATIO); // 设置outScaleShape的第2维度
+    } else {
+        outScaleShape->SetDimNum(1);
+        outScaleShape->SetDim(0, m);
+    }
+
+    int64_t dimValue = static_cast<int64_t>(weightScaleShape->GetDim(nDimIndex));
+    int64_t n = 0;
+    if (dimValue == DYNAMIC_GRAPH_FIRST_INFERSHAPE_DIM_VALUE) {
+        n = dimValue;
+    } else {
+        n = static_cast<int64_t>(weightScaleShape->GetDim(nDimIndex) / SPLIT_RATIO);
+        if (weightScaleShape->GetDimNum() == WEIGHTSCALE_DIM_PERTOKEN) {
+            n = static_cast<int64_t>(weightScaleShape->GetDim(1) / SPLIT_RATIO);
+        }
+    }
+    auto outShape = context->GetOutputShape(0);
+    OP_CHECK_NULL_WITH_CONTEXT(context, outShape);
+    outShape->SetDimNum(DIM_LEN);
+    outShape->SetDim(0, m);
+    outShape->SetDim(1, n);
+    return GRAPH_SUCCESS;
+}
+
+static graphStatus InferDataType4GroupedMatmulSwigluQuantV2(gert::InferDataTypeContext *context)
+{
+    OP_CHECK_NULL_WITH_CONTEXT(context, context);
+    auto attrs = context->GetAttrs();
+    OP_CHECK_NULL_WITH_CONTEXT(context, attrs);
+    const int64_t* outDtype = attrs->GetInt(GMMSQ_INDEX_ATTR_QUANT_DTYPE);
+    OP_CHECK_NULL_WITH_CONTEXT(context, outDtype);
+    const int64_t* quantMode = attrs->GetInt(GMMSQ_INDEX_ATTR_QUANT_MODE);
+    OP_CHECK_NULL_WITH_CONTEXT(context, quantMode);
+
+    fe::PlatformInfo platformInfo;
+    fe::OptionalInfo optionalInfo;
+    auto ret = fe::PlatformInfoManager::Instance().GetPlatformInfoWithOutSocVersion(platformInfo, optionalInfo);
+    if (ret == GRAPH_SUCCESS && GmmDavidSupportSoc.count(platformInfo.str_info.short_soc_version) > 0) {
+        auto xDtype = context->GetInputDataType(X_INDEX);
+        auto weightDtype = context->GetDynamicInputDataType(WEIGHT_INDEX, 0);
+        OP_CHECK_IF(!isSupportedInputDtypeForDavid(xDtype) || !isSupportedInputDtypeForDavid(weightDtype),
+                OP_LOGE(context->GetNodeName(), "Invalid Input on this platform, expected FLOAT8_E4M3,"
+                            "FLOAT8_E5M2, FLOAT4_E2M1, INT_8, HIFLOAT8, but actual value of x is %s, weight is %s.",
+                            ge::TypeUtils::DataTypeToSerialString(xDtype).c_str(),
+                            ge::TypeUtils::DataTypeToSerialString(weightDtype).c_str()), return GRAPH_FAILED);
+
+        OP_CHECK_IF(*quantMode != QUANT_MODE_MX_TYPE && *quantMode != QUANT_MODE_PERTOKEN_TYPE,
+                OP_LOGE(context->GetNodeName(), "On this platform, quantMode should be 0(Pertoken) or 2(MX),"
+                            " but actual value is %ld.", *quantMode), return GRAPH_FAILED);
+    }
+    auto weightScaleDtype = context->GetDynamicInputDataType(WEIGHTSCALE_INDEX, 0);
+    if (*quantMode == QUANT_MODE_MX_TYPE) {
+        if (weightScaleDtype == ge::DataType::DT_FLOAT8_E8M0) {
+            context->SetOutputDataType(1, DataType::DT_FLOAT8_E8M0);
+        }  else {
+            OP_LOGE(context->GetNodeName(), "In mx quant mode, quantMode should be 2, but actual value is %ld.", *quantMode);
+            return GRAPH_FAILED;
+        }
+    } else if (*quantMode == QUANT_MODE_PERTOKEN_TYPE) {
+        context->SetOutputDataType(1, DataType::DT_FLOAT);
+    }
+    context->SetOutputDataType(0, static_cast<ge::DataType>(*outDtype));
+    return GRAPH_SUCCESS;
+}
+
+IMPL_OP_INFERSHAPE(GroupedMatmulSwigluQuantV2)
+    .InferShape(InferShape4GroupedMatmulSwigluQuantV2)
+    .InferDataType(InferDataType4GroupedMatmulSwigluQuantV2);
+} // namespace ops

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/grouped_matmul_swiglu_quant_v2_tiling.cpp

@@ -0,0 +1,78 @@
+/**
+ * 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 grouped_matmul_swiglu_quant_v2_tiling.cpp
+ * \brief
+ */
+
+#include "grouped_matmul_swiglu_quant_v2_tiling.h"
+#include <climits>
+#include <graph/utils/type_utils.h>
+#include "register/op_impl_registry.h"
+#include "log/log.h"
+#include "err/ops_err.h"
+#include "tiling_base/tiling_base.h"
+#include "register/op_def_registry.h"
+#include "tiling_base/tiling_templates_registry.h"
+#include "grouped_matmul_swiglu_quant_v2_fusion_tiling.h"
+#include "grouped_matmul_swiglu_quant_v2_base_tiling.h"
+#include "platform/platform_infos_def.h"
+
+using namespace ge;
+using namespace AscendC;
+using namespace optiling::GroupedMatmulSwigluQuantV2Tiling;
+using namespace Ops::Transformer::OpTiling;
+
+namespace optiling {
+
+REGISTER_OPS_TILING_TEMPLATE(GroupedMatmulSwigluQuantV2, GroupedMatmulSwigluQuantV2FusionTiling, 0);
+REGISTER_OPS_TILING_TEMPLATE(GroupedMatmulSwigluQuantV2, GroupedMatmulSwigluQuantV2BaseTiling, 1);
+
+static ge::graphStatus GroupedMatmulSwigluQuantV2TilingFunc(gert::TilingContext *context)
+{
+    OP_CHECK_IF(context == nullptr,
+            OPS_REPORT_CUBE_INNER_ERR("GroupedMatmulSwigluQuantV2TilingFunc", "Tilingcontext is null"),
+            return ge::GRAPH_FAILED);
+    auto compileInfoPtr = context->GetCompileInfo<GMMSwigluV2CompileInfo>();
+    if (compileInfoPtr->supportL12BtBf16) {
+        std::vector<int32_t> registerList = {2};
+        OP_LOGD("GroupedMatmulSwigluQuantV2TilingFunc", "Using the tiling strategy in the mxfp8");
+        return TilingRegistry::GetInstance().DoTilingImpl(context, registerList);
+    }else {
+        std::vector<int32_t> registerList = {0,1};
+        OP_LOGD("GroupedMatmulSwigluQuantV2TilingFunc", "Using the tiling strategy in the int8");
+        return TilingRegistry::GetInstance().DoTilingImpl(context, registerList);
+    }
+}
+
+ASCENDC_EXTERN_C graphStatus TilingPrepareForGMMSwigluQuantV2(gert::TilingParseContext *context)
+{
+    // get info
+    auto platformInfoPtr = context->GetPlatformInfo();
+    OP_CHECK_NULL_WITH_CONTEXT(context, platformInfoPtr);
+    auto compileInfoPtr = context->GetCompiledInfo<GMMSwigluV2CompileInfo>();
+    OP_CHECK_NULL_WITH_CONTEXT(context, compileInfoPtr);
+
+    auto ascendcPlatform = platform_ascendc::PlatformAscendC(platformInfoPtr);
+    compileInfoPtr->aicNum_ = ascendcPlatform.GetCoreNumAic();
+    compileInfoPtr->aivNum_ = ascendcPlatform.GetCoreNumAiv();
+    std::string platformRes;
+    platformInfoPtr->GetPlatformRes("AICoreintrinsicDtypeMap", "Intrinsic_data_move_l12bt", platformRes);
+    compileInfoPtr->supportL12BtBf16 = (platformRes.find("bf16") != std::string::npos);
+    ascendcPlatform.GetCoreMemSize(platform_ascendc::CoreMemType::UB, compileInfoPtr->ubSize_);
+    OP_LOGD(context->GetNodeName(), "ubSize is %lu, aicNum is %u.", compileInfoPtr->ubSize_, compileInfoPtr->aicNum_);
+    return GRAPH_SUCCESS;
+}
+
+IMPL_OP_OPTILING(GroupedMatmulSwigluQuantV2)
+    .Tiling(GroupedMatmulSwigluQuantV2TilingFunc)
+    .TilingParse<GMMSwigluV2CompileInfo>(TilingPrepareForGMMSwigluQuantV2);
+} // namespace optiling

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/grouped_matmul_swiglu_quant_v2_tiling.h

@@ -0,0 +1,174 @@
+/**
+ * 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 grouped_matmul_swiglu_quant_v2_tiling.h
+ * \brief
+ */
+#ifndef __OP_HOST_OP_TILING_GROUPED_MATMUL_SWIGLU_QUANT_V2_TILING_H__
+#define __OP_HOST_OP_TILING_GROUPED_MATMUL_SWIGLU_QUANT_V2_TILING_H__
+
+#include <set>
+#include "tiling_base/tiling_base.h"
+#include "tiling/tiling_api.h"
+
+namespace optiling {
+
+// GMM 基本信息
+BEGIN_TILING_DATA_DEF(GMMSwigluQuantV2BaseParams)
+TILING_DATA_FIELD_DEF(int64_t, groupNum);
+TILING_DATA_FIELD_DEF(int64_t, coreNum);
+TILING_DATA_FIELD_DEF(int64_t, K);
+TILING_DATA_FIELD_DEF(int64_t, N);
+TILING_DATA_FIELD_DEF(int64_t, M);
+TILING_DATA_FIELD_DEF(int64_t, baseM);
+TILING_DATA_FIELD_DEF(int64_t, baseN);
+TILING_DATA_FIELD_DEF(int64_t, mLimit);
+TILING_DATA_FIELD_DEF(int64_t, workSpaceOffset1);
+TILING_DATA_FIELD_DEF(int64_t, workSpaceOffset2);
+TILING_DATA_FIELD_DEF(int64_t, quantGroupNum);
+TILING_DATA_FIELD_DEF(int64_t, isSingleTensor);
+TILING_DATA_FIELD_DEF(int64_t, groupListType);
+TILING_DATA_FIELD_DEF(int64_t, smoothScaleDimNum);
+TILING_DATA_FIELD_DEF(int64_t, singleN);
+TILING_DATA_FIELD_DEF(float, swigluLimit);
+END_TILING_DATA_DEF;
+REGISTER_TILING_DATA_CLASS(GMMSwigluQuantV2BaseParamsOp, GMMSwigluQuantV2BaseParams)
+
+// SwigluQuant部分tiling 基本信息
+BEGIN_TILING_DATA_DEF(GMMSwigluQuantV2)
+TILING_DATA_FIELD_DEF(int64_t, maxProcessRowNum);
+TILING_DATA_FIELD_DEF(int64_t, groupListLen);
+TILING_DATA_FIELD_DEF(int64_t, tokenLen);
+END_TILING_DATA_DEF;
+REGISTER_TILING_DATA_CLASS(GMMSwigluQuantV2Op, GMMSwigluQuantV2)
+
+// 结构体集合
+BEGIN_TILING_DATA_DEF(GMMSwigluQuantV2TilingData)
+TILING_DATA_FIELD_DEF_STRUCT(GMMSwigluQuantV2BaseParams, gmmSwigluQuantV2BaseParams);
+TILING_DATA_FIELD_DEF_STRUCT(GMMSwigluQuantV2, gmmSwigluQuantV2);
+TILING_DATA_FIELD_DEF_STRUCT(TCubeTiling, mmTilingData);
+END_TILING_DATA_DEF;
+
+BEGIN_TILING_DATA_DEF(GMMSwigluQuantV2TilingFusionData)
+TILING_DATA_FIELD_DEF(int64_t, cubeBlockDim);
+TILING_DATA_FIELD_DEF(int64_t, vectorBlockDim);
+TILING_DATA_FIELD_DEF(int64_t, groupNum);
+TILING_DATA_FIELD_DEF(int64_t, K);
+TILING_DATA_FIELD_DEF(int64_t, N);
+TILING_DATA_FIELD_DEF(int64_t, M);
+// vector
+TILING_DATA_FIELD_DEF(int64_t, ubFactorDimx);
+TILING_DATA_FIELD_DEF(int64_t, ubFactorDimy);
+TILING_DATA_FIELD_DEF(int64_t, actRight);
+TILING_DATA_FIELD_DEF(int64_t, groupListType);
+TILING_DATA_FIELD_DEF(int8_t, isSingleTensor);
+TILING_DATA_FIELD_DEF(float, swigluLimit);
+TILING_DATA_FIELD_DEF_STRUCT(TCubeTiling, matmulTiling);
+END_TILING_DATA_DEF;
+
+BEGIN_TILING_DATA_DEF(GMMSwigluQuantParams)
+TILING_DATA_FIELD_DEF(uint32_t, groupNum);
+TILING_DATA_FIELD_DEF(uint8_t, groupListType);
+TILING_DATA_FIELD_DEF(uint8_t, quantDtype);
+TILING_DATA_FIELD_DEF(uint8_t, reserved1);
+TILING_DATA_FIELD_DEF(uint8_t, dequantDtype);
+TILING_DATA_FIELD_DEF(uint32_t, rowLen);
+TILING_DATA_FIELD_DEF(uint32_t, ubAvail);
+END_TILING_DATA_DEF;
+REGISTER_TILING_DATA_CLASS(GMMSwigluQuantParamsOp, GMMSwigluQuantParams)
+
+BEGIN_TILING_DATA_DEF(GMMSwigluQuantTilingDataParams)
+TILING_DATA_FIELD_DEF_STRUCT(GMMSwigluQuantParams, gmmSwigluQuantParams);
+TILING_DATA_FIELD_DEF_STRUCT(TCubeTiling, mmTilingData);
+END_TILING_DATA_DEF;
+
+REGISTER_TILING_DATA_CLASS(GroupedMatmulSwigluQuantV2_0, GMMSwigluQuantTilingDataParams)
+REGISTER_TILING_DATA_CLASS(GroupedMatmulSwigluQuantV2_1, GMMSwigluQuantTilingDataParams)
+
+REGISTER_TILING_DATA_CLASS(GroupedMatmulSwigluQuantV2, GMMSwigluQuantV2TilingData)
+REGISTER_TILING_DATA_CLASS(GroupedMatmulSwigluQuantV2_3, GMMSwigluQuantV2TilingFusionData)
+
+struct GMMSwigluV2CompileInfo {
+    uint64_t ubSize_ = 0;
+    uint32_t aicNum_ = 0;
+    uint32_t aivNum_ = 0;
+    uint32_t baseM_ = 128;
+    uint32_t baseN_ = 256;
+    bool supportL12BtBf16;
+};
+
+namespace GroupedMatmulSwigluQuantV2Tiling {
+constexpr uint32_t X_INDEX = 0;
+constexpr uint32_t WEIGHT_INDEX = 3;
+constexpr uint32_t WEIGHT_SCALE_INDEX = 4;
+constexpr uint32_t GROUPLIST_INDEX = 2;
+constexpr uint32_t SMOOTH_SCALE_INDEX = 7;
+constexpr uint32_t BATCH_MODE_SCHEDULE = 1;
+constexpr uint32_t ATTR_INDEX_DEQUANT_MODE = 0;
+constexpr uint32_t ATTR_INDEX_GROUPLIST_TYPE = 5;
+constexpr uint32_t ATTR_INDEX_TUNING_CONFIG = 6;
+constexpr uint32_t ATTR_INDEX_SWIGLU_LIMIT = 7;
+constexpr uint32_t ATTR_INDEX_TRANSPOSE_WEIGHT = 4;
+constexpr uint32_t DIM_0 = 0;
+constexpr uint32_t DIM_1 = 1;
+constexpr uint32_t DIM_2 = 2;
+constexpr uint32_t DIM_3 = 3;
+constexpr uint32_t DIM_4 = 4;
+constexpr uint32_t NUM_FOUR = 4;
+constexpr uint32_t NUM_EIGHT = 8;
+constexpr uint32_t SYS_WORKSPACE_SIZE = static_cast<uint32_t>(16 * 1024 * 1024);
+constexpr int64_t USER_WORKSPACE_LIMIT = static_cast<int64_t>(64 * 1024 * 1024);
+constexpr int64_t DOUBLE_WORKSPACE_SPLIT = 2;
+constexpr int64_t INT32_DTYPE_SIZE = 4;
+constexpr int64_t FP32_DTYPE_SIZE = 4;
+constexpr int64_t FP32_BLOCK_SIZE = 8;
+constexpr int64_t BLOCK_BYTE = 32;
+constexpr int64_t SWIGLU_REDUCE_FACTOR = 2;
+constexpr int64_t DOUBLE_BUFFER = 2;
+constexpr int64_t ND_WEIGHT_DIM_LIMIT = 3;
+constexpr int64_t NZ_WEIGHT_DIM_LIMIT = 5;
+constexpr int64_t DOUBLE_ROW = 2;
+constexpr int64_t PERCHANNEL_WSCALE_DIM_LIMIT = 2;
+constexpr int64_t PERGROUP_WSCALE_DIM_LIMIT = 3;
+constexpr int64_t A4W4_WEIGHT_NOTRANS_TILING_KEY_MODE = 4;
+constexpr int64_t A4W4_WEIGHT_TRANS_TILING_KEY_MODE = 5;
+constexpr int64_t A8W8_FUSION_KEY_MODE = 3;
+constexpr int64_t A8W4_MSD_TILING_KEY_MODE = 2;
+constexpr int64_t SPLITWORKSPACE_TILING_KEY_MODE = 1;
+constexpr int64_t COMMON_TILING_KEY_MODE = 0;
+constexpr int64_t A8W4_BASEM = 128;
+constexpr int64_t A8W4_BASEK = 256;
+constexpr int64_t A8W4_BASEN = 256;
+constexpr int64_t SIZE_OF_HALF_2 = 2;
+
+class GroupedMatmulSwigluQuantV2Tiling : public Ops::Transformer::OpTiling::TilingBaseClass {
+public:
+    explicit GroupedMatmulSwigluQuantV2Tiling(gert::TilingContext* context) : Ops::Transformer::OpTiling::TilingBaseClass(context) {};
+
+    ~GroupedMatmulSwigluQuantV2Tiling() override = default;
+
+protected:
+    ge::graphStatus GetPlatformInfo() override {return ge::GRAPH_SUCCESS;};
+
+    ge::graphStatus GetShapeAttrsInfo() override {return ge::GRAPH_SUCCESS;};
+
+    ge::graphStatus DoLibApiTiling() override {return ge::GRAPH_SUCCESS;};
+
+    ge::graphStatus GetWorkspaceSize() override {return ge::GRAPH_SUCCESS;};
+
+    virtual void FillTilingData() = 0;
+    virtual void PrintTilingData() = 0;
+};
+
+} // namespace GroupedMatmulSwigluQuantV2Tiling
+} // namespace optiling
+
+#endif // __OP_HOST_OP_TILING_GROUPED_MATMUL_SWIGLU_QUANT_V2_TILING_H__

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/op_api/aclnn_grouped_matmul_swiglu_quant_v2.cpp

@@ -0,0 +1,208 @@
+/**
+ * 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 <dlfcn.h>
+#include <new>
+#include <memory>
+#include <unordered_map>
+#include "gmm_dsq_base.h"
+#include "grouped_matmul_swiglu_quant_v2_utils.h"
+#include "grouped_matmul_swiglu_quant_v2.h"
+#include "aclnn_grouped_matmul_swiglu_quant_weight_nz_v2.h"
+#include "aclnn_grouped_matmul_swiglu_quant_v2.h"
+
+using namespace op;
+using namespace gmm_dsq;
+using namespace gmm_dsq_base;
+
+class GmmDsqHandlerFactory {
+private:
+    std::unordered_map<NpuArch, std::unique_ptr<GroupedMatmulSwigluQuantHandler>> handlers_;
+
+public:
+    void registerHandler(NpuArch npuArch, std::unique_ptr<GroupedMatmulSwigluQuantHandler> handler)
+    {
+        handlers_[npuArch] = std::move(handler);
+    }
+
+    GroupedMatmulSwigluQuantHandler *getHandler(NpuArch npuArch)
+    {
+        auto it = handlers_.find(npuArch);
+        return it != handlers_.end() ? it->second.get() : nullptr;
+    }
+};
+
+static aclnnStatus aclnnGroupedMatmulSwigluQuantGetWorkspaceSizeCommon(const char* interfaceName,
+    GroupedMatmulSwigluQuantParamsBase &params, uint64_t *workspaceSize, aclOpExecutor **executor)
+{
+    GmmDsqHandlerFactory factory;
+    auto npuArch = op::GetCurrentPlatformInfo().GetCurNpuArch();
+    factory.registerHandler(NpuArch::DAV_2201,
+        std::make_unique<gmm_dsq_base::GroupedMatmulSwigluQuantBaseHandler>());
+    factory.registerHandler(NpuArch::DAV_3510,
+        std::make_unique<gmmSwigluQuantV2::GroupedMatmulSwigluQuantBaseHandler>());
+
+    if (auto *handler = factory.getHandler(npuArch)) {
+        handler->Initialize(interfaceName, params, workspaceSize, executor);
+        return handler->Process();
+    } else {
+         OP_LOGE(ACLNN_ERR_PARAM_INVALID, "interfaceName failed: the soc version is not support");
+    }
+
+    return ACLNN_ERR_PARAM_INVALID;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+aclnnStatus aclnnGroupedMatmulSwigluQuantV2GetWorkspaceSize(const aclTensor *x,
+        const aclTensorList *weight, const aclTensorList *weightScale,
+        const aclTensorList *weightAssistMatrix, const aclTensor *bias,
+        const aclTensor *xScale, const aclTensor *smoothScale,
+        const aclTensor *groupList, int64_t dequantMode,
+        int64_t dequantDtype, int64_t quantMode,
+        int64_t groupListType, const aclIntArray *tuningConfigOptional,  double swigluLimit,
+        aclTensor *output, aclTensor *outputScale,
+        uint64_t *workspaceSize, aclOpExecutor **executor)
+{
+    OP_CHECK_COMM_INPUT(workspaceSize, executor);
+    L2_DFX_PHASE_1(aclnnGroupedMatmulSwigluQuantV2,
+                   DFX_IN(x, weight, weightScale, xScale, groupList),
+                   DFX_OUT(output, outputScale));
+    CHECK_COND((output != nullptr), ACLNN_ERR_PARAM_INVALID,
+               "Expected a proper Tensor but got null for argument output.");
+
+    GroupedMatmulSwigluQuantParamsBase params =
+        GroupedMatmulSwigluQuantParamsBuilder::Create(x, weight, weightScale, output, outputScale)
+        .SetXScale(xScale).SetSmoothScale(smoothScale)
+        .SetGroupList(groupList).SetGroupListType(groupListType)
+        .SetWeightAssistMatrix(weightAssistMatrix)
+        .SetDequantAttr(dequantMode, dequantDtype)
+        .SetQuantAttr(quantMode, static_cast<int64_t> (output->GetDataType()))
+        .SetTransposeAttr(false).SetBias(bias)
+        .SetLimitAttr(swigluLimit)
+        .SetScenario()
+        .SetTuningConfig(tuningConfigOptional).Build();
+    // 调用公共接口
+    return aclnnGroupedMatmulSwigluQuantGetWorkspaceSizeCommon(__FUNCTION__, params, workspaceSize, executor);
+}
+
+aclnnStatus aclnnGroupedMatmulSwigluQuantWeightNzV2GetWorkspaceSize(const aclTensor *x,
+        const aclTensorList *weight, const aclTensorList *weightScale,
+        const aclTensorList *weightAssistMatrix, const aclTensor *bias,
+        const aclTensor *xScale, const aclTensor *smoothScale,
+        const aclTensor *groupList, int64_t dequantMode,
+        int64_t dequantDtype, int64_t quantMode,
+        int64_t groupListType,  const aclIntArray *tuningConfigOptional, double swigluLimit,
+        aclTensor *output, aclTensor *outputScale,
+        uint64_t *workspaceSize, aclOpExecutor **executor)
+{
+    OP_CHECK_COMM_INPUT(workspaceSize, executor);
+    L2_DFX_PHASE_1(aclnnGroupedMatmulSwigluQuantWeightNzV2,
+                   DFX_IN(x, weight, weightScale, xScale, groupList),
+                   DFX_OUT(output, outputScale));
+    // weight在该场景下强制绑定StorageFormat 和 ViewFormat 为NZ
+    CHECK_RET(weight != nullptr, ACLNN_ERR_PARAM_NULLPTR);
+    size_t wLength = weight->Size();
+    if (wLength == 1) {
+        // 单Tensor场景
+        auto w = (*weight)[0];
+        auto storgeShape = w->GetStorageShape();
+        auto viewShape = w->GetViewShape();
+        aclTensor *weightNZ = const_cast<aclTensor *>(w);
+        auto storageShape = w->GetStorageShape();
+        auto groupListViewShape = groupList->GetViewShape();
+        auto expertNum = groupListViewShape[0];
+        auto weightScale0 = (*weightScale)[0];
+        auto weightScaleStorageShape = weightScale0->GetViewShape();
+        auto n = weightScaleStorageShape[1];
+        auto xViewShape = x->GetViewShape();
+        auto k = xViewShape[1];
+        storageShape = {expertNum, n / 64, k / 16, 16, 8};
+        w->SetStorageShape(storageShape);
+        CHECK_COND((storgeShape.GetDimNum() == WEIGHT_NZ_DIM_LIMIT), ACLNN_ERR_PARAM_INVALID,
+                   "aclnnGroupedMatmulSwigluQuantWeightNzV2, The dimnum of storageShape for second input (weight)"
+                 "must be 5. \n But StorageShape got %s , and dimNum is %lu.",
+                   op::ToString(storgeShape).GetString(), storgeShape.GetDimNum());
+        // weight的StorageFormat无条件视为NZ
+        weightNZ->SetStorageFormat(op::Format::FORMAT_FRACTAL_NZ);
+        if (viewShape.GetDimNum() == WEIGHT_NZ_DIM_LIMIT) {
+            // 若weight的viewShape为5维则视为NZ
+            weightNZ->SetViewFormat(op::Format::FORMAT_FRACTAL_NZ);
+        } else if (viewShape.GetDimNum() == WEIGHT_ND_DIM_LIMIT) {
+            // 若weight的viewShape为3维则视为ND
+            weightNZ->SetViewFormat(op::Format::FORMAT_ND);
+        }
+    } else {
+        // 多Tensor场景
+        for (size_t i = 0; i < wLength; i++) {
+            auto w = (*weight)[i];
+            auto storgeShape = w->GetStorageShape();
+            auto viewShape = w->GetViewShape();
+            aclTensor *weightNZ = const_cast<aclTensor *>(w);
+            auto storageShape = w->GetStorageShape();
+            auto groupListViewShape = groupList->GetViewShape();
+            auto weightScale0 = (*weightScale)[i];
+            auto weightScaleStorageShape = weightScale0->GetViewShape();
+            auto n = weightScaleStorageShape[0];
+            auto xViewShape = x->GetViewShape();
+            auto k = xViewShape[1];
+            storageShape = {n / 64, k / 16, 16, 8};
+            w->SetStorageShape(storageShape);
+            CHECK_COND((storgeShape.GetDimNum() == MULTI_WEIGHT_NZ_DIM_LIMIT), ACLNN_ERR_PARAM_INVALID,
+                       "aclnnGroupedMatmulSwigluQuantWeightNzV2, The dimnum of storageShape for second input (weight)"
+                     "must be 4. \n But StorageShape got %s , and dimNum is %lu.",
+                       op::ToString(storgeShape).GetString(), storgeShape.GetDimNum());
+            // weight的StorageFormat无条件视为NZ
+            weightNZ->SetStorageFormat(op::Format::FORMAT_FRACTAL_NZ);
+            if (viewShape.GetDimNum() == MULTI_WEIGHT_NZ_DIM_LIMIT) {
+                // 若weight的viewShape为4维则视为NZ
+                weightNZ->SetViewFormat(op::Format::FORMAT_FRACTAL_NZ);
+            } else if (viewShape.GetDimNum() == MULTI_WEIGHT_ND_DIM_LIMIT) {
+                // 若weight的viewShape为2维则视为ND
+                weightNZ->SetViewFormat(op::Format::FORMAT_ND);
+            }
+        }
+    }
+    GroupedMatmulSwigluQuantParamsBase params =
+        GroupedMatmulSwigluQuantParamsBuilder::Create(x, weight, weightScale, output, outputScale)
+        .SetXScale(xScale).SetSmoothScale(smoothScale)
+        .SetGroupList(groupList).SetGroupListType(groupListType)
+        .SetWeightAssistMatrix(weightAssistMatrix)
+        .SetDequantAttr(dequantMode, dequantDtype)
+        .SetLimitAttr(swigluLimit)
+        .SetScenario()
+        .SetTuningConfig(tuningConfigOptional).Build();
+    // 调用公共接口
+    return aclnnGroupedMatmulSwigluQuantGetWorkspaceSizeCommon(__FUNCTION__, params, workspaceSize, executor);
+}
+
+aclnnStatus aclnnGroupedMatmulSwigluQuantV2(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor,
+                                            aclrtStream stream)
+{
+    L2_DFX_PHASE_2(aclnnGroupedMatmulSwigluQuantV2);
+    CHECK_COND(CommonOpExecutorRun(workspace, workspaceSize, executor, stream) == ACLNN_SUCCESS, ACLNN_ERR_INNER,
+               "This is an error in GroupedMatmulSwigluQuantV2 launch aicore");
+    return ACLNN_SUCCESS;
+}
+
+aclnnStatus aclnnGroupedMatmulSwigluQuantWeightNzV2(void *workspace, uint64_t workspaceSize, aclOpExecutor *executor,
+                                                    aclrtStream stream)
+{
+    L2_DFX_PHASE_2(aclnnGroupedMatmulSwigluQuantWeightNzV2);
+    CHECK_COND(CommonOpExecutorRun(workspace, workspaceSize, executor, stream) == ACLNN_SUCCESS, ACLNN_ERR_INNER,
+               "This is an error in GroupedMatmulSwigluQuantWeightNzV2 launch aicore");
+    return ACLNN_SUCCESS;
+}
+
+#ifdef __cplusplus
+}
+#endif

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/op_api/aclnn_grouped_matmul_swiglu_quant_v2.h

@@ -0,0 +1,76 @@
+/**
+ * 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_HOST_OP_API_ACLNN_GROUPED_MATMUL_SWIGLU_QUANT_V2_H
+#define OP_HOST_OP_API_ACLNN_GROUPED_MATMUL_SWIGLU_QUANT_V2_H
+#include "aclnn/aclnn_base.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief aclnnGroupedMatmulSwigluQuantV2 的第一段接口，根据具体的计算流程，计算workspace大小。
+ * @domain aclnn_ops_infer
+ *
+ * @param [in] x: 表示公式中的x，数据类型支持INT8、FLOAT4_E2M1、FLOAT8_E4M3FN、FLOAT8_E5M2、HIFLOAT8数据类型，数据格式支持ND。
+ * @param [in] weight:
+ * 表示公式中的weight，数据类型支持INT4、FLOAT4_E2M1、FLOAT8_E4M3FN、FLOAT8_E5M2、INT8、HIFLOAT8数据类型，数据格式支持ND。
+ * @param [in] weightScale:
+ * 表示量化参数，数据类型支持UINT64、FLOAT32、FLOAT8_E8M0、BF16、FLOAT16数据类型，数据格式支持ND。
+ * @param [in] weightAssistMatrix:
+ * 表示weight辅助矩阵，数据类型支持FLOAT32数据类型。
+ * @param [in] bias:
+ * 表示偏移，数据类型支持FLOAT32数据类型，数据格式支持ND。
+ * @param [in] xScale:
+ * 表示perToken量化参数，数据类型支持FLOAT8_E8M0、FLOAT32数据类型，数据格式支持ND。
+ * @param [in] smoothScale:
+ * 左矩阵的的量化因子，数据类型支持FLOAT32数据类型，数据格式支持ND。
+ * @param [in] groupList: 必选参数，表示每个分组参与计算的Token个数，数据类型支持INT64。
+ * @param [in] dequantMode: 表示反量化计算类型，用于确定激活矩阵与权重矩阵的反量化方式。
+ * @param [in] dequantDtype: 表示中间GroupedMatmul的结果数据类型。
+ * @param [in] quantMode: 表示量化计算类型，用于确定swiglu结果的量化模式。
+ * @param [in] groupListType: 表示指定分组的解释方式，用于确定groupList的语义。
+ * @param [in] tuningConfig: 用于算子预估m/e的大小，走不同的算子模板，以适配不不同场景性能要求。
+ * @param [in] swigluLimit: clamp。
+ * @param [out] quantOutput: 表示公式中的out，数据类型支持INT8、FLOAT4_E2M1、FLOAT8_E4M3FN、FLOAT8_E5M2、HIFLOAT8数据类型，数据格式支持ND。
+ * @param [out] quantScaleOutput: 表示公式中的outQuantScale，数据类型支持FLOAT32、FLOAT8_E8M0数据类型。
+ * @param [out] workspaceSize: 返回用户需要在npu device侧申请的workspace大小。
+ * @param [out] executor: 返回op执行器，包含算子计算流程。
+ * @return aclnnStatus: 返回状态码。
+ */
+aclnnStatus aclnnGroupedMatmulSwigluQuantV2GetWorkspaceSize(const aclTensor *x,
+        const aclTensorList *weight, const aclTensorList *weightScale,
+        const aclTensorList *weightAssistMatrix, const aclTensor *bias,
+        const aclTensor *xScale, const aclTensor *smoothScale,
+        const aclTensor *groupList,  int64_t dequantMode,
+        int64_t dequantDtype, int64_t quantMode, int64_t groupListType,
+        const aclIntArray *tuningConfigOptional, double swigluLimit,
+        aclTensor *output, aclTensor *outputScale,
+        uint64_t *workspaceSize, aclOpExecutor **executor);
+
+/**
+ * @brief aclnnGroupedMatmulSwigluQuantV2的第二段接口，用于执行计算。
+ * @param [in] workspace: 在npu device侧申请的workspace内存起址。
+ * @param [in] workspaceSize: 在npu
+ * device侧申请的workspace大小，由第一段接口aclnnGroupedMatmulSwigluQuantV2GetWorkspaceSize获取。
+ * @param [in] stream: acl stream流。
+ * @param [in] executor: op执行器，包含了算子计算流程。
+ * @return aclnnStatus: 返回状态码。
+ */
+__attribute__((visibility("default"))) aclnnStatus aclnnGroupedMatmulSwigluQuantV2(void *workspace,
+                                                                                   uint64_t workspaceSize,
+                                                                                   aclOpExecutor *executor,
+                                                                                   aclrtStream stream);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/op_api/aclnn_grouped_matmul_swiglu_quant_weight_nz_v2.h

@@ -0,0 +1,75 @@
+/**
+ * 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__HOST_OP_API_ACLNN_GROUPED_MATMUL_SWIGLU_QUANT_WEIGHT_NZ_V2_H
+#define OP__HOST_OP_API_ACLNN_GROUPED_MATMUL_SWIGLU_QUANT_WEIGHT_NZ_V2_H
+#include "aclnn/aclnn_base.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief aclnnGroupedMatmulSwigluQuantWeightNzV2 的第一段接口，根据具体的计算流程，计算workspace大小。
+ * @domain aclnn_ops_infer
+ *
+ * @param [in] x: 表示公式中的x，数据类型支持INT8数据类型，数据格式支持ND。
+ * @param [in] weight:
+ * 表示公式中的weight，数据类型支持INT8、INT4数据类型，数据格式支持NZ。
+ * @param [in] weightScale:
+ * 表示量化参数，数据类型支持FLOAT32、UINT64数据类型，数据格式支持ND。
+ * @param [in] weightAssistMatrix:
+ * 表示weight辅助矩阵，数据类型支持FLOAT32数据类型。
+ * @param [in] bias:
+ * 表示偏移，数据类型支持FLOAT32数据类型，数据格式支持ND。
+ * @param [in] xScale:
+ * 表示perToken量化参数，数据类型支持FLOAT8_E8M0数据类型，数据格式支持ND。
+ * @param [in] smoothScale:
+ * 左矩阵的的量化因子，数据类型支持FLOAT32数据类型，数据格式支持ND。
+ * @param [in] groupList: 必选参数，代表输入和输出分组轴上的索引情况，数据类型支持INT64。
+ * @param [in] dequantMode: 表示反量化计算类型，用于确定激活矩阵与权重矩阵的反量化方式。
+ * @param [in] dequantDtype: 表示中间GroupedMatmul的结果数据类型。
+ * @param [in] quantMode: 表示量化计算类型，用于确定swiglu结果的量化模式。
+ * @param [in] groupListType: 表示指定分组的解释方式，用于确定groupList的语义。
+ * @param [in] tuningConfig: 用于算子预估m/e的大小，走不同的算子模板，以适配不不同场景性能要求。
+ * @param [out] quantOutput: 表示公式中的out，数据类型支持INT8、FLOAT8_E4M3FN、FLOAT8_E5M2数据类型，数据格式支持ND。
+ * @param [out] quantScaleOutput: 表示公式中的outQuantScale，数据类型支持FLOAT32、FLOAT8_E8M0数据类型。
+ * @param [out] workspaceSize: 返回用户需要在npu device侧申请的workspace大小。
+ * @param [out] executor: 返回op执行器，包含算子计算流程。
+ * @return aclnnStatus: 返回状态码。
+ */
+aclnnStatus aclnnGroupedMatmulSwigluQuantWeightNzV2GetWorkspaceSize(const aclTensor *x,
+        const aclTensorList *weight, const aclTensorList *weightScale,
+        const aclTensorList *weightAssistMatrix, const aclTensor *bias,
+        const aclTensor *xScale, const aclTensor *smoothScale,
+        const aclTensor *groupList,  int64_t dequantMode,
+        int64_t dequantDtype, int64_t quantMode, int64_t groupListType,
+        const aclIntArray *tuningConfigOptional,  double swigluLimit,
+        aclTensor *output, aclTensor *outputScale,
+        uint64_t *workspaceSize, aclOpExecutor **executor);
+
+/**
+ * @brief aclnnGroupedMatmulSwigluQuantWeightNzV2的第二段接口，用于执行计算。
+ * @param [in] workspace: 在npu device侧申请的workspace内存起址。
+ * @param [in] workspaceSize: 在npu
+ * device侧申请的workspace大小，由第一段接口aclnnGroupedMatmulSwigluQuantWeightNzV2GetWorkspaceSize获取。
+ * @param [in] stream: acl stream流。
+ * @param [in] executor: op执行器，包含了算子计算流程。
+ * @return aclnnStatus: 返回状态码。
+ */
+__attribute__((visibility("default"))) aclnnStatus aclnnGroupedMatmulSwigluQuantWeightNzV2(void *workspace,
+                                                                                           uint64_t workspaceSize,
+                                                                                           aclOpExecutor *executor,
+                                                                                           aclrtStream stream);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/op_api/gmm_dsq_base.h

@@ -0,0 +1,682 @@
+/**
+ * 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_HOST_OP_API_ACLNN_GMM_DSQ_BASE_H
+#define OP_HOST_OP_API_ACLNN_GMM_DSQ_BASE_H
+
+#include "grouped_matmul_swiglu_quant_utils.h"
+
+namespace gmm_dsq_base {
+
+using namespace gmm_dsq;
+
+constexpr int64_t SPLIT = 2L;
+constexpr int64_t K_LIMIT_A8W8 = 65536L;
+constexpr int64_t K_LIMIT_A8W4 = 20000L;
+constexpr int64_t N_LIMIT = 10240L;
+constexpr int64_t NZ_DIM_4_INT8 = 32L;
+constexpr int64_t NZ_DIM_4_INT4 = 64L;
+constexpr int64_t NZ_DIM_3 = 16L;
+constexpr int64_t OUTPUT_IDX_0 = 0L;
+constexpr int64_t OUTPUT_IDX_1 = 1L;
+constexpr int64_t DIM_IDX_0 = 0L;
+constexpr int64_t DIM_IDX_1 = 1L;
+constexpr int64_t DIM_IDX_2 = 2L;
+constexpr int64_t DIM_IDX_3 = 4L;
+constexpr size_t X_DIM_LIMIT = 2UL;
+constexpr size_t MULTI_WEIGHT_NZ_DIM_LIMIT = 4UL;
+constexpr size_t MULTI_WEIGHT_ND_DIM_LIMIT = 2UL;
+constexpr size_t WEIGHT_SCALE_DIM_LIMIT = 2UL;
+constexpr size_t SINGLE_WEIGHT_SCALE_PERGROUP_DIM_LIMIT = 3UL;
+constexpr size_t SINGLE_WEIGHT_SCALE_PERCHANNEL_DIM_LIMIT = 2UL;
+constexpr size_t MULTI_WEIGHT_SCALE_PERGROUP_DIM_LIMIT = 2UL;
+constexpr size_t MULTI_WEIGHT_SCALE_PERCHANNEL_DIM_LIMIT = 1UL;
+constexpr size_t TOKEN_SCALE_DIM_LIMIT = 1UL;
+constexpr size_t SINGLE_WEIGHT_ASSIST_MATRIX_DIM_LIMIT = 2UL;
+constexpr size_t MULTI_WEIGHT_ASSIST_MATRIX_DIM_LIMIT = 1UL;
+constexpr size_t GROUP_LIST_DIM_LIMIT = 1UL;
+constexpr size_t QUANTOUT_DIM_LIMIT = 2UL;
+constexpr size_t QUANTSCALEOUT_DIM_LIMIT = 1UL;
+constexpr size_t INT4_PER_INT32 = 8UL;
+constexpr size_t NZ_ALIGN_K = 16UL;
+constexpr size_t NZ_ALIGN_N = 32UL;
+constexpr size_t SMOOTH_SCALE_1D_DIM_LIMIT = 1UL;
+constexpr size_t SMOOTH_SCALE_2D_DIM_LIMIT = 2UL;
+
+const std::initializer_list<DataType> X_DTYPE_SUPPORT_LIST = {DataType::DT_INT8, DataType::DT_INT4};
+const std::initializer_list<DataType> WEIGHT_DTYPE_SUPPORT_LIST = {DataType::DT_INT8, DataType::DT_INT4};
+const std::initializer_list<DataType> WEIGHT_SCALE_DTYPE_SUPPORT_LIST = {
+    DataType::DT_FLOAT, DataType::DT_FLOAT16, DataType::DT_BF16};
+const std::initializer_list<DataType> WEIGHT_SCALE_A8W4_DTYPE_SUPPORT_LIST = {DataType::DT_UINT64};
+const std::initializer_list<DataType> X_SCALE_DTYPE_SUPPORT_LIST = {DataType::DT_FLOAT};
+const std::initializer_list<DataType> GROUP_LIST_DTYPE_SUPPORT_LIST = {DataType::DT_INT64};
+const std::initializer_list<DataType> QUANTOUT_DTYPE_SUPPORT_LIST = {DataType::DT_INT8};
+const std::initializer_list<DataType> QUANTSCALEOUT_DTYPE_SUPPORT_LIST = {DataType::DT_FLOAT};
+const std::initializer_list<DataType> WEIGHT_ASSIST_DTYPE_SUPPORT_LIST = {DataType::DT_FLOAT};
+const std::initializer_list<DataType> SMOOTH_SCALE_DTYPE_SUPPORT_LIST = {DataType::DT_FLOAT};
+
+class GroupedMatmulSwigluQuantBaseHandler : public GroupedMatmulSwigluQuantHandler {
+protected:
+    bool CheckInputOutDimsA8W8()
+    {
+        OP_CHECK_WRONG_DIMENSION(gmmDsqParams_.x, X_DIM_LIMIT, return false);
+        size_t wLength = gmmDsqParams_.weight->Size();
+        for (size_t i = 0; i < wLength; i++) {
+            const aclTensor* w = (*gmmDsqParams_.weight)[i];
+            const aclTensor* wScale = (*gmmDsqParams_.weightScale)[i];
+            op::Format wFormat = w->GetViewFormat();
+            if (wLength == static_cast<size_t>(1)) { // 单Tensor场景
+                if (IsPrivateFormat(wFormat)) {
+                    OP_CHECK_WRONG_DIMENSION(w, WEIGHT_NZ_DIM_LIMIT, return false);
+                } else {
+                    OP_CHECK_WRONG_DIMENSION(w, WEIGHT_ND_DIM_LIMIT, return false);
+                }
+                OP_CHECK_WRONG_DIMENSION(wScale, WEIGHT_SCALE_DIM_LIMIT, return false);
+            } else { // 多Tensor场景
+                if (IsPrivateFormat(wFormat)) {
+                    OP_CHECK_WRONG_DIMENSION(w, MULTI_WEIGHT_NZ_DIM_LIMIT, return false);
+                } else {
+                    OP_CHECK_WRONG_DIMENSION(w, MULTI_WEIGHT_ND_DIM_LIMIT, return false);
+                }
+                OP_CHECK_WRONG_DIMENSION(wScale, MULTI_WEIGHT_SCALE_PERCHANNEL_DIM_LIMIT, return false);
+            }
+        }
+
+        OP_CHECK_WRONG_DIMENSION(gmmDsqParams_.xScale, TOKEN_SCALE_DIM_LIMIT, return false);
+        OP_CHECK_WRONG_DIMENSION(gmmDsqParams_.groupList, GROUP_LIST_DIM_LIMIT, return false);
+        OP_CHECK_WRONG_DIMENSION(gmmDsqParams_.output, QUANTOUT_DIM_LIMIT, return false);
+        OP_CHECK_WRONG_DIMENSION(gmmDsqParams_.outputScale, QUANTSCALEOUT_DIM_LIMIT, return false);
+        return true;
+    }
+
+    bool CheckInputOutDimsA4W4orA8W4()
+    {
+        OP_CHECK_WRONG_DIMENSION(gmmDsqParams_.x, X_DIM_LIMIT, return false);
+        if (gmmDsqParams_.isA4W4 && gmmDsqParams_.weightAssistMatrix != nullptr) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "In the A4W4 scenario, the weightAssistMatrix input must be nullptr.");
+            return false;
+        } else if (gmmDsqParams_.isA8W4 && gmmDsqParams_.weightAssistMatrix == nullptr) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "In the A8W4 scenario, the weightAssistMatrix input must not be nullptr.");
+            return false;
+        }
+        size_t wLength = gmmDsqParams_.weight->Size();
+        for (size_t i = 0; i < wLength; i++) {
+            const aclTensor* w = (*gmmDsqParams_.weight)[i];
+            const aclTensor* wScale = (*gmmDsqParams_.weightScale)[i];
+            op::Format weightViewFormat = w->GetViewFormat();
+            bool isSingle = (wLength == 1);
+            // 检查权重维度
+            OP_CHECK_WRONG_DIMENSION(w,
+                (isSingle ?
+                    (IsPrivateFormat(weightViewFormat) ? WEIGHT_NZ_DIM_LIMIT : WEIGHT_ND_DIM_LIMIT) :
+                    (IsPrivateFormat(weightViewFormat) ? MULTI_WEIGHT_NZ_DIM_LIMIT : MULTI_WEIGHT_ND_DIM_LIMIT)),
+                return false);
+            // 检查权重Scale维度
+            OP_CHECK_WRONG_DIMENSION(wScale,
+                (isSingle ?
+                    (gmmDsqParams_.dequantMode == 0 ? SINGLE_WEIGHT_SCALE_PERCHANNEL_DIM_LIMIT : SINGLE_WEIGHT_SCALE_PERGROUP_DIM_LIMIT) :
+                    (gmmDsqParams_.dequantMode == 0 ? MULTI_WEIGHT_SCALE_PERCHANNEL_DIM_LIMIT : MULTI_WEIGHT_SCALE_PERGROUP_DIM_LIMIT)),
+                return false);
+            // 检查辅助矩阵（A8W4模式）
+            if (gmmDsqParams_.isA8W4) {
+                const aclTensor* weightAssistMatrix = (*gmmDsqParams_.weightAssistMatrix)[i];
+                OP_CHECK_WRONG_DIMENSION(weightAssistMatrix,
+                    (isSingle ? SINGLE_WEIGHT_ASSIST_MATRIX_DIM_LIMIT : MULTI_WEIGHT_ASSIST_MATRIX_DIM_LIMIT),
+                    return false);
+            }
+        }
+        OP_CHECK_WRONG_DIMENSION(gmmDsqParams_.xScale, TOKEN_SCALE_DIM_LIMIT, return false);
+        OP_CHECK_WRONG_DIMENSION(gmmDsqParams_.groupList, GROUP_LIST_DIM_LIMIT, return false);
+        OP_CHECK_WRONG_DIMENSION(gmmDsqParams_.output, QUANTOUT_DIM_LIMIT, return false);
+        OP_CHECK_WRONG_DIMENSION(gmmDsqParams_.outputScale, QUANTSCALEOUT_DIM_LIMIT, return false);
+        return true;
+    }
+
+    bool CheckSingleTensorListTypeA8W8(int64_t e, int64_t k, int64_t n)
+    {
+        // weight的NDshape期望为[E, K, N]
+        op::Shape weightNDExpectShape1 = {e, k, n};
+        // 单tesnsor weight的NZshape期望为[E, N // 32, K // 16, 16, 32]
+        op::Shape weightNZExpectShape1 = {e, static_cast<int64_t>(n / NZ_DIM_4_INT8), static_cast<int64_t>(k / NZ_DIM_3),
+                                        NZ_DIM_3, NZ_DIM_4_INT8};
+        // weight的NDshape期望为[K, N]
+        op::Shape weightNDExpectShape2 = {k, n};
+        // weight的NZshape期望为[N // 32, K // 16, 16, 32]
+        op::Shape weightNZExpectShape2 = {static_cast<int64_t>(n / NZ_DIM_4_INT8), static_cast<int64_t>(k / NZ_DIM_3),
+                                        NZ_DIM_3, NZ_DIM_4_INT8};
+
+        // weightScale的shape期望为[E, N]
+        op::Shape weightScaleExpectShape1 = {e, n};
+        op::Shape weightScaleExpectShape2 = {n};
+
+        const aclTensor* w = (*gmmDsqParams_.weight)[0];
+        const aclTensor* wScale = (*gmmDsqParams_.weightScale)[0];
+
+        op::Format wFormat = w->GetViewFormat();
+        op::Format storageFormat = w->GetStorageFormat();
+        if (IsPrivateFormat(wFormat)) {
+            if (!(w->GetViewShape() == weightNZExpectShape1 || w->GetViewShape() == weightNZExpectShape2)) {
+                OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected tensor for weight to have same size as %s or %s, but got %s.",
+                        op::ToString(weightNZExpectShape1).GetString(),
+                        op::ToString(weightNZExpectShape2).GetString(),
+                        op::ToString(w->GetViewShape()).GetString());
+                return false;
+            }
+        } else {
+            if (!(w->GetViewShape() == weightNDExpectShape1 || w->GetViewShape() == weightNDExpectShape2)) {
+                OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected tensor for weight to have same size as %s or %s, but got %s.",
+                        op::ToString(weightNDExpectShape1).GetString(),
+                        op::ToString(weightNDExpectShape2).GetString(),
+                        op::ToString(w->GetViewShape()).GetString());
+                return false;
+            }
+
+            if (IsPrivateFormat(storageFormat) && (k % NZ_ALIGN_K != 0 || n % NZ_ALIGN_N != 0)) {
+                OP_LOGE(ACLNN_ERR_PARAM_INVALID, "In W8a8 Nz mode, k should align to 16, n align to 32");
+                return false;
+            }
+        }
+
+        if (!(wScale->GetViewShape() == weightScaleExpectShape1 || wScale->GetViewShape() == weightScaleExpectShape2)) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected tensor for weight_scale to have same size as %s or %s, but got %s.",
+                    op::ToString(weightScaleExpectShape1).GetString(),
+                    op::ToString(weightScaleExpectShape2).GetString(),
+                    op::ToString(wScale->GetViewShape()).GetString());
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckMultiTensorTypeA8W8(int64_t k, int64_t n)
+    {
+        // weight的NDshape期望为[K, N]
+        op::Shape weightNDExpectShape = {k, n};
+        // weight的NZshape期望为[N // 32, K // 16, 16, 32]
+        op::Shape weightNZExpectShape = {static_cast<int64_t>(n / NZ_DIM_4_INT8), static_cast<int64_t>(k / NZ_DIM_3),
+                                        NZ_DIM_3, NZ_DIM_4_INT8};
+
+        // weightScale的shape期望为[N]
+        op::Shape weightScaleExpectShape = {n};
+        size_t wLength = gmmDsqParams_.weight->Size();
+
+        for (size_t i = 0; i < wLength; i++) {
+            const aclTensor* w = (*gmmDsqParams_.weight)[0];
+            const aclTensor* wScale = (*gmmDsqParams_.weightScale)[0];
+            op::Format wFormat = w->GetViewFormat();
+            op::Format storageFormat = w->GetStorageFormat();
+            if (IsPrivateFormat(wFormat)) {
+                OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(w, weightNZExpectShape, return false);
+            } else {
+                OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(w, weightNDExpectShape, return false);
+                if (IsPrivateFormat(storageFormat) && (k % NZ_ALIGN_K != 0 || n % NZ_ALIGN_N != 0)) {
+                    OP_LOGE(ACLNN_ERR_PARAM_INVALID, "In W8a8 Nz mode, k should align to 16, n align to 32");
+                    return false;
+                }
+            }
+            OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(wScale, weightScaleExpectShape, return false);
+        }
+
+        return true;
+    }
+
+    bool CheckTensorListShapeA8W8(int64_t e,int64_t k, int64_t n)
+    {
+        size_t wLength = gmmDsqParams_.weight->Size();
+        if (wLength == static_cast<size_t>(1)) {
+            return CheckSingleTensorListTypeA8W8(e, k, n);
+        }
+
+        return CheckMultiTensorTypeA8W8(k, n);
+    }
+
+    bool CheckInputOutShapeA8W8()
+    {
+        int64_t m = gmmDsqParams_.x->GetViewShape().GetDim(0);
+        int64_t k = gmmDsqParams_.x->GetViewShape().GetDim(1);
+        auto n_index = ((*gmmDsqParams_.weightScale)[0])->GetViewShape().GetDimNum() - 1;
+        int64_t n = ((*gmmDsqParams_.weightScale)[0])->GetViewShape().GetDim(n_index);
+        size_t wLength = gmmDsqParams_.weight->Size();
+        int64_t e = wLength;
+        if (wLength == static_cast<size_t>(1)) {
+            e = ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(0);
+        }
+        if (n % SPLIT != 0) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "%s, N is %ld , not an even number.", interfaceName_.c_str(), n);
+            return false;
+        }
+        int64_t nAfterHalve = static_cast<int64_t>(n / SPLIT);
+        // x的shape期望为[M, K]
+        op::Shape xExpectShape = {m, k};
+        // xScale的shape期望为[E, N]
+        op::Shape xScaleExpectShape = {m};
+        // output的shape期望为[M, N / 2]
+        op::Shape outputExpectShape = {m, nAfterHalve};
+        // outputScale的shape期望为[M]
+        op::Shape outputScaleExpectShape = {m};
+
+        auto ret = CheckTensorListShapeA8W8(e, k, n);
+        if (!ret) {
+            return false;
+        }
+
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(gmmDsqParams_.x, xExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(gmmDsqParams_.xScale, xScaleExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(gmmDsqParams_.output, outputExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(gmmDsqParams_.outputScale, outputScaleExpectShape, return false);
+        // groupList的长度应小于等于weight的专家数
+        int64_t groupListLen = gmmDsqParams_.groupList->GetViewShape().GetDim(0);
+        if (groupListLen > e) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "%s A8W8, Length of 'groupList' out of range (expected to be in range of [1, "
+                    "%ld], but got %ld)", interfaceName_.c_str(),
+                    e, groupListLen);
+            return false;
+        }
+        if (n > N_LIMIT) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "%s A8W8: The current version does not support the scenario that "
+                    "N(%ld) is greater than %ld.", interfaceName_.c_str(),
+                    n, N_LIMIT);
+            return false;
+        }
+        if (k >= K_LIMIT_A8W8) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "%s A8W8, The current version does not support the scenario."
+                    "The tail axis dimension of input0(x) is %ld, which need lower than %ld.",
+                    interfaceName_.c_str(), k, K_LIMIT_A8W8);
+            return false;
+        }
+        if (gmmDsqParams_.smoothScale != nullptr) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "%s, smoothScale must be nullptr in A8W8 scenario.", interfaceName_.c_str());
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckSingleTensorListTypeA8W4orA4W4(int64_t e, int64_t k, int64_t n)
+    {
+        // weight的NDshape期望为[E, K, N]
+        op::Shape weightNDExpectShape = {e, k, n};
+        // 单tesnsor weight的NZshape期望为[E, N // 64, K // 16, 16, 64]
+        op::Shape weightNZExpectShape = {e, static_cast<int64_t>(n / NZ_DIM_4_INT4), static_cast<int64_t>(k / NZ_DIM_3),
+                                        NZ_DIM_3, NZ_DIM_4_INT4};
+        // 单tensor NZ转置
+        op::Shape weightNZTransposeExpectShape1 = {e, static_cast<int64_t>(k / NZ_DIM_4_INT4), static_cast<int64_t>(n / NZ_DIM_3),
+                                        NZ_DIM_4_INT4, NZ_DIM_3};
+        op::Shape weightNZTransposeExpectShape2 = {e, static_cast<int64_t>(k / NZ_DIM_4_INT4), static_cast<int64_t>(n / NZ_DIM_3),
+                                        NZ_DIM_3, NZ_DIM_4_INT4};
+
+        // 辅助矩阵的shape期望为[E, N]
+        op::Shape weightAssistMatrixExpectShape = {e, n};
+
+        const aclTensor* w = (*gmmDsqParams_.weight)[0];
+        const aclTensor* weightAssistMatrix = nullptr;
+        if (gmmDsqParams_.weightAssistMatrix != nullptr && (*gmmDsqParams_.weightAssistMatrix)[0] != nullptr) {
+            weightAssistMatrix = (*gmmDsqParams_.weightAssistMatrix)[0];
+            OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(weightAssistMatrix, weightAssistMatrixExpectShape, return false);
+        }
+        op::Format weightViewFormat = w->GetViewFormat();
+        if (IsPrivateFormat(weightViewFormat)) {
+            if (!(w->GetViewShape() == weightNZExpectShape || w->GetViewShape() == weightNZTransposeExpectShape1 || w->GetViewShape() == weightNZTransposeExpectShape2)) {
+                OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Expected tensor for weight to have same size as %s %s or %s, but got %s.",
+                        op::ToString(weightNZExpectShape).GetString(),
+                        op::ToString(weightNZTransposeExpectShape1).GetString(),
+                        op::ToString(weightNZTransposeExpectShape2).GetString(),
+                        op::ToString(w->GetViewShape()).GetString());
+                return false;
+            }
+        } else {
+            OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(w, weightNDExpectShape, return false);
+        }
+        return true;
+    }
+
+    bool CheckMultiTensorTypeA8W4orA4W4(int64_t k, int64_t n)
+    {
+        // weight的NDshape期望为[K, N]
+        op::Shape weightNDExpectShape = {k, n};
+        // weight的NZshape期望为[N // 64, K // 16, 16, 64]
+        op::Shape weightNZExpectShape = {static_cast<int64_t>(n / NZ_DIM_4_INT4), static_cast<int64_t>(k / NZ_DIM_3),
+                                        NZ_DIM_3, NZ_DIM_4_INT4};
+
+        op::Shape weightAssistMatrixExpectShape = {n};
+        size_t wLength = gmmDsqParams_.weight->Size();
+
+        for (size_t i = 0; i < wLength; i++) {
+            const aclTensor* w = (*gmmDsqParams_.weight)[i];
+            const aclTensor* weightAssistMatrix = nullptr;
+            if (gmmDsqParams_.weightAssistMatrix != nullptr && (*gmmDsqParams_.weightAssistMatrix)[i] != nullptr) {
+                weightAssistMatrix = (*gmmDsqParams_.weightAssistMatrix)[i];
+                OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(weightAssistMatrix, weightAssistMatrixExpectShape, return false);
+            }
+            op::Format weightViewFormat = w->GetViewFormat();
+            if (IsPrivateFormat(weightViewFormat)) {
+                OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(w, weightNZExpectShape, return false);
+            } else {
+                OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(w, weightNDExpectShape, return false);
+            }
+        }
+
+        return true;
+    }
+
+    bool CheckSmoothScaleA4W4(int64_t e, int64_t nAfterHalve)
+    {
+        if (gmmDsqParams_.smoothScale == nullptr) {
+            return true;
+        }
+        OP_CHECK_DTYPE_NOT_SUPPORT(gmmDsqParams_.smoothScale, SMOOTH_SCALE_DTYPE_SUPPORT_LIST, return false);
+        size_t dimNum = gmmDsqParams_.smoothScale->GetViewShape().GetDimNum();
+        if (dimNum == SMOOTH_SCALE_1D_DIM_LIMIT) {
+            op::Shape expectShape = {e};
+            OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(gmmDsqParams_.smoothScale, expectShape, return false);
+        } else if (dimNum == SMOOTH_SCALE_2D_DIM_LIMIT) {
+            op::Shape expectShape = {e, nAfterHalve};
+            OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(gmmDsqParams_.smoothScale, expectShape, return false);
+        } else {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "%s, smoothScale dimNum should be 1 or 2 in A4W4 scenario, but got %lu.",
+                    interfaceName_.c_str(), dimNum);
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckTensorListShapeA8W4orA4W4(int64_t e, int64_t k, int64_t n)
+    {
+        size_t wLength = gmmDsqParams_.weight->Size();
+        if (wLength == static_cast<size_t>(1)) {
+            return CheckSingleTensorListTypeA8W4orA4W4(e, k, n);
+        }
+
+        return CheckMultiTensorTypeA8W4orA4W4(k, n);
+    }
+
+    bool CheckInputOutShapeA8W4orA4W4()
+    {
+        int64_t m = gmmDsqParams_.x->GetViewShape().GetDim(0);
+        int64_t k = gmmDsqParams_.x->GetViewShape().GetDim(1);
+        int64_t e = 1;
+        int64_t n = 1;
+        int64_t KGroupCount = 1; // K轴的组数，perchannel场景相当于pergroup场景中的组数为1
+        int64_t KGroupSize = k;  // K轴每组的元素个数
+        op::Shape weightScaleExpectShape;
+        size_t wLength = gmmDsqParams_.weight->Size();
+        if (gmmDsqParams_.dequantMode == 0 && wLength == static_cast<size_t>(1)) {
+            e = ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(0);
+            // weightScale入参在perchannel单tensor场景期望shape [E, N]
+            n = ((*gmmDsqParams_.weightScale)[0])->GetViewShape().GetDim(DIM_IDX_1);
+            weightScaleExpectShape = {e, n}; // 单
+        } else if (gmmDsqParams_.dequantMode == 0 && wLength != static_cast<size_t>(1)) {
+            e = wLength;
+            // weightScale入参在perchannel多tensor场景期望shape [N]
+            n = ((*gmmDsqParams_.weightScale)[0])->GetViewShape().GetDim(DIM_IDX_0);
+            weightScaleExpectShape = {n}; // 多
+        } else if (gmmDsqParams_.dequantMode == 1 && wLength == static_cast<size_t>(1)) {
+            e = ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(0);
+            // weightScale入参在pergroup单tensor场景期望shape [E, KGroupCount, N]
+            n = ((*gmmDsqParams_.weightScale)[0])->GetViewShape().GetDim(DIM_IDX_2);
+            KGroupCount = ((*gmmDsqParams_.weightScale)[0])->GetViewShape().GetDim(DIM_IDX_1);
+            KGroupSize = KGroupCount > 0 ? k / KGroupCount : k;
+            weightScaleExpectShape = {e, KGroupCount, n}; // 单
+        } else if (gmmDsqParams_.dequantMode == 1 && wLength != static_cast<size_t>(1)) {
+            e = wLength;
+            // weightScale入参在pergroup多tensor场景期望shape [KGroupCount, N]
+            n = ((*gmmDsqParams_.weightScale)[0])->GetViewShape().GetDim(DIM_IDX_1);
+            KGroupCount = ((*gmmDsqParams_.weightScale)[0])->GetViewShape().GetDim(DIM_IDX_0);
+            KGroupSize = KGroupCount > 0 ? k / KGroupCount : k;
+            weightScaleExpectShape = {KGroupCount, n}; // 多
+        }
+        if (KGroupCount == 0 || k % KGroupCount != 0) {
+            OP_LOGE(
+                ACLNN_ERR_PARAM_INVALID,
+                "%s, "
+                "The number of groups along the k-axis is %ld, and the length of the k-axis is %ld, which is illegal. "
+                "The number of groups must be greater than 0, and k-axis length %% number of groups == 0 must be true.",
+                interfaceName_.c_str(), KGroupCount, k);
+            return false;
+        }
+        if (n % SPLIT != 0) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "%s, N is %ld , not an even number.", interfaceName_.c_str(), n);
+            return false;
+        }
+        int64_t nAfterHalve = static_cast<int64_t>(n / SPLIT);
+        // x的shape期望为[M, K]
+        op::Shape xExpectShape = {m, k};
+        // xScale的shape期望为[E, N]
+        op::Shape xScaleExpectShape = {m};
+        // output的shape期望为[M, N / 2]
+        op::Shape outputExpectShape = {m, nAfterHalve};
+        // outputScale的shape期望为[M]
+        op::Shape outputScaleExpectShape = {m};
+        auto ret = CheckTensorListShapeA8W4orA4W4(e, k, n);
+        if (!ret) {
+            return false;
+        }
+
+        for (size_t i = 0; i < wLength; i++) {
+            const aclTensor* wScale = (*gmmDsqParams_.weightScale)[i];
+            OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(wScale, weightScaleExpectShape, return false);
+        }
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(gmmDsqParams_.x, xExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(gmmDsqParams_.xScale, xScaleExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(gmmDsqParams_.output, outputExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(gmmDsqParams_.outputScale, outputScaleExpectShape, return false);
+        // groupList的长度应小于等于weight的专家数
+        int64_t groupListLen = gmmDsqParams_.groupList->GetViewShape().GetDim(0);
+        if (groupListLen > e) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "%s A8W4 or A4W4, Length of 'groupList' out of range (expected to be in range of [1, "
+                    "%ld], but got %ld)", interfaceName_.c_str(),
+                    e, groupListLen);
+            return false;
+        }
+        if (n > N_LIMIT) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "%s A8W4 or A4W4: The current version does not support the scenario that "
+                    "N(%ld) is greater than %ld.", interfaceName_.c_str(),
+                    n, N_LIMIT);
+            return false;
+        }
+        if (k >= K_LIMIT_A8W4) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "%s A8W4 or A4W4, The current version does not support the scenario."
+                    "The tail axis dimension of input0(x) is %ld, which need lower than %ld.",
+                    interfaceName_.c_str(), k, K_LIMIT_A8W4);
+            return false;
+        }
+        if (gmmDsqParams_.isA4W4) {
+            if (!CheckSmoothScaleA4W4(e, nAfterHalve)) {
+                return false;
+            }
+        } else if (gmmDsqParams_.isA8W4 && gmmDsqParams_.smoothScale != nullptr) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "%s, smoothScale must be nullptr in A8W4 scenario.", interfaceName_.c_str());
+            return false;
+        }
+        (void)KGroupSize;
+        return true;
+    }
+
+    bool IsTransposeLastTwoDims(const aclTensor *tensor)
+    {
+        auto shape = tensor->GetViewShape();
+        int64_t dim1 = shape.GetDimNum() - 1;
+        int64_t dim2 = shape.GetDimNum() - 2;
+        auto strides = tensor->GetViewStrides();
+        if (strides[dim2] == 1 && strides[dim1] == shape.GetDim(dim2)) {
+            int64_t tmpNxD = shape.GetDim(dim1) * shape.GetDim(dim2);
+            for (int64_t batchDim = shape.GetDimNum() - 3; batchDim >= 0; batchDim--) {
+                if (strides[batchDim] != tmpNxD) {
+                    return false;
+                }
+                tmpNxD *= shape.GetDim(batchDim);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    void UnpackInt32ToInt4(const aclTensor *&tensorS32, const std::string &tensorType)
+    {
+        OP_LOGD("Unpack %s from int32 to int4 start.", tensorType.c_str());
+        auto tensorS4 = const_cast<aclTensor *>(tensorS32);
+        op::Shape tensorShape = tensorS4->GetViewShape();
+        auto viewShapeDim = tensorShape.GetDimNum();
+        op::Strides newStride = tensorS4->GetViewStrides();
+        bool transposeTensor = false;
+        auto changeDimIdx = viewShapeDim - 1;
+        // 轴大于等于2才判断是否转置
+        if (viewShapeDim >= DIM_IDX_2 && IsTransposeLastTwoDims(tensorS4)) {
+            transposeTensor = true;
+            changeDimIdx = viewShapeDim - DIM_IDX_2;
+        }
+        tensorShape[changeDimIdx] = tensorShape.GetDim(changeDimIdx) * INT4_PER_INT32;
+        bool isNz = tensorS4->GetStorageFormat() == op::Format::FORMAT_FRACTAL_NZ;
+        tensorS4->SetViewShape(tensorShape);
+        tensorS4->SetDataType(DataType::DT_INT4);
+        if (isNz){
+            OP_LOGD("Reset %s storageShape because tensor is NZ format.", tensorType.c_str());
+            auto storageShape = tensorS4->GetStorageShape();
+            auto storageShapeDim = storageShape.GetDimNum();
+            storageShape[storageShapeDim - 1] *= INT4_PER_INT32;
+            tensorS4->SetStorageShape(storageShape);
+        }
+        if (transposeTensor) {
+            OP_LOGD("Reset %s stride because tensor is transposed.", tensorType.c_str());
+            auto strideSize = newStride.size();
+            // 转置场景，B32承载B4时Strides缩小了8倍，需要调整回来
+            newStride[strideSize - 1] *= INT4_PER_INT32;
+            for(int64_t batchDim = strideSize - 3; batchDim >= 0; batchDim--) {
+                newStride[batchDim] *= INT4_PER_INT32;
+            }
+            tensorS4->SetViewStrides(newStride);
+        }
+        OP_LOGD("Unpack %s from int32 to int4 finished.", tensorType.c_str());
+    }
+
+    bool CheckInputOutDims() override
+    {
+        if (gmmDsqParams_.x->GetDataType() == DataType::DT_INT8
+                && ((*gmmDsqParams_.weight)[0])->GetDataType() == DataType::DT_INT8) {
+            return CheckInputOutDimsA8W8();
+        }
+        // A8W4或者A4W4场景 INT32为兼容torch_npu考虑，实际计算时，1个INT32数据会被视为8个INT4数据
+        if (gmmDsqParams_.isA8W4 || gmmDsqParams_.isA4W4) {
+            bool transposeWeight = IsTransposeLastTwoDims((*gmmDsqParams_.weight)[0]);
+            gmmDsqParams_.transposeWeight = transposeWeight;
+            // 将INT32视为8个Int4数据，调整viewShape和dtype便于后续统一校验
+            if (gmmDsqParams_.x->GetDataType() == DataType::DT_INT32) {
+                UnpackInt32ToInt4(gmmDsqParams_.x, "x");
+            }
+            if (((*gmmDsqParams_.weight)[0])->GetDataType() == DataType::DT_INT32) {
+                size_t wLength = gmmDsqParams_.weight->Size();
+                for (size_t i = 0; i < wLength; i++) {
+                    const aclTensor *w = (*gmmDsqParams_.weight)[i];
+                    UnpackInt32ToInt4(w, "weight");
+                }
+            }
+
+            if (transposeWeight == true){
+                const aclTensor* w = (*gmmDsqParams_.weight)[0];
+                bool isNZ = w->GetStorageFormat() == op::Format::FORMAT_FRACTAL_NZ;
+                if (!isNZ) {
+                    OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                            "In weight Transpose scenario.weight Format expect is FRACTAL_NZ when weight is transposed, but got [%s].",
+                            op::ToString(w->GetStorageFormat()).GetString());
+                    return false;
+                }
+                if (!gmmDsqParams_.isA4W4) {
+                    OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                            "In weight Transpose scenario, only A4W4 is supported.");
+                    return false;
+                }
+            }
+            if (((*gmmDsqParams_.weightScale)[0])->GetDataType() == DataType::DT_INT64) {
+                size_t weightScaleLength = gmmDsqParams_.weightScale->Size();
+                for (size_t i = 0; i < weightScaleLength; i++) {
+                    auto weightScale_fix = const_cast<aclTensor *>((*gmmDsqParams_.weightScale)[i]);
+                    weightScale_fix->SetDataType(DataType::DT_UINT64);
+                }
+            }
+            return CheckInputOutDimsA4W4orA8W4();
+        }
+        return false;
+    }
+
+    bool CheckInputOutShape() override
+    {
+        if (gmmDsqParams_.x->GetDataType() == DataType::DT_INT8
+                && ((*gmmDsqParams_.weight)[0])->GetDataType() == DataType::DT_INT8) {
+            return CheckInputOutShapeA8W8();
+        }
+        // A8W4场景或A4W4场景
+        if (gmmDsqParams_.isA8W4 || gmmDsqParams_.isA4W4) {
+            return CheckInputOutShapeA8W4orA4W4();
+        }
+        return false;
+    }
+
+    bool CheckDtypeValid() override
+    {
+        size_t wLength = gmmDsqParams_.weight->Size();
+        for (size_t i = 0; i < wLength; i++) {
+            const aclTensor* wScale = (*gmmDsqParams_.weightScale)[i];
+            const aclTensor* w = (*gmmDsqParams_.weight)[i];
+
+            OP_CHECK_DTYPE_NOT_SUPPORT(w, WEIGHT_DTYPE_SUPPORT_LIST, return false);
+
+            if (w->GetDataType() == DataType::DT_INT4) {
+                OP_CHECK_DTYPE_NOT_SUPPORT(wScale, WEIGHT_SCALE_A8W4_DTYPE_SUPPORT_LIST, return false);
+                if (gmmDsqParams_.weightAssistMatrix != nullptr && (*gmmDsqParams_.weightAssistMatrix)[i] != nullptr) {
+                    const aclTensor* weightAssistMatrix = (*gmmDsqParams_.weightAssistMatrix)[i];
+                    OP_CHECK_DTYPE_NOT_SUPPORT(weightAssistMatrix, WEIGHT_ASSIST_DTYPE_SUPPORT_LIST, return false);
+                }
+            } else if (w->GetDataType() == DataType::DT_INT8) {
+                OP_CHECK_DTYPE_NOT_SUPPORT(wScale, WEIGHT_SCALE_DTYPE_SUPPORT_LIST, return false);
+            }
+        }
+        OP_CHECK_DTYPE_NOT_SUPPORT(gmmDsqParams_.x, X_DTYPE_SUPPORT_LIST, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(gmmDsqParams_.xScale, X_SCALE_DTYPE_SUPPORT_LIST, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(gmmDsqParams_.groupList, GROUP_LIST_DTYPE_SUPPORT_LIST, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(gmmDsqParams_.output, QUANTOUT_DTYPE_SUPPORT_LIST, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(gmmDsqParams_.outputScale, QUANTSCALEOUT_DTYPE_SUPPORT_LIST, return false);
+
+        return true;
+    }
+
+    bool CheckFormat() override
+    {
+        const aclTensor* w = (*gmmDsqParams_.weight)[0];
+        bool isNZ = w->GetStorageFormat() == op::Format::FORMAT_FRACTAL_NZ;
+        if ((gmmDsqParams_.x->GetDataType() == DataType::DT_INT8 && w->GetDataType() == DataType::DT_INT8) && !isNZ) {
+            // fp16 in fp32 out that is split k template, not precision-advanced now
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "%s, The current version does not support the scenario."
+                    "weight Format expect is FRACTAL_NZ, but got [%s].", interfaceName_.c_str(),
+                    op::ToString(w->GetStorageFormat()).GetString());
+            return false;
+        }
+        if (IsPrivateFormat(gmmDsqParams_.x->GetStorageFormat())) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "%s, The current version does not support the scenario."
+                    "x Format Not support Private Format.", interfaceName_.c_str());
+            return false;
+        }
+        if (IsPrivateFormat(gmmDsqParams_.output->GetStorageFormat())) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "%s, The current version does not support the scenario."
+                    "output Format Not support Private Format.", interfaceName_.c_str());
+            return false;
+        }
+        return true;
+    }
+};
+}
+#endif

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/op_api/grouped_matmul_swiglu_quant_utils.h

@@ -0,0 +1,409 @@
+/**
+ * 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_HOST_OP_API_GROUPED_MATMUL_SWIGLU_QUANT_UTILS_H
+#define OP_HOST_OP_API_GROUPED_MATMUL_SWIGLU_QUANT_UTILS_H
+
+#include "aclnn_kernels/contiguous.h"
+#include "acl/acl.h"
+#include "aclnn/aclnn_base.h"
+#include "aclnn_kernels/common/op_error_check.h"
+#include "opdev/common_types.h"
+#include "opdev/data_type_utils.h"
+#include "opdev/format_utils.h"
+#include "opdev/op_dfx.h"
+#include "opdev/op_executor.h"
+#include "opdev/op_log.h"
+#include "opdev/platform.h"
+#include "opdev/shape_utils.h"
+#include "opdev/tensor_view_utils.h"
+#include "opdev/make_op_executor.h"
+#include "grouped_matmul_swiglu_quant_v2.h"
+
+namespace gmm_dsq {
+using namespace op;
+constexpr int64_t OUTPUT_IDX_0 = 0L;
+constexpr int64_t OUTPUT_IDX_1 = 1L;
+constexpr size_t WEIGHT_NZ_DIM_LIMIT = 5UL;
+constexpr size_t WEIGHT_ND_DIM_LIMIT = 3UL;
+
+struct GroupedMatmulSwigluQuantParamsBase {
+    const aclTensor *x = nullptr;
+    const aclTensorList *weight = nullptr;
+    const aclTensorList *weightScale = nullptr;
+    const aclTensorList *weightAssistMatrix = nullptr;
+    const aclTensor *xScale = nullptr;
+    const aclTensor *bias = nullptr;
+    const aclTensor *smoothScale = nullptr;
+    const aclTensor *groupList = nullptr;
+    const aclTensor *output = nullptr;
+    const aclTensor *outputScale = nullptr;
+    const aclIntArray *tuningConfig = nullptr;
+    int64_t dequantMode = 0;
+    int64_t dequantDtype = 0;
+    int64_t quantMode = 0;
+    int64_t quantDtype = 0;
+    int64_t groupListType = 0;
+    bool transposeWeight = false;
+    double swigluLimit=0;
+    bool isA8W4 = false;
+    bool isA4W4 = false;
+};
+
+class GroupedMatmulSwigluQuantParamsBuilder {
+public:
+    static GroupedMatmulSwigluQuantParamsBuilder Create(const aclTensor *x, const aclTensorList *weight,
+        const aclTensorList *weightScale, const aclTensor *output, const aclTensor *outputScale)
+    {
+        GroupedMatmulSwigluQuantParamsBuilder b;
+        b.p_.x = x;
+        b.p_.weight = weight;
+        b.p_.weightScale = weightScale;
+        b.p_.output = output;
+        b.p_.outputScale = outputScale;
+        return b;
+    }
+
+    GroupedMatmulSwigluQuantParamsBuilder &SetWeightAssistMatrix(const aclTensorList *weightAssistMatrix)
+    {
+        p_.weightAssistMatrix = weightAssistMatrix;
+        return *this;
+    }
+
+    GroupedMatmulSwigluQuantParamsBuilder &SetXScale(const aclTensor *xScale)
+    {
+        p_.xScale = xScale;
+        return *this;
+    }
+
+    GroupedMatmulSwigluQuantParamsBuilder &SetSmoothScale(const aclTensor *smoothScale)
+    {
+        p_.smoothScale = smoothScale;
+        return *this;
+    }
+
+    GroupedMatmulSwigluQuantParamsBuilder &SetBias(const aclTensor *bias)
+    {
+        p_.bias = bias;
+        return *this;
+    }
+
+    GroupedMatmulSwigluQuantParamsBuilder &SetGroupList(const aclTensor *groupList)
+    {
+        p_.groupList = groupList;
+        return *this;
+    }
+
+    GroupedMatmulSwigluQuantParamsBuilder &SetGroupListType(const int64_t groupListType)
+    {
+        p_.groupListType = groupListType;
+        return *this;
+    }
+
+    GroupedMatmulSwigluQuantParamsBuilder &SetTuningConfig(const aclIntArray *tuningConfig)
+    {
+        p_.tuningConfig = tuningConfig;
+        return *this;
+    }
+
+    GroupedMatmulSwigluQuantParamsBuilder &SetDequantAttr(int64_t dequantMode, int64_t dequantDtype)
+    {
+        p_.dequantMode = dequantMode;
+        p_.dequantDtype = dequantDtype;
+        return *this;
+    }
+
+    GroupedMatmulSwigluQuantParamsBuilder &SetQuantAttr(int64_t quantMode, int64_t quantDtype)
+    {
+        p_.quantMode = quantMode;
+        p_.quantDtype = quantDtype;
+        return *this;
+    }
+
+    GroupedMatmulSwigluQuantParamsBuilder &SetTransposeAttr(bool transposeWeight)
+    {
+        p_.transposeWeight = transposeWeight;
+        return *this;
+    }
+    GroupedMatmulSwigluQuantParamsBuilder &SetLimitAttr(double swigluLimit)
+    {
+        p_.swigluLimit = swigluLimit;
+        return *this;
+    }
+    GroupedMatmulSwigluQuantParamsBuilder &SetScenario()
+    {
+        p_.isA8W4 = ((this->p_.x->GetDataType() == DataType::DT_INT8 &&
+                    ((*this->p_.weight)[0])->GetDataType() == DataType::DT_INT4) ||
+                    (this->p_.x->GetDataType() == DataType::DT_INT8 &&
+                    ((*this->p_.weight)[0])->GetDataType() == DataType::DT_INT32));
+        p_.isA4W4 = ((this->p_.x->GetDataType() == DataType::DT_INT4 &&
+                    ((*this->p_.weight)[0])->GetDataType() == DataType::DT_INT4) ||
+                    (this->p_.x->GetDataType() == DataType::DT_INT4 &&
+                    ((*this->p_.weight)[0])->GetDataType() == DataType::DT_INT32) ||
+                    (this->p_.x->GetDataType() == DataType::DT_INT32 &&
+                    ((*this->p_.weight)[0])->GetDataType() == DataType::DT_INT4) ||
+                    (this->p_.x->GetDataType() == DataType::DT_INT32 &&
+                    ((*this->p_.weight)[0])->GetDataType() == DataType::DT_INT32));
+        return *this;
+    }
+
+    GroupedMatmulSwigluQuantParamsBase Build() const
+    {
+        return p_;
+    }
+
+private:
+    GroupedMatmulSwigluQuantParamsBase p_;
+};
+
+class GroupedMatmulSwigluQuantHandler {
+public:
+    virtual ~GroupedMatmulSwigluQuantHandler() = default;
+
+protected:
+    bool CheckTensorListNull(const aclTensorList *&tensors) const
+    {
+        OP_CHECK_NULL(tensors, return false);
+        if (tensors->Size() == 0) {
+            return true;
+        } else if ((tensors->Size() == 1) && ((*tensors)[0] == nullptr)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    virtual bool CheckNotNull(void)
+    {
+        OP_CHECK_NULL(gmmDsqParams_.x, return false);
+        OP_CHECK_NULL(gmmDsqParams_.weight, return false);
+        OP_CHECK_NULL(gmmDsqParams_.weightScale, return false);
+        OP_CHECK_NULL(gmmDsqParams_.xScale, return false);
+        OP_CHECK_NULL(gmmDsqParams_.groupList, return false);
+        OP_CHECK_NULL(gmmDsqParams_.output, return false);
+        OP_CHECK_NULL(gmmDsqParams_.outputScale, return false);
+
+        auto ret = CheckTensorListNull(gmmDsqParams_.weight);
+        if (ret) {
+            return false;
+        }
+
+        ret = CheckTensorListNull(gmmDsqParams_.weightScale);
+        if (ret) {
+            return false;
+        }
+
+        if (!gmmDsqParams_.weight || !gmmDsqParams_.weightScale) {
+            OP_LOGE(ACLNN_ERR_PARAM_NULLPTR,
+            "The weight or weightScale is nullptr.");
+            return false;
+        }
+        return true;
+    }
+
+    virtual bool CheckEmptyTensor(void)
+    {
+        if ((*gmmDsqParams_.weight)[0]->IsEmpty() || (*gmmDsqParams_.weightScale)[0]->IsEmpty()) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The weight or weightScale is an empty container.");
+            return false;
+        }
+        return true;
+    }
+
+    virtual bool CheckInputOutDims() = 0;
+    virtual bool CheckInputOutShape() = 0;
+    virtual bool CheckDtypeValid() = 0;
+    virtual bool CheckFormat() = 0;
+
+    virtual aclnnStatus CheckParams()
+    {
+        // 1. 检查参数是否为空指针、空tensor
+        CHECK_RET(CheckNotNull(), ACLNN_ERR_PARAM_NULLPTR);
+        CHECK_RET(CheckEmptyTensor(), ACLNN_ERR_PARAM_INVALID);
+
+        // 2. 校验输入、输出参数维度
+        CHECK_RET(CheckInputOutDims(), ACLNN_ERR_PARAM_INVALID);
+
+        // 3. 校验输入、输出shape参数
+        CHECK_RET(CheckInputOutShape(), ACLNN_ERR_PARAM_INVALID);
+
+        // 4. 检查输入的数据类型是否在支持的数据类型范围之内
+        CHECK_RET(CheckDtypeValid(), ACLNN_ERR_PARAM_INVALID);
+
+        // 5. 检查数据形状是否支持
+        CHECK_RET(CheckFormat(), ACLNN_ERR_PARAM_INVALID);
+
+        return ACLNN_SUCCESS;
+    }
+
+    void CheckOptionalTensorListEmpty(const aclTensorList *&tensorList) const
+    {
+        if (tensorList == nullptr) {
+            return;
+        }
+
+        if (tensorList->Size() == 0) {
+            tensorList = nullptr;
+        } else if (tensorList->Size() == 1) {
+            op::Shape shape = (*tensorList)[0]->GetViewShape();
+            if (shape.GetDimNum() == 1 && shape.GetDim(0) == 0) {
+                tensorList = nullptr;
+            }
+        }
+    }
+
+    void CreateEmptyTensor(const aclDataType dataType, const aclTensorList *&tensorList,
+            aclTensorList *&emptyTensorList) const
+    {
+        if (tensorList != nullptr) {
+            return;
+        }
+
+        FVector<aclTensor*> emptyTensors;
+        aclTensor *emptyTensor = l0Executor_->AllocTensor({0}, static_cast<op::DataType>(dataType));
+        emptyTensors.emplace_back(emptyTensor);
+        emptyTensorList = l0Executor_->AllocTensorList(emptyTensors.data(), emptyTensors.size());
+        tensorList = emptyTensorList;
+    }
+
+    aclnnStatus DataContiguous(const aclTensorList *&tensors) const
+    {
+        std::vector<const aclTensor *> tensorsVec;
+        const aclTensor *contiguousTensor = nullptr;
+        for (size_t i = 0; i < tensors->Size(); ++i) {
+            const aclTensor *tensor = (*tensors)[i];
+            contiguousTensor = l0op::Contiguous(tensor, l0Executor_);
+            CHECK_RET(contiguousTensor != nullptr, ACLNN_ERR_INNER_NULLPTR);
+            tensorsVec.push_back(contiguousTensor);
+        }
+        tensors = l0Executor_->AllocTensorList(tensorsVec.data(), tensorsVec.size());
+        return ACLNN_SUCCESS;
+    }
+
+    aclnnStatus DataContiguousWeight(const aclTensorList *&tensors) const
+    {
+        std::vector<const aclTensor *> tensorsVec;
+        const aclTensor *contiguousTensor = nullptr;
+        for (size_t i = 0; i < tensors->Size(); ++i) {
+            const aclTensor *tensor = (*tensors)[i];
+            if (!IsPrivateFormat(tensor->GetStorageFormat())) {
+                contiguousTensor = l0op::Contiguous(tensor, l0Executor_);
+                CHECK_RET(contiguousTensor != nullptr, ACLNN_ERR_INNER_NULLPTR);
+                tensorsVec.push_back(contiguousTensor);
+            } else {
+                tensorsVec.push_back(tensor);
+            }
+        }
+        tensors = l0Executor_->AllocTensorList(tensorsVec.data(), tensorsVec.size());
+        return ACLNN_SUCCESS;
+    }
+
+    virtual aclnnStatus CovertDataContiguous()
+    {
+        aclTensorList *emptyWeightAssistMatrixList = nullptr;
+        CreateEmptyTensor(aclDataType::ACL_FLOAT, gmmDsqParams_.weightAssistMatrix,
+            emptyWeightAssistMatrixList);
+
+        CHECK_COND(DataContiguousWeight(gmmDsqParams_.weight) == ACLNN_SUCCESS, ACLNN_ERR_INNER_NULLPTR,
+                    "Contiguous weight failed.");
+        CHECK_COND(DataContiguous(gmmDsqParams_.weightScale) == ACLNN_SUCCESS, ACLNN_ERR_INNER_NULLPTR,
+                    "Contiguous weightScale failed.");
+        if (gmmDsqParams_.weightAssistMatrix != nullptr && gmmDsqParams_.weightAssistMatrix->Size() != 0) {
+            CHECK_COND(DataContiguous(gmmDsqParams_.weightAssistMatrix) == ACLNN_SUCCESS, ACLNN_ERR_INNER_NULLPTR,
+                    "Contiguous weightAssistMatrix failed.");
+        }
+
+        gmmDsqParams_.x = l0op::Contiguous(gmmDsqParams_.x, l0Executor_);
+        CHECK_COND(gmmDsqParams_.x != nullptr, ACLNN_ERR_INNER_NULLPTR, "Contiguous groupList failed.");
+        gmmDsqParams_.xScale = l0op::Contiguous(gmmDsqParams_.xScale, l0Executor_);
+        CHECK_COND(gmmDsqParams_.xScale != nullptr, ACLNN_ERR_INNER_NULLPTR, "Contiguous xScale failed.");
+        gmmDsqParams_.groupList = l0op::Contiguous(gmmDsqParams_.groupList, l0Executor_);
+        CHECK_COND(gmmDsqParams_.groupList != nullptr, ACLNN_ERR_INNER_NULLPTR, "Contiguous groupList failed.");
+
+        return ACLNN_SUCCESS;
+    }
+
+public:
+    void Initialize(const char *interfaceName, GroupedMatmulSwigluQuantParamsBase &params, uint64_t *workspaceSize, aclOpExecutor **executor)
+    {
+        interfaceName_ = interfaceName;
+        gmmDsqParams_ = params;
+        workspaceSize_ = workspaceSize;
+        executor_ = executor;
+    }
+
+    aclnnStatus Process()
+    {
+        // 固定写法，创建OpExecutor
+        auto uniqueExecutor = CREATE_EXECUTOR();
+        CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
+        l0Executor_ = uniqueExecutor.get();
+
+        auto ret = CheckParams();
+        CHECK_RET(ret == ACLNN_SUCCESS, ret);
+
+        if (op::GetCurrentPlatformInfo().GetCurNpuArch() == NpuArch::DAV_3510) {
+            auto x1MDim = gmmDsqParams_.x->GetViewShape().GetDim(0);
+            auto x2NIndex = (*gmmDsqParams_.weight)[0]->GetViewShape().GetDimNum() - 1;
+            auto x2NDim = (*gmmDsqParams_.weight)[0]->GetViewShape().GetDim(x2NIndex);
+            if (x1MDim == 0 || x2NDim == 0) {
+                *workspaceSize_ = 0ULL;
+                uniqueExecutor.ReleaseTo(executor_);
+                return ACLNN_SUCCESS;
+            }
+        }
+        for (size_t i = 0; i < gmmDsqParams_.weight->Size(); i++) {
+            auto *w = (*gmmDsqParams_.weight)[i];
+            if (IsPrivateFormat(w->GetStorageFormat())) {
+                w->SetOriginalShape(w->GetViewShape());
+            }
+        }
+        // 空Tensor场景
+        if (gmmDsqParams_.output->IsEmpty() || gmmDsqParams_.groupList->IsEmpty() || gmmDsqParams_.outputScale->IsEmpty()) {
+            *workspaceSize_ = 0ULL;
+            uniqueExecutor.ReleaseTo(executor_);
+            return ACLNN_SUCCESS;
+        }
+
+        ret = CovertDataContiguous();
+        CHECK_RET(ret == ACLNN_SUCCESS, ret);
+        auto ret0 = l0op::GroupedMatmulSwigluQuantV2(gmmDsqParams_.x, gmmDsqParams_.weight, gmmDsqParams_.weightScale,
+                                                gmmDsqParams_.xScale, gmmDsqParams_.weightAssistMatrix,
+                                                gmmDsqParams_.bias,
+                                                gmmDsqParams_.smoothScale, gmmDsqParams_.groupList,
+                                                gmmDsqParams_.dequantMode, gmmDsqParams_.dequantDtype,
+                                                gmmDsqParams_.quantMode, gmmDsqParams_.quantDtype,
+                                                gmmDsqParams_.transposeWeight, gmmDsqParams_.groupListType,
+                                                gmmDsqParams_.tuningConfig,gmmDsqParams_.swigluLimit, uniqueExecutor.get());
+        CHECK_RET(ret0 != std::tuple(nullptr, nullptr), ACLNN_ERR_INNER_NULLPTR);
+
+        auto out0 = std::get<OUTPUT_IDX_0>(ret0);
+        auto ret1 = l0op::ViewCopy(out0, gmmDsqParams_.output, uniqueExecutor.get());
+        CHECK_RET(ret1 != nullptr, ACLNN_ERR_INNER_NULLPTR);
+
+        auto out1 = std::get<OUTPUT_IDX_1>(ret0);
+        auto ret2 = l0op::ViewCopy(out1, gmmDsqParams_.outputScale, uniqueExecutor.get());
+        CHECK_RET(ret2 != nullptr, ACLNN_ERR_INNER_NULLPTR);
+
+        *workspaceSize_ = uniqueExecutor->GetWorkspaceSize();
+        uniqueExecutor.ReleaseTo(executor_);
+        return ACLNN_SUCCESS;
+    }
+
+protected:
+    string interfaceName_;
+    GroupedMatmulSwigluQuantParamsBase gmmDsqParams_;
+    uint64_t *workspaceSize_;
+    aclOpExecutor **executor_;
+    aclOpExecutor *l0Executor_;
+};
+
+} // namespace gmm_dsq
+#endif

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/op_api/grouped_matmul_swiglu_quant_v2.cpp

@@ -0,0 +1,87 @@
+/**
+ * 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 "opdev/op_log.h"
+#include "opdev/op_dfx.h"
+#include "opdev/make_op_executor.h"
+#include "util/math_util.h"
+#include "grouped_matmul_swiglu_quant_utils.h"
+#include "grouped_matmul_swiglu_quant_v2.h"
+
+using namespace op;
+using namespace gmm_dsq;
+
+namespace l0op {
+OP_TYPE_REGISTER(GroupedMatmulSwigluQuantV2);
+
+constexpr int64_t SWIGLU_SPLIT_SIZE = 64L;
+
+const std::tuple<aclTensor *, aclTensor *> GroupedMatmulSwigluQuantV2(const aclTensor *x, const aclTensorList *weight,
+                         const aclTensorList *weightScale,
+                         const aclTensor *xScale, const aclTensorList *weightAssistanceMatrix,
+                         const aclTensor *bias, const aclTensor *smoothScale,
+                         const aclTensor *groupList, int64_t dequantMode, int64_t dequantDtype,
+                         int64_t quantMode, int64_t quantDtype, bool transposeWeight, int64_t groupListType,
+                         const aclIntArray *tuningConfigOptional, double swigluLimit,aclOpExecutor *executor)
+{
+    L0_DFX(GroupedMatmulSwigluQuantV2, x, weight, weightScale, xScale, weightAssistanceMatrix, smoothScale,
+           groupList, dequantMode, dequantDtype, quantMode, quantDtype, transposeWeight, tuningConfigOptional, swigluLimit);
+    if (x == nullptr) {
+        OP_LOGE(ACLNN_ERR_PARAM_INVALID, "x is nullptr.");
+        return std::tuple(nullptr, nullptr);
+    }
+    int64_t m = xScale->GetViewShape().GetDim(0);
+    int64_t n = (*weightScale)[0]->GetViewShape().GetDim(1);
+    int64_t nAfterHalve = static_cast<int64_t>(n / 2);
+    gert::Shape outShape({m, nAfterHalve});
+    gert::Shape scaleOutShape({m});
+    auto out = executor->AllocTensor(outShape, DataType::DT_INT8, ge::FORMAT_ND);
+    auto scaleOut = executor->AllocTensor(scaleOutShape, DataType::DT_FLOAT, ge::FORMAT_ND);
+    if (op::GetCurrentPlatformInfo().GetCurNpuArch() == NpuArch::DAV_3510) {
+        n = transposeWeight ? (*weightScale)[0]->GetViewShape().GetDim(1) : // 转置情况下weightScale的第1维是n
+                            (*weightScale)[0]->GetViewShape().GetDim(2); // 非转置情况下weightScale的第2维是n
+        nAfterHalve = static_cast<int64_t>(n / 2); // outShape需要为[M, N / 2]
+        gert::Shape outShapeV2({m, nAfterHalve});
+        gert::Shape scaleOutShapeV2;
+        // 当quantMode等于2时，out_scale 的形状为三维
+        if (quantMode == 2) {
+            int64_t nAfterSplit = static_cast<int64_t>(Ops::Base::CeilDiv(nAfterHalve, SWIGLU_SPLIT_SIZE));
+            scaleOutShapeV2 = gert::Shape({m, nAfterSplit, 2});
+        } else {
+            scaleOutShapeV2 = gert::Shape({m});
+        }
+        out = executor->AllocTensor(outShapeV2, static_cast<ge::DataType>(quantDtype), ge::FORMAT_ND);
+        // 当quantMode等于2时，outScale的DataType为FLOAT8_E8M0
+        scaleOut = quantMode == 2 ? executor->AllocTensor(scaleOutShapeV2, DataType::DT_FLOAT8_E8M0, ge::FORMAT_ND) :
+                                    executor->AllocTensor(scaleOutShapeV2, DataType::DT_FLOAT, ge::FORMAT_ND);
+    }
+    auto ret = INFER_SHAPE(GroupedMatmulSwigluQuantV2,
+                    OP_INPUT(x, xScale, groupList, weight, weightScale, weightAssistanceMatrix, bias, smoothScale),
+                    OP_OUTPUT(out, scaleOut), OP_ATTR(dequantMode, dequantDtype, quantMode, quantDtype, transposeWeight,
+                    groupListType, tuningConfigOptional, swigluLimit));
+    if (ret != ACLNN_SUCCESS) {
+        OP_LOGE(ACLNN_ERR_PARAM_INVALID, "InferShape failed.");
+        return std::tuple(nullptr, nullptr);
+    }
+
+    ret = ADD_TO_LAUNCHER_LIST_AICORE(
+        GroupedMatmulSwigluQuantV2,
+        OP_INPUT(x, xScale, groupList, weight, weightScale, weightAssistanceMatrix, bias, smoothScale),
+        OP_OUTPUT(out, scaleOut), OP_ATTR(dequantMode, dequantDtype, quantMode, quantDtype, transposeWeight,
+                        groupListType, tuningConfigOptional, swigluLimit));
+    if (ret != ACLNN_SUCCESS) {
+        OP_LOGE(ACLNN_ERR_PARAM_INVALID, "ADD_TO_LAUNCHER_LIST_AICORE failed.");
+        return std::tuple(nullptr, nullptr);
+    }
+
+    return std::tie(out, scaleOut);
+}
+
+} // namespace l0op

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/op_api/grouped_matmul_swiglu_quant_v2.h

@@ -0,0 +1,26 @@
+/**
+ * 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_HOST_OP_API_GROUPED_MATMUL_SWIGLU_QUANT_V2_H
+#define OP_HOST_OP_API_GROUPED_MATMUL_SWIGLU_QUANT_V2_H
+
+#include "opdev/op_executor.h"
+
+namespace l0op {
+
+const std::tuple<aclTensor *, aclTensor *> GroupedMatmulSwigluQuantV2(const aclTensor *x, const aclTensorList *weight,
+                         const aclTensorList *weightScale,
+                         const aclTensor *xScale, const aclTensorList *weightAssistanceMatrix,
+                         const aclTensor *bias, const aclTensor *smoothScale,
+                         const aclTensor *groupList, int64_t dequantMode, int64_t dequantDtype,
+                         int64_t quantMode, int64_t quantDtype, bool transposeWeight, int64_t groupListType,
+                         const aclIntArray *tuningConfigOptional,  double swigluLimit, aclOpExecutor *executor);
+}
+
+#endif

csrc/gmm/grouped_matmul_swiglu_quant_v2/op_host/op_api/grouped_matmul_swiglu_quant_v2_utils.h

@@ -0,0 +1,814 @@
+/**
+ * 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_HOST_OP_API_GROUPED_MATMUL_SWIGLU_QUANT_V2_UTILS_H
+#define OP_HOST_OP_API_GROUPED_MATMUL_SWIGLU_QUANT_V2_UTILS_H
+
+#include "grouped_matmul_swiglu_quant_utils.h"
+#include "util/math_util.h"
+
+namespace gmmSwigluQuantV2 {
+
+using namespace gmm_dsq;
+
+constexpr int64_t OUTPUT_IDX_0 = 0L;
+constexpr int64_t OUTPUT_IDX_1 = 1L;
+constexpr size_t MX_SPLIT_K_PER_TOKEN_SCALE_DIM = 3UL;
+constexpr size_t LAST_SECOND_DIM_INDEX = 2;
+constexpr size_t LAST_THIRD_DIM_INDEX = 3;
+constexpr int64_t MXFP_MULTI_BASE_SIZE = 2L;
+constexpr size_t MX_SPLIT_M_SCALE_DIM = 4UL;
+constexpr size_t MX_X_DIM = 2UL;
+constexpr size_t MX_X_SCALE_DIM = 3UL;
+constexpr size_t MX_WEIGHT_DIM = 3UL;
+constexpr size_t MX_WEIGHT_SCALE_DIM = 4UL;
+constexpr size_t MX_OUTPUT_DIM = 2UL;
+constexpr size_t MX_OUTPUT_SCALE_DIM = 3UL;
+constexpr size_t PERTOKEN_X_DIM = 2;
+constexpr size_t PERTOKEN_X_SCALE_DIM = 1;
+constexpr size_t PERTOKEN_WEIGHT_DIM = 3;
+constexpr size_t PERTOKEN_WEIGHT_SCALE_DIM = 2;
+constexpr size_t PERTOKEN_OUTPUT_DIM = 2;
+constexpr size_t PERTOKEN_OUTPUT_SCALE_DIM = 1;
+constexpr int64_t SWIGLU_SPLIT_FACTOR = 2L;
+constexpr int64_t SWIGLU_SPLIT_SIZE = 64L;
+constexpr int64_t MXFP4_K_CONSTRAINT = 2L;
+constexpr int64_t SWIGLU_N_CONSTRAINT = 2L;
+constexpr int64_t MXFP4_N_CONSTRAINT = 4L;
+constexpr size_t SINGLE_TENSOR_SIZE = 1;
+constexpr int64_t MAX_GROUP_LIST_SIZE = 1024L;
+constexpr int64_t QUNAT_MODE_MX = 2;
+constexpr int64_t QUNAT_MODE_PERTOKEN = 0;
+
+const std::initializer_list<DataType> X_DTYPE_SUPPORT_LIST = {DataType::DT_FLOAT8_E4M3FN, DataType::DT_FLOAT8_E5M2};
+const std::initializer_list<DataType> X_DTYPE_SUPPORT_LIST_MXFP4 = {DataType::DT_FLOAT4_E2M1};
+const std::initializer_list<DataType> XW_DTYPE_SUPPORT_LIST_PERTOKEN = {
+    DataType::DT_INT8, DataType::DT_FLOAT8_E4M3FN, DataType::DT_FLOAT8_E5M2, DataType::DT_HIFLOAT8};
+const std::initializer_list<DataType> WEIGHT_DTYPE_SUPPORT_LIST = {DataType::DT_FLOAT8_E4M3FN,
+                                                                   DataType::DT_FLOAT8_E5M2};
+const std::initializer_list<DataType> WEIGHT_DTYPE_SUPPORT_LIST_MXFP4 = {DataType::DT_FLOAT4_E2M1};
+const std::initializer_list<DataType> WEIGHT_SCALE_DTYPE_SUPPORT_LIST = {DataType::DT_FLOAT8_E8M0};
+const std::initializer_list<DataType> WEIGHT_SCALE_DTYPE_SUPPORT_LIST_PERTOKEN_XINT8 = {
+    DataType::DT_FLOAT16, DataType::DT_BF16, DataType::DT_FLOAT};
+const std::initializer_list<DataType> WEIGHT_SCALE_DTYPE_SUPPORT_LIST_PERTOKEN_XFP8HIF8 = {DataType::DT_BF16,
+                                                                                           DataType::DT_FLOAT};
+const std::initializer_list<DataType> X_SCALE_DTYPE_SUPPORT_LIST = {DataType::DT_FLOAT8_E8M0};
+const std::initializer_list<DataType> X_SCALE_DTYPE_SUPPORT_LIST_PERTOKEN = {DataType::DT_FLOAT};
+const std::initializer_list<DataType> GROUP_LIST_DTYPE_SUPPORT_LIST = {DataType::DT_INT64};
+const std::initializer_list<DataType> QUANTOUT_DTYPE_SUPPORT_LIST_MXFP4 = {
+    DataType::DT_FLOAT8_E4M3FN, DataType::DT_FLOAT8_E5M2, DataType::DT_FLOAT4_E2M1};
+const std::initializer_list<DataType> QUANTOUT_DTYPE_SUPPORT_LIST_PERTOKEN = {
+    DataType::DT_INT8, DataType::DT_FLOAT8_E4M3FN, DataType::DT_FLOAT8_E5M2, DataType::DT_HIFLOAT8};
+const std::initializer_list<DataType> QUANTSCALEOUT_DTYPE_SUPPORT_LIST = {DataType::DT_FLOAT8_E8M0};
+const std::initializer_list<DataType> QUANTSCALEOUT_DTYPE_SUPPORT_LIST_PERTOKEN = {DataType::DT_FLOAT};
+
+class GroupedMatmulSwigluQuantBaseHandler : public GroupedMatmulSwigluQuantHandler {
+protected:
+    bool IsTransposeForMxShape(const aclTensor *tensor) const
+    {
+        auto shape = tensor->GetViewShape();
+        if (shape.GetDimNum() < MX_SPLIT_K_PER_TOKEN_SCALE_DIM) {
+            return false;
+        }
+        int64_t firstLastDim = shape.GetDimNum() - 1;
+        int64_t secondLastDim = shape.GetDimNum() - LAST_SECOND_DIM_INDEX;
+        int64_t thirdLastDim = shape.GetDimNum() - LAST_THIRD_DIM_INDEX;
+        auto strides = tensor->GetViewStrides();
+        if (strides[firstLastDim] == 1 && strides[thirdLastDim] == MXFP_MULTI_BASE_SIZE &&
+            strides[secondLastDim] == shape.GetDim(thirdLastDim) * MXFP_MULTI_BASE_SIZE) {
+            return true;
+        }
+        return false;
+    }
+
+    bool IsTransposeLastTwoDims(const aclTensor *tensor) const
+    {
+        auto shape = tensor->GetViewShape();
+        int64_t dim1 = shape.GetDimNum() - 1;
+        int64_t dim2 = shape.GetDimNum() - 2;
+        auto strides = tensor->GetViewStrides();
+        if (strides[dim2] == 1 && strides[dim1] == shape.GetDim(dim2)) {
+            int64_t tmpNxD = shape.GetDim(dim1) * shape.GetDim(dim2);
+            for (int64_t batchDim = shape.GetDimNum() - 3; batchDim >= 0; batchDim--) {
+                if (strides[batchDim] != tmpNxD) {
+                    return false;
+                }
+                tmpNxD *= shape.GetDim(batchDim);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    void CreateContiguousTensorListForMXTypeMScale(const aclTensorList *tensorList,
+                                                   std::vector<aclTensor *> &newTensorList,
+                                                   aclOpExecutor *executor) const
+    {
+        op::Shape shape;
+        for (uint64_t idx = 0; idx < (*tensorList).Size(); idx++) {
+            const aclTensor *inputTensor = (*tensorList)[idx];
+            op::Shape viewShape = inputTensor->GetViewShape();
+            shape.SetScalar();
+            if (viewShape.GetDimNum() < MX_SPLIT_M_SCALE_DIM) {
+                continue;
+            }
+            shape.AppendDim(viewShape.GetDim(0));
+            shape.AppendDim(viewShape.GetDim(viewShape.GetDimNum() - LAST_SECOND_DIM_INDEX));
+            shape.AppendDim(viewShape.GetDim(viewShape.GetDimNum() - LAST_THIRD_DIM_INDEX));
+            shape.AppendDim(viewShape.GetDim(viewShape.GetDimNum() - 1));
+            aclTensor *tensor =
+                executor->CreateView(inputTensor, shape, inputTensor->GetViewOffset()); // use executor to create tensor
+            tensor->SetStorageFormat(inputTensor->GetStorageFormat());
+            newTensorList.emplace_back(tensor);
+        }
+    }
+
+    void CreateContiguousTensorList(const aclTensorList *tensorList, std::vector<aclTensor *> &newTensorList,
+                                    aclOpExecutor *executor) const
+    {
+        op::Shape shape;
+        for (uint64_t idx = 0; idx < (*tensorList).Size(); idx++) {
+            const aclTensor *inputTensor = (*tensorList)[idx];
+            op::Shape viewShape = inputTensor->GetViewShape();
+            uint32_t viewShapeDimsNum = viewShape.GetDimNum();
+            shape.SetScalar();
+            // 2: the second last dimension; in for-loops, it indicates dimensions before the second last remain unchanged.
+            for (uint32_t i = 0; i < viewShapeDimsNum - 2; ++i) {
+                shape.AppendDim(viewShape.GetDim(i));
+            }
+            // viewShapeDimsNum - 1, the dim value of the last dim. viewShapeDimsNum - 2, the dim value of the second
+            // last dim.
+            shape.AppendDim(viewShape.GetDim(viewShapeDimsNum - 1));
+            shape.AppendDim(viewShape.GetDim(viewShapeDimsNum - 2)); // 2:the second last dim.
+            aclTensor *tensor =
+                executor->CreateView(inputTensor, shape, inputTensor->GetViewOffset()); // use executor to create tensor
+            tensor->SetStorageFormat(inputTensor->GetStorageFormat());
+            newTensorList.emplace_back(tensor);
+        }
+    }
+
+    static void CheckOptionalTensorListEmpty(const aclTensorList *&tensorList)
+    {
+        if (tensorList != nullptr) {
+            if (tensorList->Size() == 0) {
+                tensorList = nullptr;
+            } else if ((*tensorList)[0] == nullptr) {
+                tensorList = nullptr;
+            } else if (tensorList->Size() == 1) {
+                op::Shape shape = (*tensorList)[0]->GetViewShape();
+                if (shape.GetDimNum() == 1 && shape.GetDim(0) == 0) {
+                    tensorList = nullptr;
+                }
+            }
+        }
+    }
+
+    bool CheckAttrs()
+    {
+        CheckOptionalTensorListEmpty(gmmDsqParams_.weightAssistMatrix);
+        if (gmmDsqParams_.tuningConfig != nullptr && gmmDsqParams_.tuningConfig->Size() == 0) {
+            gmmDsqParams_.tuningConfig = nullptr;
+        }
+        if (gmmDsqParams_.weightAssistMatrix != nullptr) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "The current version does not support weightAssistMatrix, it should be nullptr.");
+            return false;
+        }
+        if (gmmDsqParams_.bias != nullptr) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The current version does not support bias, it should be nullptr.");
+            return false;
+        }
+        if (gmmDsqParams_.smoothScale != nullptr) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The current version does not support smoothScale, it should be nullptr.");
+            return false;
+        }
+        if (gmmDsqParams_.tuningConfig != nullptr) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "The current version does not support tuningConfig, it should be nullptr.");
+            return false;
+        }
+        if ((gmmDsqParams_.dequantMode != QUNAT_MODE_MX && gmmDsqParams_.dequantMode != QUNAT_MODE_PERTOKEN) ||
+            (gmmDsqParams_.quantMode != QUNAT_MODE_MX && gmmDsqParams_.quantMode != QUNAT_MODE_PERTOKEN) ||
+            (gmmDsqParams_.dequantMode != gmmDsqParams_.quantMode)) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "Both dequantMode and quantMode must be 0 (pertoken) or 2 (mx), and they must be equal. Actual "
+                    "value: dequantMode=%lu, dequantMode=%lu.",
+                    gmmDsqParams_.dequantMode, gmmDsqParams_.quantMode);
+            return false;
+        }
+        ge::DataType dequantDtype = static_cast<ge::DataType>(gmmDsqParams_.dequantDtype);
+        if (gmmDsqParams_.quantMode == QUNAT_MODE_MX && dequantDtype != ge::DT_FLOAT) {
+             OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                     "In mx quant mode, dequantDtype should be 0, but actual value is %lu.",
+                     gmmDsqParams_.dequantDtype);
+             return false;
+        }
+        if (gmmDsqParams_.quantMode == QUNAT_MODE_PERTOKEN && dequantDtype != ge::DT_FLOAT && dequantDtype != ge::DT_BF16 &&
+            dequantDtype != ge::DT_FLOAT16) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "In pertoken quant mode, dequantDtype should be 0, 1, 27, but actual value is %lu.",
+                    gmmDsqParams_.dequantDtype);
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckMXTranspose()
+    {
+        // 判断weight和weightScale是否转置，是则对两者进行转置动作
+        bool transposeWeightScale = IsTransposeForMxShape((*gmmDsqParams_.weightScale)[0]);
+        bool transposeWeight = IsTransposeLastTwoDims((*gmmDsqParams_.weight)[0]);
+        bool transposeX = IsTransposeLastTwoDims(gmmDsqParams_.x);
+        bool transposeXScale = IsTransposeForMxShape(gmmDsqParams_.xScale);
+
+        if (transposeWeightScale != transposeWeight) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "The transposition of weightScale/weight should be equal, but actual transpositions are %s/%s.",
+                    transposeWeightScale ? "true" : "false", transposeWeight ? "true" : "false");
+            return false;
+        }
+
+        if (transposeWeightScale && transposeWeight) {
+            gmmDsqParams_.transposeWeight = true;
+            auto uniqueExecutor = CREATE_EXECUTOR();
+            CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
+            aclOpExecutor *executorPtr = uniqueExecutor.get();
+            CHECK_RET(executorPtr != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
+            std::vector<aclTensor *> scaleTensorList;
+            std::vector<aclTensor *> weightTensorList;
+            CreateContiguousTensorListForMXTypeMScale(gmmDsqParams_.weightScale, scaleTensorList, executorPtr);
+            gmmDsqParams_.weightScale = executorPtr->AllocTensorList(scaleTensorList.data(), scaleTensorList.size());
+            CreateContiguousTensorList(gmmDsqParams_.weight, weightTensorList, executorPtr);
+            gmmDsqParams_.weight = executorPtr->AllocTensorList(weightTensorList.data(), weightTensorList.size());
+            uniqueExecutor.ReleaseTo(executor_);
+        }
+
+        if ((gmmDsqParams_.x->GetViewShape().GetDim(0) == 1 && gmmDsqParams_.x->GetViewShape().GetDim(1) == 1) ||
+            (gmmDsqParams_.xScale->GetViewShape().GetDim(0) == 1 &&
+             gmmDsqParams_.xScale->GetViewShape().GetDim(1) == 1)) {
+            return true;
+        }
+        if (transposeX || transposeXScale) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "The transposition of x/xScale should be false, but actual transposition are %s/%s.",
+                    transposeX ? "true" : "false", transposeXScale ? "true" : "false");
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckPertokenTranspose()
+    {
+        bool transposeWeight = IsTransposeLastTwoDims((*gmmDsqParams_.weight)[0]);
+        bool transposeX = IsTransposeLastTwoDims(gmmDsqParams_.x);
+
+        if (transposeWeight) {
+            gmmDsqParams_.transposeWeight = true;
+            auto uniqueExecutor = CREATE_EXECUTOR();
+            CHECK_RET(uniqueExecutor.get() != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
+            aclOpExecutor *executorPtr = uniqueExecutor.get();
+            CHECK_RET(executorPtr != nullptr, ACLNN_ERR_INNER_CREATE_EXECUTOR);
+            std::vector<aclTensor *> weightTensorList;
+            CreateContiguousTensorList(gmmDsqParams_.weight, weightTensorList, executorPtr);
+            gmmDsqParams_.weight = executorPtr->AllocTensorList(weightTensorList.data(), weightTensorList.size());
+            uniqueExecutor.ReleaseTo(executor_);
+        }
+        if ((gmmDsqParams_.x->GetViewShape().GetDim(0) == 1 && gmmDsqParams_.x->GetViewShape().GetDim(1) == 1) ||
+            (gmmDsqParams_.xScale->GetViewShape().GetDim(0) == 1 &&
+             gmmDsqParams_.xScale->GetViewShape().GetDim(1) == 1)) {
+            return true;
+        }
+        if (transposeX) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The transposition of x should be false, but actual transposition are %s.",
+                    transposeX ? "true" : "false");
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckMXShape()
+    {
+        int64_t m = gmmDsqParams_.x->GetViewShape().GetDim(0); // 从x的第0维获取m
+        int64_t k = gmmDsqParams_.x->GetViewShape().GetDim(1); // 从x的第1维获取k
+        // 转置情况下从weight的第1维获取n，非转置情况下从weight的第2维获取n
+        int64_t n = gmmDsqParams_.transposeWeight ? ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(1) :
+                                                    ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(2);
+        int64_t e = ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(0); // 从weight的第0维获取e
+
+        // x的shape期望为[M, K]
+        op::Shape xExpectShape = {m, k};
+        // xScale的shape期望为[M, CeilDiv(K, 64), 2]
+        op::Shape xScaleExpectShape = {m, Ops::Base::CeilDiv(k, SWIGLU_SPLIT_SIZE), SWIGLU_SPLIT_FACTOR};
+        // weight的shape期望为[E, K, N]
+        op::Shape weightExpectShape = {e, k, n};
+        // weightScale的shape期望为[E, CeilDiv(K, 64), N, 2]
+        op::Shape weightScaleExpectShape = {e, Ops::Base::CeilDiv(k, SWIGLU_SPLIT_SIZE), n, SWIGLU_SPLIT_FACTOR};
+        // weight转置的shape期望为[E, N, K]
+        op::Shape weightTransExpectShape = {e, n, k};
+        // weightScale转置的shape期望为[E, N, CeilDiv(K, 64), 2]
+        op::Shape weightScaleTransExpectShape = {e, n, Ops::Base::CeilDiv(k, SWIGLU_SPLIT_SIZE), SWIGLU_SPLIT_FACTOR};
+        int64_t nAfterHalve = static_cast<int64_t>(n / SWIGLU_SPLIT_FACTOR);
+        // output的shape期望为[M, N / 2]
+        op::Shape outputExpectShape = {m, nAfterHalve};
+        // outputScale的shape期望为[M, CeilDiv(N / 2, 64), 2]
+        op::Shape outputScaleExpectShape = {m, Ops::Base::CeilDiv(nAfterHalve, SWIGLU_SPLIT_SIZE), SWIGLU_SPLIT_FACTOR};
+        const aclTensor *x = gmmDsqParams_.x;
+        const aclTensor *xScale = gmmDsqParams_.xScale;
+        const aclTensor *output = gmmDsqParams_.output;
+        const aclTensor *outputScale = gmmDsqParams_.outputScale;
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(x, xExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(xScale, xScaleExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(output, outputExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(outputScale, outputScaleExpectShape, return false);
+
+        const aclTensor *weightScale = (*gmmDsqParams_.weightScale)[0];
+        const aclTensor *weight = (*gmmDsqParams_.weight)[0];
+        if (gmmDsqParams_.transposeWeight) {
+            OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(weightScale, weightScaleTransExpectShape, return false);
+            OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(weight, weightTransExpectShape, return false);
+        } else {
+            OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(weightScale, weightScaleExpectShape, return false);
+            OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(weight, weightExpectShape, return false);
+        }
+        // 进行swiglu操作需满足n为偶数
+        if (n % SWIGLU_N_CONSTRAINT != 0) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Swiglu operation requires n to be even , but n actual value is %lu.", n);
+            return false;
+        }
+        // groupList的长度应等于weight的专家数
+        int64_t groupListLen = gmmDsqParams_.groupList->GetViewShape().GetDim(0);
+        if (groupListLen != e) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "Length of 'groupList' should be equal to the number of experts in weight.");
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckPertokenShape()
+    {
+        int64_t m = gmmDsqParams_.x->GetViewShape().GetDim(0); // 从x的第0维获取m
+        int64_t k = gmmDsqParams_.x->GetViewShape().GetDim(1); // 从x的第1维获取k
+        // 转置情况下从weight的第1维获取n，非转置情况下从weight的第2维获取n
+        int64_t n = gmmDsqParams_.transposeWeight ? ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(1) :
+                                                    ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(2);
+        int64_t e = ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(0); // 从weight的第0维获取e
+
+        // x的shape期望为[M, K]
+        op::Shape xExpectShape = {m, k};
+        // xScale的shape期望为[M]
+        op::Shape xScaleExpectShape = {m};
+        // weight的shape期望为根据转置的情况来具体确认[E, K, N] 或者[E, N, K]
+        op::Shape weightExpectShape = gmmDsqParams_.transposeWeight ? op::Shape{e, n, k} : op::Shape{e, k, n};
+        // weightScale的shape期望为[E, N]
+        op::Shape weightScaleExpectShape = {e, n};
+        int64_t nAfterHalve = static_cast<int64_t>(n / SWIGLU_SPLIT_FACTOR);
+        // output的shape期望为[M, N / 2]
+        op::Shape outputExpectShape = {m, nAfterHalve};
+        // outputScale的shape期望为[M]
+        op::Shape outputScaleExpectShape = {m};
+        const aclTensor *x = gmmDsqParams_.x;
+        const aclTensor *xScale = gmmDsqParams_.xScale;
+        const aclTensor *weight = (*gmmDsqParams_.weight)[0];
+        const aclTensor *weightScale = (*gmmDsqParams_.weightScale)[0];
+        const aclTensor *output = gmmDsqParams_.output;
+        const aclTensor *outputScale = gmmDsqParams_.outputScale;
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(x, xExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(xScale, xScaleExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(weight, weightExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(weightScale, weightScaleExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(output, outputExpectShape, return false);
+        OP_CHECK_SHAPE_NOT_EQUAL_WITH_EXPECTED_SIZE(outputScale, outputScaleExpectShape, return false);
+        return true;
+    }
+
+    bool CheckFp8DtypeValid(const aclTensor *x, const aclTensor *xScale, const aclTensor *groupList,
+                            const aclTensor *output, const aclTensor *outputScale)
+    {
+        size_t weightLength = gmmDsqParams_.weight->Size();
+        for (size_t i = 0; i < weightLength; i++) {
+            const aclTensor *weightScale = (*gmmDsqParams_.weightScale)[i];
+            const aclTensor *weight = (*gmmDsqParams_.weight)[i];
+            OP_CHECK_DTYPE_NOT_SUPPORT(weight, WEIGHT_DTYPE_SUPPORT_LIST, return false);
+            OP_CHECK_DTYPE_NOT_SUPPORT(weightScale, WEIGHT_SCALE_DTYPE_SUPPORT_LIST, return false);
+        }
+        OP_CHECK_DTYPE_NOT_SUPPORT(x, X_DTYPE_SUPPORT_LIST, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(xScale, X_SCALE_DTYPE_SUPPORT_LIST, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(groupList, GROUP_LIST_DTYPE_SUPPORT_LIST, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(outputScale, QUANTSCALEOUT_DTYPE_SUPPORT_LIST, return false);
+        DataType outputDtype = gmmDsqParams_.output->GetDataType();
+        if (outputDtype != DataType::DT_FLOAT8_E4M3FN && outputDtype != DataType::DT_FLOAT8_E5M2) {
+            OP_LOGE(
+                ACLNN_ERR_PARAM_INVALID,
+                "When the dtypes of x and weight inputs are DT_FLOAT8_E4M3FN or "
+                "DT_FLOAT8_E5M2, the dtypes of output should be DT_FLOAT8_E4M3FN or DT_FLOAT8_E5M2, but actual value "
+                "is %s.",
+                op::ToString(outputDtype).GetString());
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckFp4DtypeValid(const aclTensor *x, const aclTensor *xScale, const aclTensor *groupList,
+                            const aclTensor *output, const aclTensor *outputScale)
+    {
+        size_t weightLength = gmmDsqParams_.weight->Size();
+        for (size_t i = 0; i < weightLength; i++) {
+            const aclTensor *weightScale = (*gmmDsqParams_.weightScale)[i];
+            const aclTensor *weight = (*gmmDsqParams_.weight)[i];
+            OP_CHECK_DTYPE_NOT_SUPPORT(weight, WEIGHT_DTYPE_SUPPORT_LIST_MXFP4, return false);
+            OP_CHECK_DTYPE_NOT_SUPPORT(weightScale, WEIGHT_SCALE_DTYPE_SUPPORT_LIST, return false);
+        }
+        OP_CHECK_DTYPE_NOT_SUPPORT(x, X_DTYPE_SUPPORT_LIST_MXFP4, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(xScale, X_SCALE_DTYPE_SUPPORT_LIST, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(groupList, GROUP_LIST_DTYPE_SUPPORT_LIST, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(output, QUANTOUT_DTYPE_SUPPORT_LIST_MXFP4, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(outputScale, QUANTSCALEOUT_DTYPE_SUPPORT_LIST, return false);
+        return true;
+    }
+
+    bool CheckPertokenDtypeValid(const aclTensor *x, const aclTensor *xScale, const aclTensor *groupList,
+                                 const aclTensor *output, const aclTensor *outputScale)
+    {
+        OP_CHECK_DTYPE_NOT_SUPPORT(x, XW_DTYPE_SUPPORT_LIST_PERTOKEN, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(xScale, X_SCALE_DTYPE_SUPPORT_LIST_PERTOKEN, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(groupList, GROUP_LIST_DTYPE_SUPPORT_LIST, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(output, QUANTOUT_DTYPE_SUPPORT_LIST_PERTOKEN, return false);
+        OP_CHECK_DTYPE_NOT_SUPPORT(outputScale, QUANTSCALEOUT_DTYPE_SUPPORT_LIST_PERTOKEN, return false);
+        size_t weightLength = gmmDsqParams_.weight->Size();
+        for (size_t i = 0; i < weightLength; i++) {
+            const aclTensor *weight = (*gmmDsqParams_.weight)[i];
+            const aclTensor *weightScale = (*gmmDsqParams_.weightScale)[i];
+            OP_CHECK_DTYPE_NOT_SUPPORT(weight, XW_DTYPE_SUPPORT_LIST_PERTOKEN, return false);
+            DataType xDtype = gmmDsqParams_.x->GetDataType();
+            if (xDtype == DataType::DT_INT8) {
+                OP_CHECK_DTYPE_NOT_SUPPORT(weightScale, WEIGHT_SCALE_DTYPE_SUPPORT_LIST_PERTOKEN_XINT8, return false);
+            } else {
+                OP_CHECK_DTYPE_NOT_SUPPORT(weightScale, WEIGHT_SCALE_DTYPE_SUPPORT_LIST_PERTOKEN_XFP8HIF8,
+                                           return false);
+            }
+        }
+        DataType xDtype = gmmDsqParams_.x->GetDataType();
+        return IsDtypeCompatiblePertoken(xDtype, ((*gmmDsqParams_.weight)[0])->GetDataType());
+    }
+
+    bool IsDtypeCompatiblePertoken(const DataType a, const DataType b) const
+    {
+        if ((a == DataType::DT_FLOAT8_E4M3FN || a == DataType::DT_FLOAT8_E5M2) &&
+            (b == DataType::DT_FLOAT8_E4M3FN || b == DataType::DT_FLOAT8_E5M2)) {
+            return true;
+        }
+        return a == b;
+    }
+
+    bool checkMxfp4InputShape()
+    {
+        int64_t kValue = gmmDsqParams_.x->GetViewShape().GetDim(1);
+        // 转置情况下从weight的第1维获取n，非转置情况下从weight的第2维获取n
+        int64_t nValue = gmmDsqParams_.transposeWeight ? ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(1) :
+                                                         ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(2);
+        // mxfp4场景不支持k=2
+        if (kValue == MXFP4_K_CONSTRAINT) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "When the dtypes of x and weight inputs are DT_FLOAT4_E2M1, the K value \
+should be greater than 2, but actual value is %lu.",
+                    kValue);
+            return false;
+        }
+
+        // 1：检查K是否为偶数
+        int64_t kModValue = kValue % MXFP4_K_CONSTRAINT;
+        // 2：检查N是否为偶数
+        int64_t nModValue = nValue % MXFP4_N_CONSTRAINT;
+        if (kModValue != 0) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "When the dtypes of x and weight inputs are DT_FLOAT4_E2M1, the K value \
+should be even, but actual value is %lu.",
+                    kValue);
+            return false;
+        }
+
+        // mxfp4场景下，当输出类型为fp4时，N需要满足为大于等于4的偶数
+        DataType outputDtype = gmmDsqParams_.output->GetDataType();
+        if (outputDtype == DataType::DT_FLOAT4_E2M1) {
+            if (!(nValue >= MXFP4_N_CONSTRAINT && nModValue == 0)) {
+                OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                        "When the output dtype is DT_FLOAT4_E2M1, the N value should be even \
+and greater or equal to 4, but actual value is %lu.",
+                        nValue);
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    bool CheckEmptyTensor() override
+    {
+        if (gmmDsqParams_.x->GetViewShape().GetDim(1) <= 0) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "When the M value is not 0, the K value in x should be positive, but actual value is %ld",
+                    gmmDsqParams_.x->GetViewShape().GetDim(1));
+            return false;
+        }
+        auto weightKIndex = ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDimNum() - LAST_SECOND_DIM_INDEX;
+        if (((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(weightKIndex) <= 0) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "When the N value is not 0, the K value in weight should be positive, but actual value is %ld",
+                    ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(weightKIndex));
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckInputOutDims() override
+    {
+        if (!CheckAttrs()) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "CheckAttrs failed.");
+            return false;
+        }
+
+        if (gmmDsqParams_.quantMode == QUNAT_MODE_MX) {
+            return CheckInputOutDimsForMX();
+        } else if (gmmDsqParams_.quantMode == QUNAT_MODE_PERTOKEN) {
+            return CheckInputOutDimsForPertoken();
+        } else {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "Quant mode %d is not supported. Supported modes are 0 (pertoken) and 2 (MX).",
+                    gmmDsqParams_.quantMode);
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckInputOutDimsForMX()
+    {
+        auto xDimNumber = gmmDsqParams_.x->GetViewShape().GetDimNum();
+        auto xScaleDimNumber = gmmDsqParams_.xScale->GetViewShape().GetDimNum();
+        auto outputDimNumber = gmmDsqParams_.output->GetViewShape().GetDimNum();
+        auto outputScaleDimNumber = gmmDsqParams_.outputScale->GetViewShape().GetDimNum();
+        if (xDimNumber != MX_X_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of x should be equal 2, current dim is %lu.", xDimNumber);
+            return false;
+        }
+        if (xScaleDimNumber != MX_X_SCALE_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of xScale should be equal 3, current dim is %lu.",
+                    xScaleDimNumber);
+            return false;
+        }
+        if (gmmDsqParams_.weight->Size() != SINGLE_TENSOR_SIZE) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The size of weight should be 1, current size is %lu.",
+                    gmmDsqParams_.weight->Size());
+            return false;
+        }
+        if (gmmDsqParams_.weightScale->Size() != SINGLE_TENSOR_SIZE) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The size of weightScale should be 1, current size is %lu.",
+                    gmmDsqParams_.weightScale->Size());
+            return false;
+        }
+        if (outputDimNumber != MX_OUTPUT_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of output should be equal 2, current dim is %lu.",
+                    outputDimNumber);
+            return false;
+        }
+        if (outputScaleDimNumber != MX_OUTPUT_SCALE_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of outputScale should be equal 3, current dim is %lu.",
+                    outputScaleDimNumber);
+            return false;
+        }
+        auto weightDimNumber = ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDimNum();
+        auto weightScaleDimNumber = ((*gmmDsqParams_.weightScale)[0])->GetViewShape().GetDimNum();
+        if (weightScaleDimNumber != MX_WEIGHT_SCALE_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of weightScale should be equal 2, current dim is %lu.",
+                    weightScaleDimNumber);
+            return false;
+        }
+        if (weightDimNumber != MX_WEIGHT_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of weight should be equal 3, current dim is %lu.",
+                    weightDimNumber);
+            return false;
+        }
+        return true;
+    }
+    bool CheckInputOutDimsForPertoken()
+    {
+        auto xDimNumber = gmmDsqParams_.x->GetViewShape().GetDimNum();
+        auto xScaleDimNumber = gmmDsqParams_.xScale->GetViewShape().GetDimNum();
+        auto outputDimNumber = gmmDsqParams_.output->GetViewShape().GetDimNum();
+        auto outputScaleDimNumber = gmmDsqParams_.outputScale->GetViewShape().GetDimNum();
+        if (xDimNumber != PERTOKEN_X_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of x should be equal 2, current dim is %lu.", xDimNumber);
+            return false;
+        }
+        if (xScaleDimNumber != PERTOKEN_X_SCALE_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of xScale should be equal 1, current dim is %lu.",
+                    xScaleDimNumber);
+            return false;
+        }
+        if (outputDimNumber != PERTOKEN_OUTPUT_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of output should be equal 2, current dim is %lu.",
+                    outputDimNumber);
+            return false;
+        }
+        if (outputScaleDimNumber != PERTOKEN_OUTPUT_SCALE_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of outputScale should be equal 1, current dim is %lu.",
+                    outputScaleDimNumber);
+            return false;
+        }
+        if (gmmDsqParams_.weight->Size() != SINGLE_TENSOR_SIZE) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The size of weight should be 1, current size is %lu.",
+                    gmmDsqParams_.weight->Size());
+            return false;
+        }
+        if (gmmDsqParams_.weightScale->Size() != SINGLE_TENSOR_SIZE) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The size of weightScale should be 1, current size is %lu.",
+                    gmmDsqParams_.weightScale->Size());
+            return false;
+        }
+        auto weightDimNumber = ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDimNum();
+        auto weightScaleDimNumber = ((*gmmDsqParams_.weightScale)[0])->GetViewShape().GetDimNum();
+        if (weightScaleDimNumber != PERTOKEN_WEIGHT_SCALE_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of weightScale should be equal 2, current dim is %lu.",
+                    weightScaleDimNumber);
+            return false;
+        }
+        if (weightDimNumber != PERTOKEN_WEIGHT_DIM) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "The dim num of weight should be equal 3, current dim is %lu.",
+                    weightDimNumber);
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckInputOutShape() override
+    {
+        int64_t groupListLen = gmmDsqParams_.groupList->GetViewShape().GetDim(0);
+        if (groupListLen > MAX_GROUP_LIST_SIZE) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "The length of groupList should not be greater than 1024, but actual is %ld.", groupListLen);
+            return false;
+        }
+        // 从x的第1维获取k
+        int64_t kInX = gmmDsqParams_.x->GetViewShape().GetDim(1);
+        // 根据是否转置从weight中读取维度k
+        int64_t kInWeight = gmmDsqParams_.transposeWeight ? ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(2) :
+                                                    ((*gmmDsqParams_.weight)[0])->GetViewShape().GetDim(1);
+        if (kInX != kInWeight) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "Expected input tensor x and weight tensor to have consistent k-dimension, but k=%ld in x, while "
+                    "k=%ld in weight.",
+                    kInX, kInWeight);
+            return false;
+        }
+        if (gmmDsqParams_.quantMode == QUNAT_MODE_MX) {
+            return CheckInputOutShapeForMX();
+        } else if (gmmDsqParams_.quantMode == QUNAT_MODE_PERTOKEN) {
+            return CheckInputOutShapeForPertoken();
+        } else {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID,
+                    "Quant mode %d is not supported. Supported modes are 0 (pertoken) and 2 (MX).",
+                    gmmDsqParams_.quantMode);
+            return false;
+        }
+
+        return true;
+    }
+
+    bool CheckInputOutShapeForMX()
+    {
+        if (!CheckMXTranspose()) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "CheckMXTranspose failed.");
+            return false;
+        }
+        if (!CheckMXShape()) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "CheckMXShape failed.");
+            return false;
+        }
+        DataType xDtype = gmmDsqParams_.x->GetDataType();
+        DataType weightDtype = ((*gmmDsqParams_.weight)[0])->GetDataType();
+        if (xDtype == DataType::DT_FLOAT4_E2M1 && weightDtype == DataType::DT_FLOAT4_E2M1) {
+            return checkMxfp4InputShape();
+        }
+        return true;
+    }
+
+    bool CheckInputOutShapeForPertoken()
+    {
+        if (!CheckPertokenTranspose()) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "CheckPertokenTranspose failed.");
+            return false;
+        }
+        if (!CheckPertokenShape()) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "CheckPerTokenShape failed.");
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckDtypeValid() override
+    {
+        DataType xDtype = gmmDsqParams_.x->GetDataType();
+        DataType weightDtype = ((*gmmDsqParams_.weight)[0])->GetDataType();
+        DataType xScaleDtype = gmmDsqParams_.xScale->GetDataType();
+        DataType weightScaleDtype = ((*gmmDsqParams_.weightScale)[0])->GetDataType();
+        const aclTensor *x = gmmDsqParams_.x;
+        const aclTensor *xScale = gmmDsqParams_.xScale;
+        const aclTensor *groupList = gmmDsqParams_.groupList;
+        const aclTensor *output = gmmDsqParams_.output;
+        const aclTensor *outputScale = gmmDsqParams_.outputScale;
+        if(std::find(X_DTYPE_SUPPORT_LIST.begin(), X_DTYPE_SUPPORT_LIST.end(), xDtype) == X_DTYPE_SUPPORT_LIST.end() &&
+           std::find(X_DTYPE_SUPPORT_LIST_MXFP4.begin(), X_DTYPE_SUPPORT_LIST_MXFP4.end(), xDtype) == X_DTYPE_SUPPORT_LIST_MXFP4.end() &&
+           std::find(XW_DTYPE_SUPPORT_LIST_PERTOKEN.begin(), XW_DTYPE_SUPPORT_LIST_PERTOKEN.end(), xDtype) == XW_DTYPE_SUPPORT_LIST_PERTOKEN.end()){
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Quant case with x dtype %s is not supported; supported types are: INT8, FLOAT8_E4M3FN, "
+                        "FLOAT8_E5M2, HIFLOAT8, and FLOAT4_E2M1.", op::ToString(xDtype).GetString());
+            return false;
+        }
+        if(std::find(WEIGHT_DTYPE_SUPPORT_LIST.begin(), WEIGHT_DTYPE_SUPPORT_LIST.end(), weightDtype) == WEIGHT_DTYPE_SUPPORT_LIST.end() &&
+           std::find(WEIGHT_DTYPE_SUPPORT_LIST_MXFP4.begin(), WEIGHT_DTYPE_SUPPORT_LIST_MXFP4.end(), weightDtype) == WEIGHT_DTYPE_SUPPORT_LIST_MXFP4.end() &&
+           std::find(XW_DTYPE_SUPPORT_LIST_PERTOKEN.begin(), XW_DTYPE_SUPPORT_LIST_PERTOKEN.end(), weightDtype) == XW_DTYPE_SUPPORT_LIST_PERTOKEN.end()){
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Quant case with weight dtype %s is not supported; supported types are: INT8, FLOAT8_E4M3FN, "
+                        "FLOAT8_E5M2, HIFLOAT8, and FLOAT4_E2M1.", op::ToString(weightDtype).GetString());
+            return false;
+        }
+        if (gmmDsqParams_.quantMode == QUNAT_MODE_MX &&
+            (xDtype == DataType::DT_FLOAT8_E4M3FN || xDtype == DataType::DT_FLOAT8_E5M2) &&
+            (weightDtype == DataType::DT_FLOAT8_E4M3FN || weightDtype == DataType::DT_FLOAT8_E5M2)) {
+            return CheckFp8DtypeValid(x, xScale, groupList, output, outputScale);
+        } else if (gmmDsqParams_.quantMode == QUNAT_MODE_MX && xDtype == DataType::DT_FLOAT4_E2M1 &&
+                   weightDtype == DataType::DT_FLOAT4_E2M1) {
+            return CheckFp4DtypeValid(x, xScale, groupList, output, outputScale);
+        } else if (gmmDsqParams_.quantMode == QUNAT_MODE_PERTOKEN &&
+                   std::find(XW_DTYPE_SUPPORT_LIST_PERTOKEN.begin(), XW_DTYPE_SUPPORT_LIST_PERTOKEN.end(), xDtype) !=
+                       XW_DTYPE_SUPPORT_LIST_PERTOKEN.end() &&
+                   std::find(XW_DTYPE_SUPPORT_LIST_PERTOKEN.begin(), XW_DTYPE_SUPPORT_LIST_PERTOKEN.end(),
+                             weightDtype) != XW_DTYPE_SUPPORT_LIST_PERTOKEN.end()) {
+            return CheckPertokenDtypeValid(x, xScale, groupList, output, outputScale);
+        } else {
+            OP_LOGE(
+                ACLNN_ERR_PARAM_INVALID,
+                "In quantization mode %d, the combination of x dtype %s, weight dtype %s is not supported. "
+                "Supported combinations are: "
+                "Quantmode 0 (pertoken): (x=int8, weight=int8) or (x=float8_e4m3fn/float8_e5m2, "
+                "weight=float8_e4m3fn/float8_e5m2) or (x=hifloat8, weight=hifloat8); "
+                "Quantmode 2 (mx): (x=float8_e4m3fn/float8_e5m2, weight=float8_e4m3fn/float8_e5m2) or (x=float4_e2m1, weight=float4_e2m1).",
+                gmmDsqParams_.quantMode, op::ToString(xDtype).GetString(), op::ToString(weightDtype).GetString());
+            return false;
+        }
+        return true;
+    }
+
+    bool CheckFormat() override
+    {
+        size_t wLength = gmmDsqParams_.weight->Size();
+        for (size_t i = 0; i < wLength; i++) {
+            const aclTensor *weightScale = (*gmmDsqParams_.weightScale)[i];
+            const aclTensor *weight = (*gmmDsqParams_.weight)[i];
+            if (op::IsPrivateFormat(weight->GetStorageFormat())) {
+                OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format of weight should be ND, current format is format is %s.",
+                        op::ToString(weight->GetStorageFormat()).GetString());
+                return false;
+            }
+            if (op::IsPrivateFormat(weightScale->GetStorageFormat())) {
+                OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format of weightScale should be ND, current format is format is %s.",
+                        op::ToString(weightScale->GetStorageFormat()).GetString());
+                return false;
+            }
+        }
+
+        if (op::IsPrivateFormat(gmmDsqParams_.x->GetStorageFormat())) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format of x should be ND, current format is format is %s.",
+                    op::ToString(gmmDsqParams_.x->GetStorageFormat()).GetString());
+            return false;
+        }
+        if (op::IsPrivateFormat(gmmDsqParams_.xScale->GetStorageFormat())) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format of xScale should be ND, current format is format is %s.",
+                    op::ToString(gmmDsqParams_.xScale->GetStorageFormat()).GetString());
+            return false;
+        }
+        if (op::IsPrivateFormat(gmmDsqParams_.groupList->GetStorageFormat())) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format of groupList should be ND, current format is format is %s.",
+                    op::ToString(gmmDsqParams_.groupList->GetStorageFormat()).GetString());
+            return false;
+        }
+        if (op::IsPrivateFormat(gmmDsqParams_.output->GetStorageFormat())) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format of output should be ND, current format is format is %s.",
+                    op::ToString(gmmDsqParams_.output->GetStorageFormat()).GetString());
+            return false;
+        }
+        if (op::IsPrivateFormat(gmmDsqParams_.outputScale->GetStorageFormat())) {
+            OP_LOGE(ACLNN_ERR_PARAM_INVALID, "Format of outputScale should be ND, current format is format is %s.",
+                    op::ToString(gmmDsqParams_.outputScale->GetStorageFormat()).GetString());
+            return false;
+        }
+        return true;
+    }
+};
+} // namespace gmmSwigluQuantV2
+#endif