diff --git a/atvc/include/broadcast/tiling/broadcast_tiling.h b/atvc/include/broadcast/tiling/broadcast_tiling.h
index 3e62c61b27006d3c2ae0f2c50951d351a4e5ba6f..a054aaa3265a0b2958bde14c0f81ee5b3d138530 100644
--- a/atvc/include/broadcast/tiling/broadcast_tiling.h
+++ b/atvc/include/broadcast/tiling/broadcast_tiling.h
@@ -254,7 +254,7 @@ private:
         }
 
         if (tilingData.coreNum > compileInfo_.vectorCoreNum) {
-            printf("[ERROR] Check tiling failed, coreNum(%u) > vector Real Core count(%u)\n",
+            printf("[ERROR] Check tiling failed, coreNum(%u) > vector Real Core count(%lu)\n",
                 tilingData.coreNum, compileInfo_.vectorCoreNum);
             return false;
         }
diff --git a/atvc/include/common/dtype_utils.h b/atvc/include/common/dtype_utils.h
index c9e430557d5bf462c83563d7939767ef1aef3b79..94eafcdf25dcba49e6d5e1d01dd71d0bca383969 100644
--- a/atvc/include/common/dtype_utils.h
+++ b/atvc/include/common/dtype_utils.h
@@ -48,8 +48,17 @@ inline ge::DataType GetPromoteDataType(ge::DataType dtype)
             return ge::DataType::DT_INT32;
         case ge::DataType::DT_INT64:
             return ge::DataType::DT_INT64;
+        case ge::DataType::DT_UINT8:
+            return ge::DataType::DT_UINT8;
+        case ge::DataType::DT_UINT16:
+            return ge::DataType::DT_UINT16;
+        case ge::DataType::DT_UINT32:
+            return ge::DataType::DT_UINT32;
+        case ge::DataType::DT_UINT64:
+            return ge::DataType::DT_UINT64;
+        default:
+            return ge::DataType::DT_UNDEFINED;
     }
-    return ge::DataType::DT_UNDEFINED;
 }
 }
 
diff --git a/impl/matmul/kfc/matmul_server_impl.h b/impl/matmul/kfc/matmul_server_impl.h
index 8a4099a7d470ceec6b2b5b45a1a68cb2d016869d..c1aa131068f9f64fca0377875969e701bf8a7a0b 100644
--- a/impl/matmul/kfc/matmul_server_impl.h
+++ b/impl/matmul/kfc/matmul_server_impl.h
@@ -310,6 +310,7 @@ __aicore__ inline bool MatmulService<A_TYPE, B_TYPE, C_TYPE, BIAS_TYPE, MM_CFG,
     cGlobal.SetGlobalBuffer(reinterpret_cast<__gm__ DstT*>(body->cAddr), size);
     mul.IterateBatch(cGlobal, body->enPartialSum, (uint8_t)(body->enAtomic),body->enSequentialWrite,
                     body->matrixStrideA, body->matrixStrideB, body->matrixStrideC);
+    mul.End();
 
     // Now release UB
     if constexpr (PhyPosIsUB(A_TYPE::pos) || PhyPosIsUB(B_TYPE::pos) ||
@@ -544,4 +545,4 @@ __aicore__ inline bool MatmulService<A_TYPE, B_TYPE, C_TYPE, BIAS_TYPE, MM_CFG,
 }
 #endif
 } // namespace AscendC
-#endif // __MATMUL_SERVER_IMPL_H__
\ No newline at end of file
+#endif // __MATMUL_SERVER_IMPL_H__
diff --git a/impl/matmul/kfc/matmul_server_impl_c310.h b/impl/matmul/kfc/matmul_server_impl_c310.h
index e32d85313b1006a225d0cdb4c21f2c5c2d4e5626..7925e231568aea760fbd0358c306dd8d7161a7af 100644
--- a/impl/matmul/kfc/matmul_server_impl_c310.h
+++ b/impl/matmul/kfc/matmul_server_impl_c310.h
@@ -447,6 +447,7 @@ __aicore__ inline bool MatmulService<A_TYPE, B_TYPE, C_TYPE, BIAS_TYPE, MM_CFG,
         cGlobal.SetGlobalBuffer(reinterpret_cast<__gm__ DstT *>(body->cAddr), size);
         mul.IterateBatch(cGlobal,body->enPartialSum, (uint8_t)(body->enAtomic),body->enSequentialWrite,
             body->matrixStrideA, body->matrixStrideB, body->matrixStrideC);
+        mul.End();
     }
     
     if constexpr (GetPhyType(C_TYPE::pos) == Hardware::UB) {
@@ -459,6 +460,7 @@ __aicore__ inline bool MatmulService<A_TYPE, B_TYPE, C_TYPE, BIAS_TYPE, MM_CFG,
         }
         mul.IterateBatch(cLocal,body->enPartialSum, (uint8_t)(body->enAtomic), body->enSequentialWrite,
                          body->matrixStrideA, body->matrixStrideB, body->matrixStrideC);
+        mul.End();
     }
     if (body->sync || body->waitIterateBatch) {
         IterNotify();
@@ -496,4 +498,4 @@ __aicore__ inline bool MatmulService<A_TYPE, B_TYPE, C_TYPE, BIAS_TYPE, MM_CFG,
 }
 #endif
 } // namespace AscendC
-#endif // __MATMUL_SERVER_IMPL_C310_H__
\ No newline at end of file
+#endif // __MATMUL_SERVER_IMPL_C310_H__
diff --git a/impl/matmul/policy/matmul_private_modules.h b/impl/matmul/policy/matmul_private_modules.h
index 996f48cf7d4b9b2df656c4e152967ce4faf2ce4d..53f5f2892ed452cff7aa4e2a91531f7a1326715b 100644
--- a/impl/matmul/policy/matmul_private_modules.h
+++ b/impl/matmul/policy/matmul_private_modules.h
@@ -87,7 +87,7 @@ struct MatmulPrivateModules {
     using MatmulUserDefineInfo = AscendC::Impl::Detail::MatmulUserDefineInfo<IMPL, MM_CFG, UserDefDataType>;
 
     using MatmulUnitFlag = AscendC::Impl::Detail::MatmulUnitFlag<IMPL, MM_CFG>;
-    using BatchLoop = AscendC::Impl::Detail::BatchLoop<IMPL, MatmulInputAType<A_TYPE, typename A_TYPE::T>, MM_CFG>;
+    using BatchLoop = AscendC::Impl::Detail::BatchLoop<IMPL, MatmulInputAType<A_TYPE, typename A_TYPE::T>, BIAS_TYPE, MM_CFG>;
     using CopyCubeOutUtils = AscendC::Impl::Detail::CopyCubeOutWrapper<IMPL, A_TYPE, B_TYPE, C_TYPE, MM_CFG>;
 
     // using compute modules
diff --git a/impl/matmul/resource/cube_in_buffer/cube_in_buffer.h b/impl/matmul/resource/cube_in_buffer/cube_in_buffer.h
index d27f12ca3f30cc46a741a26d325f3e98e0a4c31f..be2e419a9baf24a3b1a0069f9c57e7fd5068668a 100644
--- a/impl/matmul/resource/cube_in_buffer/cube_in_buffer.h
+++ b/impl/matmul/resource/cube_in_buffer/cube_in_buffer.h
@@ -22,9 +22,11 @@
 #if __CCE_AICORE__ == 220
 #include "cube_in_buffer_double_buffer_sparse.h"
 #include "cube_in_buffer_n_buffer.h"
+#include "cube_in_buffer_bmm_db.h"
 #endif
 #if defined(__DAV_C310__)
 #include "cube_in_buffer_n_buffer.h"
+#include "cube_in_buffer_bmm_db.h"
 #endif
 
-#endif // _CUBE_IN_BUFFER_H_
\ No newline at end of file
+#endif // _CUBE_IN_BUFFER_H_
diff --git a/impl/matmul/resource/cube_in_buffer/cube_in_buffer_bmm_db.h b/impl/matmul/resource/cube_in_buffer/cube_in_buffer_bmm_db.h
new file mode 100644
index 0000000000000000000000000000000000000000..1bce8c0d9b57d25475dfcdfe5b030a47be120374
--- /dev/null
+++ b/impl/matmul/resource/cube_in_buffer/cube_in_buffer_bmm_db.h
@@ -0,0 +1,110 @@
+/**
+ * Copyright (c) 2025 Huawei Technologies Co., Ltd.
+ * This file is a part of the CANN Open Software.
+ * Licensed under CANN Open Software License Agreement Version 1.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 cube_in_buffer_bmm_db.h
+* \brief
+*/
+
+#ifndef IMPL_MATMUL_RESOURCE_CUBE_IN_BUFFER_CUBE_IN_BUFFER_BMM_DB_H
+#define IMPL_MATMUL_RESOURCE_CUBE_IN_BUFFER_CUBE_IN_BUFFER_BMM_DB_H
+
+#include "cube_in_buffer_intf.h"
+
+namespace AscendC {
+namespace Impl {
+namespace Detail {
+/*
+    CubeInBuffer is considered entirely experimental.
+    We retain the freedom to make incompatible changes, but do not guarantee the stability.
+    CubeInBuffer is only for internal usage, does not support extension or customized specialization!
+*/
+template <typename IMPL, class INPUT_TYPE, const auto& MM_CFG, PolicyType POLICY_TYPE>
+class CubeInBuffer<IMPL, INPUT_TYPE, MM_CFG, POLICY_TYPE, enable_if_t<
+GetCubeInBufferType<INPUT_TYPE, MM_CFG>() == CubeInBufferType::BMM_DOUBLE_BUFFER>> {
+    using TransT = typename INPUT_TYPE::TRANS_T;
+public:
+    __aicore__ inline CubeInBuffer() {}
+    __aicore__ inline ~CubeInBuffer() {}
+    __aicore__ inline void Init(int32_t baseBlockSize, int32_t cacheNum)
+    {
+        int32_t matrixByteSize = baseBlockSize * AscendC::GetBitSize<TransT>() / ONE_BYTE_BIT_SIZE;
+        auto queDepth = cacheNum;
+        GetTPipePtr()->InitBuffer(qid_, queDepth, matrixByteSize / queDepth);
+    }
+
+    __aicore__ inline void Destroy()
+    {
+        qid_.FreeAllEvent();
+    }
+
+    __aicore__ inline LocalTensor<TransT> AllocTensor(int32_t needCache = 0)
+    {
+        cacheHead_ = qid_.template AllocTensor<TransT>();
+        if (needCache) {
+            isCached_ = true;
+        }
+        return cacheHead_[0];
+    }
+
+    __aicore__ inline void FreeTensor(int32_t needCache = 0, const LocalTensor<TransT>& tensor = NULL_TENSOR<TransT>)
+    {
+        if (!needCache) {
+            qid_.FreeTensor(cacheHead_);
+        }
+    }
+
+    __aicore__ inline void Reset()
+    {
+        if (isCached_) {
+            qid_.FreeTensor(cacheHead_);
+            isCached_ = false;
+        }
+    }
+
+    __aicore__ inline bool Hit(int32_t iterIndex, int32_t bufferPos = -1)
+    {
+        return isCached_;
+    }
+
+    __aicore__ inline LocalTensor<TransT> GetBuffer(int32_t iterIndex, int32_t bufferPos = -1)
+    {
+        return cacheHead_[0];
+    }
+
+    __aicore__ inline void EnQue(LocalTensor<TransT>& tensor)
+    {
+        qid_.EnQue(tensor);
+    }
+
+    __aicore__ inline void DeQue()
+    {
+        (void) qid_.DeQue();
+    }
+
+    __aicore__ inline uint64_t GetBufferHeadAddr()
+    {
+// wait for GetTQueHeadAddr
+#if defined(__DAV_C310__) || defined(__DAV_310R6__)
+        return GetTQueHeadAddr(qid_);
+#else
+        return 0;
+#endif
+    }
+
+private:
+    typename CubeInQueType<INPUT_TYPE>::QUE qid_;
+    LocalTensor<TransT> cacheHead_;
+    bool isCached_ {false};
+};
+
+}  // namespace Detail
+}  // namespace Impl
+}  // namespace AscendC
+#endif // _CUBE_IN_BUFFER_BMM_DB_H_
diff --git a/impl/matmul/resource/cube_in_buffer/cube_in_buffer_utils.h b/impl/matmul/resource/cube_in_buffer/cube_in_buffer_utils.h
index 7a7fcadedae5dfe082047ff6fc053f51e5e09b34..348f9feed4bde5a33fabbc348c1959e36be6dd83 100644
--- a/impl/matmul/resource/cube_in_buffer/cube_in_buffer_utils.h
+++ b/impl/matmul/resource/cube_in_buffer/cube_in_buffer_utils.h
@@ -45,6 +45,7 @@ enum class CubeInBufferType : uint8_t {
     DOUBLE_BUFFER_SPARSE,
     NORMAL_MX,
     DOUBLE_BUFFER_MX,
+    BMM_DOUBLE_BUFFER
 };
 
 template <typename INPUT_TYPE, const auto& MM_CFG>
@@ -66,6 +67,13 @@ __aicore__ inline constexpr bool IsSetNoDB()
         (INPUT_TYPE::layout != LayoutMode::NONE && ToMatmulConfig(MM_CFG).batchMode != BatchMode::SINGLE_LARGE_THAN_L1);
 }
 
+template <typename INPUT_TYPE, const auto& MM_CFG>
+__aicore__ inline constexpr bool IsBmmDoubleBuffer()
+{
+    return !MatmulFeatureTrait<MM_CFG>::IsNeedUB() && INPUT_TYPE::layout != LayoutMode::NONE &&
+           ToMatmulConfig(MM_CFG).batchMode == BatchMode::BATCH_LESS_THAN_L1;
+}
+
 template <typename INPUT_TYPE, const auto& MM_CFG>
 __aicore__ inline constexpr CubeInBufferType GetCubeInBufferType()
 {
@@ -82,7 +90,9 @@ __aicore__ inline constexpr CubeInBufferType GetCubeInBufferType()
             return CubeInBufferType::NORMAL;
         }
     } else if constexpr (DoMatmulNorm(MM_CFG)) {
-        if constexpr (IsSetNoDB<INPUT_TYPE, MM_CFG>()) {
+        if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            return CubeInBufferType::BMM_DOUBLE_BUFFER;
+        } else if (IsSetNoDB<INPUT_TYPE, MM_CFG>()) {
             return CubeInBufferType::SINGLE_BUFFER;
         } else if (IsScaleTag<INPUT_TYPE>()) {
             return CubeInBufferType::NORMAL_MX;
@@ -107,4 +117,4 @@ __aicore__ inline constexpr CubeInBufferType GetCubeInBufferType()
 }  // namespace Detail
 }  // namespace Impl
 }  // namespace AscendC
-#endif // _CUBE_IN_BUFFER_UTILS_H_
\ No newline at end of file
+#endif // _CUBE_IN_BUFFER_UTILS_H_
diff --git a/impl/matmul/scheduler/batch/batch_scheduler.h b/impl/matmul/scheduler/batch/batch_scheduler.h
index 20f7051d09e3d2c9d855f8da218450df0299c637..add2660f324c192a9a910ae05c7f5ca88d8274b6 100644
--- a/impl/matmul/scheduler/batch/batch_scheduler.h
+++ b/impl/matmul/scheduler/batch/batch_scheduler.h
@@ -61,6 +61,89 @@ public:
     __aicore__ inline BatchScheduler() = default;
     __aicore__ inline ~BatchScheduler() = default;
 
+    template <class T>
+    __aicore__ inline void ComputeInner(const T& dst, LocalTensor<TransAT>& a1, LocalTensor<TransAT>& b1,
+                                        LocalTensor<BiasT>& bias, bool enPartialSum, uint8_t enAtomic,
+                                        bool enSequentialWrite, BatchOffsetInfo& batchOffsetInfo,
+                                        BatchSchedulerContext& ctx, event_t eventIDMte2ToMte1, event_t eventIDMToMte1)
+    {
+        auto batchLoop = MATMUL_MODULE(BatchLoop);
+        for (batchLoop->InnerStart(); !batchLoop->InnerEnd(); batchLoop->InnerNext()) {
+            BASE_MODULE::isFirstIter_ = true;
+            if (batchOffsetInfo.setBiasFlag && (batchLoop->GetBatchIndex() % batchOffsetInfo.divisorBias == 1)) {
+                MATMUL_MODULE(BiasScheduler)->StopBias(bias);
+            }
+            UpdateOffset(batchOffsetInfo, ctx);
+            while (BASE_MODULE::MoveNext()) { // iterate
+                MATMUL_MODULE(CubeOutBuffer)->AllocTensor();
+                ComputeBatch(a1, b1, bias, enPartialSum, ctx);
+                BatchScheduler::GetBatchResultImpl(dst, ctx, enAtomic, enSequentialWrite);
+                SetFlag<HardEvent::M_MTE1>(eventIDMToMte1);
+                WaitFlag<HardEvent::M_MTE1>(eventIDMToMte1);
+            }
+            EndIterate();
+        }
+    }
+
+    template <class T, const auto& MM_CFG_ALIAS = MM_CFG>
+    __aicore__ inline enable_if_t<ToMatmulConfig(MM_CFG_ALIAS).batchMode != BatchMode::BATCH_LESS_THAN_L1>
+    ComputeSplit(const T& dst, LocalTensor<BiasT>& bias, bool enPartialSum, uint8_t enAtomic, bool enSequentialWrite,
+                 uint32_t matrixStrideA, uint32_t matrixStrideB, BatchOffsetInfo& batchOffsetInfo,
+                 BatchSchedulerContext& ctx)
+    {
+        auto a1 = MATMUL_MODULE(BatchCopyCubeInA)->AllocTensor();
+        auto b1 = MATMUL_MODULE(BatchCopyCubeInB)->AllocTensor();
+        event_t eventIDMte2ToMte1 = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::MTE2_MTE1));
+        event_t eventIDMToMte1 = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::M_MTE1));
+        auto batchLoop = MATMUL_MODULE(BatchLoop);
+        for (batchLoop->SplitStart(); !batchLoop->SplitEnd(); batchLoop->SplitNext()) {
+            MATMUL_MODULE(BatchCopyCubeInA)->BatchLoad(a1, matrixStrideA, batchLoop->GetOuterIndex(),
+                batchLoop->GetSplitIndex(), batchLoop->GetSplitSize());
+            MATMUL_MODULE(BatchCopyCubeInB)->BatchLoad(b1, matrixStrideB, batchLoop->GetOuterIndex(),
+                batchLoop->GetSplitIndex(), batchLoop->GetSplitSize());
+            SetFlag<HardEvent::MTE2_MTE1>(eventIDMte2ToMte1);
+            WaitFlag<HardEvent::MTE2_MTE1>(eventIDMte2ToMte1);
+            ComputeInner(dst, a1, b1, bias, enPartialSum, enAtomic, enSequentialWrite, batchOffsetInfo, ctx,
+                         eventIDMte2ToMte1, eventIDMToMte1);
+            BASE_MODULE::End();
+        }
+        MATMUL_MODULE(BatchCopyCubeInA)->BatchDestroy(a1);
+        MATMUL_MODULE(BatchCopyCubeInB)->BatchDestroy(b1);
+    }
+
+    template <class T, const auto& MM_CFG_ALIAS = MM_CFG>
+    __aicore__ inline enable_if_t<ToMatmulConfig(MM_CFG_ALIAS).batchMode == BatchMode::BATCH_LESS_THAN_L1>
+    ComputeSplit(const T& dst, LocalTensor<BiasT>& bias, bool enPartialSum, uint8_t enAtomic, bool enSequentialWrite,
+                 uint32_t matrixStrideA, uint32_t matrixStrideB, BatchOffsetInfo& batchOffsetInfo,
+                 BatchSchedulerContext& ctx)
+    {
+        auto batchLoop = MATMUL_MODULE(BatchLoop);
+        for (batchLoop->SplitStart(); !batchLoop->SplitEnd(); batchLoop->SplitNext()) {
+            LocalTensor<TransAT> a1;
+            LocalTensor<TransBT> b1;
+            event_t eventIDMte2ToMte1 = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::MTE2_MTE1));
+            event_t eventIDMToMte1 = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::M_MTE1));
+            auto splitIdxA = batchLoop->template GetSplitIndex<InputTypeTag::A>();
+            auto splitIdxB = batchLoop->template GetSplitIndex<InputTypeTag::B>();
+            MATMUL_MODULE(BatchCopyCubeInA)->BatchLoad(a1, matrixStrideA, batchLoop->GetOuterIndex(),
+                splitIdxA, batchLoop->GetSplitSize());
+            MATMUL_MODULE(BatchCopyCubeInB)->BatchLoad(b1, matrixStrideB, batchLoop->GetOuterIndex(),
+                splitIdxB, batchLoop->GetSplitSize());
+            SetFlag<HardEvent::MTE2_MTE1>(eventIDMte2ToMte1);
+            WaitFlag<HardEvent::MTE2_MTE1>(eventIDMte2ToMte1);
+            ComputeInner(dst, a1, b1, bias, enPartialSum, enAtomic, enSequentialWrite, batchOffsetInfo, ctx,
+                         eventIDMte2ToMte1, eventIDMToMte1);
+
+            MATMUL_MODULE(BatchCopyCubeInA)->BatchDestroy(a1);
+            MATMUL_MODULE(BatchCopyCubeInB)->BatchDestroy(b1);
+            MATMUL_MODULE(BiasScheduler)->End();
+            MATMUL_MODULE(CubeOutBuffer)->Destroy();
+        }
+
+        MATMUL_MODULE(BatchCopyCubeInA)->Reset();
+        MATMUL_MODULE(BatchCopyCubeInB)->Reset();
+    }
+
     template<class T>
     __aicore__ inline void Schedule(const T& dst, bool enPartialSum, uint8_t enAtomic, bool enSequentialWrite,
         const uint32_t matrixStrideA, const uint32_t matrixStrideB, const uint32_t matrixStrideC)
@@ -86,37 +169,8 @@ public:
                     batchLoop->GetBatchNum(), batchLoop->GetBiasBatchSrcOffset());
             }
 
-            auto a1 = MATMUL_MODULE(BatchCopyCubeInA)->AllocTensor();
-            auto b1 = MATMUL_MODULE(BatchCopyCubeInB)->AllocTensor();
-            event_t eventIDMte2ToMte1 = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::MTE2_MTE1));
-            event_t eventIDMToMte1 = static_cast<event_t>(GetTPipePtr()->FetchEventID(HardEvent::M_MTE1));
-            auto batchLoop = MATMUL_MODULE(BatchLoop);
-            for (batchLoop->SplitStart(); !batchLoop->SplitEnd(); batchLoop->SplitNext()) {
-                MATMUL_MODULE(BatchCopyCubeInA)->BatchLoad(a1, matrixStrideA, batchLoop->GetOuterIndex(),
-                    batchLoop->GetSplitIndex(), batchLoop->GetSplitSize());
-                MATMUL_MODULE(BatchCopyCubeInB)->BatchLoad(b1, matrixStrideB, batchLoop->GetOuterIndex(),
-                    batchLoop->GetSplitIndex(), batchLoop->GetSplitSize());
-                SetFlag<HardEvent::MTE2_MTE1>(eventIDMte2ToMte1);
-                WaitFlag<HardEvent::MTE2_MTE1>(eventIDMte2ToMte1);
-                for (batchLoop->InnerStart(); !batchLoop->InnerEnd(); batchLoop->InnerNext()) {
-                    BASE_MODULE::isFirstIter_ = true;
-                    if (batchOffsetInfo.setBiasFlag && (batchLoop->GetBatchIndex() % batchOffsetInfo.divisorBias == 1)) {
-                        MATMUL_MODULE(BiasScheduler)->StopBias(bias);
-                    }
-                    UpdateOffset(batchOffsetInfo, ctx);
-                    while (BASE_MODULE::MoveNext()) { // iterate
-                        MATMUL_MODULE(CubeOutBuffer)->AllocTensor();
-                        ComputeBatch(a1, b1, bias, enPartialSum, ctx);
-                        BatchScheduler::GetBatchResultImpl(dst, ctx, enAtomic, enSequentialWrite);
-                        SetFlag<HardEvent::M_MTE1>(eventIDMToMte1);
-                        WaitFlag<HardEvent::M_MTE1>(eventIDMToMte1);
-                    }
-                    EndIterate();
-                }
-                BASE_MODULE::End();
-            }
-            MATMUL_MODULE(BatchCopyCubeInA)->BatchDestroy();
-            MATMUL_MODULE(BatchCopyCubeInB)->BatchDestroy();
+            ComputeSplit(dst, bias, enPartialSum, enAtomic, enSequentialWrite, matrixStrideA, matrixStrideB,
+                         batchOffsetInfo, ctx);
 
             if constexpr (ToMatmulConfig(MM_CFG).isBiasBatch) {
                 MATMUL_MODULE(BiasScheduler)->Destroy(bias);
@@ -139,7 +193,9 @@ private:
         return batchOffsetInfo;
     }
 
-    __aicore__ inline void UpdateOffset(BatchOffsetInfo& batchOffsetInfo, BatchSchedulerContext& ctx)
+    template <const auto& MM_CFG_ALIAS = MM_CFG>
+    __aicore__ inline enable_if_t<ToMatmulConfig(MM_CFG_ALIAS).batchMode != BatchMode::BATCH_LESS_THAN_L1>
+     UpdateOffset(BatchOffsetInfo& batchOffsetInfo, BatchSchedulerContext& ctx)
     {
         auto batchIndex = MATMUL_MODULE(BatchLoop)->GetBatchIndex();
         ctx.offsetA = batchOffsetInfo.alignA *
@@ -153,6 +209,31 @@ private:
         }
     }
 
+    template <const auto& MM_CFG_ALIAS = MM_CFG>
+    __aicore__ inline enable_if_t<ToMatmulConfig(MM_CFG_ALIAS).batchMode == BatchMode::BATCH_LESS_THAN_L1>
+     UpdateOffset(BatchOffsetInfo& batchOffsetInfo, BatchSchedulerContext& ctx)
+    {
+        auto batchAIndex = 0, batchBIndex = 0;
+        auto biasIndex = MATMUL_MODULE(BatchLoop)->GetBatchIndex();
+
+        const auto& bL = MATMUL_MODULE(BatchLoop);
+        batchAIndex = bL->GetBatchA() <= bL->GetSplitBatchNum() ? bL->GetBatchIndex()
+                                                                : bL->GetBatchIndex() % bL->GetSplitBatchNum();
+        ctx.offsetA = batchOffsetInfo.alignA *
+            (batchAIndex % batchOffsetInfo.modA + batchAIndex / batchOffsetInfo.divisorA);
+
+        batchBIndex = bL->GetBatchB() <= bL->GetSplitBatchNum() ? bL->GetBatchIndex()
+                                                                : bL->GetBatchIndex() % bL->GetSplitBatchNum();
+        ctx.offsetB = batchOffsetInfo.alignB *
+            (batchBIndex % batchOffsetInfo.modB + batchBIndex / batchOffsetInfo.divisorB);
+
+        ctx.offsetBias = batchOffsetInfo.alignBias *
+            (biasIndex % batchOffsetInfo.modBias + biasIndex / batchOffsetInfo.divisorBias);
+        if constexpr (ToMatmulConfig(MM_CFG).isNBatchOut) {
+            bL->SetBatchOutCacheNum(bL->GetBatchOutCacheNum() + 1);
+        }
+    }
+
     __aicore__ inline void ComputeBatch(LocalTensor<TransAT>& a1, LocalTensor<TransBT>& b1, LocalTensor<BiasT>& bias,
         bool enPartialSum, BatchSchedulerContext& ctx)
     {
diff --git a/impl/matmul/scheduler/iterator/batch_loop/batch_loop_intf.h b/impl/matmul/scheduler/iterator/batch_loop/batch_loop_intf.h
index 49b53b7856fb93f81980fa24b1459900303b2660..7dc0c164defb9041002547c32d48d0c5778571ae 100644
--- a/impl/matmul/scheduler/iterator/batch_loop/batch_loop_intf.h
+++ b/impl/matmul/scheduler/iterator/batch_loop/batch_loop_intf.h
@@ -24,7 +24,7 @@ namespace Detail {
     We retain the freedom to make incompatible changes, but do not guarantee the stability.
     BatchLoop is only for internal usage, does not support extension or customized specialization!
 */
-template <typename IMPL, class INPUT_TYPE, const auto &MM_CFG, typename = void>
+template <typename IMPL, class INPUT_TYPE, class BIAS_TYPE, const auto &MM_CFG, typename = void>
 class BatchLoop
 {
     public:
diff --git a/impl/matmul/scheduler/iterator/batch_loop/batch_loop_multi.h b/impl/matmul/scheduler/iterator/batch_loop/batch_loop_multi.h
index 1a8379e17fe6649c726c52bc0d56ae326e12d9fe..c85061f126ebdf0dae542ddf9aa415bb48871c3d 100644
--- a/impl/matmul/scheduler/iterator/batch_loop/batch_loop_multi.h
+++ b/impl/matmul/scheduler/iterator/batch_loop/batch_loop_multi.h
@@ -27,14 +27,15 @@ namespace Detail {
     We retain the freedom to make incompatible changes, but do not guarantee the stability.
     BatchLoop is only for internal usage, does not support extension or customized specialization!
 */
-template <typename IMPL, class INPUT_TYPE, const auto &MM_CFG>
-class BatchLoop<IMPL, INPUT_TYPE, MM_CFG,
+template <typename IMPL, class INPUT_TYPE, class BIAS_TYPE, const auto &MM_CFG>
+class BatchLoop<IMPL, INPUT_TYPE, BIAS_TYPE, MM_CFG,
     enable_if_t<(Impl::Detail::GetCopyCubeInType<INPUT_TYPE, MM_CFG>() == Impl::Detail::CopyCubeInType::BMM) ||
     (Impl::Detail::IsBMMFromL1<INPUT_TYPE, MM_CFG>())>>
 {
     MATMUL_USE_MODULE(MatmulShapeTiling);
     MATMUL_USE_MODULE(MatmulShapeInfo);
     using SrcT = typename INPUT_TYPE::T;
+    using BiasT = typename BIAS_TYPE::T;
 
 public:
     __aicore__ inline BatchLoop() = default;
@@ -44,6 +45,13 @@ public:
     {
         const auto tiling = MATMUL_MODULE(MatmulShapeTiling)->GetTiling();
         CalcBatchNum(tiling.GetALayoutInfoB(), tiling.GetBLayoutInfoB(), tiling.GetBatchNum(), tiling.GetBatchNum());
+
+        if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            auto batchNum = tiling.GetBatchNum();
+            splitSize_ = (batchNum % DB_FACTOR == 0) ? DB_FACTOR : 1;
+            splitBatchNum_ = batchNum / splitSize_;
+        }
+
         UpdateBatchNumParams();
     }
 
@@ -71,6 +79,16 @@ public:
     {
         outerIdx_++;
         dstOffset_ += batchCalcSize_;
+        if (oddAndLargeThanL1_ && outerIdx_ == batchOuter_ - 1) {
+            const int32_t tail = inputBatchNum_ % batchA_;
+            batchA_ = tail == 0 ? mainBatchInner_ : tail;
+            batchB_ = batchA_;
+            batchNum_ = batchA_;
+            batchCalcSize_ = batchNum_ * MATMUL_MODULE(MatmulShapeInfo)->GetSingleCoreM() *
+                MATMUL_MODULE(MatmulShapeInfo)->GetSingleCoreN();
+            splitSize_ = (batchA_ >= DB_FACTOR) ? DB_FACTOR : 1;
+            splitBatchNum_ = batchNum_ / splitSize_;
+        }
     }
 
     __aicore__ inline bool OuterEnd()
@@ -78,6 +96,11 @@ public:
         return outerIdx_ >= batchOuter_;
     }
 
+    __aicore__ inline int32_t GetMainBatchBlock() const
+    {
+        return mainBatchInner_; // batchNum main block in outLoop
+    }
+
     __aicore__ inline uint32_t GetOuterIndex() const
     {
         return outerIdx_;
@@ -93,6 +116,22 @@ public:
         return batchNum_;
     }
 
+    template <InputTypeTag tag, const auto& MM_CFG_ALIAS = MM_CFG>
+    __aicore__ inline enable_if_t<IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG_ALIAS>(), int32_t>
+    GetBatchNumBySplitIdx(int32_t splitIdx) const
+    {
+        auto batchNum = tag == InputTypeTag::A ? batchA_ : batchB_;
+        if (batchNum > splitBatchNum_) {
+            if (splitIdx == 0) {
+                return splitBatchNum_;
+            } else {
+                return batchNum - splitBatchNum_;
+            }
+        }
+
+        return batchNum;
+    }
+
     __aicore__ inline int32_t GetBatchA() const
     {
         return batchA_;
@@ -105,17 +144,18 @@ public:
 
     __aicore__ inline int32_t GetBiasBatchSrcOffset() const
     {
-        return outerIdx_ * batchNum_ * MATMUL_MODULE(MatmulShapeInfo)->GetSingleCoreN();
+        return outerIdx_ * mainBatchInner_ * MATMUL_MODULE(MatmulShapeInfo)->GetSingleCoreN();
     }
 
     // Double Buffer Loop
     __aicore__ inline void SplitStart()
     {
         // Check that the total amount of data to be transferred is less than L1.
-        ASSERT((batchA_ * MATMUL_MODULE(MatmulShapeTiling)->GetTiling().GetSingleCoreM() *
-            MATMUL_MODULE(MatmulShapeTiling)->GetTiling().GetSingleCoreK() +
-            batchB_ * MATMUL_MODULE(MatmulShapeTiling)->GetTiling().GetSingleCoreN() *
-            MATMUL_MODULE(MatmulShapeTiling)->GetTiling().GetSingleCoreK()) * sizeof(SrcT) <= TOTAL_L1_SIZE);
+        const auto &tiling = MATMUL_MODULE(MatmulShapeTiling)->GetTiling();
+        ASSERT((batchA_ * tiling.GetSingleCoreM() * tiling.GetSingleCoreK() + batchB_ * tiling.GetSingleCoreN() *
+            tiling.GetSingleCoreK()) * sizeof(SrcT) + tiling.IsBias() * tiling.GetSingleCoreN() * 
+            sizeof(BiasT) <= TOTAL_L1_SIZE);
+
         splitOuterIdx_ = 0;
         splitBatchIdx_ = 0;
     }
@@ -128,7 +168,22 @@ public:
 
     __aicore__ inline bool SplitEnd()
     {
-        return splitOuterIdx_ >= splitSize_;
+        if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            return splitOuterIdx_ >= splitSize_ || (splitOuterIdx_ == 1 && batchNum_ < splitBatchNum_);
+        } else {
+            return splitOuterIdx_ >= splitSize_;
+        }
+    }
+
+    template <InputTypeTag tag>
+    __aicore__ inline uint32_t GetSplitIndex() const
+    {
+        if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            auto batchNum = tag == InputTypeTag::A ? batchA_ : batchB_;
+            return splitBatchNum_ >= batchNum ? 0 : splitOuterIdx_;
+        } else {
+            return splitOuterIdx_;
+        }
     }
 
     __aicore__ inline uint32_t GetSplitIndex() const
@@ -161,7 +216,19 @@ public:
 
     __aicore__ inline bool InnerEnd()
     {
-        return innerIdx_ >= splitBatchNum_ || splitOuterIdx_ * splitBatchNum_ >= batchNum_;
+        if ((!oddAndLargeThanL1_) || (batchNum_ % DB_FACTOR == 0) || (splitSize_ < DB_FACTOR)) {
+            if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+                return (innerIdx_ >= splitBatchNum_) || (splitOuterIdx_ * splitBatchNum_ >= batchNum_) || (innerBatchIdx_ >= batchNum_);
+            } else {
+                return (innerIdx_ >= splitBatchNum_) || (splitOuterIdx_ * splitBatchNum_ >= batchNum_);
+            }
+        }
+        const auto firstBatchNum = batchNum_ / splitSize_;
+        if (splitOuterIdx_ < 1) {
+            return innerIdx_ >= firstBatchNum;
+        } else {
+            return innerIdx_ >= batchNum_ - firstBatchNum;
+        }
     }
 
     __aicore__ inline uint32_t GetInnerIndex() const
@@ -204,6 +271,17 @@ public:
         batchOutOffsetNum_ = offsetNum;
     }
 
+    template <InputTypeTag tag>
+    __aicore__ inline bool NeedCache() const
+    {
+        if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            auto batchNum = tag == InputTypeTag::A ? batchA_ : batchB_;
+            return batchNum <= splitBatchNum_;
+        } else {
+            return false;
+        }
+    }
+
 private:
     __aicore__ inline void CalcBatchNum(int32_t layoutBatchNumA, int32_t layoutBatchNumB,
         int32_t batchNumA, int32_t batchNumB)
@@ -214,6 +292,7 @@ private:
                   (batchNumA % batchNumB == 0 || batchNumB % batchNumA == 0));
             batchA_ = batchNumA;
             batchB_ = batchNumB;
+            mainBatchInner_ = 0;
             return;
         }
 
@@ -221,7 +300,9 @@ private:
               (layoutBatchNumA % layoutBatchNumB == 0 || layoutBatchNumB % layoutBatchNumA == 0));
         int32_t aMatrixSingleBatchSize = GetSingleSizeAlignA();
         int32_t bMatrixSingleBatchSize = GetSingleSizeAlignB();
-        if ((layoutBatchNumA * aMatrixSingleBatchSize + layoutBatchNumB * bMatrixSingleBatchSize) <= TOTAL_L1_SIZE) {
+        if ((layoutBatchNumA * aMatrixSingleBatchSize + layoutBatchNumB * bMatrixSingleBatchSize +
+            MATMUL_MODULE(MatmulShapeTiling)->GetTiling().IsBias() * 
+            MATMUL_MODULE(MatmulShapeTiling)->GetTiling().GetSingleCoreN() * sizeof(BiasT)) <= TOTAL_L1_SIZE) {
             batchOuter_ = 1;
             batchA_ = layoutBatchNumA;
             batchB_ = layoutBatchNumB;
@@ -272,28 +353,49 @@ private:
         int32_t largeMatrixSingleBatchSize, int32_t lessMatrixSingleBatchSize)
     {
         int32_t multiples = batchNumLarge / batchNumLess;
-        int32_t singleBatchSize = multiples * largeMatrixSingleBatchSize + lessMatrixSingleBatchSize;
+        int32_t singleBatchSize = multiples * largeMatrixSingleBatchSize + lessMatrixSingleBatchSize + 
+            MATMUL_MODULE(MatmulShapeTiling)->GetTiling().IsBias() * 
+            MATMUL_MODULE(MatmulShapeTiling)->GetTiling().GetSingleCoreN() * sizeof(BiasT);
         int32_t batchInner = TOTAL_L1_SIZE / singleBatchSize;
+        inputBatchNum_ = batchNumLarge;
+
         ASSERT(batchInner > 0);
-        while (batchNumLess % batchInner != 0 && batchInner > 0) {
-            --batchInner;
+        oddAndLargeThanL1_ = (multiples == 1) && (inputBatchNum_ % DB_FACTOR != 0);
+        if (oddAndLargeThanL1_) {
+            mainBatchInner_ = batchInner;
+            batchOuter_ = CeilT(batchNumLess, batchInner);
+            batchA_ = batchInner;
+            batchB_ = batchInner;
+        } else {
+            while (batchNumLess % batchInner != 0 && batchInner > 0) {
+                --batchInner;
+            }
+            mainBatchInner_ = batchInner;
+            batchOuter_ = batchNumLess / batchInner;
+            batchA_ = multiples * batchInner;
+            batchB_ = batchInner;
         }
-        batchOuter_ = batchNumLess / batchInner;
-        batchA_ = multiples * batchInner;
-        batchB_ = batchInner;
     }
 
     __aicore__ inline void UpdateBatchNumParams()
     {
         batchNum_ = batchA_ > batchB_ ? batchA_ : batchB_;
-        splitSize_ = (batchNum_ >= DB_FACTOR) && (batchA_ % DB_FACTOR == 0) &&
-            (batchB_ % DB_FACTOR == 0) ? DB_FACTOR : 1;
-        splitBatchNum_ = batchNum_ / splitSize_;
+        if constexpr (!IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            if (batchOuter_ > 1 && batchA_ == batchB_) {
+                splitSize_ = (batchA_ >= DB_FACTOR) ? DB_FACTOR : 1;
+                splitBatchNum_ = batchNum_ / splitSize_;
+            } else {
+                splitSize_ = (batchNum_ >= DB_FACTOR) && (batchA_ % DB_FACTOR == 0) && (batchB_ % DB_FACTOR == 0)
+                                 ? DB_FACTOR
+                                 : 1;
+                splitBatchNum_ = batchNum_ / splitSize_;
+            }
+        }
     }
 
     __aicore__ inline void UpdateSplitParams()
     {
-        splitBatchIdx_ += batchNum_ / splitSize_;
+        splitBatchIdx_ += splitBatchNum_;
     }
 
     __aicore__ inline void UpdateInnerParams()
@@ -301,9 +403,9 @@ private:
         innerBatchIdx_ = innerIdx_ + splitBatchIdx_;
     }
 
-    int32_t batchA_;
-    int32_t batchB_;
-    int32_t batchNum_;
+    int32_t batchA_; // outerLoop main/tail block
+    int32_t batchB_; // outerLoop main/tail block
+    int32_t batchNum_; // outerLoop main/tail block
     int32_t batchOuter_ = 1;
     constexpr static int32_t c0Size_ = AuxGetC0Size<typename INPUT_TYPE::T>();
 
@@ -327,6 +429,10 @@ private:
     int32_t nBatchOutNum_ = 1;
     int32_t batchOutCacheNum_ = 0;
     int32_t batchOutOffsetNum_ = 0;
+
+    int32_t inputBatchNum_ = 0; 
+    bool oddAndLargeThanL1_ = false; // new logical judgment condition for handling odd batchNum && large than L1
+    int32_t mainBatchInner_ = 0; // outerLoop main block
 };
 }  // namespace Detail
 }  // namespace Impl
diff --git a/impl/matmul/scheduler/iterator/batch_loop/batch_loop_single.h b/impl/matmul/scheduler/iterator/batch_loop/batch_loop_single.h
index 1b9cfce3a31a7f1960b183b4e0f745ba6bf0d3ff..1486c3e499007d89ac977f9cd95be1a26f84de74 100644
--- a/impl/matmul/scheduler/iterator/batch_loop/batch_loop_single.h
+++ b/impl/matmul/scheduler/iterator/batch_loop/batch_loop_single.h
@@ -27,8 +27,8 @@ namespace Detail {
     We retain the freedom to make incompatible changes, but do not guarantee the stability.
     BatchLoop is only for internal usage, does not support extension or customized specialization!
 */
-template <typename IMPL, class INPUT_TYPE, const auto &MM_CFG>
-class BatchLoop<IMPL, INPUT_TYPE, MM_CFG,
+template <typename IMPL, class INPUT_TYPE, class BIAS_TYPE, const auto &MM_CFG>
+class BatchLoop<IMPL, INPUT_TYPE, BIAS_TYPE, MM_CFG,
     enable_if_t<(INPUT_TYPE::layout == LayoutMode::NORMAL &&
     ToMatmulConfig(MM_CFG).batchMode == BatchMode::SINGLE_LARGE_THAN_L1)>>
 {
diff --git a/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in.h b/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in.h
index 809aab80f7a98e406d164163f4f05a8cc3864b72..7612ca651d84769b22d006daa31fcbbec8c1ed28 100644
--- a/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in.h
+++ b/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in.h
@@ -39,6 +39,7 @@ class BatchCopyCubeIn<IMPL, MM_CFG, INPUT_TYPE, enable_if_t<
     MATMUL_USE_MODULE_ON(MatmulTensorInfo, INPUT_TYPE::TAG);
     MATMUL_USE_MODULE(MatmulShapeInfo);
     MATMUL_USE_MODULE(MatmulShapeTiling);
+    MATMUL_USE_MODULE(BatchLoop);
 
     using TransT = typename INPUT_TYPE::TRANS_T;
     using SrcT = typename INPUT_TYPE::T;
@@ -52,12 +53,23 @@ public:
     __aicore__ inline void Init()
     {
         MATMUL_MODULE(CubeInBuffer)->Init(
-            MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum() * MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleSizeAlign<INPUT_TYPE::isTrans>(), 1);
+            MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum() *
+            MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleSizeAlign<INPUT_TYPE::isTrans>(),
+            IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>() ? MATMUL_MODULE(BatchLoop)->GetSplitSize() : 1);
     }
 
     __aicore__ inline void BatchLoad(LocalTensor<TransT>& dstTensor, const uint32_t matrixStride,
                                      const int32_t outerIdx, const int32_t splitIdx, const int32_t splitSize)
     {
+        if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            if (MATMUL_MODULE(CubeInBuffer)->Hit(0)) {
+                dstTensor = MATMUL_MODULE(CubeInBuffer)->GetBuffer(0);
+                return;
+            } else {
+                dstTensor = BASE_MODULE::AllocTensor(MATMUL_MODULE(BatchLoop)->template NeedCache<INPUT_TYPE::TAG>());
+            }
+        }
+
         if (MATMUL_MODULE(BatchCopyCubeInParams)->IsTranspose()) {
             return CopyBatchToCubeND<true, INPUT_TYPE::TAG == InputTypeTag::A>(
                     dstTensor, matrixStride, outerIdx, splitIdx, splitSize);
@@ -67,21 +79,34 @@ public:
         }
     }
 
+    __aicore__ inline void BatchDestroy(const LocalTensor<TransT>& tensor = NULL_TENSOR<TransT>)
+    {
+        if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            MATMUL_MODULE(CubeInBuffer)->FreeTensor(MATMUL_MODULE(BatchLoop)->template NeedCache<INPUT_TYPE::TAG>(), tensor);
+            if (MATMUL_MODULE(BatchLoop)->GetSplitSize() != DB_FACTOR) {
+                MATMUL_MODULE(CubeInBuffer)->Destroy();
+            }
+        } else {
+            BASE_MODULE::BatchDestroy();
+        }
+    }
+
 private:
-    template <bool IS_TRANS = false, bool IS_KROW = false>
-    __aicore__ inline void CopyBatchToCubeND(LocalTensor<TransT>& dstTensor, const uint32_t matrixStride,
-                                           const int32_t outerIdx, const int32_t splitIdx, const int32_t splitSize )
+    template <bool IS_TRANS = false, bool IS_KROW = false, const auto& MM_CFG_ALIAS = MM_CFG>
+    __aicore__ inline enable_if_t<!IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG_ALIAS>()>
+    CopyBatchToCubeND(LocalTensor<TransT>& dstTensor, uint32_t matrixStride, int32_t outerIdx, int32_t splitIdx,
+                      int32_t splitSize )
     {
         // Calculate batch outer loop offset
         // the parameter false means don't need to use constant parameters
         int64_t batchOffset = outerIdx * GetSingleSize<IS_TRANS, false>() *
-                              MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum();
+                              MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchMainBlock();
 
         // Calculate iter numbers by line of BSNGD layout
         int32_t batchNum = MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum(); // batchA_ or batchB_
         int32_t iterNum = 1;
-        UpdataBatchNum(batchNum, iterNum);
-        batchNum /= splitSize;
+        int32_t batchNumIdx = batchNum / splitSize;
+        UpdateBatchNum(batchNum, iterNum);
 
         // Calculate srcDValue for ND copy
         auto srcDValue = MATMUL_MODULE(BatchCopyCubeInParams)->template GetBatchOrgWidth<IS_TRANS>();
@@ -90,12 +115,14 @@ private:
         // if user input matrixStride, use matrixStride as srcStride
         auto srcStride = matrixStride != 0 ? matrixStride : GetSrcStride<IS_TRANS, false>();
         auto dstStride =  MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleSizeAlign<IS_TRANS>();
-        int64_t srcOffset = batchNum * splitIdx * srcStride;
-        int64_t dstOffset = batchNum * splitIdx * dstStride;
+        int64_t srcOffset = batchNumIdx * splitIdx * srcStride;
+        int64_t dstOffset = batchNumIdx * splitIdx * dstStride;
+        // if odd ground, the first block is unequal with the second block
+        auto batchBlock = splitIdx == 0 ? batchNumIdx : batchNum - batchNumIdx;
 
         // Calculate src and dst stride of one line
-        auto iterSrcStride = batchNum * GetSingleSize<IS_TRANS, false>();
-        auto iterDstStride = batchNum * GetSingleSize<IS_TRANS>();
+        auto iterSrcStride = batchBlock * GetSingleSize<IS_TRANS, false>();
+        auto iterDstStride = batchBlock * GetSingleSize<IS_TRANS>();
 
         // Complete datacopy by line
         GlobalTensor<SrcT> srcGlobal;
@@ -103,7 +130,7 @@ private:
         srcGlobal.SetAddr(batchOffset);
         for (int32_t idx = 0; idx < iterNum; ++idx) {
             if (srcStride >= UINT16_MAX) {
-                for (int i = 0; i < batchNum; ++i) {
+                for (int i = 0; i < batchBlock; ++i) {
                     MATMUL_MODULE(DataCopyWrapper)->CopyND2NZ(
                         dstTensor[dstOffset], srcGlobal[srcOffset], 0, 0,
                         MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleHeight<IS_TRANS>(),
@@ -114,6 +141,64 @@ private:
             } else {
                 MATMUL_MODULE(DataCopyWrapper)->CopyND2NZ(
                     dstTensor[dstOffset], srcGlobal[srcOffset], 0, 0,
+                    MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleHeight<IS_TRANS>(),
+                    MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleWidth<IS_TRANS>(),
+                    srcDValue, batchBlock, srcStride, dstStride);
+            }
+            dstOffset += iterDstStride;
+            srcOffset += iterSrcStride;
+        }
+    }
+
+    template <bool IS_TRANS = false, bool IS_KROW = false, const auto& MM_CFG_ALIAS = MM_CFG>
+    __aicore__ inline enable_if_t<IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG_ALIAS>()>
+    CopyBatchToCubeND(LocalTensor<TransT>& dstTensor, uint32_t matrixStride, int32_t outerIdx, int32_t splitIdx,
+                      int32_t splitSize)
+    {
+        // Calculate batch outer loop offset
+        // the parameter false means don't need to use constant parameters
+        int64_t batchOffset = outerIdx * GetSingleSize<IS_TRANS, false>() *
+                              MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum();
+
+        // Calculate iter numbers by line of BSNGD layout
+        auto batchNum = MATMUL_MODULE(BatchLoop)->template GetBatchNumBySplitIdx<INPUT_TYPE::TAG>(splitIdx);
+        int32_t iterNum = 1;
+        UpdateBatchNum(batchNum, iterNum);
+
+        // Calculate srcDValue for ND copy
+        auto srcDValue = MATMUL_MODULE(BatchCopyCubeInParams)->template GetBatchOrgWidth<IS_TRANS>();
+
+        // Calculate src and dst stride of one step
+        // if user input matrixStride, use matrixStride as srcStride
+        auto srcStride = matrixStride != 0 ? matrixStride : GetSrcStride<IS_TRANS, false>();
+        auto dstStride = MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleSizeAlign<IS_TRANS>();
+        int64_t srcOffset = 0;
+        if (MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum() > MATMUL_MODULE(BatchLoop)->GetSplitBatchNum()) {
+            if (splitIdx == 1) {
+                srcOffset = MATMUL_MODULE(BatchLoop)->GetSplitBatchNum() * srcStride;
+            }
+        }
+        int64_t dstOffset = 0;
+
+        // Calculate src and dst stride of one line
+        auto iterSrcStride = batchNum * GetSingleSize<IS_TRANS, false>();
+        auto iterDstStride = batchNum * GetSingleSize<IS_TRANS>();
+
+        // Complete datacopy by line
+        GlobalTensor<SrcT> srcGlobal;
+        srcGlobal.SetGlobalBuffer(MATMUL_MODULE(MatmulTensorInfo)->GetGlobalTensor().address_);
+        srcGlobal.SetAddr(batchOffset);
+        for (auto idx = 0; idx < iterNum; ++idx) {
+            if (srcStride >= UINT16_MAX) {
+                for (auto i = 0; i < batchNum; ++i) {
+                    MATMUL_MODULE(DataCopyWrapper)->CopyND2NZ(dstTensor[dstOffset], srcGlobal[srcOffset], 0, 0,
+                        MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleHeight<IS_TRANS>(),
+                        MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleWidth<IS_TRANS>(), srcDValue);
+                    dstOffset += dstStride;
+                    srcOffset += srcStride;
+                }
+            } else {
+                MATMUL_MODULE(DataCopyWrapper)->CopyND2NZ(dstTensor[dstOffset], srcGlobal[srcOffset], 0, 0,
                     MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleHeight<IS_TRANS>(),
                     MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleWidth<IS_TRANS>(),
                     srcDValue, batchNum, srcStride, dstStride);
@@ -123,7 +208,7 @@ private:
         }
     }
 
-     __aicore__ inline void UpdataBatchNum(int32_t &batchNum, int32_t &iterNum)
+     __aicore__ inline void UpdateBatchNum(int32_t &batchNum, int32_t &iterNum)
      {
         if constexpr (INPUT_TYPE::layout == LayoutMode::BSNGD) {
             ASCENDC_ASSERT((IsLayoutGValid()), {
@@ -210,6 +295,7 @@ class BatchCopyCubeIn<IMPL, MM_CFG, INPUT_TYPE, enable_if_t<
     MATMUL_USE_MODULE_ON(BatchCopyCubeInParams, INPUT_TYPE::TAG);
     MATMUL_USE_MODULE_ON(DataCopyWrapper, INPUT_TYPE::TAG);
     MATMUL_USE_MODULE_ON(MatmulTensorInfo, INPUT_TYPE::TAG);
+    MATMUL_USE_MODULE(BatchLoop);
 
     using SrcT = typename INPUT_TYPE::T;
     using TransT = typename INPUT_TYPE::TRANS_T;
@@ -224,16 +310,27 @@ public:
     {
         if constexpr (INPUT_TYPE::isTrans) {
             MATMUL_MODULE(CubeInBuffer)->Init(MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum() *
-                MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleSizeAlign<true, INPUT_TYPE::TAG == InputTypeTag::A>(), 1);
+            MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleSizeAlign<true, INPUT_TYPE::TAG == InputTypeTag::A>(),
+            IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>() ? MATMUL_MODULE(BatchLoop)->GetSplitSize() : 1);
         } else {
             MATMUL_MODULE(CubeInBuffer)->Init(MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum() *
-                MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleSizeAlign<false, INPUT_TYPE::TAG == InputTypeTag::B>(), 1);
+            MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleSizeAlign<false, INPUT_TYPE::TAG == InputTypeTag::B>(),
+            IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>() ? MATMUL_MODULE(BatchLoop)->GetSplitSize() : 1);
         }
     }
 
     __aicore__ inline void BatchLoad(LocalTensor<TransT>& dstTensor, const uint32_t matrixStride,
                                      const int32_t outerIdx, const int32_t splitIdx, const int32_t splitSize)
     {
+        if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            if (MATMUL_MODULE(CubeInBuffer)->Hit(0)) {
+                dstTensor = MATMUL_MODULE(CubeInBuffer)->GetBuffer(0);
+                return;
+            } else {
+                dstTensor = BASE_MODULE::AllocTensor(MATMUL_MODULE(BatchLoop)->template NeedCache<INPUT_TYPE::TAG>());
+            }
+        }
+
         if (MATMUL_MODULE(BatchCopyCubeInParams)->IsTranspose()) {
             CopyBatchToCubeNZ<true, INPUT_TYPE::TAG == InputTypeTag::A>(
                 dstTensor, outerIdx, splitIdx, splitSize);
@@ -243,10 +340,22 @@ public:
         }
     }
 
+    __aicore__ inline void BatchDestroy(const LocalTensor<TransT>& tensor = NULL_TENSOR<TransT>)
+    {
+        if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            MATMUL_MODULE(CubeInBuffer)->FreeTensor(MATMUL_MODULE(BatchLoop)->template NeedCache<INPUT_TYPE::TAG>(), tensor);
+            if (MATMUL_MODULE(BatchLoop)->GetSplitSize() != DB_FACTOR) {
+                MATMUL_MODULE(CubeInBuffer)->Destroy();
+            }
+        } else {
+            BASE_MODULE::BatchDestroy();
+        }
+    }
+
 private:
-    template <bool IS_TRANS = false, bool IS_KROW = false>
-    __aicore__ inline void CopyBatchToCubeNZ(LocalTensor<TransT>& dstTensor, const int32_t outerIdx,
-                                           const int32_t splitIdx, const int32_t splitSize)
+    template <bool IS_TRANS = false, bool IS_KROW = false, const auto& MM_CFG_ALIAS = MM_CFG>
+    __aicore__ inline enable_if_t<!IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG_ALIAS>()>
+    CopyBatchToCubeNZ(LocalTensor<TransT>& dstTensor, int32_t outerIdx, int32_t splitIdx, int32_t splitSize)
     {
         // 1. Calculate batch outer loop offset
         // NZ does not support tail block scenarios, src also uses constantized data
@@ -254,11 +363,50 @@ private:
         auto alignWidth = CeilAlign(MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleWidth<IS_TRANS>(), c0Size_);
 
         // 2. Calculate src and dst stride of one step
-        auto batchNum = MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum() / splitSize;
+        auto batchNum = MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum();
+        int32_t batchNumIdx = batchNum / splitSize;
+
         int64_t srcStride = alignWidth * alignHeight;
         int64_t dstStride = MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleSizeAlign<IS_TRANS, IS_KROW>();
-        int64_t srcOffset = batchNum * splitIdx * srcStride;
-        int64_t dstOffset = batchNum * splitIdx * dstStride;
+        int64_t srcOffset = batchNumIdx * splitIdx * srcStride;
+        int64_t dstOffset = batchNumIdx * splitIdx * dstStride;
+        auto batchBlock = splitIdx == 0 ? batchNumIdx : batchNum - batchNumIdx;
+
+        // 3. loop copy NZ data by batch
+        bool iskRowDirec = IS_KROW && IsSupportB8<TransT>();
+        auto batchOffset = outerIdx * MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchMainBlock() * srcStride;
+        GlobalTensor<SrcT> srcGlobal;
+        srcGlobal.SetGlobalBuffer(MATMUL_MODULE(MatmulTensorInfo)->GetGlobalTensor().address_);
+        srcGlobal.SetAddr(batchOffset);
+        for (int i = 0; i < batchBlock; ++i) {
+            MATMUL_MODULE(DataCopyWrapper)->CopyNZ2NZ(
+                dstTensor[dstOffset], srcGlobal[srcOffset], 0, 0,
+                alignHeight, alignWidth, alignHeight, iskRowDirec);
+            dstOffset += dstStride;
+            srcOffset += srcStride;
+        }
+    }
+
+    template <bool IS_TRANS = false, bool IS_KROW = false, const auto& MM_CFG_ALIAS = MM_CFG>
+    __aicore__ inline enable_if_t<IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG_ALIAS>()>
+    CopyBatchToCubeNZ(LocalTensor<TransT>& dstTensor, int32_t outerIdx, int32_t splitIdx, int32_t splitSize)
+    {
+        // 1. Calculate batch outer loop offset
+        // NZ does not support tail block scenarios, src also uses constantized data
+        auto alignHeight = CeilAlign(MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleHeight<IS_TRANS>(), BLOCK_CUBE);
+        auto alignWidth = CeilAlign(MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleWidth<IS_TRANS>(), c0Size_);
+
+        // 2. Calculate src and dst stride of one step
+        auto batchNum = MATMUL_MODULE(BatchLoop)->template GetBatchNumBySplitIdx<INPUT_TYPE::TAG>(splitIdx);
+        int64_t srcStride = alignWidth * alignHeight;
+        int64_t dstStride = MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleSizeAlign<IS_TRANS, IS_KROW>();
+        int64_t srcOffset = 0;
+        if (MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum() > MATMUL_MODULE(BatchLoop)->GetSplitBatchNum()) {
+            if (splitIdx == 1) {
+                srcOffset = MATMUL_MODULE(BatchLoop)->GetSplitBatchNum() * srcStride;
+            }
+        }
+        int64_t dstOffset = 0;
 
         // 3. loop copy NZ data by batch
         bool iskRowDirec = IS_KROW && IsSupportB8<TransT>();
@@ -281,4 +429,4 @@ private:
 }  // namespace Detail
 }  // namespace Impl
 }  // namespace AscendC
-#endif // IMPL_MATMUL_STAGE_COPY_CUBE_IN_BATCH_BATCH_COPY_CUBE_IN_H
\ No newline at end of file
+#endif // IMPL_MATMUL_STAGE_COPY_CUBE_IN_BATCH_BATCH_COPY_CUBE_IN_H
diff --git a/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_from_l1.h b/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_from_l1.h
index 627f96caa78ed07ea4ffb5d7aa93348573f0e9c9..7f824842710ae7c2684ca1e4d49289d135c87cf6 100644
--- a/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_from_l1.h
+++ b/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_from_l1.h
@@ -33,6 +33,7 @@ class BatchCopyCubeIn<IMPL, MM_CFG, INPUT_TYPE, enable_if_t<
     MATMUL_USE_MODULE_ON(BatchCopyCubeInParams, INPUT_TYPE::TAG);
     MATMUL_USE_MODULE_ON(MatmulTensorInfo, INPUT_TYPE::TAG);
     MATMUL_USE_MODULE(MatmulShapeInfo);
+    MATMUL_USE_MODULE(BatchLoop);
 
     using TransT = typename INPUT_TYPE::TRANS_T;
     using SrcT = typename INPUT_TYPE::T;
@@ -52,6 +53,10 @@ public:
     __aicore__ inline void BatchLoad(LocalTensor<TransT>& dstTensor, const uint32_t matrixStride,
                                      const int32_t outerIdx, const int32_t splitIdx, const int32_t splitSize)
     {
+        if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            dstTensor = AllocTensor();
+        }
+
         if (MATMUL_MODULE(BatchCopyCubeInParams)->IsTranspose()) {
             GetBatchMatrix<true, INPUT_TYPE::TAG == InputTypeTag::A>(
                 dstTensor, matrixStride, outerIdx, splitIdx, splitSize);
@@ -66,7 +71,7 @@ public:
         int32_t curRow, int32_t curCol, int32_t tileHeight, int32_t tileWidth, const ScheduleContext& context = 0)
     {}
 
-    __aicore__ inline void BatchDestroy() {}
+    __aicore__ inline void BatchDestroy(LocalTensor<TransT>& tensor = NULL_TENSOR<TransT>) {}
 
     __aicore__ inline LocalTensor<TransT> AllocTensor(int32_t iterIndex = 0)
     {
@@ -88,13 +93,19 @@ private:
     __aicore__ inline void GetBatchMatrix(LocalTensor<TransT>& dstTensor, const uint32_t matrixStride,
                                            const int32_t outerIdx, const int32_t splitIdx, const int32_t splitSize)
     {
-        // L1 input will get data at once, so no need to spilt
-        if (splitIdx > 0) {
-            return;
+        int64_t batchOffset = 0;
+        if constexpr (IsBmmDoubleBuffer<INPUT_TYPE, MM_CFG>()) {
+            auto batchNum = MATMUL_MODULE(BatchLoop)->template GetBatchNumBySplitIdx<INPUT_TYPE::TAG>(splitIdx);
+            auto dstStride = GetSingleSizeAlign<IS_TRANS, IS_KROW>();
+            batchOffset = outerIdx * GetBatchSize() + splitIdx * batchNum * dstStride;
+        } else {
+            // L1 input will get data at once, so no need to spilt
+            if (splitIdx > 0) {
+                return;
+            }
+            // Calculate batch outer loop offset
+            batchOffset = outerIdx * GetBatchSize();
         }
-        // Calculate batch outer loop offset
-        int64_t batchOffset = outerIdx * GetBatchSize();
-
         dstTensor = dstTensor[batchOffset];
         dstTensor.SetSize(GetBatchSize());
     }
@@ -120,4 +131,4 @@ private:
 }  // namespace Detail
 }  // namespace Impl
 }  // namespace AscendC
-#endif // IMPL_MATMUL_STAGE_COPY_CUBE_IN_BATCH_BATCH_COPY_CUBE_IN_FROM_L1_H
\ No newline at end of file
+#endif // IMPL_MATMUL_STAGE_COPY_CUBE_IN_BATCH_BATCH_COPY_CUBE_IN_FROM_L1_H
diff --git a/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_params.h b/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_params.h
index fb2cfe19c6ecc0f8e4af10b21643a1aa60198ad9..6e3a04a93a165ec5d8f0856344b6d71a9f76409a 100644
--- a/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_params.h
+++ b/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_params.h
@@ -36,6 +36,11 @@ public:
         }
     }
 
+    __aicore__ inline uint32_t GetBatchMainBlock()
+    {
+        return MATMUL_MODULE(BatchLoop)->GetMainBatchBlock();
+    }
+
     template <bool IS_TRANS = false>
     __aicore__ inline int32_t GetBatchOrgWidth()
     {
diff --git a/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_using_ub.h b/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_using_ub.h
index 17c68246d4cbcc3c59c9b7b34f2eb35a4cc3e4b3..13b2c5d52e115e9f7ad1d5f07e58c3a48b10c270 100644
--- a/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_using_ub.h
+++ b/impl/matmul/stage/copy_cube_in/batch/batch_copy_cube_in_using_ub.h
@@ -79,13 +79,16 @@ private:
                                            const int32_t outerIdx, const int32_t splitIdx, const int32_t splitSize)
     {
         // 1. calculate src stride and dst stride by db split loop index
-        auto batchNum = MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum() / splitSize;
+        int32_t batchNum = MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum();
+        int32_t batchNumIdx = batchNum / splitSize;
         auto alignWidth = CeilAlign(MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleWidth<isTrans>(), c0Size_);
         auto alignHeight = CeilAlign(MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleHeight<isTrans>(), BLOCK_CUBE);
         auto srcStride = GetSingleSize();
         auto dstStride = alignWidth * alignHeight;
-        uint64_t srcOffset = batchNum * splitIdx * srcStride;
-        uint64_t dstOffset = batchNum * splitIdx * dstStride;
+        uint64_t srcOffset = batchNumIdx * splitIdx * srcStride;
+        uint64_t dstOffset = batchNumIdx * splitIdx * dstStride;
+        // if odd ground, the first block is unequal with the second block
+        auto batchBlock = splitIdx == 0 ? batchNumIdx : batchNum - batchNumIdx;
 
         // 2. copy batch matrix in
         int64_t batchOffset = outerIdx * MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum() * srcStride;
@@ -94,16 +97,16 @@ private:
         srcGlobal.SetAddr(batchOffset + srcOffset);
         if constexpr (ToMatmulConfig(MM_CFG).enVecND2NZ) {
             CopyND2NZThroughVec<isTrans>(
-                dstTensor[dstOffset], srcGlobal, batchNum, outerIdx, splitIdx, alignHeight, alignWidth);
+                dstTensor[dstOffset], srcGlobal, batchBlock, outerIdx, splitIdx, alignHeight, alignWidth);
         } else {
             if constexpr (isKRow) {
                 MATMUL_MODULE(DataCopyWrapper)->CopyND2NZOnTheFly(
                     dstTensor[dstOffset], srcGlobal, 0, 0,
                     MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleHeight<isTrans>(),
-                    batchNum * alignWidth, batchNum * alignWidth);
+                    batchBlock * alignWidth, batchBlock * alignWidth);
             } else {
                 MATMUL_MODULE(DataCopyWrapper)->CopyND2NZOnTheFly(
-                    dstTensor[dstOffset], srcGlobal, 0, 0, batchNum * alignHeight,
+                    dstTensor[dstOffset], srcGlobal, 0, 0, batchBlock * alignHeight,
                     MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleWidth<isTrans>(),
                     MATMUL_MODULE(CopyCubeInParams)->template GetOrgWidth<isTrans>());
             }
@@ -303,14 +306,17 @@ private:
         // 1. Calculate batch outer loop offset
         auto alignHeight = CeilAlign(MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleHeight<isTrans>(), BLOCK_CUBE);
         auto alignWidth = CeilAlign(MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleWidth<isTrans>(), c0Size_);
-        auto batchNum = MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum() / splitSize;
+        int32_t batchNum = MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum();
+        int32_t batchNumIdx = batchNum / splitSize;
         bool iskRowDirec = isKRow && IsSameTypeV<TransT, int8_t>;
 
         // 2. Calculate src and dst stride of one step
         auto srcStride = alignWidth * alignHeight;
         auto dstStride = MATMUL_MODULE(BatchCopyCubeInParams)->template GetSingleSizeAlign<isTrans, isKRow>();
-        int64_t srcOffset = batchNum * splitIdx * srcStride;
-        int64_t dstOffset = batchNum * splitIdx * dstStride;
+        int64_t srcOffset = batchNumIdx * splitIdx * srcStride;
+        int64_t dstOffset = batchNumIdx * splitIdx * dstStride;
+        // if odd ground, the first block is unequal with the second block
+        auto batchBlock = splitIdx == 0 ? batchNumIdx : batchNum - batchNumIdx;
 
         // 3. set input srctensor addr
         auto batchOffset = outerIdx * MATMUL_MODULE(BatchCopyCubeInParams)->GetBatchNum() * srcStride;
@@ -326,7 +332,7 @@ private:
         }
 
         // 4. loop copy NZ data by batch
-        for (auto i = 0; i < batchNum; ++i) {
+        for (auto i = 0; i < batchBlock; ++i) {
             MATMUL_MODULE(DataCopyWrapper)->CopyNZ2NZ(dstTensor[dstOffset], srcTensor[srcOffset], 0, 0,
                 alignHeight, alignWidth, alignHeight, iskRowDirec);
             dstOffset += dstStride;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index e57f194e14ef8ff065a6113625b2cd05262143ca..55687963ad0acb5d652c06e9ad90559d3e0da7ef 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -171,6 +171,7 @@ file(GLOB ASCENDC_TEST_ascend910B1_AIC_CASE_SRC_FILES
     ${ASCENDC_TESTS_DIR}/matmul/cube_in_buffer/test_cube_in_buffer_single_global_buffer.cpp
     ${ASCENDC_TESTS_DIR}/matmul/cube_in_buffer/test_cube_in_buffer_double_global_buffer.cpp
     ${ASCENDC_TESTS_DIR}/matmul/cube_in_buffer/test_cube_in_buffer_n_buffer.cpp
+    ${ASCENDC_TESTS_DIR}/matmul/cube_in_buffer/test_cube_in_buffer_bmm_db.cpp
     ${ASCENDC_TESTS_DIR}/matmul/test_matmul_l0c_buffer.cpp
     ${ASCENDC_TESTS_DIR}/matmul/test_matmul_shape_info.cpp
     ${ASCENDC_TESTS_DIR}/matmul/test_matmul_shape_info_left.cpp
diff --git a/tests/matmul/cube_in_buffer/test_cube_in_buffer_bmm_db.cpp b/tests/matmul/cube_in_buffer/test_cube_in_buffer_bmm_db.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ea45a3e1129732ffce91eb9d2a7307d8bcf02f34
--- /dev/null
+++ b/tests/matmul/cube_in_buffer/test_cube_in_buffer_bmm_db.cpp
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025 rights reserved.
+ *
+ * @brief load data instruction ut for ascend910B1
+ *
+ */
+#include <gtest/gtest.h>
+#include "kernel_operator.h"
+#include "lib/matmul/tiling.h"
+#include "impl/matmul/utils/matmul_param.h"
+#include "impl/matmul/policy/matmul_policy.h"
+#include "impl/matmul/resource/cube_in_buffer/cube_in_buffer.h"
+#include "impl/matmul/policy/matmul_private_modules.h"
+
+using namespace std;
+using namespace AscendC;
+
+namespace {
+template <const auto& MM_CFG, typename IMPL, typename A_TYPE, typename B_TYPE, typename C_TYPE, typename BIAS_TYPE>
+class CustomMatmulPolicy : public Impl::Detail::MatmulPolicy<MM_CFG, IMPL, A_TYPE, B_TYPE, C_TYPE, BIAS_TYPE>
+{
+public:
+    using CubeInBufferA = Impl::Detail::CubeInBuffer<IMPL, MatmulInputAType<A_TYPE, typename A_TYPE::T>, MM_CFG>;
+    using CubeInBufferB = Impl::Detail::CubeInBuffer<IMPL, MatmulInputBType<B_TYPE, typename A_TYPE::T>, MM_CFG>;
+};
+
+template <class A_TYPE, class B_TYPE, class C_TYPE, class BIAS_TYPE, const MatmulConfig& MM_CFG, class MM_CB,
+MATMUL_POLICY_DEFAULT_OF(MatmulPolicy)>
+class MatmulImpl
+: MATMUL_IMPORT_MODULE(CubeInBufferB)
+, MATMUL_IMPORT_MODULE_PRIVATE(MatmulShapeTiling)
+{
+    MATMUL_ALLOW_USING(CubeInBufferB);
+    MATMUL_ALLOW_USING_PRIVATE(MatmulShapeTiling);
+
+public:
+    using CubeInBufferB::Init;
+    using CubeInBufferB::Destroy;
+    using CubeInBufferB::AllocTensor;
+    using CubeInBufferB::FreeTensor;
+    using CubeInBufferB::Hit;
+    using CubeInBufferB::GetBuffer;
+    using CubeInBufferB::Reset;
+    using CubeInBufferB::EnQue;
+    using CubeInBufferB::DeQue;
+    using IMPL = MatmulImpl<A_TYPE, B_TYPE, C_TYPE, BIAS_TYPE, MM_CFG, MM_CB, MATMUL_POLICY>;
+    MATMUL_USE_MODULE(MatmulShapeTiling);
+
+public:
+    using VAR_PARAMS =
+        typename Impl::Detail::MatmulParams<A_TYPE, B_TYPE, C_TYPE, BIAS_TYPE, MM_CFG, GetMatmulVersion(MM_CFG)>::PARAMS;
+    
+    MatmulImpl() {
+        InitVar();
+    }
+
+    VAR_PARAMS& GetVar() {
+        return var;
+    }
+
+    void InitVar() {
+        MATMUL_MODULE(MatmulShapeTiling)->SetTiling(&tiling);
+        var.tpipe_ = &pipe;
+    }
+
+    void SetInitParams(int32_t stepN, int32_t stepKb, int32_t baseN, int32_t baseK) {
+        tiling.stepN = stepN;
+        tiling.stepKb = stepKb;
+        tiling.baseN = baseN;
+        tiling.baseK = baseK;
+        tiling.iterateOrder = 0;
+    }
+
+    void SetRuntimeParams(int32_t baseUseN, int32_t baseUseK) {
+        var.baseUseN_ = baseUseN;
+        var.baseUseK_ = baseUseK;
+    }
+
+private:
+    TCubeTiling tiling;
+    TPipe pipe;
+    VAR_PARAMS var;
+};
+}
+
+constexpr MatmulConfig MM_CFG_CUSTOM { true, false, false, 0, 0, 0, false, false, false, false, 0, 0, 0, 0, 0, 0,  0, 0,
+    false, false, false, false, false, true, BatchMode::BATCH_LESS_THAN_L1, true, true, true, true, true, true, true,
+    IterateMode::ITERATE_MODE_DEFAULT, false, true, false, true, IterateOrder::UNDEF, ScheduleType::INNER_PRODUCT,
+    false, true};
+class test_cube_in_buffer_bmm_db : public testing::Test {
+protected:
+    void SetUp() {}
+    void TearDown() {}
+
+private:
+    using A_TYPE_BMM = MatmulType<AscendC::TPosition::GM, CubeFormat::ND, half, false>;
+    using B_TYPE = MatmulType<AscendC::TPosition::GM, CubeFormat::ND, half, false>;
+    using C_TYPE = MatmulType<AscendC::TPosition::GM, CubeFormat::ND, float>;
+    using BIAS_TYPE = MatmulType<AscendC::TPosition::GM, CubeFormat::ND, float>;
+
+    MatmulImpl<A_TYPE_BMM, B_TYPE, C_TYPE, BIAS_TYPE, MM_CFG_CUSTOM, void, CustomMatmulPolicy> mm;
+};
+
+TEST_F(test_cube_in_buffer_bmm_db, get_iter_index) {
+    mm.SetInitParams(2, 2, 32, 32);
+    int32_t mIter = 2;
+    int32_t kIter = 3;
+    mm.Init(1024, 4);
+}
+
+TEST_F(test_cube_in_buffer_bmm_db, all_interface_normal) {
+    mm.SetInitParams(2, 2, 32, 32);
+    int32_t mIter = 2;
+    int32_t kIter = 2;
+    int32_t hitCnt = 0;
+    mm.Init(1024, 4);
+    LocalTensor<half> fakeTensor;
+    for (int32_t m = 0; m < mIter; m++) {
+        for (int32_t k = 0; k < kIter; k++) {
+            int32_t iterIndex = 0;
+            if (mm.Hit(iterIndex)) {
+                fakeTensor = mm.GetBuffer(iterIndex);
+                hitCnt++;
+            } else {
+                fakeTensor = mm.AllocTensor(iterIndex);
+                mm.EnQue(fakeTensor);
+                mm.DeQue();
+            }
+            mm.FreeTensor(iterIndex, fakeTensor);
+        }
+        mm.Reset();
+    }
+    mm.Destroy();
+    ASSERT_EQ(hitCnt, 0);
+}
diff --git a/tests/matmul/iterator/test_batch_loop.cpp b/tests/matmul/iterator/test_batch_loop.cpp
index 7f7418055335952c8fccc8870aa9bb87632ca18d..00f95f97e31179103adcb84e724e5a936ca3562d 100644
--- a/tests/matmul/iterator/test_batch_loop.cpp
+++ b/tests/matmul/iterator/test_batch_loop.cpp
@@ -33,7 +33,7 @@ template <const auto& MM_CFG, typename IMPL, typename A_TYPE, typename B_TYPE, t
 class CustomMatmulPolicy : public Impl::Detail::MatmulPolicy<MM_CFG, IMPL, A_TYPE, B_TYPE, C_TYPE, BIAS_TYPE>
 {
 public:
-    using BatchLoop = Impl::Detail::BatchLoop<IMPL, MatmulInputAType<A_TYPE, typename A_TYPE::T>, MM_CFG>;
+    using BatchLoop = Impl::Detail::BatchLoop<IMPL, MatmulInputAType<A_TYPE, typename A_TYPE::T>, BIAS_TYPE, MM_CFG>;
 };
 
 template <class A_TYPE, class B_TYPE, class C_TYPE, class BIAS_TYPE, const MatmulConfig& MM_CFG,
@@ -117,7 +117,7 @@ TEST_F(TestBatchLoop, batch_loop) {
     EXPECT_EQ(mm.GetOuterIndex(), 1);
     EXPECT_EQ(mm.GetDstOffset(), 33264);
     EXPECT_EQ(mm.GetBatchNum(), 3);
-    EXPECT_EQ(mm.GetBiasBatchSrcOffset(), 231);
+    EXPECT_EQ(mm.GetBiasBatchSrcOffset(), 0);
     EXPECT_EQ(mm.GetSplitIndex(), 1);
     EXPECT_EQ(mm.GetSplitSize(), 1);
     EXPECT_EQ(mm.GetSplitBatchNum(), 3);
@@ -137,10 +137,31 @@ TEST_F(TestBatchLoop, batch_loop_db) {
     EXPECT_EQ(mm1.GetOuterIndex(), 1);
     EXPECT_EQ(mm1.GetDstOffset(), 49152);
     EXPECT_EQ(mm1.GetBatchNum(), 6);
-    EXPECT_EQ(mm1.GetBiasBatchSrcOffset(), 1536);
+    EXPECT_EQ(mm1.GetBiasBatchSrcOffset(), 0);
     EXPECT_EQ(mm1.GetSplitIndex(), 2);
     EXPECT_EQ(mm1.GetSplitSize(), 2);
     EXPECT_EQ(mm1.GetSplitBatchNum(), 3);
     EXPECT_EQ(mm1.GetInnerIndex(), 3);
     EXPECT_EQ(mm1.GetBatchIndex(), 6);
 }
+
+TEST_F(TestBatchLoop, batch_loop_bias) {
+    mm.SetSingleCoreParams(256, 256, 256, 4, 4, 4);
+    mm.Init();
+    for (mm.OuterStart(); !mm.OuterEnd();mm.OuterNext()) {
+        for (mm.SplitStart(); !mm.SplitEnd(); mm.SplitNext()) {
+            for (mm.InnerStart(); !mm.InnerEnd(); mm.InnerNext()) {
+            }
+        }
+    }
+    EXPECT_EQ(mm.GetOuterIndex(), 4);
+    EXPECT_EQ(mm.GetDstOffset(), 262144);
+    EXPECT_EQ(mm.GetBatchNum(), 1);
+    EXPECT_EQ(mm.GetBiasBatchSrcOffset(), 1024);
+    EXPECT_EQ(mm.GetSplitIndex(), 1);
+    EXPECT_EQ(mm.GetSplitSize(), 1);
+    EXPECT_EQ(mm.GetSplitBatchNum(), 1);
+    EXPECT_EQ(mm.GetInnerIndex(), 1);
+    EXPECT_EQ(mm.GetBatchIndex(), 1);
+    EXPECT_EQ(mm.GetMainBatchBlock(), 1);
+}
\ No newline at end of file
diff --git a/tests/matmul/iterator/test_batch_loop_single.cpp b/tests/matmul/iterator/test_batch_loop_single.cpp
index 50956c66caf6b203530cffc8feb96ca42acd2cff..9b5b307cb6e63bd3cf93a89e4e266c6b0ae62a7b 100644
--- a/tests/matmul/iterator/test_batch_loop_single.cpp
+++ b/tests/matmul/iterator/test_batch_loop_single.cpp
@@ -33,7 +33,7 @@ template <const auto& MM_CFG, typename IMPL, typename A_TYPE, typename B_TYPE, t
 class CustomMatmulPolicy : public Impl::Detail::MatmulPolicy<MM_CFG, IMPL, A_TYPE, B_TYPE, C_TYPE, BIAS_TYPE>
 {
 public:
-    using BatchLoop = Impl::Detail::BatchLoop<IMPL, MatmulInputAType<A_TYPE, typename A_TYPE::T>, MM_CFG>;
+    using BatchLoop = Impl::Detail::BatchLoop<IMPL, MatmulInputAType<A_TYPE, typename A_TYPE::T>, BIAS_TYPE, MM_CFG>;
 };
 
 template <class A_TYPE, class B_TYPE, class C_TYPE, class BIAS_TYPE, const MatmulConfig& MM_CFG,
diff --git a/tests/matmul/scheduler/batch_scheduler/test_batch_scheduler.cpp b/tests/matmul/scheduler/batch_scheduler/test_batch_scheduler.cpp
index 0113153f567edc11eb0dab0f73e06f0bc7701b6a..e4d2e9a705c95993c54f4d5fd6a09605b7e238f0 100644
--- a/tests/matmul/scheduler/batch_scheduler/test_batch_scheduler.cpp
+++ b/tests/matmul/scheduler/batch_scheduler/test_batch_scheduler.cpp
@@ -61,6 +61,11 @@ public:
         return 1;
     }
 
+    __aicore__ inline int32_t GetMainBatchBlock() const
+    {
+        return 1;
+    }
+
     __aicore__ inline int32_t GetBatchA() const
     {
         return 1;
@@ -90,6 +95,12 @@ public:
         return splitIdx_ >= 1;
     }
 
+    template <InputTypeTag tag>
+    __aicore__ inline uint32_t GetSplitIndex() const
+    {
+        return 0;
+    }
+
     __aicore__ inline uint32_t GetSplitIndex() const
     {
         return 0;
@@ -310,7 +321,7 @@ TEST_F(TestBatchScheduler, Schedule_ComputeMultiIter) {
     mm.Schedule(cGlobal, false, false, false, 0, 0, 0);
 }
 
-TEST_F(TestBatchScheduler, Schedule_ComputeOneIter) {
+TEST_F(TestBatchScheduler, DISABLED_Schedule_ComputeOneIter) {
     TilingParamsBatch tilingParams = {1, 32, 32, 32, 32, 32, 32, 32, 32, 32, 2, 2, 1, 1, 2, 2, 1, 0, 2, 2, 2, 1, 32, 2, 1, 32, 1, 32, 2, 1, 32, 1, 32, 2, 1, 32};
     TCubeTiling tiling;
     tilingParams.GetTiling(tiling);
@@ -318,4 +329,4 @@ TEST_F(TestBatchScheduler, Schedule_ComputeOneIter) {
     mm1.SetBias(1);
     GlobalTensor<float> cGlobal;
     mm1.Schedule(cGlobal, false, false, false, 0, 0, 0);
-}
\ No newline at end of file
+}
diff --git a/tests/matmul/scheduler/fake_modules.h b/tests/matmul/scheduler/fake_modules.h
index a6a90a7f5c50d78641f272f15e28926ae3c282b2..dd465158e23d21e63d4ac0c2cacd8f1f81a782af 100644
--- a/tests/matmul/scheduler/fake_modules.h
+++ b/tests/matmul/scheduler/fake_modules.h
@@ -115,7 +115,7 @@ public:
     __aicore__ inline void BatchLoad(LocalTensor<TransT>& dstTensor, const uint32_t matrixStride,
         const int32_t outerIdx, const int32_t splitIdx, const int32_t splitSize) {}
 
-    __aicore__ inline void BatchDestroy() {}
+    __aicore__ inline void BatchDestroy(const LocalTensor<TransT>& tensor = NULL_TENSOR<TransT>) {}
 
     __aicore__ inline void Destroy() {}
 };
diff --git a/tests/matmul/test_operator_matmul_v220_batch.cpp b/tests/matmul/test_operator_matmul_v220_batch.cpp
index ada8e93c4f000f315c6168979fd804cd8b00a0df..e5e22f02b14ff5ba16ed689d7bffa038f9d99113 100644
--- a/tests/matmul/test_operator_matmul_v220_batch.cpp
+++ b/tests/matmul/test_operator_matmul_v220_batch.cpp
@@ -250,8 +250,6 @@ KERNEL_MATMUL_TESTCASE(TEST_KERNEL_MATMUL, tiling_params_case3_910B1_batch, 32,
 KERNEL_MATMUL_TESTCASE(TEST_KERNEL_MATMUL, tiling_params_case4_910B1_batch, 64, 256, 64, 32, 64, 64, GM, GM, GM, GM, ND, ND, ND, ND, half, half, float, float, 0, 1, mm_cfg, false, false, false, false);
 // test batch split loop
 KERNEL_MATMUL_TESTCASE(TEST_KERNEL_MATMUL, tiling_params_case5_910B1_batch, 32, 32, 32, 16, 16, 32, GM, GM, GM, GM, ND, ND, ND, ND, half, half, float, float, 0, 1, mm_cfg, false, true, false, false);
-// test batch inner loop
-KERNEL_MATMUL_TESTCASE(TEST_KERNEL_MATMUL, tiling_params_case6_910B1_batch, 32, 256, 64, 32, 32, 64, GM, GM, GM, GM, ND, ND, ND, ND, half, half, float, float, 0, 1, mm_cfg, false, true, false, false);
 // test const
 KERNEL_MATMUL_TESTCASE(TEST_KERNEL_MATMUL, tiling_params_case7_910B1_batch, 32, 32, 32, 32, 32, 32, GM, GM, GM, GM, ND, ND, ND, ND, half, half, half, float, 0, 0, mm_cfg, false, true, false, false);
 // test SINGLE_LARGE_THAN_L1
@@ -265,4 +263,4 @@ KERNEL_MATMUL_TESTCASE(TEST_KERNEL_MATMUL, tiling_params_case10_910B1_batch, 81,
  
 constexpr MatmulConfig CFG_NORM_OUTER_PRODUCT_N = GetNormalConfig(false, false, false, BatchMode::BATCH_LESS_THAN_L1, true, IterateOrder::ORDER_N, ScheduleType::OUTER_PRODUCT);
 TilingParamsBatch tiling_params_case11_910B1_batch = {1, 81, 256, 64, 81, 256, 64, 32, 32, 64, 1, 2, 1, 1, 1, 2, 0, 0, 1, 1, 1, 1, 81, 1, 1, 64, 1, 256, 1, 1, 64, 1, 81, 1, 1, 256};
-KERNEL_MATMUL_TESTCASE(TEST_KERNEL_MATMUL, tiling_params_case11_910B1_batch, 81, 256, 64, 32, 32, 64, GM, GM, GM, GM, ND, ND, ND, ND, half, half, float, float, 0, 0, CFG_NORM_OUTER_PRODUCT_N, false, false, false, false);
\ No newline at end of file
+KERNEL_MATMUL_TESTCASE(TEST_KERNEL_MATMUL, tiling_params_case11_910B1_batch, 81, 256, 64, 32, 32, 64, GM, GM, GM, GM, ND, ND, ND, ND, half, half, float, float, 0, 0, CFG_NORM_OUTER_PRODUCT_N, false, false, false, false);