diff --git a/CMakePresets.json b/CMakePresets.json
index 0d470f1ed..76d74df0f 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -39,6 +39,18 @@
         "NS_USE_OMP": "OFF"
       }
     },
+    {
+      "name": "linux-release-ut-thread",
+      "displayName": "Linux Release Thread Pool for UTs",
+      "description": "Release",
+      "inherits": "linux-debug",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "NS_USE_OMP": "OFF",
+        "BTLA_UT_ALL": "ON",
+        "BTLA_UT_BENCHMARK": "ON"
+      }
+    },
     {
       "name": "windows-base",
       "description": "Target Windows with the Visual Studio development environment.",
diff --git a/bestla/bestla/bestla_device.h b/bestla/bestla/bestla_device.h
index d7c1f2fbb..68535eae1 100644
--- a/bestla/bestla/bestla_device.h
+++ b/bestla/bestla/bestla_device.h
@@ -233,9 +233,9 @@ class CpuDevice {
   inline bool AVX512_BF16() { return mHasAVX512_BF16; }
   inline bool AVX512_FP16() { return mHasAVX512_FP16; }
   inline float* const getPE() { return PE; }
-  inline size_t getPcoreNum() { return P_core.size(); }
-  inline size_t getEcoreNum() { return E_core.size(); }
-  inline size_t getSMTcoreNum() { return SMT_core.size(); }
+  inline int getPcoreNum() { return static_cast<int>(P_core.size()); }
+  inline int getEcoreNum() { return static_cast<int>(E_core.size()); }
+  inline int getSMTcoreNum() { return static_cast<int>(SMT_core.size()); }
   inline int* getPCores() { return P_core.data(); }
   inline int* getECores() { return E_core.data(); }
   inline int* getSMTCores() { return SMT_core.data(); }
@@ -467,15 +467,15 @@ class CpuDevice {
   bool isClient() { return mClient; }
 
  protected:
-  uint32_t L2Cache, L1Cache, L3Cache;
+  uint32_t L2Cache = 0, L1Cache = 0, L3Cache = 0;
   bool mHybrid = false, mClient = false;
-  bool mHasAVX2, mHasAVX_VNNI, mHasAVX, mHasAVX512_VNNI, mHasAMX_INT8, mHasAMX_BF16, mHasAVX512F, mHasAVX512BW,
-      mHasAVX512_BF16, mHasAVX512_FP16;
-  int numcores;
-  int numthreads;
+  bool mHasAVX2 = false, mHasAVX_VNNI = false, mHasAVX = false, mHasAVX512_VNNI = false, mHasAMX_INT8 = false,
+       mHasAMX_BF16 = false, mHasAVX512F = false, mHasAVX512BW, mHasAVX512_BF16 = false, mHasAVX512_FP16 = false;
+  int numcores = 0;
+  int numthreads = 0;
   std::vector<int> P_core, E_core, SMT_core;
-  uint32_t E_L2Cache, E_L1Cache;
-  float PE[int(BTLA_ISA::ISA_COUNT)];
+  uint32_t E_L2Cache = 0, E_L1Cache = 0;
+  float PE[int(BTLA_ISA::ISA_COUNT)] = {1.f};
 };
 
 #define GetCPUDevice() auto _cd = bestla::device::CpuDevice::getInstance();
diff --git a/bestla/bestla/bestla_gemm.h b/bestla/bestla/bestla_gemm.h
index fe521c4ab..88356ab25 100644
--- a/bestla/bestla/bestla_gemm.h
+++ b/bestla/bestla/bestla_gemm.h
@@ -2510,7 +2510,7 @@ class Avx512vnniN16P4 : protected bestla::xbyak::JitAvx512vnni {
   static_assert(_NTILE % RegLen == 0);
   static int constexpr NRegs = _NTILE / RegLen;
   static int constexpr MRegs = _MTILE == 0 ? (RegCount - 1 - NRegs) / (NRegs * 2) : _MTILE;
-  static_assert(NRegs * MRegs <= RegCount - 1);
+  static_assert(NRegs * MRegs * 2 <= RegCount - 1);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 4;
   static int constexpr KUNROLL = 2;
   static auto constexpr ISA = BTLA_ISA::AVX512_VNNI;
@@ -3397,7 +3397,7 @@ class AvxvnniN8P4 : protected bestla::xbyak::JitAvxvnni {
   static_assert(_NTILE % RegLen == 0);
   static int constexpr NRegs = _NTILE / RegLen;
   static int constexpr MRegs = _MTILE == 0 ? (RegCount - 3) / (NRegs * 2) : _MTILE;
-  static_assert(NRegs * MRegs <= RegCount - 3);
+  static_assert(NRegs * MRegs * 2 <= RegCount - 3);
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 4;
   static int constexpr KUNROLL = 2;
   static auto constexpr ISA = BTLA_ISA::AVX_VNNI;
@@ -4073,7 +4073,7 @@ class Avx2vnniN8P4 : protected bestla::xbyak::JitAvx2 {
   static int constexpr NRegs = _NTILE / RegLen;
   static int constexpr TmpReserve = std::is_same_v<AT, uint8_t> ? 2 : 4;
   static int constexpr MRegs = _MTILE == 0 ? (RegCount - (TmpReserve + 1)) / (NRegs * 2) : _MTILE;
-  static_assert(NRegs * MRegs <= RegCount - (TmpReserve + 1));
+  static_assert(NRegs * MRegs * 2 <= RegCount - (TmpReserve + 1));
   static int constexpr NTILE = RegLen * NRegs, MTILE = MRegs, KTILE = 4;
   static int constexpr KUNROLL = 2;
   static auto constexpr ISA = BTLA_ISA::AVX2;
@@ -4819,7 +4819,14 @@ class CoreCodeBase {
   static int constexpr PREFERRED_N = NTILE * 4;
   static auto constexpr ISA = Code::ISA;
   static auto constexpr ID = CoreAttr::make_core_id(NTILE, PACK_ROW, COMP, ISA);
-  void configure(int _M, int _N, int _K) { (void)(0); }
+  static void configure(int _M, int _N, int _K) { (void)(0); }
+
+  static CoreCodeBase<CodeT, _NTILE, _MTILE>* getInstance() {
+    static CoreCodeBase<CodeT, _NTILE, _MTILE> instance;
+    return &instance;
+  }
+
+  std::array<Code, Code::MTILE> mCodes;
 
  protected:
   CoreCodeBase() {
@@ -4827,7 +4834,6 @@ class CoreCodeBase {
       mCodes[i].generate_code(i + 1);
     }
   }
-  std::array<Code, Code::MTILE> mCodes;
 };
 
 template <template <int, int> class CodeT, int _NTILE, int _MTILE = 0>
@@ -4847,24 +4853,31 @@ class CoreCodeBaseAMX {
   static auto constexpr ID = CoreAttr::make_core_id(_NTILE, PACK_ROW, COMP, ISA);
   Xbyak::CodeGenerator cfgcode;
 
+  static CoreCodeBaseAMX<CodeT, _NTILE, _MTILE>* getInstance() {
+    static CoreCodeBaseAMX<CodeT, _NTILE, _MTILE> instance;
+    return &instance;
+  }
+
+  std::array<Code, Code::MRegs> mCodes;
+
  protected:
   CoreCodeBaseAMX() {
     for (int i = 0; i < mCodes.size(); i++) {
       mCodes[i].generate_code((i + 1) * 16);
     }
   }
-  std::array<Code, Code::MRegs> mCodes;
 };
 
 template <int _NTILE, int _MTILE = 0>
 class SCoreRowNAvx2 : public CoreCodeBase<code::Avx2N8P1, _NTILE, _MTILE> {
  public:
-  using Code = typename CoreCodeBase<code::Avx2N8P1, _NTILE, _MTILE>::Code;
-  void forward(float* matA, float* matB, float* matC, int _m, int _n, int _k, int _astride, int _bstride, int _cstride,
-               int kpos, void* tmpcache, size_t cachesize) {
+  using Base = CoreCodeBase<code::Avx2N8P1, _NTILE, _MTILE>;
+  using Code = typename Base::Code;
+  static void forward(float* matA, float* matB, float* matC, int _m, int _n, int _k, int _astride, int _bstride,
+                      int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -4874,12 +4887,13 @@ class SCoreRowNAvx2 : public CoreCodeBase<code::Avx2N8P1, _NTILE, _MTILE> {
 template <int _NTILE, int _MTILE = 0>
 class SCoreRowNAvx512f : public CoreCodeBase<code::Avx512fN16P1, _NTILE, _MTILE> {
  public:
-  using Code = typename CoreCodeBase<code::Avx512fN16P1, _NTILE, _MTILE>::Code;
-  void forward(float* matA, float* matB, float* matC, int _m, int _n, int _k, int _astride, int _bstride, int _cstride,
-               int kpos, void* tmpcache, size_t cachesize) {
+  using Base = CoreCodeBase<code::Avx512fN16P1, _NTILE, _MTILE>;
+  using Code = typename Base::Code;
+  static void forward(float* matA, float* matB, float* matC, int _m, int _n, int _k, int _astride, int _bstride,
+                      int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -4889,13 +4903,13 @@ class SCoreRowNAvx512f : public CoreCodeBase<code::Avx512fN16P1, _NTILE, _MTILE>
 template <int _NTILE, int _MTILE = 0>
 class HCoreRowNAvx512fp16 : public CoreCodeBase<code::Avx512fp16N32P1, _NTILE, _MTILE> {
  public:
-  using Code = typename CoreCodeBase<code::Avx512fp16N32P1, _NTILE, _MTILE>::Code;
-
-  void forward(utils::fp16* matA, utils::fp16* matB, utils::fp16* matC, int _m, int _n, int _k, int _astride,
-               int _bstride, int _cstride, int kpos, void* tmpcache, size_t cachesize) {
+  using Base = CoreCodeBase<code::Avx512fp16N32P1, _NTILE, _MTILE>;
+  using Code = typename Base::Code;
+  static void forward(utils::fp16* matA, utils::fp16* matB, utils::fp16* matC, int _m, int _n, int _k, int _astride,
+                      int _bstride, int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -4905,12 +4919,13 @@ class HCoreRowNAvx512fp16 : public CoreCodeBase<code::Avx512fp16N32P1, _NTILE, _
 template <int _NTILE, int _MTILE = 0>
 class HCoreRowNAvx512bf16 : public CoreCodeBase<code::Avx512bf16N16P2, _NTILE, _MTILE> {
  public:
-  using Code = typename CoreCodeBase<code::Avx512bf16N16P2, _NTILE, _MTILE>::Code;
-  void forward(utils::bf16* matA, utils::bf16* matB, float* matC, int _m, int _n, int _k, int _astride, int _bstride,
-               int _cstride, int kpos, void* tmpcache, size_t cachesize) {
+  using Base = CoreCodeBase<code::Avx512bf16N16P2, _NTILE, _MTILE>;
+  using Code = typename Base::Code;
+  static void forward(utils::bf16* matA, utils::bf16* matB, float* matC, int _m, int _n, int _k, int _astride,
+                      int _bstride, int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -4920,23 +4935,25 @@ class HCoreRowNAvx512bf16 : public CoreCodeBase<code::Avx512bf16N16P2, _NTILE, _
 template <int _NTILE, int _MTILE = 0>
 class HCoreRowNAmxbf16 : public CoreCodeBaseAMX<code::Amxbf16N16P2, _NTILE, _MTILE> {
  public:
-  using Code = typename CoreCodeBaseAMX<code::Amxbf16N16P2, _NTILE, _MTILE>::Code;
+  using Base = CoreCodeBaseAMX<code::Amxbf16N16P2, _NTILE, _MTILE>;
+  using Code = typename Base::Code;
   using AType = typename Code::AType;
   using BType = typename Code::BType;
   using CType = typename Code::CType;
 
-  void configure(int _M, int _N, int _K) {
-    code::AmxConfigure::configure(_M < 16 ? _M : 16, 16, Code::KTILE, sizeof(BType), this->mCodes[0].ATileCount,
-                                  this->mCodes[0].BTileCount, this->mCodes[0].CTileCount);
+  static void configure(int _M, int _N, int _K) {
+    code::AmxConfigure::configure(_M < 16 ? _M : 16, 16, Code::KTILE, sizeof(BType),
+                                  Base::getInstance()->mCodes[0].ATileCount, Base::getInstance()->mCodes[0].BTileCount,
+                                  Base::getInstance()->mCodes[0].CTileCount);
   }
 
-  void forward(AType* matA, BType* matB, CType* matC, int _m, int _n, int _k, int _astride, int _bstride, int _cstride,
-               int kpos, void* tmpcache, size_t cachesize) {
+  static void forward(AType* matA, BType* matB, CType* matC, int _m, int _n, int _k, int _astride, int _bstride,
+                      int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param =
         typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0, tmpcache};
     if (_m <= Code::MTILE) {
       int idx = utils::updiv(_m, 16) - 1;
-      this->mCodes[idx].mKernel(&param);
+      Base::getInstance()->mCodes[idx].mKernel(&param);
     } else {
       assert(0);
     }
@@ -4946,12 +4963,13 @@ class HCoreRowNAmxbf16 : public CoreCodeBaseAMX<code::Amxbf16N16P2, _NTILE, _MTI
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvx512vnni : public CoreCodeBase<code::Avx512vnniN16P4, _NTILE, _MTILE> {
  public:
-  using Code = typename CoreCodeBase<code::Avx512vnniN16P4, _NTILE, _MTILE>::Code;
-  void forward(uint8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
-               int _cstride, int kpos, void* tmpcache, size_t cachesize) {
+  using Base = CoreCodeBase<code::Avx512vnniN16P4, _NTILE, _MTILE>;
+  using Code = typename Base::Code;
+  static void forward(uint8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
+                      int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -4961,15 +4979,16 @@ class ICoreRowNAvx512vnni : public CoreCodeBase<code::Avx512vnniN16P4, _NTILE, _
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvx512vnniKBlock : public CoreCodeBase<code::kblock::Avx512vnniN16P4, _NTILE, _MTILE> {
  public:
-  using Code = typename CoreCodeBase<code::kblock::Avx512vnniN16P4, _NTILE, _MTILE>::Code;
-  void forward(uint8_t* matA, int8_t* matB, float* matC, uint8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
-               float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride, int _cstride,
-               int kpos, float kscale, void* tmpcache, size_t cachesize) {
+  using Base = CoreCodeBase<code::kblock::Avx512vnniN16P4, _NTILE, _MTILE>;
+  using Code = typename Base::Code;
+  static void forward(uint8_t* matA, int8_t* matB, float* matC, uint8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
+                      float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride,
+                      int _cstride, int kpos, float kscale, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA,  _astride, matB,    _bstride, matC, _cstride, zpA,     scaleA,
                                        _ldsa, scaleB,   reduceB, _ldsb,    _k,   _n,       _kblock, kpos == 0 ? 1 : 0,
                                        kscale};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -4979,13 +4998,14 @@ class ICoreRowNAvx512vnniKBlock : public CoreCodeBase<code::kblock::Avx512vnniN1
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvxvnni : public CoreCodeBase<code::AvxvnniN8P4U8, _NTILE, _MTILE> {
  public:
-  using Code = typename CoreCodeBase<code::AvxvnniN8P4U8, _NTILE, _MTILE>::Code;
+  using Base = CoreCodeBase<code::AvxvnniN8P4U8, _NTILE, _MTILE>;
+  using Code = typename Base::Code;
 
-  void forward(uint8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
-               int _cstride, int kpos, void* tmpcache, size_t cachesize) {
+  static void forward(uint8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
+                      int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -4995,13 +5015,14 @@ class ICoreRowNAvxvnni : public CoreCodeBase<code::AvxvnniN8P4U8, _NTILE, _MTILE
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvxvnniSS : public CoreCodeBase<code::AvxvnniN8P4S8, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBase<code::AvxvnniN8P4S8, _NTILE, _MTILE>;
   using Code = typename CoreCodeBase<code::AvxvnniN8P4S8, _NTILE, _MTILE>::Code;
 
-  void forward(int8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
-               int _cstride, int kpos, void* tmpcache, size_t cachesize) {
+  static void forward(int8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
+                      int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5011,13 +5032,14 @@ class ICoreRowNAvxvnniSS : public CoreCodeBase<code::AvxvnniN8P4S8, _NTILE, _MTI
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvx2vnni : public CoreCodeBase<code::Avx2vnniN8P4U8, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBase<code::Avx2vnniN8P4U8, _NTILE, _MTILE>;
   using Code = typename CoreCodeBase<code::Avx2vnniN8P4U8, _NTILE, _MTILE>::Code;
 
-  void forward(uint8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
-               int _cstride, int kpos, void* tmpcache, size_t cachesize) {
+  static void forward(uint8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
+                      int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5027,13 +5049,14 @@ class ICoreRowNAvx2vnni : public CoreCodeBase<code::Avx2vnniN8P4U8, _NTILE, _MTI
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvx2vnniSS : public CoreCodeBase<code::Avx2vnniN8P4S8, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBase<code::Avx2vnniN8P4S8, _NTILE, _MTILE>;
   using Code = typename CoreCodeBase<code::Avx2vnniN8P4S8, _NTILE, _MTILE>::Code;
 
-  void forward(int8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
-               int _cstride, int kpos, void* tmpcache, size_t cachesize) {
+  static void forward(int8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
+                      int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5043,13 +5066,14 @@ class ICoreRowNAvx2vnniSS : public CoreCodeBase<code::Avx2vnniN8P4S8, _NTILE, _M
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvx512bw : public CoreCodeBase<code::Avx512bwN16P4, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBase<code::Avx512bwN16P4, _NTILE, _MTILE>;
   using Code = typename CoreCodeBase<code::Avx512bwN16P4, _NTILE, _MTILE>::Code;
 
-  void forward(uint8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
-               int _cstride, int kpos, void* tmpcache, size_t cachesize) {
+  static void forward(uint8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
+                      int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5059,15 +5083,16 @@ class ICoreRowNAvx512bw : public CoreCodeBase<code::Avx512bwN16P4, _NTILE, _MTIL
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvxvnniKBlock : public CoreCodeBase<code::kblock::AvxvnniN8P4U8, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBase<code::kblock::AvxvnniN8P4U8, _NTILE, _MTILE>;
   using Code = typename CoreCodeBase<code::kblock::AvxvnniN8P4U8, _NTILE, _MTILE>::Code;
-  void forward(uint8_t* matA, int8_t* matB, float* matC, uint8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
-               float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride, int _cstride,
-               int kpos, float kscale, void* tmpcache, size_t cachesize) {
+  static void forward(uint8_t* matA, int8_t* matB, float* matC, uint8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
+                      float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride,
+                      int _cstride, int kpos, float kscale, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA,  _astride, matB,    _bstride, matC, _cstride, zpA,     scaleA,
                                        _ldsa, scaleB,   reduceB, _ldsb,    _k,   _n,       _kblock, kpos == 0 ? 1 : 0,
                                        kscale};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5077,15 +5102,16 @@ class ICoreRowNAvxvnniKBlock : public CoreCodeBase<code::kblock::AvxvnniN8P4U8,
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvxvnniKBlockSS : public CoreCodeBase<code::kblock::AvxvnniN8P4S8, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBase<code::kblock::AvxvnniN8P4S8, _NTILE, _MTILE>;
   using Code = typename CoreCodeBase<code::kblock::AvxvnniN8P4S8, _NTILE, _MTILE>::Code;
-  void forward(int8_t* matA, int8_t* matB, float* matC, int8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
-               float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride, int _cstride,
-               int kpos, float kscale, void* tmpcache, size_t cachesize) {
+  static void forward(int8_t* matA, int8_t* matB, float* matC, int8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
+                      float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride,
+                      int _cstride, int kpos, float kscale, void* tmpcache, size_t cachesize) {
     auto param =
         typename Code::params{matA,   _astride, matB,  _bstride, matC, _cstride, nullptr,           scaleA, _ldsa,
                               scaleB, reduceB,  _ldsb, _k,       _n,   _kblock,  kpos == 0 ? 1 : 0, kscale};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5095,15 +5121,16 @@ class ICoreRowNAvxvnniKBlockSS : public CoreCodeBase<code::kblock::AvxvnniN8P4S8
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvx512bwKBlock : public CoreCodeBase<code::kblock::Avx512bwN16P4, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBase<code::kblock::Avx512bwN16P4, _NTILE, _MTILE>;
   using Code = typename CoreCodeBase<code::kblock::Avx512bwN16P4, _NTILE, _MTILE>::Code;
-  void forward(uint8_t* matA, int8_t* matB, float* matC, uint8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
-               float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride, int _cstride,
-               int kpos, float kscale, void* tmpcache, size_t cachesize) {
+  static void forward(uint8_t* matA, int8_t* matB, float* matC, uint8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
+                      float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride,
+                      int _cstride, int kpos, float kscale, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA,  _astride, matB,    _bstride, matC, _cstride, zpA,     scaleA,
                                        _ldsa, scaleB,   reduceB, _ldsb,    _k,   _n,       _kblock, kpos == 0 ? 1 : 0,
                                        kscale};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5113,15 +5140,16 @@ class ICoreRowNAvx512bwKBlock : public CoreCodeBase<code::kblock::Avx512bwN16P4,
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvx2vnniKBlock : public CoreCodeBase<code::kblock::Avx2vnniN8P4U8, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBase<code::kblock::Avx2vnniN8P4U8, _NTILE, _MTILE>;
   using Code = typename CoreCodeBase<code::kblock::Avx2vnniN8P4U8, _NTILE, _MTILE>::Code;
-  void forward(uint8_t* matA, int8_t* matB, float* matC, uint8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
-               float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride, int _cstride,
-               int kpos, float kscale, void* tmpcache, size_t cachesize) {
+  static void forward(uint8_t* matA, int8_t* matB, float* matC, uint8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
+                      float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride,
+                      int _cstride, int kpos, float kscale, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA,  _astride, matB,    _bstride, matC, _cstride, zpA,     scaleA,
                                        _ldsa, scaleB,   reduceB, _ldsb,    _k,   _n,       _kblock, kpos == 0 ? 1 : 0,
                                        kscale};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5131,15 +5159,16 @@ class ICoreRowNAvx2vnniKBlock : public CoreCodeBase<code::kblock::Avx2vnniN8P4U8
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAvx2vnniKBlockSS : public CoreCodeBase<code::kblock::Avx2vnniN8P4S8, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBase<code::kblock::Avx2vnniN8P4S8, _NTILE, _MTILE>;
   using Code = typename CoreCodeBase<code::kblock::Avx2vnniN8P4S8, _NTILE, _MTILE>::Code;
-  void forward(int8_t* matA, int8_t* matB, float* matC, int8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
-               float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride, int _cstride,
-               int kpos, float kscale, void* tmpcache, size_t cachesize) {
+  static void forward(int8_t* matA, int8_t* matB, float* matC, int8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
+                      float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride,
+                      int _cstride, int kpos, float kscale, void* tmpcache, size_t cachesize) {
     auto param =
         typename Code::params{matA,   _astride, matB,  _bstride, matC, _cstride, nullptr,           scaleA, _ldsa,
                               scaleB, reduceB,  _ldsb, _k,       _n,   _kblock,  kpos == 0 ? 1 : 0, kscale};
     if (_m <= Code::MTILE) {
-      this->mCodes[_m - 1].mKernel(&param);
+      Base::getInstance()->mCodes[_m - 1].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5149,22 +5178,24 @@ class ICoreRowNAvx2vnniKBlockSS : public CoreCodeBase<code::kblock::Avx2vnniN8P4
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAmxint8 : public CoreCodeBaseAMX<code::Amxint8N16P4US, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBaseAMX<code::Amxint8N16P4US, _NTILE, _MTILE>;
   using Code = typename CoreCodeBaseAMX<code::Amxint8N16P4US, _NTILE, _MTILE>::Code;
   using AType = typename Code::AType;
   using BType = typename Code::BType;
   using CType = typename Code::CType;
-  void configure(int _M, int _N, int _K) {
-    code::AmxConfigure::configure(_M < 16 ? _M : 16, 16, Code::KTILE, sizeof(BType), this->mCodes[0].ATileCount,
-                                  this->mCodes[0].BTileCount, this->mCodes[0].CTileCount);
+  static void configure(int _M, int _N, int _K) {
+    code::AmxConfigure::configure(_M < 16 ? _M : 16, 16, Code::KTILE, sizeof(BType),
+                                  Base::getInstance()->mCodes[0].ATileCount, Base::getInstance()->mCodes[0].BTileCount,
+                                  Base::getInstance()->mCodes[0].CTileCount);
   }
 
-  void forward(uint8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
-               int _cstride, int kpos, void* tmpcache, size_t cachesize) {
+  static void forward(uint8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
+                      int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param =
         typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0, tmpcache};
     if (_m <= Code::MTILE) {
       int idx = utils::updiv(_m, 16) - 1;
-      this->mCodes[idx].mKernel(&param);
+      Base::getInstance()->mCodes[idx].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5174,22 +5205,24 @@ class ICoreRowNAmxint8 : public CoreCodeBaseAMX<code::Amxint8N16P4US, _NTILE, _M
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAmxint8SS : public CoreCodeBaseAMX<code::Amxint8N16P4SS, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBaseAMX<code::Amxint8N16P4SS, _NTILE, _MTILE>;
   using Code = typename CoreCodeBaseAMX<code::Amxint8N16P4SS, _NTILE, _MTILE>::Code;
   using AType = typename Code::AType;
   using BType = typename Code::BType;
   using CType = typename Code::CType;
-  void configure(int _M, int _N, int _K) {
-    code::AmxConfigure::configure(_M < 16 ? _M : 16, 16, Code::KTILE, sizeof(BType), this->mCodes[0].ATileCount,
-                                  this->mCodes[0].BTileCount, this->mCodes[0].CTileCount);
+  static void configure(int _M, int _N, int _K) {
+    code::AmxConfigure::configure(_M < 16 ? _M : 16, 16, Code::KTILE, sizeof(BType),
+                                  Base::getInstance()->mCodes[0].ATileCount, Base::getInstance()->mCodes[0].BTileCount,
+                                  Base::getInstance()->mCodes[0].CTileCount);
   }
 
-  void forward(int8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
-               int _cstride, int kpos, void* tmpcache, size_t cachesize) {
+  static void forward(int8_t* matA, int8_t* matB, int32_t* matC, int _m, int _n, int _k, int _astride, int _bstride,
+                      int _cstride, int kpos, void* tmpcache, size_t cachesize) {
     auto param =
         typename Code::params{matA, _astride, matB, _bstride, matC, _cstride, _k, _n, kpos == 0 ? 1 : 0, tmpcache};
     if (_m <= Code::MTILE) {
       int idx = utils::updiv(_m, 16) - 1;
-      this->mCodes[idx].mKernel(&param);
+      Base::getInstance()->mCodes[idx].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5199,24 +5232,26 @@ class ICoreRowNAmxint8SS : public CoreCodeBaseAMX<code::Amxint8N16P4SS, _NTILE,
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAmxint8KBlock : public CoreCodeBaseAMX<code::kblock::Amxint8N16P4US, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBaseAMX<code::kblock::Amxint8N16P4US, _NTILE, _MTILE>;
   using Code = typename CoreCodeBaseAMX<code::kblock::Amxint8N16P4US, _NTILE, _MTILE>::Code;
   using AType = typename Code::AType;
   using BType = typename Code::BType;
   using CType = typename Code::CType;
-  void configure(int _M, int _N, int _K) {
-    code::AmxConfigure::configure(_M < 16 ? _M : 16, 16, Code::KTILE, sizeof(BType), this->mCodes[0].ATileCount,
-                                  this->mCodes[0].BTileCount, this->mCodes[0].CTileCount);
+  static void configure(int _M, int _N, int _K) {
+    code::AmxConfigure::configure(_M < 16 ? _M : 16, 16, Code::KTILE, sizeof(BType),
+                                  Base::getInstance()->mCodes[0].ATileCount, Base::getInstance()->mCodes[0].BTileCount,
+                                  Base::getInstance()->mCodes[0].CTileCount);
   }
 
-  void forward(uint8_t* matA, int8_t* matB, float* matC, uint8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
-               float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride, int _cstride,
-               int kpos, float kscale, void* tmpcache, size_t cachesize) {
+  static void forward(uint8_t* matA, int8_t* matB, float* matC, uint8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
+                      float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride,
+                      int _cstride, int kpos, float kscale, void* tmpcache, size_t cachesize) {
     auto param = typename Code::params{matA,   _astride, matB,    _bstride, matC, _cstride, zpA,     scaleA,
                                        _ldsa,  scaleB,   reduceB, _ldsb,    _k,   _n,       _kblock, kpos == 0 ? 1 : 0,
                                        kscale, tmpcache};
     if (_m <= Code::MTILE) {
       int idx = utils::updiv(_m, 16) - 1;
-      this->mCodes[idx].mKernel(&param);
+      Base::getInstance()->mCodes[idx].mKernel(&param);
     } else {
       assert(0);
     }
@@ -5226,24 +5261,26 @@ class ICoreRowNAmxint8KBlock : public CoreCodeBaseAMX<code::kblock::Amxint8N16P4
 template <int _NTILE, int _MTILE = 0>
 class ICoreRowNAmxint8SSKBlock : public CoreCodeBaseAMX<code::kblock::Amxint8N16P4SS, _NTILE, _MTILE> {
  public:
+  using Base = CoreCodeBaseAMX<code::kblock::Amxint8N16P4SS, _NTILE, _MTILE>;
   using Code = typename CoreCodeBaseAMX<code::kblock::Amxint8N16P4SS, _NTILE, _MTILE>::Code;
   using AType = typename Code::AType;
   using BType = typename Code::BType;
   using CType = typename Code::CType;
-  void configure(int _M, int _N, int _K) {
-    code::AmxConfigure::configure(_M < 16 ? _M : 16, 16, Code::KTILE, sizeof(BType), this->mCodes[0].ATileCount,
-                                  this->mCodes[0].BTileCount, this->mCodes[0].CTileCount);
+  static void configure(int _M, int _N, int _K) {
+    code::AmxConfigure::configure(_M < 16 ? _M : 16, 16, Code::KTILE, sizeof(BType),
+                                  Base::getInstance()->mCodes[0].ATileCount, Base::getInstance()->mCodes[0].BTileCount,
+                                  Base::getInstance()->mCodes[0].CTileCount);
   }
 
-  void forward(int8_t* matA, int8_t* matB, float* matC, int8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
-               float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride, int _cstride,
-               int kpos, float kscale, void* tmpcache, size_t cachesize) {
+  static void forward(int8_t* matA, int8_t* matB, float* matC, int8_t* zpA, float* scaleA, int _ldsa, float* scaleB,
+                      float* reduceB, int _ldsb, int _m, int _n, int _k, int _kblock, int _astride, int _bstride,
+                      int _cstride, int kpos, float kscale, void* tmpcache, size_t cachesize) {
     auto param =
         typename Code::params{matA,   _astride, matB,  _bstride, matC, _cstride, nullptr,           scaleA, _ldsa,
                               scaleB, reduceB,  _ldsb, _k,       _n,   _kblock,  kpos == 0 ? 1 : 0, kscale, tmpcache};
     if (_m <= Code::MTILE) {
       int idx = utils::updiv(_m, 16) - 1;
-      this->mCodes[idx].mKernel(&param);
+      Base::getInstance()->mCodes[idx].mKernel(&param);
     } else {
       assert(0);
     }
diff --git a/bestla/bestla/bestla_parallel.h b/bestla/bestla/bestla_parallel.h
index 04a310a5e..3168c1f64 100644
--- a/bestla/bestla/bestla_parallel.h
+++ b/bestla/bestla/bestla_parallel.h
@@ -68,8 +68,8 @@ class IThreading {
   virtual std::pair<float, float> get_PEtime() const { return {0.0f, 0.0f}; };
 
  protected:
-  int mThreadNum;
-  const bool isSupportPE;
+  int mThreadNum = 0;
+  const bool isSupportPE = false;
 };
 
 #if BTLA_OPENMP
@@ -107,7 +107,14 @@ class OMPThreading : public IThreading {
 class StdThreading : public IThreading {
  public:
   using Timer_T = utils::timer<utils::microseconds>;
-  explicit StdThreading() : IThreading(true) { cr = nullptr; }
+  explicit StdThreading() : IThreading(true) {
+    cr = nullptr;
+    memset(func_, 0, sizeof(func_));
+    memset(flag, 0, sizeof(flag));
+    stop = true;
+    time_per_p = -1.f;
+    time_per_e = -1.f;
+  }
 
   void parallel_for(const thread_func& func) override {
     time_per_p = 0;
@@ -117,7 +124,7 @@ class StdThreading : public IThreading {
       running.store(mThreadNum - 1);
       for (int i = 0; i < 10; i++) flag[i].store(mThreadNum);
       if (cr->mHybrid) {
-        int time_p = 0, time_e = 0;
+        int64_t time_p = 0, time_e = 0;
 
         for (size_t i = 0; i < mThreadNum - 1; i++) func_[i] = &func;
         thread_time[0] = 0;
@@ -135,8 +142,8 @@ class StdThreading : public IThreading {
             time_e += thread_time[i];
           else
             time_p += thread_time[i];
-        time_per_p = (time_p) / (1.0 * (mThreadNum - cr->E_core_num));
-        time_per_e = (time_e) / (1.0 * cr->E_core_num);
+        time_per_p = (time_p) / (1.0f * (mThreadNum - cr->E_core_num));
+        time_per_e = (time_e) / (1.0f * cr->E_core_num);
         // printf("%d %d %f %f\n", time_p, time_e, time_per_p, time_per_e);
       } else {
         for (size_t i = 0; i < mThreadNum - 1; i++) {
@@ -810,7 +817,7 @@ class SchedulerDispatcher<Scheduler2D> {
 }  // namespace gemm
 
 template <class Parallel_T, class Launch_T>
-void GemmRun(Launch_T& launcher, const typename Launch_T::Param& args, parallel::IThreading* th) {
+void GemmRun(const typename Launch_T::Param& args, parallel::IThreading* th) {
   gemm::SchedulerDispatcher<Parallel_T> para(th, args.problem);
   static bool flag = false;
   if (flag) {
@@ -822,16 +829,16 @@ void GemmRun(Launch_T& launcher, const typename Launch_T::Param& args, parallel:
     typename Parallel_T::ThreadProblem thdp{tidx};
     para.getIndex(thdp);
     if (thdp.valid) {
-      launcher.run(args, thdp);
+      Launch_T::run(args, thdp);
     }
   });
 }
 
 template <class Parallel_T, class Launch_T>
-void GemmRunWithA(Launch_T& launcher, const typename Launch_T::Param& args, parallel::IThreading* th) {
+void GemmRunWithA(const typename Launch_T::Param& args, parallel::IThreading* th) {
   gemm::SchedulerDispatcher<Parallel_T> para(th, args.problem);
   using AParall = typename Launch_T::PrologueA::Parallel;
-  AParall apara = launcher.mProA.createParallel(th->num_threads(), args.problem);
+  AParall apara = Launch_T::PrologueA::createParallel(th->num_threads(), args.problem);
   static bool flag = false;
   if (flag) {
     printf("%s\n", __FUNCTION__);
@@ -842,13 +849,13 @@ void GemmRunWithA(Launch_T& launcher, const typename Launch_T::Param& args, para
     typename AParall::ThreadProblem thdpA{tidx};
     apara.getIndex(thdpA);
     if (thdpA.valid) {
-      launcher.mProA.run(args.paramA, thdpA);
+      Launch_T::PrologueA::run(args.paramA, thdpA);
     }
     th->sync(tidx);
     typename Parallel_T::ThreadProblem thdp{tidx};
     para.getIndex(thdp);
     if (thdp.valid) {
-      launcher.run(args, thdp);
+      Launch_T::run(args, thdp);
     }
   });
 }
diff --git a/bestla/bestla/bestla_prologue_a.h b/bestla/bestla/bestla_prologue_a.h
index d6e782c76..bc4681535 100644
--- a/bestla/bestla/bestla_prologue_a.h
+++ b/bestla/bestla/bestla_prologue_a.h
@@ -34,14 +34,14 @@ struct ParamActivationBase {
   const AType* A;
   int lda;
 };
-template <class _GemmCore_T, BTLA_ISA ISA_T>
+template <class _GemmCore_T>
 class ActivationBase {
  public:
   using AType = typename _GemmCore_T::AType;
   using SRCType = AType;
   using Param = ParamActivationBase<AType>;
-  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                          int k_offset, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size,
+                                  int m_offset, int k_offset, void* tmpcache, size_t cachesize) {
     auto aptr = const_cast<AType*>(_param.A) + m_offset * _param.lda + k_offset;
     auto alignedptr = utils::cpu_pointer_align(aptr);
     bool use_rawptr = k_size % _GemmCore_T::KTILE == 0 && m_size >= _GemmCore_T::MTILE;
@@ -59,14 +59,14 @@ class ActivationBase {
   }
 };
 
-template <class _GemmCore_T, BTLA_ISA ISA_T, typename SRC_T>
-class ActivationConverter : public ActivationBase<_GemmCore_T, ISA_T> {
+template <class _GemmCore_T, typename SRC_T>
+class ActivationConverter : public ActivationBase<_GemmCore_T> {
  public:
   using AType = typename _GemmCore_T::AType;
   using SRCType = SRC_T;
   using Param = ParamActivationBase<SRC_T>;
-  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                          int k_offset, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size,
+                                  int m_offset, int k_offset, void* tmpcache, size_t cachesize) {
     auto aptr = const_cast<SRC_T*>(_param.A);
     auto k_pad = utils::padto(k_size, _GemmCore_T::KTILE);
     *dststep = k_pad;
@@ -83,8 +83,8 @@ class ActivationConverter : public ActivationBase<_GemmCore_T, ISA_T> {
                                                                   m_size, k_size, _param.lda * sizeof(SRC_T),
                                                                   k_pad * sizeof(AType), true);
     } else if constexpr (std::is_same_v<AType, SRC_T>) {
-      return ActivationBase<_GemmCore_T, ISA_T>::getActivation(dstptr, dststep, {_param.A, _param.lda}, m_size, k_size,
-                                                               m_offset, k_offset, tmpcache, cachesize);
+      return ActivationBase<_GemmCore_T>::template getActivation<ISA_T>(
+          dstptr, dststep, {_param.A, _param.lda}, m_size, k_size, m_offset, k_offset, tmpcache, cachesize);
     } else {
       assert(0);
     }
@@ -92,16 +92,16 @@ class ActivationConverter : public ActivationBase<_GemmCore_T, ISA_T> {
   }
 };
 
-template <class _GemmCore_T, BTLA_ISA ISA_T>
-using ActivationConverterFp32 = ActivationConverter<_GemmCore_T, ISA_T, float>;
-template <class _GemmCore_T, BTLA_ISA ISA_T>
-using ActivationConverterBf16 = ActivationConverter<_GemmCore_T, ISA_T, utils::bf16>;
+template <class _GemmCore_T>
+using ActivationConverterFp32 = ActivationConverter<_GemmCore_T, float>;
+template <class _GemmCore_T>
+using ActivationConverterBf16 = ActivationConverter<_GemmCore_T, utils::bf16>;
 
 template <typename AType>
 struct ParamActivationKBlockQuantize : ParamActivationBase<AType> {
   storage::gemm::StorageQuantActivation* quan;
 };
-template <class _GemmCore_T, BTLA_ISA ISA_T, typename SRC_T>
+template <class _GemmCore_T, typename SRC_T>
 class ActivationKBlockQuantize {
  public:
   using AType = typename _GemmCore_T::AType;
@@ -112,7 +112,7 @@ class ActivationKBlockQuantize {
   using Parallel = parallel::Scheduler2D;
   using ThreadProblem = parallel::ThreadProblem2D;
 
-  inline Parallel createParallel(int nthreads, const utils::GemmProblem& prbm) {
+  AUTOCALL Parallel createParallel(int nthreads, const utils::GemmProblem& prbm) {
     return Parallel({
         nthreads, prbm.dims[1],  // m
         prbm.dims[3],            // k
@@ -121,7 +121,7 @@ class ActivationKBlockQuantize {
     });
   }
 
-  inline QParam createStorage(int m, int k, int kblock, bool hasreduce) {
+  AUTOCALL QParam createStorage(int m, int k, int kblock, bool hasreduce) {
     QParam tmp;
     int kpad = utils::padto(k, _GemmCore_T::KTILE);
     int mpad = utils::padto(m, _GemmCore_T::MTILE);
@@ -130,7 +130,7 @@ class ActivationKBlockQuantize {
     return tmp;
   }
 
-  void run(const Param& _param, ThreadProblem& thdp) {
+  AUTOCALL void run(const Param& _param, ThreadProblem& thdp) {
     auto quan = _param.quan;
     if (thdp.valid) {
       // min max
@@ -141,19 +141,19 @@ class ActivationKBlockQuantize {
       auto thdzptr = quan->template ZPtr<AType>() + blk_offset;
       auto thdrptr = quan->template RPtr<float>() == nullptr ? nullptr : quan->template RPtr<float>() + blk_offset;
       if constexpr (std::is_same_v<AType, uint8_t>) {
-        kernel::wrapper::QuantizeU8ColBlock::template forward<ISA_T, SRC_T>(
-            thdp.size[0], thdp.size[1], srcptr, _param.lda, thdqptr, quan->mKPad, thdsptr, quan->CStep(), thdzptr,
-            quan->mBlockSize, thdrptr);
+        kernel::wrapper::QuantizeU8ColBlock<SRC_T>::forward_auto(thdp.size[0], thdp.size[1], srcptr, _param.lda,
+                                                                 thdqptr, quan->mKPad, thdsptr, quan->CStep(), thdzptr,
+                                                                 quan->mBlockSize, thdrptr);
       }
       if constexpr (std::is_same_v<AType, int8_t>) {
-        kernel::wrapper::QuantizeS8ColBlock::template forward<ISA_T, SRC_T>(thdp.size[0], thdp.size[1], srcptr,
-                                                                            _param.lda, thdqptr, quan->mKPad, thdsptr,
-                                                                            quan->CStep(), quan->mBlockSize, thdrptr);
+        kernel::wrapper::QuantizeS8ColBlock<SRC_T>::forward_auto(thdp.size[0], thdp.size[1], srcptr, _param.lda,
+                                                                 thdqptr, quan->mKPad, thdsptr, quan->CStep(),
+                                                                 quan->mBlockSize, thdrptr);
       }
     }
   }
 
-  BTLA_CODE quantize(const Param& _param, int m, int k, parallel::IThreading* threading) {
+  AUTOCALL BTLA_CODE quantize(const Param& _param, int m, int k, parallel::IThreading* threading) {
     auto paral = Parallel({threading->num_threads(), m, k, 1, _param.quan->mBlockSize});
     threading->parallel_for([&](int tidx) {
       parallel::ThreadProblem2D thdp{tidx};
@@ -164,8 +164,8 @@ class ActivationKBlockQuantize {
   }
 
  public:  // Runtime get by launcher
-  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                          int k_offset, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size,
+                                  int m_offset, int k_offset, void* tmpcache, size_t cachesize) {
     (void)m_size;
     (void)k_size;
     auto quan = _param.quan;
@@ -175,8 +175,8 @@ class ActivationKBlockQuantize {
     return BTLA_CODE::Success;
   }
 
-  BTLA_CODE getZp(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset, int k_offset,
-                  void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getZp(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                          int k_offset, void* tmpcache, size_t cachesize) {
     auto quan = _param.quan;
     auto aptr = quan->template ZPtr<AType>();
     if (aptr == nullptr) {  // optional
@@ -190,8 +190,8 @@ class ActivationKBlockQuantize {
     return BTLA_CODE::Success;
   }
 
-  BTLA_CODE getScale(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                     int k_offset, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getScale(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                             int k_offset, void* tmpcache, size_t cachesize) {
     auto quan = _param.quan;
     auto aptr = quan->template SPtr<float>();
     int kele = utils::updiv(k_size, quan->mBlockSize);
@@ -201,8 +201,8 @@ class ActivationKBlockQuantize {
     return BTLA_CODE::Success;
   }
 
-  BTLA_CODE getReduce(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                      int k_offset, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getReduce(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                              int k_offset, void* tmpcache, size_t cachesize) {
     auto quan = _param.quan;
     auto aptr = quan->template RPtr<float>();
     int kele = utils::updiv(k_size, quan->mBlockSize);
@@ -213,17 +213,17 @@ class ActivationKBlockQuantize {
   }
 };
 
-template <class _GemmCore_T, BTLA_ISA ISA_T>
-using ActivationF32KBlockQuantize = ActivationKBlockQuantize<_GemmCore_T, ISA_T, float>;
-template <class _GemmCore_T, BTLA_ISA ISA_T>
-using ActivationBf16KBlockQuantize = ActivationKBlockQuantize<_GemmCore_T, ISA_T, utils::bf16>;
+template <class _GemmCore_T>
+using ActivationF32KBlockQuantize = ActivationKBlockQuantize<_GemmCore_T, float>;
+template <class _GemmCore_T>
+using ActivationBf16KBlockQuantize = ActivationKBlockQuantize<_GemmCore_T, utils::bf16>;
 
 template <typename AType>
 struct ParamActivationKBlockBase : ParamActivationBase<AType> {
   storage::gemm::StorageReduce* reduce;
 };
-template <class _GemmCore_T, BTLA_ISA ISA_T, typename SRC_T>
-class ActivationKBlockBase : public ActivationConverter<_GemmCore_T, ISA_T, SRC_T> {
+template <class _GemmCore_T, typename SRC_T>
+class ActivationKBlockBase : public ActivationConverter<_GemmCore_T, SRC_T> {
  public:
   using AType = typename _GemmCore_T::AType;
   using SType = storage::gemm::StorageReduce;
@@ -232,7 +232,7 @@ class ActivationKBlockBase : public ActivationConverter<_GemmCore_T, ISA_T, SRC_
   using Parallel = parallel::Scheduler2D;
   using ThreadProblem = parallel::ThreadProblem2D;
 
-  inline Parallel createParallel(int nthreads, const utils::GemmProblem& prbm) {
+  AUTOCALL Parallel createParallel(int nthreads, const utils::GemmProblem& prbm) {
     return Parallel({
         nthreads, prbm.dims[1],  // m
         prbm.dims[3],            // k
@@ -240,26 +240,26 @@ class ActivationKBlockBase : public ActivationConverter<_GemmCore_T, ISA_T, SRC_
         prbm.dims[4]  // kblock
     });
   }
-  inline SType createStorage(int m, int k, int kblock) {
+  AUTOCALL SType createStorage(int m, int k, int kblock) {
     SType tmp;
     tmp.resize(m, k, kblock == -1 ? k : kblock, BTLA_DTYPE::F32);
     return tmp;
   }
 
-  void run(const Param& _param, ThreadProblem& thdp) {
+  AUTOCALL void run(const Param& _param, ThreadProblem& thdp) {
     auto stor = _param.reduce;
     if (thdp.valid) {
       // min max
       auto srcptr = const_cast<SRC_T*>(_param.A) + thdp.loc[0] * _param.lda + thdp.loc[1];
       auto blk_offset = thdp.loc[0] * stor->lda + thdp.loc[1] / stor->kblock;
       auto thdrptr = stor->template RPtr<float>() + blk_offset;
-      auto ret = kernel::wrapper::ColBlockReduceSum::template forward<ISA_T, SRC_T>(
-          srcptr, _param.lda, thdp.size[0], thdp.size[1], stor->kblock, thdrptr, stor->lda);
+      auto ret = kernel::wrapper::ColBlockReduceSum<SRC_T>::forward_auto(srcptr, _param.lda, thdp.size[0], thdp.size[1],
+                                                                         stor->kblock, thdrptr, stor->lda);
       assert(ret == BTLA_CODE::Success);
     }
   }
 
-  BTLA_CODE reduce(const Param& _param, int m, int k, int kblock, parallel::IThreading* threading) {
+  AUTOCALL BTLA_CODE reduce(const Param& _param, int m, int k, int kblock, parallel::IThreading* threading) {
     auto paral = Parallel({threading->num_threads(), m, k, 1, kblock});
     threading->parallel_for([&](int tidx) {
       parallel::ThreadProblem2D thdp{tidx};
@@ -269,14 +269,14 @@ class ActivationKBlockBase : public ActivationConverter<_GemmCore_T, ISA_T, SRC_
     return BTLA_CODE::Success;
   }
 
-  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                          int k_offset, void* tmpcache, size_t cachesize) {
-    return ActivationConverter<_GemmCore_T, ISA_T, SRC_T>::getActivation(
+  TLACALL BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size,
+                                  int m_offset, int k_offset, void* tmpcache, size_t cachesize) {
+    return ActivationConverter<_GemmCore_T, SRC_T>::template getActivation<ISA_T>(
         dstptr, dststep, {_param.A, _param.lda}, m_size, k_size, m_offset, k_offset, tmpcache, cachesize);
   }
 
-  BTLA_CODE getReduce(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                      int k_offset, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getReduce(float** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
+                              int k_offset, void* tmpcache, size_t cachesize) {
     auto reduce = _param.reduce;
     auto aptr = reduce->template RPtr<float>();
     int kele = utils::updiv(k_size, reduce->kblock);
@@ -287,16 +287,16 @@ class ActivationKBlockBase : public ActivationConverter<_GemmCore_T, ISA_T, SRC_
   }
 };
 
-template <class _GemmCore_T, BTLA_ISA ISA_T>
-using ActivationKBlockBaseF32 = ActivationKBlockBase<_GemmCore_T, ISA_T, float>;
+template <class _GemmCore_T>
+using ActivationKBlockBaseF32 = ActivationKBlockBase<_GemmCore_T, float>;
 
 template <typename AType>
 struct ParamShuffleActivationKBlockBase : ParamActivationKBlockBase<AType> {
   int* indices = nullptr;
   storage::gemm::StorageReorderActivation* reordered = nullptr;
 };
-template <class _GemmCore_T, BTLA_ISA ISA_T, typename SRC_T>
-class ShuffleActivationKBlockBase : public ActivationKBlockBase<_GemmCore_T, ISA_T, SRC_T> {
+template <class _GemmCore_T, typename SRC_T>
+class ShuffleActivationKBlockBase : public ActivationKBlockBase<_GemmCore_T, SRC_T> {
  public:
   using AType = typename _GemmCore_T::AType;
   using RedType = storage::gemm::StorageReduce;
@@ -305,7 +305,7 @@ class ShuffleActivationKBlockBase : public ActivationKBlockBase<_GemmCore_T, ISA
   using Param = ParamShuffleActivationKBlockBase<SRC_T>;
   using Parallel = parallel::Scheduler2D;
   using ThreadProblem = parallel::ThreadProblem2D;
-  inline RAType createReorderStorage(int m, int k, int kblock) {
+  static RAType createReorderStorage(int m, int k, int kblock) {
     RAType tmp(_GemmCore_T::ID);
     int kpad = utils::padto(k, _GemmCore_T::KTILE);
     int mpad = utils::padto(m, _GemmCore_T::MTILE);
@@ -313,13 +313,13 @@ class ShuffleActivationKBlockBase : public ActivationKBlockBase<_GemmCore_T, ISA
     return tmp;
   }
 
-  inline RedType createReduceStorage(int m, int k, int kblock) {
+  static RedType createReduceStorage(int m, int k, int kblock) {
     RedType tmp;
     tmp.resize(m, k, kblock == -1 ? k : kblock, BTLA_DTYPE::F32);
     return tmp;
   }
 
-  void run(const Param& _param, ThreadProblem& thdp) {
+  AUTOCALL void run(const Param& _param, ThreadProblem& thdp) {
     auto stor = _param.reduce;
     auto reordered = _param.reordered;
     if (thdp.valid) {
@@ -335,14 +335,14 @@ class ShuffleActivationKBlockBase : public ActivationKBlockBase<_GemmCore_T, ISA
         // min max
         auto blk_offset = thdp.loc[0] * stor->lda + thdp.loc[1] / stor->kblock;
         auto thdrptr = stor->template RPtr<float>() + blk_offset;
-        auto ret = kernel::wrapper::ColBlockReduceSum::template forward<ISA_T, SRC_T>(
+        auto ret = kernel::wrapper::ColBlockReduceSum<SRC_T>::forward_auto(
             srcptr, _param.lda, thdp.size[0], thdp.size[1], stor->kblock, thdrptr, stor->lda);
         assert(ret == BTLA_CODE::Success);
       }
     }
   }
 
-  BTLA_CODE preprocess(const Param& _param, int m, int k, int kblock, parallel::IThreading* threading) {
+  AUTOCALL BTLA_CODE preprocess(const Param& _param, int m, int k, int kblock, parallel::IThreading* threading) {
     auto paral = Parallel({threading->num_threads(), m, k, 1, kblock});
     threading->parallel_for([&](int tidx) {
       parallel::ThreadProblem2D thdp{tidx};
@@ -352,31 +352,31 @@ class ShuffleActivationKBlockBase : public ActivationKBlockBase<_GemmCore_T, ISA
     return BTLA_CODE::Success;
   }
 
-  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                          int k_offset, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size,
+                                  int m_offset, int k_offset, void* tmpcache, size_t cachesize) {
     if (_param.indices == nullptr) {
-      return ActivationConverter<_GemmCore_T, ISA_T, SRC_T>::getActivation(
+      return ActivationConverter<_GemmCore_T, SRC_T>::template getActivation<ISA_T>(
           dstptr, dststep, {_param.A, _param.lda}, m_size, k_size, m_offset, k_offset, tmpcache, cachesize);
     } else {
-      return ActivationConverter<_GemmCore_T, ISA_T, SRC_T>::getActivation(
+      return ActivationConverter<_GemmCore_T, SRC_T>::template getActivation<ISA_T>(
           dstptr, dststep, {_param.reordered->template APtr<SRC_T>(), _param.reordered->mKPad}, m_size, k_size,
           m_offset, k_offset, tmpcache, cachesize);
     }
   }
 };
 
-template <class _GemmCore_T, BTLA_ISA ISA_T>
-using ShuffleActivationKBlockBaseF32 = ShuffleActivationKBlockBase<_GemmCore_T, ISA_T, float>;
-template <class _GemmCore_T, BTLA_ISA ISA_T>
-using ShuffleActivationKBlockBaseBf16 = ShuffleActivationKBlockBase<_GemmCore_T, ISA_T, utils::bf16>;
+template <class _GemmCore_T>
+using ShuffleActivationKBlockBaseF32 = ShuffleActivationKBlockBase<_GemmCore_T, float>;
+template <class _GemmCore_T>
+using ShuffleActivationKBlockBaseBf16 = ShuffleActivationKBlockBase<_GemmCore_T, utils::bf16>;
 
 template <typename AType>
 struct ParamShuffleActivationKBlockQuantize : ParamActivationKBlockQuantize<AType> {
   int* indices = nullptr;
   storage::gemm::StorageReorderActivation* reordered = nullptr;
 };
-template <class _GemmCore_T, BTLA_ISA ISA_T, typename SRC_T>
-class ShuffleActivationKBlockQuantize : public ActivationKBlockQuantize<_GemmCore_T, ISA_T, SRC_T> {
+template <class _GemmCore_T, typename SRC_T>
+class ShuffleActivationKBlockQuantize : public ActivationKBlockQuantize<_GemmCore_T, SRC_T> {
  public:
   using AType = typename _GemmCore_T::AType;
   using SType = float;
@@ -387,7 +387,7 @@ class ShuffleActivationKBlockQuantize : public ActivationKBlockQuantize<_GemmCor
   using Parallel = parallel::Scheduler2D;
   using ThreadProblem = parallel::ThreadProblem2D;
 
-  inline QParam createQuantStorage(int m, int k, int kblock, bool hasreduce) {
+  AUTOCALL QParam createQuantStorage(int m, int k, int kblock, bool hasreduce) {
     QParam tmp;
     int kpad = utils::padto(k, _GemmCore_T::KTILE);
     int mpad = utils::padto(m, _GemmCore_T::MTILE);
@@ -396,7 +396,7 @@ class ShuffleActivationKBlockQuantize : public ActivationKBlockQuantize<_GemmCor
     return tmp;
   }
 
-  inline RAType createReorderStorage(int m, int k, int kblock) {
+  AUTOCALL RAType createReorderStorage(int m, int k, int kblock) {
     RAType tmp(_GemmCore_T::ID);
     int kpad = utils::padto(k, _GemmCore_T::KTILE);
     int mpad = utils::padto(m, _GemmCore_T::MTILE);
@@ -404,7 +404,7 @@ class ShuffleActivationKBlockQuantize : public ActivationKBlockQuantize<_GemmCor
     return tmp;
   }
 
-  BTLA_CODE quantize(const Param& _param, int m, int k, parallel::IThreading* threading) {
+  AUTOCALL BTLA_CODE quantize(const Param& _param, int m, int k, parallel::IThreading* threading) {
     auto srcptr = const_cast<SRC_T*>(_param.A);
     if (_param.indices) {
       auto shuffle_src = _param.reordered->template APtr<SRC_T>();
@@ -417,15 +417,15 @@ class ShuffleActivationKBlockQuantize : public ActivationKBlockQuantize<_GemmCor
       });
       srcptr = shuffle_src;
     }
-    ActivationKBlockQuantize<_GemmCore_T, ISA_T, SRC_T>::quantize({srcptr, k, _param.quan}, m, k, threading);
+    ActivationKBlockQuantize<_GemmCore_T, SRC_T>::quantize({srcptr, k, _param.quan}, m, k, threading);
     return BTLA_CODE::Success;
   }
 };
 
-template <class _GemmCore_T, BTLA_ISA ISA_T>
-using ShuffleActivationKBlockQuantizeF32 = ShuffleActivationKBlockQuantize<_GemmCore_T, ISA_T, float>;
-template <class _GemmCore_T, BTLA_ISA ISA_T>
-using ShuffleActivationKBlockQuantizeBf16 = ShuffleActivationKBlockQuantize<_GemmCore_T, ISA_T, utils::bf16>;
+template <class _GemmCore_T>
+using ShuffleActivationKBlockQuantizeF32 = ShuffleActivationKBlockQuantize<_GemmCore_T, float>;
+template <class _GemmCore_T>
+using ShuffleActivationKBlockQuantizeBf16 = ShuffleActivationKBlockQuantize<_GemmCore_T, utils::bf16>;
 }  // namespace gemm
 }  // namespace prologue_a
 }  // namespace bestla
diff --git a/bestla/bestla/bestla_prologue_b.h b/bestla/bestla/bestla_prologue_b.h
index e3ee36a92..39c44d97b 100644
--- a/bestla/bestla/bestla_prologue_b.h
+++ b/bestla/bestla/bestla_prologue_b.h
@@ -23,7 +23,7 @@ namespace bestla {
 namespace prologue_b {
 namespace gemm {
 
-template <typename WT, BTLA_ISA ISA_T>
+template <typename WT>
 static inline void transposeWeight(const int Row, const int Col, const WT* src, const int ld_src, WT* dst,
                                    const int ld_dst, parallel::IThreading* threading) {
   bestla::parallel::Scheduler2D _para;
@@ -32,9 +32,9 @@ static inline void transposeWeight(const int Row, const int Col, const WT* src,
     bestla::parallel::ThreadProblem2D thdp{tidx};
     _para.getIndex(thdp);
     if (thdp.valid) {
-      kernel::wrapper::Transpose2D<WT>::template forward<ISA_T>(src + thdp.loc[0] * ld_src + thdp.loc[1],
-                                                                dst + thdp.loc[0] + thdp.loc[1] * ld_dst, thdp.size[0],
-                                                                thdp.size[1], ld_src, ld_dst);
+      kernel::wrapper::Transpose2D<WT>::forward_auto(src + thdp.loc[0] * ld_src + thdp.loc[1],
+                                                     dst + thdp.loc[0] + thdp.loc[1] * ld_dst, thdp.size[0],
+                                                     thdp.size[1], ld_src, ld_dst);
     }
   });
 }
@@ -45,14 +45,14 @@ struct ParamWeightPack {
   storage::gemm::StoragePackedWeight* packedW;
 };
 
-template <class _GemmCore_T, BTLA_ISA ISA_T>
+template <class _GemmCore_T>
 class WeightPack {
  public:
   using WType = typename _GemmCore_T::BType;
   using StorageType = storage::gemm::StoragePackedWeight;
   using Param = ParamWeightPack<WType>;
 
-  StorageType createStorage(int n, int k) {
+  AUTOCALL StorageType createStorage(int n, int k) {
     int KPad = utils::padto(k, _GemmCore_T::KTILE);
     int NPad = utils::padto(n, _GemmCore_T::NTILE);
     StorageType tmp(_GemmCore_T::ID);
@@ -60,15 +60,15 @@ class WeightPack {
     return tmp;
   }
 
-  void packWeightTranspose(const int N, const int K, const Param& _param, parallel::IThreading* threading) {
+  AUTOCALL void packWeightTranspose(const int N, const int K, const Param& _param, parallel::IThreading* threading) {
     auto B_NT = utils::amalloc<WType>(static_cast<size_t>(N) * K);
-    transposeWeight<WType, ISA_T>(N, K, _param.B, _param.ldb, B_NT, N, threading);
+    transposeWeight<WType>(N, K, _param.B, _param.ldb, B_NT, N, threading);
     packWeight(N, K, {B_NT, N, _param.packedW}, threading);
     utils::afree(B_NT);
   }
 
   // from KxN int8 symmetric weight to packed N//NtilexKPadxNTile int4 weight
-  void packWeight(const int N, const int K, const Param& _param, parallel::IThreading* threading) {
+  AUTOCALL void packWeight(const int N, const int K, const Param& _param, parallel::IThreading* threading) {
     parallel::Scheduler2D _para({threading->num_threads(), K, N, _GemmCore_T::KTILE, _GemmCore_T::NTILE});
     threading->parallel_for([&](int tidx) {
       parallel::ThreadProblem2D thdp{tidx};
@@ -79,21 +79,22 @@ class WeightPack {
     });
   }
 
-  void run(const Param& _param, parallel::ThreadProblem2D& thdp) {
+  AUTOCALL void run(const Param& _param, parallel::ThreadProblem2D& thdp) {
     auto packedw = _param.packedW;
     auto rowpadded = utils::padto(thdp.size[0], _GemmCore_T::KTILE);
     auto colpadded = utils::padto(thdp.size[1], _GemmCore_T::NTILE);
     const auto src = _param.B + thdp.loc[0] * _param.ldb + thdp.loc[1];
     const auto dst = packedw->template WPtr<WType>() + thdp.loc[0] * _GemmCore_T::NTILE + thdp.loc[1] * packedw->mKPad;
-    using PaddingInterleaveMNWType = kernel::wrapper::PaddingInterleaveMN<_GemmCore_T::NTILE, _GemmCore_T::PACK_ROW>;
-    auto ret = PaddingInterleaveMNWType::template forward<ISA_T>(  //
+    using PaddingInterleaveMNWType =
+        kernel::wrapper::PaddingInterleaveMN<_GemmCore_T::NTILE, _GemmCore_T::PACK_ROW, WType>;
+    auto ret = PaddingInterleaveMNWType::forward_auto(  //
         src, dst, thdp.size[0], thdp.size[1], rowpadded, colpadded, _param.ldb, packedw->mKPad);
     assert(ret == BTLA_CODE::Success);
     (void)ret;
   }
 
-  inline BTLA_CODE getWeight(WType** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                             const Param param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getWeight(WType** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                              const Param param, void* tmpcache, size_t cachesize) {
     auto wptr = param.packedW;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->template WPtr<WType>() + n_offset * KPad + k_offset * _GemmCore_T::NTILE;
@@ -109,15 +110,15 @@ struct ParamWeightKBlockNInteger {
   storage::gemm::StorageWeightKBlockNInteger* packedW;
 };
 
-template <class _GemmCore_T, BTLA_ISA ISA_T>
+template <class _GemmCore_T>
 class WeightKBlockNInteger {
  public:
   using StorageWeight = storage::gemm::StorageWeightKBlockNInteger;
   using BType = typename _GemmCore_T::BType;
   using Param = ParamWeightKBlockNInteger;
 
-  static StorageWeight createStorage(int n, int k, int blocksize, BTLA_DTYPE qtype, BTLA_DTYPE scat, BTLA_DTYPE redt,
-                                     bool is_asym) {
+  AUTOCALL StorageWeight createStorage(int n, int k, int blocksize, BTLA_DTYPE qtype, BTLA_DTYPE scat, BTLA_DTYPE redt,
+                                       bool is_asym) {
     int KPad = utils::padto(k, _GemmCore_T::KTILE);
     int NPad = utils::padto(n, _GemmCore_T::NTILE);
     StorageWeight tmp(_GemmCore_T::ID);
@@ -125,8 +126,8 @@ class WeightKBlockNInteger {
     return tmp;
   }
 
-  void doubleQuantScale(float* scale, size_t scale_size, int dq_blocksize, BTLA_DTYPE qtype,
-                        utils::aligned_vector<float>* dq_buf) {
+  AUTOCALL void doubleQuantScale(float* scale, size_t scale_size, int dq_blocksize, BTLA_DTYPE qtype,
+                                 utils::aligned_vector<float>* dq_buf) {
     if (qtype == BTLA_DTYPE::DQ8_BNB) {
       dq_buf->resize(utils::updiv(scale_size, dq_blocksize) + 1);  // add 1 for offset.
       kernel::ref::dq8_bnb_double_quant<false>(scale, scale_size, dq_blocksize, dq_buf->data());
@@ -135,7 +136,7 @@ class WeightKBlockNInteger {
     }
   }
 
-  void setDoubleQuantCorrection(utils::avector<float>* dq_buf, StorageWeight* ptr) {
+  AUTOCALL void setDoubleQuantCorrection(utils::avector<float>* dq_buf, StorageWeight* ptr) {
     if (ptr->SDtype() == BTLA_DTYPE::DQ8_BNB) {
       auto packw_dqbuf_ptr = ptr->DQPtr<float>();
       memcpy(packw_dqbuf_ptr, dq_buf->data(), dq_buf->size() * sizeof(float));
@@ -144,8 +145,9 @@ class WeightKBlockNInteger {
     }
   }
 
-  static void enableShuffle(StorageWeight* stor) { stor->enable_shuffle(); }
-  void setDoubleQuantBlkSize(StorageWeight* stor, BTLA_DTYPE stype, int dq_blksize) {
+  AUTOCALL void enableShuffle(StorageWeight* stor) { stor->enable_shuffle(); }
+
+  AUTOCALL void setDoubleQuantBlkSize(StorageWeight* stor, BTLA_DTYPE stype, int dq_blksize) {
     stor->mDqBlockSize = dq_blksize;
     auto nk_scale = utils::updiv(stor->mKPad, stor->mBlockSize);
     if (stor->IsAsym() || dq_blksize % 8 != 0) assert(0);
@@ -153,26 +155,26 @@ class WeightKBlockNInteger {
     stor->update_size();
   }
 
-  void packTransposeWeight(const int N, const int K, const float* B, const int ldb, StorageWeight* stor,
-                           parallel::IThreading* threading) {
+  AUTOCALL void packTransposeWeight(const int N, const int K, const float* B, const int ldb, StorageWeight* stor,
+                                    parallel::IThreading* threading) {
     auto B_NT = utils::amalloc<float>(static_cast<size_t>(N) * K);
-    transposeWeight<float, ISA_T>(N, K, B, ldb, B_NT, N, threading);
+    transposeWeight<float>(N, K, B, ldb, B_NT, N, threading);
     packWeight(N, K, B_NT, N, stor, threading);
     utils::afree(B_NT);
   }
 
   // from packed N//NtilexKPadxNTile int8 weight to KxN f32 weight
-  void unpackTransposeWeight(const int N, const int K, StorageWeight* stor, float* B, const int ldb,
-                             parallel::IThreading* threading) {
+  AUTOCALL void unpackTransposeWeight(const int N, const int K, StorageWeight* stor, float* B, const int ldb,
+                                      parallel::IThreading* threading) {
     auto B_NT = utils::amalloc<float>(static_cast<size_t>(N) * K);
     unpackWeight(N, K, stor, B_NT, N, threading);
-    transposeWeight<float, ISA_T>(K, N, B_NT, N, B, ldb, threading);
+    transposeWeight<float>(K, N, B_NT, N, B, ldb, threading);
     utils::afree(B_NT);
   }
 
   // from KxN f32 weight to packed N//NtilexKPadxNTile int8 weight
-  void packWeight(const int N, const int K, const float* B, const int ldb, StorageWeight* ptr,
-                  parallel::IThreading* threading) {
+  AUTOCALL void packWeight(const int N, const int K, const float* B, const int ldb, StorageWeight* ptr,
+                           parallel::IThreading* threading) {
     auto tmpq = utils::amalloc<int8_t>(static_cast<size_t>(N) * K);
     int nk_scale = utils::updiv(K, ptr->mBlockSize);
     auto ssize = static_cast<size_t>(N) * nk_scale;
@@ -184,31 +186,9 @@ class WeightKBlockNInteger {
     utils::afree(Tscales);
     utils::afree(Tzps);
   }
-
-  void unpackWeight(const int N, const int K, StorageWeight* stor, float* B, const int ldb,
-                    parallel::IThreading* threading) {
-    parallel::Scheduler2D _para({threading->num_threads(), K, N, _GemmCore_T::KTILE, _GemmCore_T::NTILE});
-    threading->parallel_for([&](int tidx) {
-      parallel::ThreadProblem2D thdp{tidx};
-      _para.getIndex(thdp);
-      if (thdp.valid) {
-        auto rowpad = utils::padto(thdp.size[0], _GemmCore_T::KTILE);
-        auto colpad = utils::padto(thdp.size[1], _GemmCore_T::NTILE);
-        auto dequant = utils::amalloc<float>((size_t)rowpad * colpad);
-        auto dstptr = dequant;
-        int dststep = 0;
-        size_t constexpr CacheSize = size_t(100) << 10;
-        int8_t tmpcache[CacheSize];
-        getWeight(&dstptr, &dststep, rowpad, colpad, thdp.loc[0], thdp.loc[1], {stor}, tmpcache, CacheSize);
-        kernel::wrapper::RevertPaddingInterleaveMN<_GemmCore_T::NTILE, _GemmCore_T::PACK_ROW>::template forward<ISA_T>(
-            dstptr, B + thdp.loc[0] * ldb + thdp.loc[1], thdp.size[0], thdp.size[1], rowpad, colpad, dststep, ldb);
-        utils::afree(dequant);
-      }
-    });
-  }
-
-  static void unpackWeight(const int N, const int K, StorageWeight* stor, int8_t* B, const int ldb,
-                           parallel::IThreading* threading) {
+  template <typename T>
+  AUTOCALL void unpackWeight(const int N, const int K, StorageWeight* stor, T* B, const int ldb,
+                             parallel::IThreading* threading) {
     parallel::Scheduler2D _para({threading->num_threads(), K, N, _GemmCore_T::KTILE, _GemmCore_T::NTILE});
     threading->parallel_for([&](int tidx) {
       parallel::ThreadProblem2D thdp{tidx};
@@ -216,21 +196,31 @@ class WeightKBlockNInteger {
       if (thdp.valid) {
         auto rowpad = utils::padto(thdp.size[0], _GemmCore_T::KTILE);
         auto colpad = utils::padto(thdp.size[1], _GemmCore_T::NTILE);
-        auto dequant = utils::amalloc<int8_t>((size_t)rowpad * colpad);
+        auto dequant = utils::amalloc<T>((size_t)rowpad * colpad);
         auto dstptr = dequant;
         int dststep = 0;
         size_t constexpr CacheSize = size_t(100) << 10;
         int8_t tmpcache[CacheSize];
-        getWeight(&dstptr, &dststep, rowpad, colpad, thdp.loc[0], thdp.loc[1], {stor}, tmpcache, CacheSize);
-        kernel::wrapper::RevertPaddingInterleaveMN<_GemmCore_T::NTILE, _GemmCore_T::PACK_ROW>::template forward<ISA_T>(
+        GetCPUDevice();
+        if (_cd->AVX512F()) {
+          getWeight<BTLA_ISA::AVX512F>(&dstptr, &dststep, rowpad, colpad, thdp.loc[0], thdp.loc[1], {stor}, tmpcache,
+                                       CacheSize);
+        } else if (_cd->AVX2()) {
+          getWeight<BTLA_ISA::AVX2>(&dstptr, &dststep, rowpad, colpad, thdp.loc[0], thdp.loc[1], {stor}, tmpcache,
+                                    CacheSize);
+        } else {
+          getWeight<BTLA_ISA::NoSIMD>(&dstptr, &dststep, rowpad, colpad, thdp.loc[0], thdp.loc[1], {stor}, tmpcache,
+                                      CacheSize);
+        }
+        kernel::wrapper::RevertPaddingInterleaveMN<_GemmCore_T::NTILE, _GemmCore_T::PACK_ROW, T>::forward_auto(
             dstptr, B + thdp.loc[0] * ldb + thdp.loc[1], thdp.size[0], thdp.size[1], rowpad, colpad, dststep, ldb);
         utils::afree(dequant);
       }
     });
   }
 
-  static void setQuantCorrection(const int N, const int K, const int8_t* zero_points, const float* scales,
-                                 StorageWeight* stor, parallel::IThreading* threading) {
+  AUTOCALL void setQuantCorrection(const int N, const int K, const int8_t* zero_points, const float* scales,
+                                   StorageWeight* stor, parallel::IThreading* threading) {
     int rawnk_scale = utils::updiv(K, stor->mBlockSize);
     int nk_scale = utils::updiv(stor->mKPad, stor->mBlockSize);
     parallel::Scheduler2D _para({threading->num_threads(), 1, nk_scale, 1, 1});
@@ -323,7 +313,7 @@ class WeightKBlockNInteger {
     }
   }
 
-  static void setShuffleIndices(const int* groupindices, StorageWeight* stor, parallel::IThreading* threading) {
+  AUTOCALL void setShuffleIndices(const int* groupindices, StorageWeight* stor, parallel::IThreading* threading) {
     auto groupsize = utils::updiv(stor->mK, stor->mBlockSize);
     parallel::Scheduler2D _para({threading->num_threads(), 1, groupsize, 1, 1});
     auto countptr = utils::amalloc<int>(groupsize);
@@ -333,7 +323,7 @@ class WeightKBlockNInteger {
       _para.getIndex(thdp);
       if (thdp.valid) {
         auto siptr = stor->ShfIndice();
-        for (size_t i = 0; i < stor->mK; i++) {
+        for (int i = 0; i < stor->mK; i++) {
           if (groupindices[i] >= thdp.loc[1] && groupindices[i] < thdp.loc[1] + thdp.size[1]) {
             siptr[groupindices[i] * stor->mBlockSize + countptr[groupindices[i]]] = i;
             countptr[groupindices[i]]++;
@@ -344,8 +334,8 @@ class WeightKBlockNInteger {
     utils::afree(countptr);
   }
 
-  static void setTransposeQuantCorrection(const int N, const int K, const int8_t* zero_points, const float* scales,
-                                          StorageWeight* stor, parallel::IThreading* threading) {
+  AUTOCALL void setTransposeQuantCorrection(const int N, const int K, const int8_t* zero_points, const float* scales,
+                                            StorageWeight* stor, parallel::IThreading* threading) {
     int rawnk_scale = utils::updiv(K, stor->mBlockSize);
     int nk_scale = utils::updiv(stor->mKPad, stor->mBlockSize);
     parallel::Scheduler2D _para({threading->num_threads(), 1, nk_scale, 1, 1});
@@ -357,7 +347,7 @@ class WeightKBlockNInteger {
           if (scales) {
             for (int i = thdp.loc[1]; i < thdp.loc[1] + thdp.size[1]; i++) {
               if (i < rawnk_scale) {
-                for (size_t j = 0; j < N; j++) {
+                for (int j = 0; j < N; j++) {
                   stor->template SPtr<float>()[i * stor->mNPad + j] = scales[j * rawnk_scale + i];
                 }
               } else {
@@ -375,7 +365,7 @@ class WeightKBlockNInteger {
           if (scales) {
             for (int i = thdp.loc[1]; i < thdp.loc[1] + thdp.size[1]; i++) {
               if (i < rawnk_scale) {
-                for (size_t j = 0; j < N; j++) {
+                for (int j = 0; j < N; j++) {
                   stor->template SPtr<utils::bf16>()[i * stor->mNPad + j] = utils::bf16(scales[j * rawnk_scale + i]);
                 }
               } else {
@@ -393,7 +383,7 @@ class WeightKBlockNInteger {
           if (scales) {
             for (int i = thdp.loc[1]; i < thdp.loc[1] + thdp.size[1]; i++) {
               if (i < rawnk_scale) {
-                for (size_t j = 0; j < N; j++) {
+                for (int j = 0; j < N; j++) {
                   stor->template SPtr<utils::f8>()[i * stor->mNPad + j] = scales[j * rawnk_scale + i];
                 }
               } else {
@@ -413,7 +403,7 @@ class WeightKBlockNInteger {
         if (thdp.valid) {
           for (int i = thdp.loc[1]; i < thdp.loc[1] + thdp.size[1]; i++) {
             if (i < rawnk_scale) {
-              for (size_t j = 0; j < N; j++) {
+              for (int j = 0; j < N; j++) {
                 stor->template ZPtr<int8_t>()[i * stor->mNPad + j] = zero_points[j * rawnk_scale + i];
               }
             } else {
@@ -424,8 +414,8 @@ class WeightKBlockNInteger {
       });
   }
 
-  void packQWeight(const int N, const int K, const int8_t* B, const int ldb, const float* scales,
-                   const int8_t* zero_points, StorageWeight* stor, parallel::IThreading* threading) {
+  AUTOCALL void packQWeight(const int N, const int K, const int8_t* B, const int ldb, const float* scales,
+                            const int8_t* zero_points, StorageWeight* stor, parallel::IThreading* threading) {
     if (stor->SDtype() == BTLA_DTYPE::DQ8_BNB) assert(stor->mDqBlockSize != 0);
     if (stor->IsDoubleQuant()) {
       int nk_scale = utils::updiv(K, stor->mBlockSize);
@@ -435,7 +425,7 @@ class WeightKBlockNInteger {
       setDoubleQuantCorrection(&dq_buf, stor);
     }
     setQuantCorrection(N, K, zero_points, scales, stor, threading);
-    if (stor->mDType == BTLA_DTYPE::S8 || stor->mDType == BTLA_DTYPE::F8_E4M3 || stor->mDType == BTLA_DTYPE::F8_E5M2) {
+    if (stor->mDType == BTLA_DTYPE::S8) {
       reorderWeight(N, K, B, ldb, stor->WPtr<int8_t>(), threading);
     } else {
       auto reordered = utils::amalloc<int8_t>((size_t)stor->mKPad * stor->mNPad);
@@ -446,9 +436,9 @@ class WeightKBlockNInteger {
     reduceWeight(stor, threading);
   }
 
-  virtual void packNbitsWeightQ4(const int N, const int K, bool isasym, const uint8_t* B, const int ldb,
-                                 const float* scales, const uint8_t* zero_points, void* ptr,
-                                 parallel::IThreading* threading) {
+  AUTOCALL void packNbitsWeightQ4(const int N, const int K, bool isasym, const uint8_t* B, const int ldb,
+                                  const float* scales, const uint8_t* zero_points, void* ptr,
+                                  parallel::IThreading* threading) {
     auto stor = reinterpret_cast<StorageWeight*>(ptr);
     auto tmp = utils::amalloc<float>(static_cast<size_t>(stor->mKPad) * stor->mNPad);
     auto blks = utils::updiv(K, stor->mBlockSize);
@@ -500,7 +490,7 @@ class WeightKBlockNInteger {
     utils::afree(tmp);
   }
 
-  void reduceWeight(StorageWeight* stor, parallel::IThreading* threading) {
+  AUTOCALL void reduceWeight(StorageWeight* stor, parallel::IThreading* threading) {
     if (stor->HasReduce()) {
       auto deq = utils::amalloc<float>((size_t)stor->mK * stor->mN);
       unpackWeight(stor->mN, stor->mK, stor, deq, stor->mN, threading);
@@ -517,8 +507,8 @@ class WeightKBlockNInteger {
     }
   }
 
-  void quantizeWeight(const int N, const int K, const float* B, const int ldb, int8_t* qB, float* scales,
-                      int8_t* zero_points, void* stor, parallel::IThreading* threading) {
+  AUTOCALL void quantizeWeight(const int N, const int K, const float* B, const int ldb, int8_t* qB, float* scales,
+                               int8_t* zero_points, void* stor, parallel::IThreading* threading) {
     auto ptr = reinterpret_cast<StorageWeight*>(stor);
     int bsize = ptr->mBlockSize == -1 ? K : ptr->mBlockSize;
     parallel::Scheduler2D _para({threading->num_threads(), K, N, bsize, 16});
@@ -526,15 +516,17 @@ class WeightKBlockNInteger {
       parallel::ThreadProblem2D thdp({tidx});
       _para.getIndex(thdp);
       if (thdp.valid) {
-        quantRowBlock(B + thdp.loc[0] * ldb + thdp.loc[1], qB + thdp.loc[0] * N + thdp.loc[1], thdp.size[0],
-                      thdp.size[1], ldb, N, scales + thdp.loc[0] / bsize * N + thdp.loc[1],
-                      zero_points == nullptr ? zero_points : zero_points + thdp.loc[0] / bsize * N + thdp.loc[1], ptr);
+        kernel::wrapper::QuantizeSignIntRowBlock::forward_auto(
+            B + thdp.loc[0] * ldb + thdp.loc[1], qB + thdp.loc[0] * N + thdp.loc[1], thdp.size[0], thdp.size[1], ldb, N,
+            scales + thdp.loc[0] / bsize * N + thdp.loc[1],
+            zero_points == nullptr ? zero_points : zero_points + thdp.loc[0] / bsize * N + thdp.loc[1], ptr->mBlockSize,
+            ptr->mDType);
       }
     });
   }
 
-  static void reorderWeight(const int N, const int K, const int8_t* B, const int ldb, int8_t* dstptr,
-                            parallel::IThreading* threading) {
+  AUTOCALL void reorderWeight(const int N, const int K, const int8_t* B, const int ldb, int8_t* dstptr,
+                              parallel::IThreading* threading) {
     int KPad = utils::padto(K, _GemmCore_T::KTILE);
     parallel::Scheduler2D _para({threading->num_threads(), K, N, _GemmCore_T::KTILE, _GemmCore_T::NTILE});
     threading->parallel_for([&](int tidx) {
@@ -546,8 +538,8 @@ class WeightKBlockNInteger {
         const auto src = B + thdp.loc[0] * ldb + thdp.loc[1];
         const auto dst = dstptr + thdp.loc[0] * _GemmCore_T::NTILE + thdp.loc[1] * KPad;
         using PaddingInterleaveMNWType =
-            kernel::wrapper::PaddingInterleaveMN<_GemmCore_T::NTILE, _GemmCore_T::PACK_ROW>;
-        auto ret = PaddingInterleaveMNWType::template forward<ISA_T>(  //
+            kernel::wrapper::PaddingInterleaveMN<_GemmCore_T::NTILE, _GemmCore_T::PACK_ROW, int8_t>;
+        auto ret = PaddingInterleaveMNWType::forward_auto(  //
             src, dst, thdp.size[0], thdp.size[1], rowpadded, colpadded, ldb, KPad);
         assert(ret == BTLA_CODE::Success);
         (void)ret;
@@ -555,45 +547,45 @@ class WeightKBlockNInteger {
     });
   }
 
-  static void compressBit3Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
-                                 parallel::IThreading* threading) {
+  AUTOCALL void compressBit3Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
+                                   parallel::IThreading* threading) {
     auto bit1_offset = size_t(N) * K;
     auto bit2ptr = reinterpret_cast<utils::bit2x4*>(dstptr);
     auto bit1ptr = reinterpret_cast<utils::bit1x8*>(dstptr + bit1_offset / 4);
-    auto ret = kernel::wrapper::CompressBit3::forward<ISA_T>(B, bit2ptr, bit1ptr, bit1_offset);
+    auto ret = kernel::wrapper::CompressBit3::forward_auto(B, bit2ptr, bit1ptr, bit1_offset);
     assert(ret == BTLA_CODE::Success);
   }
 
-  static void compressBit5Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
-                                 parallel::IThreading* threading) {
+  AUTOCALL void compressBit5Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
+                                   parallel::IThreading* threading) {
     auto bit1_offset = size_t(N) * K;
     auto bit4ptr = reinterpret_cast<utils::bit4x2*>(dstptr);
     auto bit1ptr = reinterpret_cast<utils::bit1x8*>(dstptr + bit1_offset / 2);
-    auto ret = kernel::wrapper::CompressBit5::forward<ISA_T>(B, bit4ptr, bit1ptr, bit1_offset);
+    auto ret = kernel::wrapper::CompressBit5::forward_auto(B, bit4ptr, bit1ptr, bit1_offset);
     assert(ret == BTLA_CODE::Success);
   }
 
-  static void compressBit6Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
-                                 parallel::IThreading* threading) {
+  AUTOCALL void compressBit6Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
+                                   parallel::IThreading* threading) {
     auto bit2_offset = size_t(N) * K;
     auto bit4ptr = reinterpret_cast<utils::bit4x2*>(dstptr);
     auto bit2ptr = reinterpret_cast<utils::bit2x4*>(dstptr + bit2_offset / 2);
-    auto ret = kernel::wrapper::CompressBit6::forward<ISA_T>(B, bit4ptr, bit2ptr, bit2_offset);
+    auto ret = kernel::wrapper::CompressBit6::forward_auto(B, bit4ptr, bit2ptr, bit2_offset);
     assert(ret == BTLA_CODE::Success);
   }
 
-  static void compressBit7Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
-                                 parallel::IThreading* threading) {
+  AUTOCALL void compressBit7Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
+                                   parallel::IThreading* threading) {
     auto eltsize = size_t(N) * K;
     auto bit4ptr = reinterpret_cast<utils::bit4x2*>(dstptr);
     auto bit2ptr = reinterpret_cast<utils::bit2x4*>(bit4ptr + eltsize / 2);
     auto bit1ptr = reinterpret_cast<utils::bit1x8*>(bit2ptr + eltsize / 4);
-    auto ret = kernel::wrapper::CompressBit7::forward<ISA_T>(B, bit4ptr, bit2ptr, bit1ptr, eltsize);
+    auto ret = kernel::wrapper::CompressBit7::forward_auto(B, bit4ptr, bit2ptr, bit1ptr, eltsize);
     assert(ret == BTLA_CODE::Success);
   }
 
-  static void compressBit2Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
-                                 parallel::IThreading* threading) {
+  AUTOCALL void compressBit2Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
+                                   parallel::IThreading* threading) {
     // TODO(zhe): 1D parallel compress
     parallel::Scheduler2D _para({threading->num_threads(), 1, K * N, 1, 64});
     auto bit2ptr = reinterpret_cast<utils::bit2x4*>(dstptr);
@@ -602,15 +594,15 @@ class WeightKBlockNInteger {
       _para.getIndex(thdp);
       if (thdp.valid) {
         auto ret =
-            kernel::wrapper::CompressBit2::forward<ISA_T>(B + thdp.loc[1], bit2ptr + thdp.loc[1] / 4, thdp.size[1]);
+            kernel::wrapper::CompressBit2::forward_auto(B + thdp.loc[1], bit2ptr + thdp.loc[1] / 4, thdp.size[1]);
         assert(ret == BTLA_CODE::Success);
         (void)ret;
       }
     });
   }
 
-  static void compressBit1Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
-                                 parallel::IThreading* threading) {
+  AUTOCALL void compressBit1Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
+                                   parallel::IThreading* threading) {
     // TODO(zhe): 1D parallel compress
     parallel::Scheduler2D _para({threading->num_threads(), 1, K * N, 1, 64});
     auto bit1ptr = reinterpret_cast<utils::bit1x8*>(dstptr);
@@ -619,15 +611,15 @@ class WeightKBlockNInteger {
       _para.getIndex(thdp);
       if (thdp.valid) {
         auto ret =
-            kernel::wrapper::CompressBit1::forward<ISA_T>(B + thdp.loc[1], bit1ptr + thdp.loc[1] / 8, thdp.size[1]);
+            kernel::wrapper::CompressBit1::forward_auto(B + thdp.loc[1], bit1ptr + thdp.loc[1] / 8, thdp.size[1]);
         assert(ret == BTLA_CODE::Success);
         (void)ret;
       }
     });
   }
 
-  static void compressBit4Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
-                                 parallel::IThreading* threading) {
+  AUTOCALL void compressBit4Weight(const int N, const int K, const int8_t* B, int8_t* dstptr, BTLA_DTYPE qtype,
+                                   parallel::IThreading* threading) {
     parallel::Scheduler2D _para({threading->num_threads(), 1, K * N, 1, 64});
     threading->parallel_for([&](int tidx) {
       parallel::ThreadProblem2D thdp({tidx});
@@ -636,10 +628,10 @@ class WeightKBlockNInteger {
         BTLA_CODE ret = BTLA_CODE::NotSupport;
         if (qtype == BTLA_DTYPE::S4_CLIP) {
           auto bit4ptr = reinterpret_cast<utils::int4x2*>(dstptr);
-          ret = kernel::wrapper::CompressS8S4::forward<ISA_T>(B + thdp.loc[1], bit4ptr + thdp.loc[1] / 2, thdp.size[1]);
+          ret = kernel::wrapper::CompressS8S4::forward_auto(B + thdp.loc[1], bit4ptr + thdp.loc[1] / 2, thdp.size[1]);
         } else if (qtype == BTLA_DTYPE::F4_BNB || qtype == BTLA_DTYPE::F4_NF4 || qtype == BTLA_DTYPE::F4_E2M1) {
           auto bit4ptr = reinterpret_cast<utils::f4x2*>(dstptr);
-          ret = kernel::wrapper::CompressFp4::forward<ISA_T>(B + thdp.loc[1], bit4ptr + thdp.loc[1] / 2, thdp.size[1]);
+          ret = kernel::wrapper::CompressFp4::forward_auto(B + thdp.loc[1], bit4ptr + thdp.loc[1] / 2, thdp.size[1]);
         } else {
           assert(0);
         }
@@ -648,8 +640,8 @@ class WeightKBlockNInteger {
       }
     });
   }
-  static void compressWeight(const int N, const int K, const int8_t* B, const int ldb, int8_t* dstptr, BTLA_DTYPE qtype,
-                             parallel::IThreading* threading) {
+  AUTOCALL void compressWeight(const int N, const int K, const int8_t* B, const int ldb, int8_t* dstptr,
+                               BTLA_DTYPE qtype, parallel::IThreading* threading) {
     if (qtype == BTLA_DTYPE::S7_CLIP) return compressBit7Weight(N, K, B, dstptr, qtype, threading);
     if (qtype == BTLA_DTYPE::S6_CLIP) return compressBit6Weight(N, K, B, dstptr, qtype, threading);
     if (qtype == BTLA_DTYPE::S5_CLIP) return compressBit5Weight(N, K, B, dstptr, qtype, threading);
@@ -662,8 +654,8 @@ class WeightKBlockNInteger {
   }
 
   template <typename RED_T>
-  static void reduce(const int N, const int K, const int KBlock, const float* B, const int ldb, RED_T* rptr,
-                     const int ldr, parallel::IThreading* threading) {
+  AUTOCALL void reduce(const int N, const int K, const int KBlock, const float* B, const int ldb, RED_T* rptr,
+                       const int ldr, parallel::IThreading* threading) {
     parallel::Scheduler2D _para({threading->num_threads(), K, N, KBlock, 16});
     threading->parallel_for([&](int tidx) {
       parallel::ThreadProblem2D thdp({tidx});
@@ -674,8 +666,7 @@ class WeightKBlockNInteger {
         using RowReduceSum = kernel::wrapper::RowReduceSum<RED_T>;
         for (int i = 0; i < thdp.size[0]; i += KBlock) {
           int rowremain = utils::remainsize(thdp.loc[0] + i, K, KBlock);
-          auto ret = RowReduceSum::template forward<ISA_T>(  //
-              src + i * ldb, ldb, rowremain, thdp.size[1], dst + i / KBlock * ldr);
+          auto ret = RowReduceSum::forward_auto(src + i * ldb, ldb, rowremain, thdp.size[1], dst + i / KBlock * ldr);
           assert(ret == BTLA_CODE::Success);
           (void)ret;
         }
@@ -684,43 +675,42 @@ class WeightKBlockNInteger {
   }
 
  public:
-  virtual inline BTLA_CODE getWeight(float** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                     const Param& _param, void* tmpcache, size_t cachesize) {
-    return getFpWeight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
-  }
-
-  virtual inline BTLA_CODE getWeight(utils::bf16** dstptr, int* dststep, int k_size, int n_size, int k_offset,
-                                     int n_offset, const Param& _param, void* tmpcache, size_t cachesize) {
-    return getFpWeight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+  template <BTLA_ISA ISA_T, typename _T>
+  static inline BTLA_CODE getWeight(_T** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                                    const Param& _param, void* tmpcache, size_t cachesize) {
+    if constexpr (std::is_same_v<_T, int8_t>) {
+      return getQWeight<ISA_T>(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+    }
+    return getFpWeight<ISA_T>(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
   }
 
-  static inline BTLA_CODE getWeight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                    const Param& _param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getQWeight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                               const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
     if (wptr->mDType == BTLA_DTYPE::S8) {
-      return getQ8Weight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+      return getQ8Weight<ISA_T>(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
     } else if (wptr->mDType == BTLA_DTYPE::S6_CLIP) {
-      return getQ6Weight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+      return getQ6Weight<ISA_T>(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
     } else if (wptr->mDType == BTLA_DTYPE::S5_CLIP) {
-      return getQ5Weight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+      return getQ5Weight<ISA_T>(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
     } else if (wptr->mDType == BTLA_DTYPE::S4_CLIP) {
-      return getQ4Weight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+      return getQ4Weight<ISA_T>(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
     } else if (wptr->mDType == BTLA_DTYPE::S3_CLIP) {
-      return getQ3Weight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+      return getQ3Weight<ISA_T>(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
     } else if (wptr->mDType == BTLA_DTYPE::S2_CLIP) {
-      return getQ2Weight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+      return getQ2Weight<ISA_T>(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
     } else if (wptr->mDType == BTLA_DTYPE::S7_CLIP) {
-      return getQ7Weight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+      return getQ7Weight<ISA_T>(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
     } else if (wptr->mDType == BTLA_DTYPE::S1_CLIP) {
-      return getQ1Weight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+      return getQ1Weight<ISA_T>(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
     } else {
       assert(0);
     }
     return BTLA_CODE::NotSupport;
   }
 
-  static inline BTLA_CODE getScale(float** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                   const Param& _param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getScale(float** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                             const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
     if (wptr->SDtype() == BTLA_DTYPE::F32) {
       auto aptr = wptr->template SPtr<float>();
@@ -739,7 +729,7 @@ class WeightKBlockNInteger {
     if (wptr->SDtype() == BTLA_DTYPE::DQ8_BNB) {
       auto aptr = wptr->template SPtr<uint8_t>();
       auto internal_k_offset = k_offset / wptr->mBlockSize;
-      auto dq_offset_idx = wptr->mCorrection.mDQCorrectionBuf.mBufSize / sizeof(float) - 1;
+      auto dq_offset_idx = static_cast<int>(wptr->mCorrection.mDQCorrectionBuf.mBufSize / sizeof(float) - 1);
       kernel::wrapper::Dq8GetScale::template forward<ISA_T>(
           aptr + internal_k_offset * wptr->CStep() + n_offset, *dstptr, utils::updiv(k_size, wptr->mBlockSize), n_size,
           internal_k_offset * wptr->mN + n_offset, wptr->mDqBlockSize, dq_offset_idx, wptr->DQPtr<float>(),
@@ -748,8 +738,8 @@ class WeightKBlockNInteger {
     return BTLA_CODE::Success;
   }
 
-  static inline BTLA_CODE getReduce(float** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                    const Param& _param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getReduce(float** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                              const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
     if (wptr->RDtype() == BTLA_DTYPE::F32) {
       auto aptr = wptr->template RPtr<float>();
@@ -769,7 +759,7 @@ class WeightKBlockNInteger {
   }
 
  protected:
-  template <typename _T>
+  template <BTLA_ISA ISA_T, typename _T>
   static inline BTLA_CODE getFpWeight(_T** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
                                       const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
@@ -876,8 +866,8 @@ class WeightKBlockNInteger {
     return BTLA_CODE::Success;
   }
 
-  static inline BTLA_CODE getQ8Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                      const Param& _param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getQ8Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                                const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->template WPtr<int8_t>() + n_offset * KPad + k_offset * _GemmCore_T::NTILE;
@@ -888,8 +878,8 @@ class WeightKBlockNInteger {
     return BTLA_CODE::Success;
   }
 
-  static inline BTLA_CODE getQ4Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                      const Param& _param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getQ4Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                                const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
     auto KPad = wptr->mKPad;
     auto bptr = wptr->template WPtr<utils::int4x2>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2;
@@ -907,8 +897,8 @@ class WeightKBlockNInteger {
     return BTLA_CODE::Success;
   }
 
-  static inline BTLA_CODE getQ3Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                      const Param& _param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getQ3Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                                const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
     int8_t* bit3_ptr = wptr->template WPtr<int8_t>();
     auto zpptr = wptr->template ZPtr<int8_t>();
@@ -929,8 +919,8 @@ class WeightKBlockNInteger {
     return BTLA_CODE::Success;
   }
 
-  static inline BTLA_CODE getQ5Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                      const Param& _param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getQ5Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                                const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
     int8_t* bit5_ptr = wptr->template WPtr<int8_t>();
     auto zpptr = wptr->template ZPtr<int8_t>();
@@ -951,8 +941,8 @@ class WeightKBlockNInteger {
     return BTLA_CODE::Success;
   }
 
-  static inline BTLA_CODE getQ6Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                      const Param& _param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getQ6Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                                const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
     int8_t* bit6_ptr = wptr->template WPtr<int8_t>();
     auto zpptr = wptr->template ZPtr<int8_t>();
@@ -973,8 +963,8 @@ class WeightKBlockNInteger {
     return BTLA_CODE::Success;
   }
 
-  static inline BTLA_CODE getQ7Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                      const Param& _param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getQ7Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                                const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
     int8_t* bit6_ptr = wptr->template WPtr<int8_t>();
     auto zpptr = wptr->template ZPtr<int8_t>();
@@ -996,8 +986,8 @@ class WeightKBlockNInteger {
     return BTLA_CODE::Success;
   }
 
-  static inline BTLA_CODE getQ2Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                      const Param& _param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getQ2Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                                const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
     int8_t* bit2_ptr = wptr->template WPtr<int8_t>();
     int8_t* zpptr = wptr->template ZPtr<int8_t>();
@@ -1016,8 +1006,8 @@ class WeightKBlockNInteger {
     return BTLA_CODE::Success;
   }
 
-  static inline BTLA_CODE getQ1Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                      const Param& _param, void* tmpcache, size_t cachesize) {
+  TLACALL BTLA_CODE getQ1Weight(int8_t** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                                const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = _param.packedW;
     int8_t* bit1_ptr = wptr->template WPtr<int8_t>();
     int8_t* zpptr = wptr->template ZPtr<int8_t>();
@@ -1035,27 +1025,19 @@ class WeightKBlockNInteger {
     *dststep = k_size;
     return BTLA_CODE::Success;
   }
-
-  virtual inline void quantRowBlock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
-                                    float* scales, int8_t* zero_points, void* stor) {
-    auto ptr = reinterpret_cast<StorageWeight*>(stor);
-    auto quant_dtype = ptr->mDType;
-    kernel::wrapper::QuantizeSignIntRowBlock::forward<ISA_T>(srcptr, dstptr, row, col, ld_src, ld_dst, scales,
-                                                             zero_points, ptr->mBlockSize, quant_dtype);
-  }
 };
 
 struct ParamWeightKBlockNFloat {
   storage::gemm::StorageWeightKBlockNFloat* packedW;
 };
 
-template <class _GemmCore_T, BTLA_ISA ISA_T>
-class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
+template <class _GemmCore_T>
+class WeightKBlockNFloat {
  public:
-  using Param = ParamWeightKBlockNInteger;  // NFloat storage Param same with NInteger storage.
+  using Param = ParamWeightKBlockNFloat;  // NFloat storage Param same with NInteger storage.
   using StorageWeight = storage::gemm::StorageWeightKBlockNFloat;
-
-  StorageWeight createStorage(const int N, const int K, int blocksize, BTLA_DTYPE fT, BTLA_DTYPE scaT) {
+  using QuantBaseT = WeightKBlockNInteger<_GemmCore_T>;
+  AUTOCALL StorageWeight createStorage(const int N, const int K, int blocksize, BTLA_DTYPE fT, BTLA_DTYPE scaT) {
     int KPad = utils::padto(K, _GemmCore_T::KTILE);
     int NPad = utils::padto(N, _GemmCore_T::NTILE);
     StorageWeight tmp(_GemmCore_T::ID);
@@ -1063,19 +1045,212 @@ class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
     return tmp;
   }
 
-  inline BTLA_CODE getWeight(float** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                             const Param& _param, void* tmpcache, size_t cachesize) override {
-    return getFpWeight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+  AUTOCALL void packTransposeWeight(const int N, const int K, const float* B, const int ldb, StorageWeight* stor,
+                                    parallel::IThreading* threading) {
+    auto B_NT = utils::amalloc<float>(static_cast<size_t>(N) * K);
+    transposeWeight<float>(N, K, B, ldb, B_NT, N, threading);
+    packWeight(N, K, B_NT, N, stor, threading);
+    utils::afree(B_NT);
+  }
+
+  // from KxN f32 weight to packed N//NtilexKPadxNTile int8 weight
+  AUTOCALL void packWeight(const int N, const int K, const float* B, const int ldb, StorageWeight* ptr,
+                           parallel::IThreading* threading) {
+    auto tmpq = utils::amalloc<int8_t>(static_cast<size_t>(N) * K);
+    int nk_scale = utils::updiv(K, ptr->mBlockSize);
+    auto ssize = static_cast<size_t>(N) * nk_scale;
+    auto Tscales = utils::amalloc<float>(ssize);
+    auto Tzps = utils::amalloc<int8_t>(ptr->IsAsym() ? ssize : 0);
+    quantizeWeight(N, K, B, ldb, tmpq, Tscales, Tzps, ptr, threading);
+    packQWeight(N, K, tmpq, N, Tscales, Tzps, ptr, threading);
+    utils::afree(tmpq);
+    utils::afree(Tscales);
+    utils::afree(Tzps);
+  }
+
+  AUTOCALL void quantizeWeight(const int N, const int K, const float* B, const int ldb, int8_t* qB, float* scales,
+                               int8_t* zero_points, void* stor, parallel::IThreading* threading) {
+    auto ptr = reinterpret_cast<StorageWeight*>(stor);
+    int bsize = ptr->mBlockSize == -1 ? K : ptr->mBlockSize;
+    parallel::Scheduler2D _para({threading->num_threads(), K, N, bsize, 16});
+    threading->parallel_for([&](int tidx) {
+      parallel::ThreadProblem2D thdp({tidx});
+      _para.getIndex(thdp);
+      if (thdp.valid) {
+        quantRowBlock(B + thdp.loc[0] * ldb + thdp.loc[1], qB + thdp.loc[0] * N + thdp.loc[1], thdp.size[0],
+                      thdp.size[1], ldb, N, scales + thdp.loc[0] / bsize * N + thdp.loc[1], ptr);
+      }
+    });
   }
 
-  inline BTLA_CODE getWeight(utils::bf16** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                             const Param& _param, void* tmpcache, size_t cachesize) override {
-    return getFpWeight(dstptr, dststep, k_size, n_size, k_offset, n_offset, _param, tmpcache, cachesize);
+  // from packed N//NtilexKPadxNTile int8 weight to KxN f32 weight
+  AUTOCALL void unpackTransposeWeight(const int N, const int K, StorageWeight* stor, float* B, const int ldb,
+                                      parallel::IThreading* threading) {
+    auto B_NT = utils::amalloc<float>(static_cast<size_t>(N) * K);
+    unpackWeight(N, K, stor, B_NT, N, threading);
+    transposeWeight<float>(K, N, B_NT, N, B, ldb, threading);
+    utils::afree(B_NT);
   }
 
-  template <typename _DST_T>
-  inline BTLA_CODE getFpWeight(_DST_T** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                               const Param& _param, void* tmpcache, size_t cachesize) {
+  AUTOCALL void unpackWeight(const int N, const int K, StorageWeight* stor, float* B, const int ldb,
+                             parallel::IThreading* threading) {
+    parallel::Scheduler2D _para({threading->num_threads(), K, N, _GemmCore_T::KTILE, _GemmCore_T::NTILE});
+    threading->parallel_for([&](int tidx) {
+      parallel::ThreadProblem2D thdp{tidx};
+      _para.getIndex(thdp);
+      if (thdp.valid) {
+        auto rowpad = utils::padto(thdp.size[0], _GemmCore_T::KTILE);
+        auto colpad = utils::padto(thdp.size[1], _GemmCore_T::NTILE);
+        auto dequant = utils::amalloc<float>((size_t)rowpad * colpad);
+        auto dstptr = dequant;
+        int dststep = 0;
+        size_t constexpr CacheSize = size_t(100) << 10;
+        int8_t tmpcache[CacheSize];
+        GetCPUDevice();
+        if (_cd->AVX512F()) {
+          getWeight<BTLA_ISA::AVX512F>(&dstptr, &dststep, rowpad, colpad, thdp.loc[0], thdp.loc[1], {stor}, tmpcache,
+                                       CacheSize);
+        } else if (_cd->AVX2()) {
+          getWeight<BTLA_ISA::AVX2>(&dstptr, &dststep, rowpad, colpad, thdp.loc[0], thdp.loc[1], {stor}, tmpcache,
+                                    CacheSize);
+        } else {
+          getWeight<BTLA_ISA::NoSIMD>(&dstptr, &dststep, rowpad, colpad, thdp.loc[0], thdp.loc[1], {stor}, tmpcache,
+                                      CacheSize);
+        }
+        kernel::wrapper::RevertPaddingInterleaveMN<_GemmCore_T::NTILE, _GemmCore_T::PACK_ROW, float>::forward_auto(
+            dstptr, B + thdp.loc[0] * ldb + thdp.loc[1], thdp.size[0], thdp.size[1], rowpad, colpad, dststep, ldb);
+        utils::afree(dequant);
+      }
+    });
+  }
+
+  AUTOCALL void setDoubleQuantCorrection(utils::avector<float>* dq_buf, StorageWeight* ptr) {
+    if (ptr->SDtype() == BTLA_DTYPE::DQ8_BNB) {
+      auto packw_dqbuf_ptr = ptr->DQPtr<float>();
+      memcpy(packw_dqbuf_ptr, dq_buf->data(), dq_buf->size() * sizeof(float));
+    } else {
+      assert(0);
+    }
+  }
+
+  AUTOCALL void packQWeight(const int N, const int K, const int8_t* B, const int ldb, const float* scales,
+                            const int8_t* zero_points, StorageWeight* stor, parallel::IThreading* threading) {
+    if (stor->IsDoubleQuant()) {
+      int nk_scale = utils::updiv(K, stor->mBlockSize);
+      auto ssize = static_cast<size_t>(N) * nk_scale;
+      utils::avector<float> dq_buf;
+      QuantBaseT::doubleQuantScale(const_cast<float*>(scales), ssize, stor->mDqBlockSize, stor->SDtype(), &dq_buf);
+      setDoubleQuantCorrection(&dq_buf, stor);
+    }
+    setQuantCorrection(N, K, zero_points, scales, stor, threading);
+    if (stor->mDType == BTLA_DTYPE::F8_E4M3 || stor->mDType == BTLA_DTYPE::F8_E5M2) {
+      QuantBaseT::reorderWeight(N, K, B, ldb, stor->WPtr<int8_t>(), threading);
+    } else {
+      auto reordered = utils::amalloc<int8_t>((size_t)stor->mKPad * stor->mNPad);
+      QuantBaseT::reorderWeight(N, K, B, ldb, reordered, threading);
+      QuantBaseT::compressWeight(stor->mNPad, stor->mKPad, reordered, stor->mNPad, stor->WPtr<int8_t>(), stor->mDType,
+                                 threading);
+      utils::afree(reordered);
+    }
+  }
+
+  AUTOCALL void setQuantCorrection(const int N, const int K, const int8_t* zero_points, const float* scales,
+                                   StorageWeight* stor, parallel::IThreading* threading) {
+    int rawnk_scale = utils::updiv(K, stor->mBlockSize);
+    int nk_scale = utils::updiv(stor->mKPad, stor->mBlockSize);
+    parallel::Scheduler2D _para({threading->num_threads(), 1, nk_scale, 1, 1});
+    if (stor->SDtype() == BTLA_DTYPE::F32) {  // fp32 to fp32 direct copy
+      threading->parallel_for([&](int tidx) {
+        parallel::ThreadProblem2D thdp{tidx};
+        _para.getIndex(thdp);
+        if (thdp.valid) {
+          for (int i = thdp.loc[1]; i < thdp.loc[1] + thdp.size[1]; i++) {
+            if (i < rawnk_scale) {
+              if (scales != nullptr)
+                std::memcpy(stor->template SPtr<float>() + i * stor->mNPad, scales + i * N, N * sizeof(scales[0]));
+              if (zero_points != nullptr)
+                std::memcpy(stor->template ZPtr<int8_t>() + i * stor->mNPad, zero_points + i * N,
+                            N * sizeof(zero_points[0]));
+            } else {
+              if (scales != nullptr)
+                std::memset(stor->template SPtr<float>() + i * stor->mNPad, 0, stor->mNPad * sizeof(float));
+              if (zero_points != nullptr)
+                std::memset(stor->template ZPtr<int8_t>() + i * stor->mNPad, 0, stor->mNPad * sizeof(zero_points[0]));
+            }
+          }
+        }
+      });
+    } else if (stor->SDtype() == BTLA_DTYPE::BF16) {
+      threading->parallel_for([&](int tidx) {
+        parallel::ThreadProblem2D thdp{tidx};
+        _para.getIndex(thdp);
+        if (thdp.valid) {
+          for (int i = thdp.loc[1]; i < thdp.loc[1] + thdp.size[1]; i++) {
+            if (i < rawnk_scale) {
+              if (scales != nullptr) {
+                for (int j = 0; j < N; j++) {
+                  stor->template SPtr<utils::bf16>()[j + i * stor->mNPad] = static_cast<utils::bf16>(scales[i * N + j]);
+                }
+              }
+              if (zero_points != nullptr) {
+                std::memcpy(stor->template ZPtr<int8_t>() + i * stor->mNPad, zero_points + i * N,
+                            N * sizeof(zero_points[0]));
+              }
+            } else {
+              if (scales != nullptr)
+                std::memset(stor->template SPtr<utils::bf16>() + i * stor->mNPad, 0, stor->mNPad * sizeof(utils::bf16));
+              if (zero_points != nullptr)
+                std::memset(stor->template ZPtr<int8_t>() + i * stor->mNPad, 0, stor->mNPad * sizeof(zero_points[0]));
+            }
+          }
+        }
+      });
+    } else if (stor->SDtype() == BTLA_DTYPE::F8_E8M0) {
+      threading->parallel_for([&](int tidx) {
+        parallel::ThreadProblem2D thdp{tidx};
+        _para.getIndex(thdp);
+        if (thdp.valid) {
+          for (int i = thdp.loc[1]; i < thdp.loc[1] + thdp.size[1]; i++) {
+            if (i < rawnk_scale) {
+              if (scales != nullptr) {
+                for (int j = 0; j < N; j++) {
+                  stor->template SPtr<utils::f8>()[j + i * stor->mNPad] = static_cast<int8_t>(scales[i * N + j]);
+                }
+              }
+            } else {
+              if (scales != nullptr)
+                std::memset(stor->template SPtr<utils::f8>() + i * stor->mNPad, 0, stor->mNPad * sizeof(utils::f8));
+            }
+          }
+        }
+      });
+    } else if (stor->SDtype() == BTLA_DTYPE::DQ8_BNB) {
+      threading->parallel_for([&](int tidx) {
+        parallel::ThreadProblem2D thdp{tidx};
+        _para.getIndex(thdp);
+        if (thdp.valid) {
+          for (int i = thdp.loc[1]; i < thdp.loc[1] + thdp.size[1]; i++) {
+            if (i < rawnk_scale) {
+              if (scales != nullptr) {
+                for (int j = 0; j < N; j++) {
+                  stor->template SPtr<uint8_t>()[j + i * stor->mNPad] = static_cast<uint8_t>(scales[i * N + j]);
+                }
+              }
+            } else {
+              if (scales != nullptr)
+                std::memset(stor->template SPtr<uint8_t>() + i * stor->mNPad, 0, stor->mNPad * sizeof(uint8_t));
+            }
+          }
+        }
+      });
+    } else {
+      assert(0);
+    }
+  }
+
+  template <BTLA_ISA ISA_T, typename _T>
+  static inline BTLA_CODE getWeight(_T** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                                    const Param& _param, void* tmpcache, size_t cachesize) {
     auto wptr = reinterpret_cast<StorageWeight*>(_param.packedW);
     auto NPad = wptr->mNPad;
     auto KPad = wptr->mKPad;
@@ -1104,18 +1279,18 @@ class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
               ColSize, ColSize, ColSize, sptr, k_offset / _GemmCore_T::PACK_ROW,
               wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, wptr->mDType);
         } else if (wptr->mDType == BTLA_DTYPE::F4_NF4) {
-          kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float,
-                                                                                                 BTLA_DTYPE::F4_NF4>(
+          kernel::wrapper::DecompressKBlockF4Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float,
+                                                                                             BTLA_DTYPE::F4_NF4>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
         } else if (wptr->mDType == BTLA_DTYPE::F4_E2M1) {
-          kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float,
-                                                                                                 BTLA_DTYPE::F4_E2M1>(
+          kernel::wrapper::DecompressKBlockF4Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float,
+                                                                                             BTLA_DTYPE::F4_E2M1>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
         } else if (wptr->mDType == BTLA_DTYPE::F4_BNB) {
-          kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float,
-                                                                                                 BTLA_DTYPE::F4_BNB>(
+          kernel::wrapper::DecompressKBlockF4Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, float,
+                                                                                             BTLA_DTYPE::F4_BNB>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
         } else {
@@ -1126,18 +1301,18 @@ class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
         auto f4ptr = reinterpret_cast<utils::f4x2*>(bptr + i * KPad / 2);
         auto fp_ptr = *dstptr + i * k_size;
         if (wptr->mDType == BTLA_DTYPE::F4_NF4) {
-          kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16,
-                                                                                                 BTLA_DTYPE::F4_NF4>(
+          kernel::wrapper::DecompressKBlockF4Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16,
+                                                                                             BTLA_DTYPE::F4_NF4>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
         } else if (wptr->mDType == BTLA_DTYPE::F4_E2M1) {
-          kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16,
-                                                                                                 BTLA_DTYPE::F4_E2M1>(
+          kernel::wrapper::DecompressKBlockF4Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16,
+                                                                                             BTLA_DTYPE::F4_E2M1>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
         } else if (wptr->mDType == BTLA_DTYPE::F4_BNB) {
-          kernel::wrapper::DecompressKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16,
-                                                                                                 BTLA_DTYPE::F4_BNB>(
+          kernel::wrapper::DecompressKBlockF4Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T, utils::bf16,
+                                                                                             BTLA_DTYPE::F4_BNB>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, sptr,
               k_offset / _GemmCore_T::PACK_ROW, wptr->mBlockSize / _GemmCore_T::PACK_ROW, NPad, tmpcache, cachesize);
         } else {
@@ -1151,8 +1326,8 @@ class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
         auto internal_kblock = wptr->mBlockSize / _GemmCore_T::PACK_ROW;
         auto dq_offset_idx = static_cast<int>(wptr->mCorrection.mDQCorrectionBuf.mBufSize / sizeof(float) - 1);
         if (wptr->mDType == BTLA_DTYPE::F4_NF4) {
-          kernel::wrapper::DecompressDqKBlockF4Fp<_DST_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T,
-                                                                                                   BTLA_DTYPE::F4_NF4>(
+          kernel::wrapper::DecompressDqKBlockF4Fp<_T, _GemmCore_T::PACK_ROW>::template forward<ISA_T,
+                                                                                               BTLA_DTYPE::F4_NF4>(
               f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, wptr->template SPtr<uint8_t>(),
               wptr->template DQPtr<float>(), internal_k_offset, internal_n_offset, internal_kblock, wptr->mDqBlockSize,
               dq_offset_idx, NPad, wptr->mN, tmpcache, cachesize);
@@ -1167,65 +1342,25 @@ class WeightKBlockNFloat : public WeightKBlockNInteger<_GemmCore_T, ISA_T> {
     return BTLA_CODE::Success;
   }
 
-  template <typename T>
-  static inline BTLA_CODE getKBlockWeight(T** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                                          const Param& _param, void* tmpcache, size_t cachesize) {
-    auto wptr = reinterpret_cast<StorageWeight*>(_param.packedW);
-    auto NPad = wptr->mNPad;
-    auto KPad = wptr->mKPad;
-    char* bptr;
-    if (wptr->mDType == BTLA_DTYPE::F8_E4M3 || wptr->mDType == BTLA_DTYPE::F8_E5M2) {
-      bptr = wptr->template WPtr<char>() + n_offset * KPad + k_offset * _GemmCore_T::NTILE;
-    } else {
-      bptr = wptr->template WPtr<char>() + n_offset * KPad / 2 + k_offset * _GemmCore_T::NTILE / 2;
-    }
-    int constexpr ColSize = _GemmCore_T::NTILE * _GemmCore_T::PACK_ROW;
-    for (int i = 0; i < n_size; i += _GemmCore_T::NTILE) {
-      if (wptr->mDType == BTLA_DTYPE::F8_E4M3 || wptr->mDType == BTLA_DTYPE::F8_E5M2) {
-        kernel::wrapper::DecompressKBlockF8FpNoScale<T>::template forward<ISA_T>(
-            reinterpret_cast<utils::f8*>(bptr) + i * KPad, *dstptr + i * k_size, k_size / _GemmCore_T::PACK_ROW,
-            ColSize, ColSize, ColSize, tmpcache, cachesize, wptr->mDType);
-      } else {
-        auto f4ptr = reinterpret_cast<utils::f4x2*>(bptr + i * KPad / 2);
-        auto fp_ptr = *dstptr + i * k_size;
-        if (wptr->mDType == BTLA_DTYPE::F4_NF4) {
-          kernel::wrapper::DecompressKBlockF4FpNoscale<T>::template forward<ISA_T, BTLA_DTYPE::F4_NF4>(
-              f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
-        } else if (wptr->mDType == BTLA_DTYPE::F4_E2M1) {
-          kernel::wrapper::DecompressKBlockF4FpNoscale<T>::template forward<ISA_T, BTLA_DTYPE::F4_E2M1>(
-              f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
-        } else if (wptr->mDType == BTLA_DTYPE::F4_BNB) {
-          kernel::wrapper::DecompressKBlockF4FpNoscale<T>::template forward<ISA_T, BTLA_DTYPE::F4_BNB>(
-              f4ptr, fp_ptr, k_size / _GemmCore_T::PACK_ROW, ColSize, ColSize, ColSize, tmpcache, cachesize);
-        } else {
-          assert(0);
-        }
-      }
-    }
-    *dststep = k_size;
-    return BTLA_CODE::Success;
-  }
-
  protected:
-  void quantRowBlock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst, float* scales,
-                     int8_t* zero_points, void* stor) override {
-    auto ptr = reinterpret_cast<StorageWeight*>(stor);
+  AUTOCALL void quantRowBlock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                              float* scales, StorageWeight* ptr) {
     auto quant_dtype = ptr->mDType;
     if (quant_dtype == BTLA_DTYPE::F8_E4M3) {
-      kernel::wrapper::QuantizeF8RowBlock::forward<ISA_T, BTLA_DTYPE::F8_E4M3>(srcptr, dstptr, row, col, ld_src, ld_dst,
-                                                                               scales, ptr->mBlockSize, ptr->SDtype());
+      kernel::wrapper::QuantizeF8RowBlock<BTLA_DTYPE::F8_E4M3>::forward_auto(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                                             scales, ptr->mBlockSize, ptr->SDtype());
     } else if (quant_dtype == BTLA_DTYPE::F8_E5M2) {
-      kernel::wrapper::QuantizeF8RowBlock::forward<ISA_T, BTLA_DTYPE::F8_E5M2>(srcptr, dstptr, row, col, ld_src, ld_dst,
-                                                                               scales, ptr->mBlockSize, ptr->SDtype());
+      kernel::wrapper::QuantizeF8RowBlock<BTLA_DTYPE::F8_E5M2>::forward_auto(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                                             scales, ptr->mBlockSize, ptr->SDtype());
     } else if (quant_dtype == BTLA_DTYPE::F4_BNB) {
-      kernel::wrapper::QuantizeF4RowBlock::forward<ISA_T, BTLA_DTYPE::F4_BNB>(srcptr, dstptr, row, col, ld_src, ld_dst,
-                                                                              scales, zero_points, ptr->mBlockSize);
+      kernel::wrapper::QuantizeF4RowBlock<BTLA_DTYPE::F4_BNB>::forward_auto(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                                            scales, ptr->mBlockSize);
     } else if (quant_dtype == BTLA_DTYPE::F4_E2M1) {
-      kernel::wrapper::QuantizeF4RowBlock::forward<ISA_T, BTLA_DTYPE::F4_E2M1>(srcptr, dstptr, row, col, ld_src, ld_dst,
-                                                                               scales, zero_points, ptr->mBlockSize);
+      kernel::wrapper::QuantizeF4RowBlock<BTLA_DTYPE::F4_E2M1>::forward_auto(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                                             scales, ptr->mBlockSize);
     } else if (quant_dtype == BTLA_DTYPE::F4_NF4) {
-      kernel::wrapper::QuantizeF4RowBlock::forward<ISA_T, BTLA_DTYPE::F4_NF4>(srcptr, dstptr, row, col, ld_src, ld_dst,
-                                                                              scales, zero_points, ptr->mBlockSize);
+      kernel::wrapper::QuantizeF4RowBlock<BTLA_DTYPE::F4_NF4>::forward_auto(srcptr, dstptr, row, col, ld_src, ld_dst,
+                                                                            scales, ptr->mBlockSize);
     } else {
       assert(0);
     }
diff --git a/bestla/bestla/bestla_utils.h b/bestla/bestla/bestla_utils.h
index 67c59d00f..d346ecf88 100644
--- a/bestla/bestla/bestla_utils.h
+++ b/bestla/bestla/bestla_utils.h
@@ -96,6 +96,18 @@
 #define CompileAMXINT8() (CompileAMX())
 #endif
 
+// called by launcher, time critical functions
+#define TLACALL             \
+  template <BTLA_ISA ISA_T> \
+  static inline
+
+#define ISACALL             \
+  template <BTLA_ISA ISA_T> \
+  static
+
+// runtime auto-dispatch ISA, not time critical functions
+#define AUTOCALL static
+
 #include <immintrin.h>
 
 namespace bestla {
diff --git a/bestla/bestla/bestla_wrapper.h b/bestla/bestla/bestla_wrapper.h
index 00c7e8d40..04144e1da 100644
--- a/bestla/bestla/bestla_wrapper.h
+++ b/bestla/bestla/bestla_wrapper.h
@@ -258,14 +258,14 @@ class NBitsHelper {
 }  // namespace gemv_nbits
 
 namespace gemm {
-template <BTLA_ISA _RT_ISA_T, class _GemmCore_T, template <class _T, BTLA_ISA> class _PrologueA_T,
-          template <class _T, BTLA_ISA> class _PrologueB_T, class _Epilogue_T>
+template <class _GemmCore_T, template <class _T> class _PrologueA_T, template <class _T> class _PrologueB_T,
+          class _Epilogue_T>
 class LauncherBase {
  public:
   using GemmCore = _GemmCore_T;
-  static constexpr BTLA_ISA ISA = _RT_ISA_T;
-  using PrologueA = _PrologueA_T<GemmCore, _RT_ISA_T>;
-  using PrologueB = _PrologueB_T<GemmCore, _RT_ISA_T>;
+  static constexpr BTLA_ISA ISA = GemmCore::ISA;
+  using PrologueA = _PrologueA_T<GemmCore>;
+  using PrologueB = _PrologueB_T<GemmCore>;
   using Epilogue = _Epilogue_T;
   using AType = typename GemmCore::AType;
   using AParam = typename PrologueA::Param;
@@ -273,30 +273,24 @@ class LauncherBase {
   using BParam = typename PrologueB::Param;
   using CType = typename GemmCore::CType;
   using EpiParam = typename Epilogue::Param;
-  static_assert(GemmCore::ISA <= _RT_ISA_T, "RunTime ISA should cover GEMM's ISA");
   struct Param {
     const utils::GemmProblem problem;
     const AParam paramA;
     const BParam paramB;
     const EpiParam paramC;
   };
-  _GemmCore_T mGemmCore;
-  PrologueA mProA;
-  PrologueB mProB;
 
   class GEMVWrapper {
    public:
     static constexpr bool support() {
-      if constexpr (!std::is_same_v<PrologueB, prologue_b::gemm::WeightKBlockNInteger<_GemmCore_T, _RT_ISA_T>>) {
+      if constexpr (!std::is_same_v<PrologueB, prologue_b::gemm::WeightKBlockNInteger<_GemmCore_T>>) {
         return false;
       }
-      if constexpr (!std::is_same_v<PrologueA,
-                                    prologue_a::gemm::ShuffleActivationKBlockBaseF32<_GemmCore_T, _RT_ISA_T>> &&
-                    !std::is_same_v<PrologueA, prologue_a::gemm::ActivationKBlockBaseF32<_GemmCore_T, _RT_ISA_T>> &&
-                    !std::is_same_v<PrologueA, prologue_a::gemm::ActivationF32KBlockQuantize<_GemmCore_T, _RT_ISA_T>> &&
-                    !std::is_same_v<PrologueA,
-                                    prologue_a::gemm::ShuffleActivationKBlockQuantizeF32<_GemmCore_T, _RT_ISA_T>> &&
-                    !std::is_same_v<PrologueA, prologue_a::gemm::ActivationBase<_GemmCore_T, _RT_ISA_T>>) {
+      if constexpr (!std::is_same_v<PrologueA, prologue_a::gemm::ShuffleActivationKBlockBaseF32<_GemmCore_T>> &&
+                    !std::is_same_v<PrologueA, prologue_a::gemm::ActivationKBlockBaseF32<_GemmCore_T>> &&
+                    !std::is_same_v<PrologueA, prologue_a::gemm::ActivationF32KBlockQuantize<_GemmCore_T>> &&
+                    !std::is_same_v<PrologueA, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32<_GemmCore_T>> &&
+                    !std::is_same_v<PrologueA, prologue_a::gemm::ActivationBase<_GemmCore_T>>) {
         return false;
       }
 
@@ -388,19 +382,18 @@ class LauncherBase {
             utils::GemvParamA paramA{
                 _param.paramA.quan->template APtr<uint8_t>(), _param.paramA.quan->template SPtr<float>(),
                 _param.paramA.quan->template ZPtr<uint8_t>(), _param.paramA.quan->mKPad, _param.paramA.quan->CStep()};
-            kernel::wrapper::GEMVWoqNBits::forward_u8s8_fp32<_RT_ISA_T, ScaleT, GemmCore::NTILE, MTILE>(
+            kernel::wrapper::GEMVWoqNBits::forward_u8s8_fp32<ISA, ScaleT, GemmCore::NTILE, MTILE>(
                 paramA, paramB, tmpc_ptr, GemmCore::NTILE, k, kblocksize, StackTmp, TmpSize);
             Epilogue::Fp32Epi::template forward<ISA>(tmpc_ptr, GemmCore::NTILE, 0, _config.loc[1] + in, MTILE,
                                                      GemmCore::NTILE, _param.paramC.param2, StackTmp, TmpSize);
           } else {
             const float* Aptr = _param.paramA.A;
-            if constexpr (std::is_same_v<PrologueA,
-                                         prologue_a::gemm::ShuffleActivationKBlockBaseF32<_GemmCore_T, _RT_ISA_T>>) {
+            if constexpr (std::is_same_v<PrologueA, prologue_a::gemm::ShuffleActivationKBlockBaseF32<_GemmCore_T>>) {
               if (_param.paramA.reordered && _param.paramA.reordered->template APtr<float>()) {
                 Aptr = _param.paramA.reordered->template APtr<float>();
               }
             }
-            kernel::wrapper::GEMVWoqNBits::forward_fp32_fp32<_RT_ISA_T, ScaleT, GemmCore::NTILE, MTILE>(
+            kernel::wrapper::GEMVWoqNBits::forward_fp32_fp32<ISA, ScaleT, GemmCore::NTILE, MTILE>(
                 Aptr, _param.paramA.lda, paramB, tmpc_ptr, GemmCore::NTILE, k, kblocksize, StackTmp, TmpSize);
             Epilogue::template forward<ISA>(tmpc_ptr, GemmCore::NTILE, 0, _config.loc[1] + in, MTILE, GemmCore::NTILE,
                                             _param.paramC, StackTmp, TmpSize);
@@ -412,19 +405,18 @@ class LauncherBase {
             utils::GemvParamA paramA{
                 _param.paramA.quan->template APtr<uint8_t>(), _param.paramA.quan->template SPtr<float>(),
                 _param.paramA.quan->template ZPtr<uint8_t>(), _param.paramA.quan->mKPad, _param.paramA.quan->CStep()};
-            kernel::wrapper::GEMVWoqNBits::forward_u8s8_fp32<_RT_ISA_T, ScaleT, GemmCore::NTILE, MTILE>(
+            kernel::wrapper::GEMVWoqNBits::forward_u8s8_fp32<ISA, ScaleT, GemmCore::NTILE, MTILE>(
                 paramA, paramB, tmpc_ptr, GemmCore::NTILE, k, kblocksize, StackTmp, TmpSize);
             Epilogue::Fp32Epi::template forward<ISA>(tmpc_ptr, GemmCore::NTILE, 0, _config.loc[1] + in, MTILE,
                                                      (_config.size[1] - in), _param.paramC.param2, StackTmp, TmpSize);
           } else {
             const float* Aptr = _param.paramA.A;
-            if constexpr (std::is_same_v<PrologueA,
-                                         prologue_a::gemm::ShuffleActivationKBlockBaseF32<_GemmCore_T, _RT_ISA_T>>) {
+            if constexpr (std::is_same_v<PrologueA, prologue_a::gemm::ShuffleActivationKBlockBaseF32<_GemmCore_T>>) {
               if (_param.paramA.reordered && _param.paramA.reordered->template APtr<float>()) {
                 Aptr = _param.paramA.reordered->template APtr<float>();
               }
             }
-            kernel::wrapper::GEMVWoqNBits::forward_fp32_fp32<_RT_ISA_T, ScaleT, GemmCore::NTILE, MTILE>(
+            kernel::wrapper::GEMVWoqNBits::forward_fp32_fp32<ISA, ScaleT, GemmCore::NTILE, MTILE>(
                 Aptr, _param.paramA.lda, paramB, tmpc_ptr, GemmCore::NTILE, k, kblocksize, StackTmp, TmpSize);
             Epilogue::template forward<ISA>(tmpc_ptr, GemmCore::NTILE, 0, _config.loc[1] + in, MTILE,
                                             (_config.size[1] - in), _param.paramC, StackTmp, TmpSize);
@@ -464,7 +456,7 @@ class LauncherBase {
     }
   };
 
-  void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
+  static void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
     if (GEMVWrapper::support() && GEMVWrapper::implemented(_param)) {
       GEMVWrapper::gemv(_param, _config);
     } else {
@@ -473,8 +465,8 @@ class LauncherBase {
   }
 
  protected:
-  void gemm(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
-    mGemmCore.configure(_config.size[0], _config.size[1], _param.problem.dims[3]);
+  static void gemm(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
+    GemmCore::configure(_config.size[0], _config.size[1], _param.problem.dims[3]);
     auto StackTmp = alloca(_config.stacksize);
     auto tmpB = reinterpret_cast<BType*>(StackTmp);
     tmpB = utils::cpu_pointer_align(tmpB);
@@ -493,8 +485,8 @@ class LauncherBase {
     }
   }
 
-  void run_block(const Param& _param, const parallel::gemm::ThreadProblemBase& _config, int blk_m, int blk_n,
-                 int blk_msize, int blk_nsize, AType* tmpA, BType* tmpB, CType* tmpC, void* tmpcache) {
+  static void run_block(const Param& _param, const parallel::gemm::ThreadProblemBase& _config, int blk_m, int blk_n,
+                        int blk_msize, int blk_nsize, AType* tmpA, BType* tmpB, CType* tmpC, void* tmpcache) {
     int n_padded = utils::padto(blk_nsize, GemmCore::NTILE);
     auto& K = _param.problem.dims[3];
     for (int iterk = 0; iterk < _param.problem.dims[3]; iterk += _config.block[2]) {
@@ -503,8 +495,8 @@ class LauncherBase {
       int k_paddedle = utils::padto_le(k_remain, GemmCore::KTILE);
       auto bptr_cache = tmpB;
       int bcache_step = 0;
-      mProB.getWeight(&bptr_cache, &bcache_step, k_padded, n_padded, iterk, _config.loc[1] + blk_n, _param.paramB,
-                      tmpcache, _config.tmpcachesize);
+      PrologueB::template getWeight<ISA>(&bptr_cache, &bcache_step, k_padded, n_padded, iterk, _config.loc[1] + blk_n,
+                                         _param.paramB, tmpcache, _config.tmpcachesize);
       int bcache_stride = bcache_step * sizeof(BType);
       for (int i = 0; i < blk_msize; i += GemmCore::MTILE) {
         int m_remain = utils::remainsize(i, blk_msize, GemmCore::MTILE);
@@ -513,9 +505,9 @@ class LauncherBase {
         if (k_paddedle) {
           AType* aptr_cache = tmpA;
           int acache_step = 0;
-          mProA.getActivation(&aptr_cache, &acache_step, _param.paramA, m_remain, k_paddedle,
-                              (blk_m + i + _config.loc[0]), iterk, tmpcache, _config.tmpcachesize);
-          mGemmCore.forward(aptr_cache, bptr_cache, cptr_cache, m_remain, n_padded, k_paddedle,
+          PrologueA::template getActivation<ISA>(&aptr_cache, &acache_step, _param.paramA, m_remain, k_paddedle,
+                                                 (blk_m + i + _config.loc[0]), iterk, tmpcache, _config.tmpcachesize);
+          GemmCore::forward(aptr_cache, bptr_cache, cptr_cache, m_remain, n_padded, k_paddedle,
                             acache_step * sizeof(AType), bcache_stride, ccache_stride, iterk, tmpcache,
                             _config.tmpcachesize);
         }
@@ -523,9 +515,10 @@ class LauncherBase {
         if (k_tail) {
           AType* aptr_cache = tmpA;
           int acache_step = 0;
-          mProA.getActivation(&aptr_cache, &acache_step, _param.paramA, m_remain, k_tail, (blk_m + i + _config.loc[0]),
-                              iterk + k_paddedle, tmpcache, _config.tmpcachesize);
-          mGemmCore.forward(aptr_cache, bptr_cache + k_paddedle * GemmCore::NTILE, cptr_cache, m_remain, n_padded,
+          PrologueA::template getActivation<ISA>(&aptr_cache, &acache_step, _param.paramA, m_remain, k_tail,
+                                                 (blk_m + i + _config.loc[0]), iterk + k_paddedle, tmpcache,
+                                                 _config.tmpcachesize);
+          GemmCore::forward(aptr_cache, bptr_cache + k_paddedle * GemmCore::NTILE, cptr_cache, m_remain, n_padded,
                             GemmCore::KTILE, acache_step * sizeof(AType), bcache_stride, ccache_stride,
                             iterk + k_paddedle, tmpcache, _config.tmpcachesize);
         }
@@ -536,14 +529,14 @@ class LauncherBase {
   }
 };
 
-template <BTLA_ISA _RT_ISA_T, class _GemmCore_T, template <class _T, BTLA_ISA> class _PrologueA_T,
-          template <class _T, BTLA_ISA> class _PrologueB_T, class _Epilogue_T>
+template <class _GemmCore_T, template <class _T> class _PrologueA_T, template <class _T> class _PrologueB_T,
+          class _Epilogue_T>
 class LauncherIntKBlock {
  public:
   using GemmCore = _GemmCore_T;
-  static constexpr BTLA_ISA ISA = _RT_ISA_T;
-  using PrologueA = _PrologueA_T<GemmCore, _RT_ISA_T>;
-  using PrologueB = _PrologueB_T<GemmCore, _RT_ISA_T>;
+  static constexpr BTLA_ISA ISA = GemmCore::ISA;
+  using PrologueA = _PrologueA_T<GemmCore>;
+  using PrologueB = _PrologueB_T<GemmCore>;
   using Epilogue = _Epilogue_T;
   using AType = typename GemmCore::AType;
   using AParam = typename PrologueA::Param;
@@ -552,26 +545,21 @@ class LauncherIntKBlock {
   using CType = typename GemmCore::CType;
   using EpiParam = typename Epilogue::Param;
   using AccType = float;
-  static_assert(GemmCore::ISA <= _RT_ISA_T, "RunTime ISA should cover GEMM's ISA");
   struct Param {
     const utils::GemmProblem problem;
     const AParam paramA;
     const BParam paramB;
     const EpiParam paramC;
   };
-  _GemmCore_T mGemmCore;
-  PrologueA mProA;
-  PrologueB mProB;
 
   class GEMVWrapper {
    public:
     static constexpr bool support() {
-      if constexpr (!std::is_same_v<PrologueB, prologue_b::gemm::WeightKBlockNInteger<_GemmCore_T, _RT_ISA_T>>) {
+      if constexpr (!std::is_same_v<PrologueB, prologue_b::gemm::WeightKBlockNInteger<_GemmCore_T>>) {
         return false;
       }
-      if constexpr (!std::is_same_v<PrologueA, prologue_a::gemm::ActivationF32KBlockQuantize<_GemmCore_T, _RT_ISA_T>> &&
-                    !std::is_same_v<PrologueA,
-                                    prologue_a::gemm::ShuffleActivationKBlockQuantizeF32<_GemmCore_T, _RT_ISA_T>>) {
+      if constexpr (!std::is_same_v<PrologueA, prologue_a::gemm::ActivationF32KBlockQuantize<_GemmCore_T>> &&
+                    !std::is_same_v<PrologueA, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32<_GemmCore_T>>) {
         return false;
       }
       if constexpr (GemmCore::ISA == BTLA_ISA::AVX_VNNI) {
@@ -661,10 +649,10 @@ class LauncherIntKBlock {
         int in = 0;
         for (; in < size_padded; in += GemmCore::NTILE) {
           if constexpr (std::is_same_v<AType, uint8_t>) {
-            kernel::wrapper::GEMVWoqNBits::forward_u8s8_fp32<_RT_ISA_T, ScaleT, GemmCore::NTILE, MTILE>(
+            kernel::wrapper::GEMVWoqNBits::forward_u8s8_fp32<ISA, ScaleT, GemmCore::NTILE, MTILE>(
                 paramA, paramB, tmpc_ptr, GemmCore::NTILE, k, kblocksize, StackTmp, TmpSize);
           } else if constexpr (std::is_same_v<AType, int8_t>) {
-            kernel::wrapper::GEMVWoqNBits::forward_s8s8_fp32<_RT_ISA_T, ScaleT, GemmCore::NTILE, MTILE>(
+            kernel::wrapper::GEMVWoqNBits::forward_s8s8_fp32<ISA, ScaleT, GemmCore::NTILE, MTILE>(
                 paramA, paramB, tmpc_ptr, GemmCore::NTILE, k, kblocksize, StackTmp, TmpSize);
           }
           Epilogue::template forward<ISA>(tmpc_ptr, GemmCore::NTILE, 0, _config.loc[1] + in, MTILE, GemmCore::NTILE,
@@ -673,10 +661,10 @@ class LauncherIntKBlock {
         }
         if (size_padded != _config.size[1]) {
           if constexpr (std::is_same_v<AType, uint8_t>) {
-            kernel::wrapper::GEMVWoqNBits::forward_u8s8_fp32<_RT_ISA_T, ScaleT, GemmCore::NTILE, MTILE>(
+            kernel::wrapper::GEMVWoqNBits::forward_u8s8_fp32<ISA, ScaleT, GemmCore::NTILE, MTILE>(
                 paramA, paramB, tmpc_ptr, GemmCore::NTILE, k, kblocksize, StackTmp, TmpSize);
           } else if constexpr (std::is_same_v<AType, int8_t>) {
-            kernel::wrapper::GEMVWoqNBits::forward_s8s8_fp32<_RT_ISA_T, ScaleT, GemmCore::NTILE, MTILE>(
+            kernel::wrapper::GEMVWoqNBits::forward_s8s8_fp32<ISA, ScaleT, GemmCore::NTILE, MTILE>(
                 paramA, paramB, tmpc_ptr, GemmCore::NTILE, k, kblocksize, StackTmp, TmpSize);
           }
           Epilogue::template forward<ISA>(tmpc_ptr, GemmCore::NTILE, 0, _config.loc[1] + in, MTILE,
@@ -715,7 +703,7 @@ class LauncherIntKBlock {
     }
   };
 
-  void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
+  static void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
     if (GEMVWrapper::support() && GEMVWrapper::implemented(_param)) {
       GEMVWrapper::gemv(_param, _config);
     } else {
@@ -724,8 +712,8 @@ class LauncherIntKBlock {
   }
 
  protected:
-  void gemm(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
-    mGemmCore.configure(_config.size[0], _config.size[1], _param.problem.dims[3]);
+  static void gemm(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
+    GemmCore::configure(_config.size[0], _config.size[1], _param.problem.dims[3]);
     auto StackTmp = alloca(_config.stacksize);
     auto tmpB = reinterpret_cast<BType*>(StackTmp);
     tmpB = utils::cpu_pointer_align(tmpB);
@@ -751,8 +739,8 @@ class LauncherIntKBlock {
 
   // _config.block[2]%kblock==0
   // _config.block[2]>=kblock
-  void run_block(const Param& _param, const parallel::gemm::ThreadProblemBase& _config, int blk_m, int blk_n,
-                 int blk_msize, int blk_nsize, AType* tmpA, BType* tmpB, AccType* tmpC, int8_t* tmpcache) {
+  static void run_block(const Param& _param, const parallel::gemm::ThreadProblemBase& _config, int blk_m, int blk_n,
+                        int blk_msize, int blk_nsize, AType* tmpA, BType* tmpB, AccType* tmpC, int8_t* tmpcache) {
     int n_padded = utils::padto(blk_nsize, GemmCore::NTILE);
     auto& K = _param.problem.dims[3];
     auto& KBlock = _param.problem.dims[4];
@@ -785,12 +773,12 @@ class LauncherIntKBlock {
       int ldsb_cache = tmp_ldsb;
       auto scaleB_cache = scaleB;
       auto reduceB_cache = reduceB;
-      mProB.getWeight(&bptr_cache, &bcache_step, k_padded, n_padded, iterk, _config.loc[1] + blk_n, _param.paramB, tmp_,
-                      _config.tmpcachesize);
-      mProB.getScale(&scaleB_cache, &ldsb_cache, k_padded, n_padded, iterk, _config.loc[1] + blk_n, _param.paramB, tmp_,
-                     _config.tmpcachesize);
-      mProB.getReduce(&reduceB_cache, &ldsb_cache, k_padded, n_padded, iterk, _config.loc[1] + blk_n, _param.paramB,
-                      tmp_, _config.tmpcachesize);
+      PrologueB::template getWeight<ISA>(&bptr_cache, &bcache_step, k_padded, n_padded, iterk, _config.loc[1] + blk_n,
+                                         _param.paramB, tmp_, _config.tmpcachesize);
+      PrologueB::template getScale<ISA>(&scaleB_cache, &ldsb_cache, k_padded, n_padded, iterk, _config.loc[1] + blk_n,
+                                        _param.paramB, tmp_, _config.tmpcachesize);
+      PrologueB::template getReduce<ISA>(&reduceB_cache, &ldsb_cache, k_padded, n_padded, iterk, _config.loc[1] + blk_n,
+                                         _param.paramB, tmp_, _config.tmpcachesize);
       int bcache_stride = bcache_step * sizeof(BType);
       for (int i = 0; i < blk_msize; i += GemmCore::MTILE) {
         int m_remain = utils::remainsize(i, blk_msize, GemmCore::MTILE);
@@ -801,13 +789,13 @@ class LauncherIntKBlock {
         auto zpA_cache = zpA;
         auto scaleA_cache = scaleA;
         int ldsa_cache = tmp_ldsa;
-        mProA.getActivation(&aptr_cache, &acache_step, _param.paramA, m_remain, k_padded, (blk_m + i + _config.loc[0]),
-                            iterk, tmp_, _config.tmpcachesize);
-        mProA.getZp(&zpA_cache, &ldsa_cache, _param.paramA, m_remain, k_padded, (blk_m + i + _config.loc[0]), iterk,
-                    tmp_, _config.tmpcachesize);
-        mProA.getScale(&scaleA_cache, &ldsa_cache, _param.paramA, m_remain, k_padded, (blk_m + i + _config.loc[0]),
-                       iterk, tmp_, _config.tmpcachesize);
-        mGemmCore.forward(aptr_cache, bptr_cache, cptr_cache, zpA_cache, scaleA_cache, ldsa_cache, scaleB_cache,
+        PrologueA::template getActivation<ISA>(&aptr_cache, &acache_step, _param.paramA, m_remain, k_padded,
+                                               (blk_m + i + _config.loc[0]), iterk, tmp_, _config.tmpcachesize);
+        PrologueA::template getZp<ISA>(&zpA_cache, &ldsa_cache, _param.paramA, m_remain, k_padded,
+                                       (blk_m + i + _config.loc[0]), iterk, tmp_, _config.tmpcachesize);
+        PrologueA::template getScale<ISA>(&scaleA_cache, &ldsa_cache, _param.paramA, m_remain, k_padded,
+                                          (blk_m + i + _config.loc[0]), iterk, tmp_, _config.tmpcachesize);
+        GemmCore::forward(aptr_cache, bptr_cache, cptr_cache, zpA_cache, scaleA_cache, ldsa_cache, scaleB_cache,
                           reduceB_cache, ldsb_cache, m_remain, n_padded, k_padded, KBlock, acache_step * sizeof(AType),
                           bcache_stride, ccache_stride, iterk, 1.f, tmp_, _config.tmpcachesize);
       }
@@ -817,8 +805,9 @@ class LauncherIntKBlock {
   }
 
   // _config.block[2]<kblock
-  void run_largekblock(const Param& _param, const parallel::gemm::ThreadProblemBase& _config, int blk_m, int blk_n,
-                       int blk_msize, int blk_nsize, AType* tmpA, BType* tmpB, AccType* tmpC, int8_t* tmpcache) {
+  static void run_largekblock(const Param& _param, const parallel::gemm::ThreadProblemBase& _config, int blk_m,
+                              int blk_n, int blk_msize, int blk_nsize, AType* tmpA, BType* tmpB, AccType* tmpC,
+                              int8_t* tmpcache) {
     int n_padded = utils::padto(blk_nsize, GemmCore::NTILE);
     auto& K = _param.problem.dims[3];
     auto& KBlock = _param.problem.dims[4];
@@ -851,12 +840,12 @@ class LauncherIntKBlock {
         int ldsb_cache = tmp_ldsb;
         auto scaleB_cache = scaleB;
         auto reduceB_cache = reduceB;
-        mProB.getWeight(&bptr_cache, &bcache_step, k_padded, n_padded, iterkk, _config.loc[1] + blk_n, _param.paramB,
-                        tmp_, _config.tmpcachesize);
-        mProB.getScale(&scaleB_cache, &ldsb_cache, k_padded, n_padded, iterkk, _config.loc[1] + blk_n, _param.paramB,
-                       tmp_, _config.tmpcachesize);
-        mProB.getReduce(&reduceB_cache, &ldsb_cache, k_padded, n_padded, iterkk, _config.loc[1] + blk_n, _param.paramB,
-                        tmp_, _config.tmpcachesize);
+        PrologueB::template getWeight<ISA>(&bptr_cache, &bcache_step, k_padded, n_padded, iterkk,
+                                           _config.loc[1] + blk_n, _param.paramB, tmp_, _config.tmpcachesize);
+        PrologueB::template getScale<ISA>(&scaleB_cache, &ldsb_cache, k_padded, n_padded, iterkk,
+                                          _config.loc[1] + blk_n, _param.paramB, tmp_, _config.tmpcachesize);
+        PrologueB::template getReduce<ISA>(&reduceB_cache, &ldsb_cache, k_padded, n_padded, iterkk,
+                                           _config.loc[1] + blk_n, _param.paramB, tmp_, _config.tmpcachesize);
 
         int bcache_stride = bcache_step * sizeof(BType);
         for (int i = 0; i < blk_msize; i += GemmCore::MTILE) {
@@ -868,14 +857,14 @@ class LauncherIntKBlock {
           auto zpA_cache = zpA;
           auto scaleA_cache = scaleA;
           int ldsa_cache = tmp_ldsa;
-          mProA.getActivation(&aptr_cache, &acache_step, _param.paramA, m_remain, k_padded,
-                              (blk_m + i + _config.loc[0]), iterkk, tmp_, _config.tmpcachesize);
-          mProA.getZp(&zpA_cache, &ldsa_cache, _param.paramA, m_remain, k_padded, (blk_m + i + _config.loc[0]), iterkk,
-                      tmp_, _config.tmpcachesize);
-          mProA.getScale(&scaleA_cache, &ldsa_cache, _param.paramA, m_remain, k_padded, (blk_m + i + _config.loc[0]),
-                         iterkk, tmp_, _config.tmpcachesize);
+          PrologueA::template getActivation<ISA>(&aptr_cache, &acache_step, _param.paramA, m_remain, k_padded,
+                                                 (blk_m + i + _config.loc[0]), iterkk, tmp_, _config.tmpcachesize);
+          PrologueA::template getZp<ISA>(&zpA_cache, &ldsa_cache, _param.paramA, m_remain, k_padded,
+                                         (blk_m + i + _config.loc[0]), iterkk, tmp_, _config.tmpcachesize);
+          PrologueA::template getScale<ISA>(&scaleA_cache, &ldsa_cache, _param.paramA, m_remain, k_padded,
+                                            (blk_m + i + _config.loc[0]), iterkk, tmp_, _config.tmpcachesize);
           auto kscale = k_remain / float(KBlock);
-          mGemmCore.forward(aptr_cache, bptr_cache, cptr_cache, zpA_cache, scaleA_cache, ldsa_cache, scaleB_cache,
+          GemmCore::forward(aptr_cache, bptr_cache, cptr_cache, zpA_cache, scaleA_cache, ldsa_cache, scaleB_cache,
                             reduceB_cache, ldsb_cache, m_remain, n_padded, k_padded, k_padded,
                             acache_step * sizeof(AType), bcache_stride, ccache_stride, iterkk, kscale, tmp_,
                             _config.tmpcachesize);
diff --git a/bestla/bestla/kernel_avx512f.h b/bestla/bestla/kernel_avx512f.h
index eef6c96fc..cdfa341e1 100644
--- a/bestla/bestla/kernel_avx512f.h
+++ b/bestla/bestla/kernel_avx512f.h
@@ -1159,7 +1159,7 @@ constexpr auto broadcast_F4_E2M1_quantv = broadcast_N_2_Nx16<8>(F4_E2M1_simd_qua
 
 template <BTLA_DTYPE F4_T>
 inline BTLA_CODE quantize_f32_f4_rowblock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
-                                          float* scales, int8_t* zero_points, int blocksize) {
+                                          float* scales, int blocksize) {
   // assert(col % 16 == 0);
   auto align_row = row / blocksize * blocksize;
   auto align_blk = blocksize / 4 * 4;
@@ -3601,7 +3601,7 @@ static inline BTLA_CODE decompress_s7_s8(utils::bit4x2* bit4ptr, utils::bit2x4*
                                          int8_t* dstptr, size_t unpack_elt, int8_t* tmp, size_t tmpsize) {
   int constexpr VBits = 512;
   int constexpr VElt = VBits / 8;
-  int i = 0;
+  size_t i = 0;
   int constexpr FullRange = 1 << (7 - 1);
   uint32_t mask = 0x0f0f0f0f;
   auto vmask = _mm512_set1_epi32(*reinterpret_cast<int*>(&mask));
@@ -3916,7 +3916,7 @@ static inline BTLA_CODE decompress_s6_s8(utils::bit4x2* bit4ptr, utils::bit2x4*
                                          size_t unpack_elt, int8_t* tmp, size_t tmpsize) {
   int constexpr VBits = 512;
   int constexpr VElt = VBits / 8;
-  int i = 0;
+  size_t i = 0;
   int constexpr FullRange = 1 << (6 - 1);
   uint32_t mask = 0x0f0f0f0f;
   auto vmask = _mm512_set1_epi32(*reinterpret_cast<int*>(&mask));
diff --git a/bestla/bestla/kernel_ref.h b/bestla/bestla/kernel_ref.h
index eb04a2d8d..68759c0b1 100644
--- a/bestla/bestla/kernel_ref.h
+++ b/bestla/bestla/kernel_ref.h
@@ -409,8 +409,8 @@ static inline void convert_s4_s8_8(int8_t* dstptr, int8_t* srcptr) {
   dstptr[7] = static_cast<int8_t>(tmp);
 }
 
-static inline BTLA_CODE decompress_s6_s8(utils::bit4x2* bit4ptr, utils::bit2x4* bit2ptr, int8_t* dstptr, int unpack_elt,
-                                         int8_t* tmp, size_t tmpsize) {
+static inline BTLA_CODE decompress_s6_s8(utils::bit4x2* bit4ptr, utils::bit2x4* bit2ptr, int8_t* dstptr,
+                                         size_t unpack_elt, int8_t* tmp, size_t tmpsize) {
   int constexpr FullRange = 1 << (6 - 1);
   for (size_t i = 0; i < unpack_elt; i += 4) {
     auto bit2 = bit2ptr[i / 4];
@@ -424,8 +424,8 @@ static inline BTLA_CODE decompress_s6_s8(utils::bit4x2* bit4ptr, utils::bit2x4*
   return BTLA_CODE::Success;
 }
 
-static inline BTLA_CODE decompress_s5_s8(utils::bit4x2* bit4ptr, utils::bit1x8* bit1ptr, int8_t* dstptr, int unpack_elt,
-                                         int8_t* tmp, size_t tmpsize) {
+static inline BTLA_CODE decompress_s5_s8(utils::bit4x2* bit4ptr, utils::bit1x8* bit1ptr, int8_t* dstptr,
+                                         size_t unpack_elt, int8_t* tmp, size_t tmpsize) {
   int constexpr FullRange = 1 << (5 - 1);
   for (size_t i = 0; i < unpack_elt; i += 8) {
     auto bit1 = bit1ptr[i / 8];
@@ -446,7 +446,7 @@ static inline BTLA_CODE decompress_s5_s8(utils::bit4x2* bit4ptr, utils::bit1x8*
 }
 
 static inline BTLA_CODE decompress_s7_s8(utils::bit4x2* bit4ptr, utils::bit2x4* bit2ptr, utils::bit1x8* bit1ptr,
-                                         int8_t* dstptr, int unpack_elt, int8_t* tmp, size_t tmpsize) {
+                                         int8_t* dstptr, size_t unpack_elt, int8_t* tmp, size_t tmpsize) {
   int constexpr FullRange = 1 << (7 - 1);
   for (size_t i = 0; i < unpack_elt; i += 8) {
     auto bit2 = bit2ptr[i / 4];
@@ -478,8 +478,8 @@ static inline BTLA_CODE decompress_s4_s8(utils::int4x2* srcptr, int8_t* dstptr,
   return BTLA_CODE::Success;
 }
 
-static inline BTLA_CODE decompress_s3_s8(utils::bit2x4* bit2ptr, utils::bit1x8* bit1ptr, int8_t* dstptr, int unpack_elt,
-                                         int8_t* tmp, size_t tmpsize) {
+static inline BTLA_CODE decompress_s3_s8(utils::bit2x4* bit2ptr, utils::bit1x8* bit1ptr, int8_t* dstptr,
+                                         size_t unpack_elt, int8_t* tmp, size_t tmpsize) {
   for (size_t i = 0; i < unpack_elt; i += 8) {
     auto bit1 = bit1ptr[i / 8];
     auto tmp = bit2ptr[i / 4];
@@ -508,7 +508,7 @@ static inline BTLA_CODE decompress_s2_s8(utils::bit2x4* srcptr, int8_t* dstptr,
   return BTLA_CODE::Success;
 }
 
-static inline BTLA_CODE decompress_s1_s8(utils::bit1x8* bit1ptr, int8_t* dstptr, int unpack_elt, int8_t* tmp,
+static inline BTLA_CODE decompress_s1_s8(utils::bit1x8* bit1ptr, int8_t* dstptr, size_t unpack_elt, int8_t* tmp,
                                          size_t tmpsize) {
   int8_t constexpr FullRange = 1 << (1 - 1);
   for (size_t i = 0; i < unpack_elt; i += 8) {
@@ -1037,7 +1037,7 @@ inline BTLA_CODE decompress_kblock_s8_fp(int8_t* srcptr, DST_T* dstptr, int row,
         auto zp = zero_points ? zero_points[kpos + j] : 0;
         for (int ir = 0; ir < PackRow; ir++) {
           float tmp = static_cast<float>(srcptr[i * col + j * PackRow + ir] - zp) * scale;
-          dstptr[i * col + j * PackRow + ir] = tmp;
+          dstptr[i * col + j * PackRow + ir] = static_cast<DST_T>(tmp);
         }
       }
     } else if (sdtype == BTLA_DTYPE::BF16) {
@@ -1047,7 +1047,7 @@ inline BTLA_CODE decompress_kblock_s8_fp(int8_t* srcptr, DST_T* dstptr, int row,
         auto zp = zero_points ? zero_points[kpos + j] : 0;
         for (int ir = 0; ir < PackRow; ir++) {
           float tmp = static_cast<float>(srcptr[i * col + j * PackRow + ir] - zp) * scale;
-          dstptr[i * col + j * PackRow + ir] = tmp;
+          dstptr[i * col + j * PackRow + ir] = static_cast<DST_T>(tmp);
         }
       }
     }
@@ -1233,7 +1233,7 @@ static inline float fp4_bnb_dequantize(uint8_t val, float absmax) { return fp4_b
 
 static inline int8_t fp4_bnb_quantize(float x) {
   int sign = x < 0 ? 0b1000 : 0b0000;
-  x = fabsf(x);
+  x = fabs(x);
   if (x > 0.29166667f)
     if (x > 0.583333f)
       if (x > 0.8333333f)
@@ -1269,7 +1269,7 @@ static inline int8_t fp4_e2m1_quantize(float x) {
   // 0b111 = 6
 
   int sign = x < 0 ? 0b1000 : 0b0000;
-  x = fabsf(x);
+  x = fabs(x);
   if (x > 1.75f / 6) {
     if (x > 3.5f / 6) {
       if (x > 5.f / 6)
@@ -1801,7 +1801,7 @@ static inline BTLA_CODE quantize_f32_f8_rowblock_mxscale(const float* srcptr, in
 
 template <BTLA_DTYPE F4_T>
 static inline BTLA_CODE quantize_f32_f4_rowblock(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src,
-                                                 int ld_dst, float* scales, int8_t* zero_points, int blocksize) {
+                                                 int ld_dst, float* scales, int blocksize) {
   int raw_blocksize = blocksize;
   for (int i = 0; i < col; i++) {
     int align_row_loop = row / blocksize * blocksize;
@@ -1816,30 +1816,8 @@ static inline BTLA_CODE quantize_f32_f4_rowblock(const float* srcptr, int8_t* ds
         dstptr[(j + ij) * ld_dst + i] = f4_quantize<F4_T>(srcptr[(j + ij) * ld_src + i] * (1.f / absmax));
       }
     };
-    auto calc_store_scale_and_quantv_asym = [&](int blocksize) {
-      float amax = 0;
-      float amin = 0;
-      for (size_t ij = 0; ij < blocksize; ij++) {
-        amax = std::max(amax, srcptr[(j + ij) * ld_src + i]);
-        amin = std::max(amax, srcptr[(j + ij) * ld_src + i]);
-      }
-      float scale = (amax - amin) / 2;
-      scales[j / raw_blocksize * ld_dst + i] = scale;
-      float fmedium = (amax + amin) / 2;
-      zero_points[j / raw_blocksize * ld_dst + i] = f4_quantize<F4_T>((0 - fmedium) * (1.f / scale));
-      for (size_t ij = 0; ij < blocksize; ij++) {
-        dstptr[(j + ij) * ld_dst + i] = f4_quantize<F4_T>((srcptr[(j + ij) * ld_src + i] - fmedium) * (1.f / scale));
-      }
-    };
-    auto dispatch_calc = [&](int blocksize) {
-      if (zero_points == nullptr) {
-        calc_store_scale_and_quantv_sym(blocksize);
-      } else {
-        calc_store_scale_and_quantv_asym(blocksize);
-      }
-    };
-    for (; j < align_row_loop; j += blocksize) dispatch_calc(blocksize);
-    if (j < row) dispatch_calc(row - align_row_loop);
+    for (; j < align_row_loop; j += blocksize) calc_store_scale_and_quantv_sym(blocksize);
+    if (j < row) calc_store_scale_and_quantv_sym(row - align_row_loop);
   }
   return BTLA_CODE::Success;
 }
diff --git a/bestla/bestla/kernel_wrapper.h b/bestla/bestla/kernel_wrapper.h
index 4491e6515..d410574b8 100644
--- a/bestla/bestla/kernel_wrapper.h
+++ b/bestla/bestla/kernel_wrapper.h
@@ -27,43 +27,57 @@
 namespace bestla {
 namespace kernel {
 namespace wrapper {
-template <int NTile, int RowPack>
+template <int NTILE, int RowPack, typename T_SRC, typename T_DST = T_SRC>
 class PaddingInterleaveMN {
   // M x N ===> N/NTile x M/RowPack x NTile x RowPack (leading dim stride = NTile * dststride)
  public:
-  template <BTLA_ISA ISA_T, typename T_SRC, typename T_DST = T_SRC>
-  static BTLA_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
-                           int dst_step) {
+  TLACALL BTLA_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
+                            int dst_step) {
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       const auto kern_ret = kernel::avx512f::padding_interleave_cvt<T_SRC, T_DST, RowPack>::forward(
-          src, dst, NTile, row, col, row_pad, col_pad, src_step, dst_step);
+          src, dst, NTILE, row, col, row_pad, col_pad, src_step, dst_step);
       if (kern_ret != BTLA_CODE::NotSupport) return kern_ret;
     }
 #endif
-    return ref::padding_interleave(src, dst, row, col, row_pad, col_pad, src_step, dst_step, NTile, RowPack);
+    return ref::padding_interleave(src, dst, row, col, row_pad, col_pad, src_step, dst_step, NTILE, RowPack);
+  }
+
+  AUTOCALL BTLA_CODE forward_auto(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad,
+                                  int src_step, int dst_step) {
+    GetCPUDevice();
+    if (_cd->AVX512F()) {
+      return forward<BTLA_ISA::AVX512F>(src, dst, row, col, row_pad, col_pad, src_step, dst_step);
+    }
+    if (_cd->AVX2()) {
+      return forward<BTLA_ISA::AVX2>(src, dst, row, col, row_pad, col_pad, src_step, dst_step);
+    }
+    return forward<BTLA_ISA::NoSIMD>(src, dst, row, col, row_pad, col_pad, src_step, dst_step);
   }
 };
 
-template <int NTile, int RowPack>
+template <int NTile, int RowPack, typename T_SRC, typename T_DST = T_SRC>
 class RevertPaddingInterleaveMN {
   // M x N ===> N/NTile x M/RowPack x NTile x RowPack (leading dim stride = NTile * dststride)
  public:
-  template <BTLA_ISA ISA_T, typename T_SRC, typename T_DST = T_SRC>
-  static BTLA_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
-                           int dst_step) {
+  TLACALL BTLA_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
+                            int dst_step) {
     return ref::revert_padding_interleave(src, dst, row, col, row_pad, col_pad, src_step, dst_step, NTile, RowPack);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad,
+                                  int src_step, int dst_step) {
+    return forward<BTLA_ISA::NoSIMD>(src, dst, row, col, row_pad, col_pad, src_step, dst_step);
+  }
 };
 
-template <int MTile, int ColPack>
+template <int MTile, int ColPack, typename T_SRC, typename T_DST = T_SRC>
 class PaddingTransInterleaveMN {
   // row and cols are in terms of src
   // M x N ===> M/MTile x N/ColPack x MTile x ColPack (leading dim stride = MTile * dststride)
  public:
-  template <BTLA_ISA ISA_T, typename T_SRC, typename T_DST = T_SRC>
-  static BTLA_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
-                           int dst_step) {
+  TLACALL BTLA_CODE forward(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad, int src_step,
+                            int dst_step) {
 #if CompileAVX512F()
     // Note: rows/cols and i/j are in terms of src
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
@@ -74,6 +88,15 @@ class PaddingTransInterleaveMN {
 #endif
     return ref::padding_trans_interleave(src, dst, row, col, row_pad, col_pad, src_step, dst_step, MTile, ColPack);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const T_SRC* src, T_DST* dst, int row, int col, int row_pad, int col_pad,
+                                  int src_step, int dst_step) {
+    GetCPUDevice();
+    if (_cd->AVX512F()) {
+      return forward<BTLA_ISA::AVX512F>(src, dst, row, col, row_pad, col_pad, src_step, dst_step);
+    }
+    return forward<BTLA_ISA::NoSIMD>(src, dst, row, col, row_pad, col_pad, src_step, dst_step);
+  }
 };
 
 class Memcpy2D {
@@ -90,18 +113,20 @@ class Memcpy2D {
       }
     }
     if constexpr (utils::isa_base<ISA_T>::avx2) {
-      auto align_col = col * sizeof(_SRC_T) / 32 * 32 / sizeof(_SRC_T);
+      auto align_col = static_cast<int>(col * sizeof(_SRC_T) / 32 * 32 / sizeof(_SRC_T));
       ret = kernel::jit::JitMemcpy2DAvx2::forward<_SRC_T, _DST_T>(srcptr, dstptr, row, align_col, srcstep, dststep,
                                                                   const_elt_v);
       if (col - align_col > 0)
-        ret = kernel::ref::memcpy2d(srcptr + align_col, dstptr + align_col, row, (col - align_col) * sizeof(_SRC_T),
-                                    srcstep * sizeof(_SRC_T), dststep * sizeof(_DST_T));
+        ret = kernel::ref::memcpy2d(
+            srcptr + align_col, dstptr + align_col, row, static_cast<int>((col - align_col) * sizeof(_SRC_T)),
+            static_cast<int>(srcstep * sizeof(_SRC_T)), static_cast<int>(dststep * sizeof(_DST_T)));
       if (ret == BTLA_CODE::Success) {
         return ret;
       }
     }
-    return kernel::ref::memcpy2d(srcptr, dstptr, row, col * sizeof(_SRC_T), srcstep * sizeof(_SRC_T),
-                                 dststep * sizeof(_DST_T));
+    return kernel::ref::memcpy2d(srcptr, dstptr, row, static_cast<int>(col * sizeof(_SRC_T)),
+                                 static_cast<int>(srcstep * sizeof(_SRC_T)),
+                                 static_cast<int>(dststep * sizeof(_DST_T)));
   }
 
   template <BTLA_ISA ISA_T, typename _SRC_T, typename _DST_T, BTLA_ELTWISEOP OP_T>
@@ -116,13 +141,13 @@ class Memcpy2D {
       }
     }
     if constexpr (utils::isa_base<ISA_T>::avx2) {
-      auto align_col = col * sizeof(_SRC_T) / 32 * 32 / sizeof(_SRC_T);
+      auto align_col = static_cast<int>(col * sizeof(_SRC_T) / 32 * 32 / sizeof(_SRC_T));
       ret = kernel::jit::JitMemcpy2DAvx2::forward1<_SRC_T, _DST_T, OP_T>(srcptr, dstptr, row, align_col, srcstep,
                                                                          dststep, const_elt_v);
       if (col - align_col > 0)
         ret = kernel::ref::memcpy2d_withop<_SRC_T, _DST_T, OP_T>(
-            srcptr + align_col, dstptr + align_col, row, (col - align_col) * sizeof(_SRC_T), srcstep * sizeof(_SRC_T),
-            dststep * sizeof(_DST_T), const_elt_v);
+            srcptr + align_col, dstptr + align_col, row, static_cast<int>((col - align_col) * sizeof(_SRC_T)),
+            static_cast<int>(srcstep * sizeof(_SRC_T)), static_cast<int>(dststep * sizeof(_DST_T)), const_elt_v);
       if (ret == BTLA_CODE::Success) {
         return ret;
       }
@@ -259,86 +284,113 @@ class Dq8GetScale {
 
 class CompressS8S4 {
  public:
-  template <BTLA_ISA ISA_T>
-  static inline BTLA_CODE forward(const int8_t* srcptr, bestla::utils::int4x2* dstptr, size_t size) {
+  TLACALL BTLA_CODE forward(const int8_t* srcptr, bestla::utils::int4x2* dstptr, size_t size) {
     return ref::compress_s8_s4(srcptr, dstptr, size);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const int8_t* srcptr, bestla::utils::int4x2* dstptr, size_t size) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, dstptr, size);
+  }
 };
 
 class CompressFp4 {
  public:
-  template <BTLA_ISA ISA_T>
-  static inline BTLA_CODE forward(const int8_t* srcptr, bestla::utils::f4x2* dstptr, size_t size) {
+  TLACALL BTLA_CODE forward(const int8_t* srcptr, bestla::utils::f4x2* dstptr, size_t size) {
     return ref::compress_f4(srcptr, dstptr, size);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const int8_t* srcptr, bestla::utils::f4x2* dstptr, size_t size) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, dstptr, size);
+  }
 };
 
 class CompressBit7 {
  public:
-  template <BTLA_ISA ISA_T>
-  static inline BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit4x2* bit4ptr, utils::bit2x4* bit2ptr,
-                                  utils::bit1x8* bit1ptr, size_t size) {
+  TLACALL BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit4x2* bit4ptr, utils::bit2x4* bit2ptr,
+                            utils::bit1x8* bit1ptr, size_t size) {
     return ref::compress_7bit(srcptr, bit4ptr, bit2ptr, bit1ptr, size);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const int8_t* srcptr, bestla::utils::bit4x2* bit4ptr, utils::bit2x4* bit2ptr,
+                                  utils::bit1x8* bit1ptr, size_t size) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, bit4ptr, bit2ptr, bit1ptr, size);
+  }
 };
 
 class CompressBit6 {
  public:
-  template <BTLA_ISA ISA_T>
-  static inline BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit4x2* bit4ptr, utils::bit2x4* bit2ptr,
-                                  size_t size) {
+  TLACALL BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit4x2* bit4ptr, utils::bit2x4* bit2ptr, size_t size) {
     return ref::compress_6bit(srcptr, bit4ptr, bit2ptr, size);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const int8_t* srcptr, bestla::utils::bit4x2* bit4ptr, utils::bit2x4* bit2ptr,
+                                  size_t size) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, bit4ptr, bit2ptr, size);
+  }
 };
 
 class CompressBit5 {
  public:
-  template <BTLA_ISA ISA_T>
-  static inline BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit4x2* bit4ptr, utils::bit1x8* bit1ptr,
-                                  size_t size) {
+  TLACALL BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit4x2* bit4ptr, utils::bit1x8* bit1ptr, size_t size) {
     return ref::compress_5bit(srcptr, bit4ptr, bit1ptr, size);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const int8_t* srcptr, bestla::utils::bit4x2* bit4ptr, utils::bit1x8* bit1ptr,
+                                  size_t size) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, bit4ptr, bit1ptr, size);
+  }
 };
 
 class CompressBit3 {
  public:
-  template <BTLA_ISA ISA_T>
-  static inline BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit2x4* bit2ptr, utils::bit1x8* bit1ptr,
-                                  size_t size) {
+  TLACALL BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit2x4* bit2ptr, utils::bit1x8* bit1ptr, size_t size) {
     return ref::compress_3bit(srcptr, bit2ptr, bit1ptr, size);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const int8_t* srcptr, bestla::utils::bit2x4* bit2ptr, utils::bit1x8* bit1ptr,
+                                  size_t size) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, bit2ptr, bit1ptr, size);
+  }
 };
 
 class CompressBit2 {
  public:
-  template <BTLA_ISA ISA_T>
-  static inline BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit2x4* bit2ptr, size_t size) {
+  TLACALL BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit2x4* bit2ptr, size_t size) {
     return ref::compress_2bit(srcptr, bit2ptr, size);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const int8_t* srcptr, bestla::utils::bit2x4* bit2ptr, size_t size) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, bit2ptr, size);
+  }
 };
 
 class CompressBit1 {
  public:
-  template <BTLA_ISA ISA_T>
-  static inline BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit1x8* bit1ptr, size_t size) {
+  TLACALL BTLA_CODE forward(const int8_t* srcptr, bestla::utils::bit1x8* bit1ptr, size_t size) {
     return ref::compress_1bit(srcptr, bit1ptr, size);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const int8_t* srcptr, bestla::utils::bit1x8* bit1ptr, size_t size) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, bit1ptr, size);
+  }
 };
 
 template <typename _T>
 class Transpose2D {
  public:
-  template <BTLA_ISA ISA_T>
-  static inline BTLA_CODE forward(const _T* srcptr, _T* dstptr, int row, int col, int ld_src, int ld_dst) {
+  TLACALL BTLA_CODE forward(const _T* srcptr, _T* dstptr, int row, int col, int ld_src, int ld_dst) {
     return ref::transpose2d(srcptr, dstptr, row, col, ld_src, ld_dst);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const _T* srcptr, _T* dstptr, int row, int col, int ld_src, int ld_dst) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, dstptr, row, col, ld_src, ld_dst);
+  }
 };
 
 class QuantizeSignIntRowBlock {
  public:
-  template <BTLA_ISA ISA_T>
-  static inline BTLA_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
-                                  float* scales, int8_t* zero_points, int blocksize, BTLA_DTYPE qtype) {
+  TLACALL BTLA_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                            float* scales, int8_t* zero_points, int blocksize, BTLA_DTYPE qtype) {
     // TODO(Yu) simd version for quick quant
     // #if CompileAVX512F()
     //     if constexpr (utils::isa_base<ISA_T>::avx512f) {
@@ -349,39 +401,56 @@ class QuantizeSignIntRowBlock {
     return ref::quantize_f32_sign_int_rowblock(srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points, blocksize,
                                                qtype);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  float* scales, int8_t* zero_points, int blocksize, BTLA_DTYPE qtype) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points, blocksize, qtype);
+  }
 };
 
+template <BTLA_DTYPE F8_T>
 class QuantizeF8RowBlock {
  public:
-  template <BTLA_ISA ISA_T, BTLA_DTYPE F8_T>
-  static inline BTLA_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
-                                  float* scales, int blocksize, BTLA_DTYPE scale_dtype) {
+  TLACALL BTLA_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                            float* scales, int blocksize, BTLA_DTYPE scale_dtype) {
     return ref::quantize_f32_f8_rowblock_mxscale<F8_T>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, blocksize,
                                                        scale_dtype);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  float* scales, int blocksize, BTLA_DTYPE scale_dtype) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, blocksize, scale_dtype);
+  }
 };
 
+template <BTLA_DTYPE F4_T>
 class QuantizeF4RowBlock {
  public:
-  template <BTLA_ISA ISA_T, BTLA_DTYPE F4_T>
-  static inline BTLA_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
-                                  float* scales, int8_t* zero_points, int blocksize) {
+  TLACALL BTLA_CODE forward(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                            float* scales, int blocksize) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
-      return avx512f::quantize_f32_f4_rowblock<F4_T>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points,
-                                                     blocksize);
+      return avx512f::quantize_f32_f4_rowblock<F4_T>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, blocksize);
     }
 #endif
-    return ref::quantize_f32_f4_rowblock<F4_T>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, zero_points,
-                                               blocksize);
+    return ref::quantize_f32_f4_rowblock<F4_T>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, blocksize);
+  }
+
+  AUTOCALL BTLA_CODE forward_auto(const float* srcptr, int8_t* dstptr, int row, int col, int ld_src, int ld_dst,
+                                  float* scales, int blocksize) {
+    GetCPUDevice();
+    if (_cd->AVX512F()) {
+      return forward<BTLA_ISA::AVX512F>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, blocksize);
+    }
+    return forward<BTLA_ISA::NoSIMD>(srcptr, dstptr, row, col, ld_src, ld_dst, scales, blocksize);
   }
 };
 
+template <typename SRC_T>
 class QuantizeU8ColBlock {
  public:
-  template <BTLA_ISA ISA_T, typename SRC_T>
-  static inline BTLA_CODE forward(int row, int col, const SRC_T* srcptr, int ld_src, uint8_t* dstptr, int ld_dst,
-                                  float* scales, int ld_scale, uint8_t* zps, int blocksize, float* blkreduce) {
+  TLACALL BTLA_CODE forward(int row, int col, const SRC_T* srcptr, int ld_src, uint8_t* dstptr, int ld_dst,
+                            float* scales, int ld_scale, uint8_t* zps, int blocksize, float* blkreduce) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::quantize_fp_u8_colblock<SRC_T>(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale, zps,
@@ -397,13 +466,28 @@ class QuantizeU8ColBlock {
     return ref::quantize_fp_u8_colblock(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale, zps, blocksize,
                                         blkreduce);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(int row, int col, const SRC_T* srcptr, int ld_src, uint8_t* dstptr, int ld_dst,
+                                  float* scales, int ld_scale, uint8_t* zps, int blocksize, float* blkreduce) {
+    GetCPUDevice();
+    if (_cd->AVX512F()) {
+      return forward<BTLA_ISA::AVX512F>(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale, zps, blocksize,
+                                        blkreduce);
+    }
+    if (_cd->AVX2()) {
+      return forward<BTLA_ISA::AVX2>(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale, zps, blocksize,
+                                     blkreduce);
+    }
+    return forward<BTLA_ISA::NoSIMD>(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale, zps, blocksize,
+                                     blkreduce);
+  }
 };
 
+template <typename SRC_T>
 class QuantizeS8ColBlock {
  public:
-  template <BTLA_ISA ISA_T, typename SRC_T>
-  static inline BTLA_CODE forward(int row, int col, const SRC_T* srcptr, int ld_src, int8_t* dstptr, int ld_dst,
-                                  float* scales, int ld_scale, int blocksize, float* reduce) {
+  TLACALL BTLA_CODE forward(int row, int col, const SRC_T* srcptr, int ld_src, int8_t* dstptr, int ld_dst,
+                            float* scales, int ld_scale, int blocksize, float* reduce) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f) {
       return avx512f::quantize_fp_s8_colblock<SRC_T>(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale,
@@ -412,6 +496,18 @@ class QuantizeS8ColBlock {
 #endif
     return ref::quantize_fp_s8_colblock(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale, blocksize, reduce);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(int row, int col, const SRC_T* srcptr, int ld_src, int8_t* dstptr, int ld_dst,
+                                  float* scales, int ld_scale, int blocksize, float* reduce) {
+    GetCPUDevice();
+    if (_cd->AVX512F()) {
+      return forward<BTLA_ISA::AVX512F>(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale, blocksize, reduce);
+    }
+    if (_cd->AVX2()) {
+      return forward<BTLA_ISA::AVX2>(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale, blocksize, reduce);
+    }
+    return forward<BTLA_ISA::NoSIMD>(row, col, srcptr, ld_src, dstptr, ld_dst, scales, ld_scale, blocksize, reduce);
+  }
 };
 
 class Broadcast {
@@ -450,13 +546,13 @@ class DecompressKBlockS4S8 {
   static inline BTLA_CODE forward(utils::int4x2* srcptr, int8_t* zpptr, int8_t* dstptr, int blocksize, int ldzp,
                                   int n_offset, int k_offset, int row, int col, void* tmp, size_t tmpsize) {
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s4_s8<PackRow, NTILE>(srcptr, zpptr, dstptr, blocksize, ldzp, n_offset,
                                                               k_offset, row, col, (int8_t*)tmp, tmpsize);
     }
 #endif
 #if CompileAVX2()
-    if constexpr (utils::isa_base<ISA_T>::avx2) {
+    if constexpr (utils::isa_base<ISA_T>::avx2 && NTILE % 8 == 0) {
       return avx2::decompress_kblock_s4_s8<PackRow, NTILE>(srcptr, zpptr, dstptr, blocksize, ldzp, n_offset, k_offset,
                                                            row, col, (int8_t*)tmp, tmpsize);
     }
@@ -474,13 +570,13 @@ class DecompressKBlockS7S8 {
                                   int8_t* dstptr, int blocksize, int ldzp, int n_offset, int k_offset, int row, int col,
                                   void* tmp, size_t tmpsize) {
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s7_s8<PackRow, NTILE>(b4ptr, b2ptr, b1ptr, zpptr, dstptr, blocksize, ldzp,
                                                               n_offset, k_offset, row, col, (int8_t*)tmp, tmpsize);
     }
 #endif
 #if CompileAVX2()
-    if constexpr (utils::isa_base<ISA_T>::avx2) {
+    if constexpr (utils::isa_base<ISA_T>::avx2 && NTILE % 8 == 0) {
       return avx2::decompress_kblock_s7_s8<PackRow, NTILE>(b4ptr, b2ptr, b1ptr, zpptr, dstptr, blocksize, ldzp,
                                                            n_offset, k_offset, row, col, (int8_t*)tmp, tmpsize);
     }
@@ -498,7 +594,7 @@ class DecompressKBlockS6S8 {
                                   int blocksize, int ldzp, int n_offset, int k_offset, int row, int col, void* tmp,
                                   size_t tmpsize) {
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s6_s8<PackRow, NTILE>(b4ptr, b2ptr, zpptr, dstptr, blocksize, ldzp, n_offset,
                                                               k_offset, row, col, (int8_t*)tmp, tmpsize);
     }
@@ -522,7 +618,7 @@ class DecompressKBlockS5S8 {
                                   int blocksize, int ldzp, int n_offset, int k_offset, int row, int col, void* tmp,
                                   size_t tmpsize) {
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s5_s8<PackRow, NTILE>(b4ptr, b1ptr, zpptr, dstptr, blocksize, ldzp, n_offset,
                                                               k_offset, row, col, (int8_t*)tmp, tmpsize);
     }
@@ -546,7 +642,7 @@ class DecompressKBlockS3S8 {
                                   int blocksize, int ldzp, int n_offset, int k_offset, int row, int col, void* tmp,
                                   size_t tmpsize) {
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s3_s8<PackRow, NTILE>(b2ptr, b1ptr, zpptr, dstptr, blocksize, ldzp, n_offset,
                                                               k_offset, row, col, (int8_t*)tmp, tmpsize);
     }
@@ -569,7 +665,7 @@ class DecompressKBlockS2S8 {
   static inline BTLA_CODE forward(utils::bit2x4* b2ptr, int8_t* zpptr, int8_t* dstptr, int blocksize, int ldzp,
                                   int n_offset, int k_offset, int row, int col, void* tmp, size_t tmpsize) {
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s2_s8<PackRow, NTILE>(b2ptr, zpptr, dstptr, blocksize, ldzp, n_offset, k_offset,
                                                               row, col, (int8_t*)tmp, tmpsize);
     }
@@ -592,7 +688,7 @@ class DecompressKBlockS1S8 {
   static inline BTLA_CODE forward(utils::bit1x8* b1ptr, int8_t* zpptr, int8_t* dstptr, int blocksize, int ldzp,
                                   int n_offset, int k_offset, int row, int col, void* tmp, size_t tmpsize) {
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s1_s8<PackRow, NTILE>(b1ptr, zpptr, dstptr, blocksize, ldzp, n_offset, k_offset,
                                                               row, col, (int8_t*)tmp, tmpsize);
     }
@@ -617,7 +713,7 @@ class DecompressKBlockS8Fp {
                                   size_t tmpsize) {
     BTLA_CODE ret = BTLA_CODE::NotSupport;
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       ret = avx512f::decompress_kblock_s8_fp<PackRow, NTILE, DstT>(srcptr, dstptr, row, col, scales, sdtype,
                                                                    zero_points, k_offset, n_offset, kblock, NPad,
                                                                    reinterpret_cast<int8_t*>(tmp), tmpsize);
@@ -648,7 +744,7 @@ class DecompressKBlockS7Fp {
                                   int n_offset, int kblock, int NPad, void* tmp, size_t tmpsize) {
     BTLA_CODE ret = BTLA_CODE::NotSupport;
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s7_fp<PackRow, NTILE, DstT>(b4ptr, b2ptr, b1ptr, dstptr, row, col, scales,
                                                                     sdtype, zero_points, k_offset, n_offset, kblock,
                                                                     NPad, reinterpret_cast<int8_t*>(tmp), tmpsize);
@@ -677,7 +773,7 @@ class DecompressKBlockS6Fp {
                                   int kblock, int NPad, void* tmp, size_t tmpsize) {
     BTLA_CODE ret = BTLA_CODE::NotSupport;
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s6_fp<PackRow, NTILE, DstT>(b4ptr, b2ptr, dstptr, row, col, scales, sdtype,
                                                                     zero_points, k_offset, n_offset, kblock, NPad,
                                                                     reinterpret_cast<int8_t*>(tmp), tmpsize);
@@ -706,7 +802,7 @@ class DecompressKBlockS5Fp {
                                   int kblock, int NPad, void* tmp, size_t tmpsize) {
     BTLA_CODE ret = BTLA_CODE::NotSupport;
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s5_fp<PackRow, NTILE, DstT>(b4ptr, b1ptr, dstptr, row, col, scales, sdtype,
                                                                     zero_points, k_offset, n_offset, kblock, NPad,
                                                                     reinterpret_cast<int8_t*>(tmp), tmpsize);
@@ -735,7 +831,7 @@ class DecompressKBlockS4Fp {
                                   int NPad, void* tmp, size_t tmpsize) {
     BTLA_CODE ret = BTLA_CODE::NotSupport;
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s4_fp<PackRow, NTILE, DstT>(srcptr, dstptr, row, col, scales, sdtype,
                                                                     zero_points, k_offset, n_offset, kblock, NPad,
                                                                     reinterpret_cast<int8_t*>(tmp), tmpsize);
@@ -764,7 +860,7 @@ class DecompressKBlockS3Fp {
                                   int kblock, int NPad, void* tmp, size_t tmpsize) {
     BTLA_CODE ret = BTLA_CODE::NotSupport;
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s3_fp<PackRow, NTILE, DstT>(b2ptr, b1ptr, dstptr, row, col, scales, sdtype,
                                                                     zero_points, k_offset, n_offset, kblock, NPad,
                                                                     reinterpret_cast<int8_t*>(tmp), tmpsize);
@@ -793,7 +889,7 @@ class DecompressKBlockS2Fp {
                                   size_t tmpsize) {
     BTLA_CODE ret = BTLA_CODE::NotSupport;
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s2_fp<PackRow, NTILE, DstT>(b2ptr, dstptr, row, col, scales, sdtype,
                                                                     zero_points, k_offset, n_offset, kblock, NPad,
                                                                     reinterpret_cast<int8_t*>(tmp), tmpsize);
@@ -822,7 +918,7 @@ class DecompressKBlockS1Fp {
                                   size_t tmpsize) {
     BTLA_CODE ret = BTLA_CODE::NotSupport;
 #if CompileAVX512F()
-    if constexpr (utils::isa_base<ISA_T>::avx512f) {
+    if constexpr (utils::isa_base<ISA_T>::avx512f && NTILE % 16 == 0) {
       return avx512f::decompress_kblock_s1_fp<PackRow, NTILE, DstT>(b1ptr, dstptr, row, col, scales, sdtype,
                                                                     zero_points, k_offset, n_offset, kblock, NPad,
                                                                     reinterpret_cast<int8_t*>(tmp), tmpsize);
@@ -1063,17 +1159,18 @@ class QuantS8RowReduceSum {
 template <typename _RT>
 class RowReduceSum {
  public:
-  template <BTLA_ISA ISA_T>
-  static inline BTLA_CODE forward(const float* srcptr, int ldsrc, int row, int col, _RT* reduce) {
+  TLACALL BTLA_CODE forward(const float* srcptr, int ldsrc, int row, int col, _RT* reduce) {
     return ref::row_reduce_sum<_RT>(srcptr, ldsrc, row, col, reduce);
   }
+  AUTOCALL BTLA_CODE forward_auto(const float* srcptr, int ldsrc, int row, int col, _RT* reduce) {
+    return forward<BTLA_ISA::NoSIMD>(srcptr, ldsrc, row, col, reduce);
+  }
 };
 
+template <typename SRC_T>
 class ColBlockReduceSum {
  public:
-  template <BTLA_ISA ISA_T, typename SRC_T>
-  static inline BTLA_CODE forward(const SRC_T* srcptr, int ldsrc, int row, int col, int blocksize, float* reduce,
-                                  int ldr) {
+  TLACALL BTLA_CODE forward(const SRC_T* srcptr, int ldsrc, int row, int col, int blocksize, float* reduce, int ldr) {
 #if CompileAVX512F()
     if constexpr (utils::isa_base<ISA_T>::avx512f && std::is_same_v<SRC_T, float>) {
       return avx512f::col_block_reduce_sum<SRC_T>(srcptr, ldsrc, row, col, blocksize, reduce, ldr);
@@ -1086,6 +1183,18 @@ class ColBlockReduceSum {
 #endif
     return ref::col_block_reduce_sum<SRC_T>(srcptr, ldsrc, row, col, blocksize, reduce, ldr);
   }
+
+  AUTOCALL BTLA_CODE forward_auto(const SRC_T* srcptr, int ldsrc, int row, int col, int blocksize, float* reduce,
+                                  int ldr) {
+    GetCPUDevice();
+    if (_cd->AVX512F()) {
+      return forward<BTLA_ISA::AVX512F>(srcptr, ldsrc, row, col, blocksize, reduce, ldr);
+    }
+    if (_cd->AVX2()) {
+      return forward<BTLA_ISA::AVX2>(srcptr, ldsrc, row, col, blocksize, reduce, ldr);
+    }
+    return forward<BTLA_ISA::NoSIMD>(srcptr, ldsrc, row, col, blocksize, reduce, ldr);
+  }
 };
 
 class RemoveZeroPointBias {
@@ -1180,13 +1289,13 @@ class GEMVWoqNBits {
                                             int ldc, int k, int blocksize, void* tmp, size_t tmpsize) {
     if (B.nbits == 6) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_6bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
 #endif
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512BW) {
+      if (ISA_T >= BTLA_ISA::AVX512BW && NTILE % 16 == 0) {
         return avx512f::gemv_6bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp, tmpsize);
       }
 #endif
@@ -1204,13 +1313,13 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 5) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_5bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
 #endif
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512BW) {
+      if (ISA_T >= BTLA_ISA::AVX512BW && NTILE % 16 == 0) {
         return avx512f::gemv_5bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp, tmpsize);
       }
 #endif
@@ -1228,13 +1337,13 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 4) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_4bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
 #endif
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512BW) {
+      if (ISA_T >= BTLA_ISA::AVX512BW && NTILE % 16 == 0) {
         return avx512f::gemv_4bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp, tmpsize);
       }
 #endif
@@ -1252,13 +1361,13 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 3) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_3bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
 #endif
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512BW) {
+      if (ISA_T >= BTLA_ISA::AVX512BW && NTILE % 16 == 0) {
         return avx512f::gemv_3bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp, tmpsize);
       }
 #endif
@@ -1276,13 +1385,13 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 2) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_2bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
 #endif
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512BW) {
+      if (ISA_T >= BTLA_ISA::AVX512BW && NTILE % 16 == 0) {
         return avx512f::gemv_2bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp, tmpsize);
       }
 #endif
@@ -1300,13 +1409,13 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 7) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_7bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
 #endif
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512BW) {
+      if (ISA_T >= BTLA_ISA::AVX512BW && NTILE % 16 == 0) {
         return avx512f::gemv_7bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp, tmpsize);
       }
 #endif
@@ -1324,13 +1433,13 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 1) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_1bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
 #endif
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512BW) {
+      if (ISA_T >= BTLA_ISA::AVX512BW && NTILE % 16 == 0) {
         return avx512f::gemv_1bit_u8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp, tmpsize);
       }
 #endif
@@ -1354,7 +1463,7 @@ class GEMVWoqNBits {
                                             int ldc, int k, int blocksize, void* tmp, size_t tmpsize) {
     if (B.nbits == 5) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_5bit_s8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
@@ -1368,7 +1477,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 4) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_4bit_s8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
@@ -1382,7 +1491,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 3) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_3bit_s8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
@@ -1396,7 +1505,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 2) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_2bit_s8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
@@ -1410,7 +1519,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 6) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_6bit_s8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
@@ -1424,7 +1533,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 7) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_7bit_s8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
@@ -1438,7 +1547,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 1) {
 #if CompileAVX512VNNI()
-      if (ISA_T >= BTLA_ISA::AVX512_VNNI) {
+      if (ISA_T >= BTLA_ISA::AVX512_VNNI && NTILE % 16 == 0) {
         return avx512f::vnni::gemv_1bit_s8s8_fp32<ScaleT, NTILE, MTILE>(A, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                         tmpsize);
       }
@@ -1458,7 +1567,7 @@ class GEMVWoqNBits {
                                             int ldc, int k, int blocksize, void* tmp, size_t tmpsize) {
     if (B.nbits == 6) {
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512F) {
+      if (ISA_T >= BTLA_ISA::AVX512F && NTILE % 16 == 0) {
         return avx512f::gemv_6bit_fp32_fp32<ScaleT, NTILE, MTILE>(A, lda, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                   tmpsize);
       }
@@ -1472,7 +1581,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 5) {
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512F) {
+      if (ISA_T >= BTLA_ISA::AVX512F && NTILE % 16 == 0) {
         return avx512f::gemv_5bit_fp32_fp32<ScaleT, NTILE, MTILE>(A, lda, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                   tmpsize);
       }
@@ -1486,7 +1595,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 4) {
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512F) {
+      if (ISA_T >= BTLA_ISA::AVX512F && NTILE % 16 == 0) {
         return avx512f::gemv_4bit_fp32_fp32<ScaleT, NTILE, MTILE>(A, lda, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                   tmpsize);
       }
@@ -1500,7 +1609,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 3) {
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512F) {
+      if (ISA_T >= BTLA_ISA::AVX512F && NTILE % 16 == 0) {
         return avx512f::gemv_3bit_fp32_fp32<ScaleT, NTILE, MTILE>(A, lda, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                   tmpsize);
       }
@@ -1514,7 +1623,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 2) {
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512F) {
+      if (ISA_T >= BTLA_ISA::AVX512F && NTILE % 16 == 0) {
         return avx512f::gemv_2bit_fp32_fp32<ScaleT, NTILE, MTILE>(A, lda, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                   tmpsize);
       }
@@ -1528,7 +1637,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 7) {
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512F) {
+      if (ISA_T >= BTLA_ISA::AVX512F && NTILE % 16 == 0) {
         return avx512f::gemv_7bit_fp32_fp32<ScaleT, NTILE, MTILE>(A, lda, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                   tmpsize);
       }
@@ -1542,7 +1651,7 @@ class GEMVWoqNBits {
     }
     if (B.nbits == 1) {
 #if CompileAVX512F()
-      if (ISA_T >= BTLA_ISA::AVX512F) {
+      if (ISA_T >= BTLA_ISA::AVX512F && NTILE % 16 == 0) {
         return avx512f::gemv_1bit_fp32_fp32<ScaleT, NTILE, MTILE>(A, lda, B, C, ldc, k, blocksize, (int8_t*)tmp,
                                                                   tmpsize);
       }
diff --git a/bestla/bestla/ut/bestla_benchmark.cpp b/bestla/bestla/ut/bestla_benchmark.cpp
index 8d62b1fac..c9d1f0195 100644
--- a/bestla/bestla/ut/bestla_benchmark.cpp
+++ b/bestla/bestla/ut/bestla_benchmark.cpp
@@ -21,20 +21,19 @@ class Benchmark_Fp32Fp32 {
   void benchmark(int m, int n, int k, int batch, AType* A, BType* B, CType* C, float timems, int threads) {
     LOG_T log;
     using Parallel = parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher =
-        wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
-                                    epilogue::gemm::AccumulatorWriteBackFp32>;
-    Launcher kernel;
+    using Launcher = wrapper::gemm::LauncherBase<Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                                 epilogue::gemm::AccumulatorWriteBackFp32>;
+
     UT_Threading::set_threads(threads);
     auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
-    auto tmpB = kernel.mProB.createStorage(n, k);
+    auto tmpB = Launcher::PrologueB::createStorage(n, k);
     std::vector<storage::gemm::StoragePackedWeight> packBs(batch, 0);
     avector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
       packBs[i].assign(bufB.data() + i * tmpB.mSize);
-      kernel.mProB.packWeight(n, k, {B + i * n * k, n, &packBs[i]}, UT_Threading::get());
+      Launcher::PrologueB::packWeight(n, k, {B + i * n * k, n, &packBs[i]}, UT_Threading::get());
     }
     auto psize = (size_t)m * n * k * 2;
     tm.start();
@@ -43,7 +42,7 @@ class Benchmark_Fp32Fp32 {
         log.start();
         utils::GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {0, 0, &packBs[i]}, {C + i * m * n, n}};
-        parallel::GemmRun<Parallel>(kernel, args, UT_Threading::get());
+        parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
         log.stop();
         if (tm.stop() >= timems) {
           break;
@@ -103,20 +102,18 @@ class Benchmark_U8S8S32 {
   void benchmark(int m, int n, int k, int batch, AType* A, BType* B, CType* C, float timems, int threads) {
     LOG_T log;
     using Parallel = parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher =
-        wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
-                                    epilogue::gemm::AccumulatorWriteBackInt32>;
-    static Launcher kernel;
+    using Launcher = wrapper::gemm::LauncherBase<Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                                 epilogue::gemm::AccumulatorWriteBackInt32>;
     UT_Threading::set_threads(threads);
     auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
-    auto tmpB = kernel.mProB.createStorage(n, k);
+    auto tmpB = Launcher::PrologueB::createStorage(n, k);
     std::vector<storage::gemm::StoragePackedWeight> packBs(batch, 0);
     avector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
       packBs[i].assign(bufB.data() + i * tmpB.mSize);
-      kernel.mProB.packWeight(n, k, {B + i * n * k, n, &packBs[i]}, UT_Threading::get());
+      Launcher::PrologueB::packWeight(n, k, {B + i * n * k, n, &packBs[i]}, UT_Threading::get());
     }
     auto psize = (size_t)m * n * k * 2;
     tm.start();
@@ -125,7 +122,7 @@ class Benchmark_U8S8S32 {
         log.start();
         utils::GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {0, 0, &packBs[i]}, {C + i * m * n, n}};
-        parallel::GemmRun<Parallel>(kernel, args, UT_Threading::get());
+        parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
         log.stop();
         if (tm.stop() >= timems) {
           break;
@@ -197,20 +194,19 @@ class Benchmark_S8S8S32 {
   void benchmark(int m, int n, int k, int batch, AType* A, BType* B, CType* C, float timems, int threads) {
     LOG_T log;
     using Parallel = parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher =
-        wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
-                                    epilogue::gemm::AccumulatorWriteBackInt32>;
-    Launcher kernel;
+    using Launcher = wrapper::gemm::LauncherBase<Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                                 epilogue::gemm::AccumulatorWriteBackInt32>;
+
     UT_Threading::set_threads(threads);
     auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
-    auto tmpB = kernel.mProB.createStorage(n, k);
+    auto tmpB = Launcher::PrologueB::createStorage(n, k);
     std::vector<storage::gemm::StoragePackedWeight> packBs(batch, 0);
     avector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
       packBs[i].assign(bufB.data() + i * tmpB.mSize);
-      kernel.mProB.packWeight(n, k, {B + i * n * k, n, &packBs[i]}, UT_Threading::get());
+      Launcher::PrologueB::packWeight(n, k, {B + i * n * k, n, &packBs[i]}, UT_Threading::get());
     }
     auto psize = (size_t)m * n * k * 2;
     tm.start();
@@ -219,7 +215,7 @@ class Benchmark_S8S8S32 {
         log.start();
         utils::GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {0, 0, &packBs[i]}, {C + i * m * n, n}};
-        parallel::GemmRun<Parallel>(kernel, args, UT_Threading::get());
+        parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
         log.stop();
         if (tm.stop() >= timems) {
           break;
@@ -291,20 +287,19 @@ class Benchmark_Bf16Bf16Fp32 {
   void benchmark(int m, int n, int k, int batch, AType* A, BType* B, CType* C, float timems, int threads) {
     LOG_T log;
     using Parallel = parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher =
-        wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
-                                    epilogue::gemm::AccumulatorWriteBackFp32>;
-    Launcher kernel;
+    using Launcher = wrapper::gemm::LauncherBase<Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                                 epilogue::gemm::AccumulatorWriteBackFp32>;
+
     UT_Threading::set_threads(threads);
     auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
-    auto tmpB = kernel.mProB.createStorage(n, k);
+    auto tmpB = Launcher::PrologueB::createStorage(n, k);
     std::vector<storage::gemm::StoragePackedWeight> packBs(batch, 0);
     avector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
       packBs[i].assign(bufB.data() + i * tmpB.mSize);
-      kernel.mProB.packWeight(n, k, {B + i * n * k, n, &packBs[i]}, UT_Threading::get());
+      Launcher::PrologueB::packWeight(n, k, {B + i * n * k, n, &packBs[i]}, UT_Threading::get());
     }
     auto psize = (size_t)m * n * k * 2;
     tm.start();
@@ -313,7 +308,7 @@ class Benchmark_Bf16Bf16Fp32 {
         log.start();
         utils::GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {0, 0, &packBs[i]}, {C + i * m * n, n}};
-        parallel::GemmRun<Parallel>(kernel, args, UT_Threading::get());
+        parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
         log.stop();
         if (tm.stop() >= timems) {
           break;
@@ -372,20 +367,19 @@ class Benchmark_Fp16Fp16Fp16 {
   void benchmark(int m, int n, int k, int batch, AType* A, BType* B, CType* C, float timems, int threads) {
     LOG_T log;
     using Parallel = parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher =
-        wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
-                                    epilogue::gemm::AccumulatorWriteBackFp16>;
-    Launcher kernel;
+    using Launcher = wrapper::gemm::LauncherBase<Core_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                                 epilogue::gemm::AccumulatorWriteBackFp16>;
+
     UT_Threading::set_threads(threads);
     auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
-    auto tmpB = kernel.mProB.createStorage(n, k);
+    auto tmpB = Launcher::PrologueB::createStorage(n, k);
     std::vector<storage::gemm::StoragePackedWeight> packBs(batch, 0);
     avector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
       packBs[i].assign(bufB.data() + i * tmpB.mSize);
-      kernel.mProB.packWeight(n, k, {B + i * n * k, n, &packBs[i]}, UT_Threading::get());
+      Launcher::PrologueB::packWeight(n, k, {B + i * n * k, n, &packBs[i]}, UT_Threading::get());
     }
     auto psize = (size_t)m * n * k * 2;
     tm.start();
@@ -394,7 +388,7 @@ class Benchmark_Fp16Fp16Fp16 {
         log.start();
         GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {0, 0, &packBs[i]}, {C + i * m * n, n}};
-        parallel::GemmRun<Parallel>(kernel, args, UT_Threading::get());
+        parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
         log.stop();
         if (tm.stop() >= timems) {
           break;
@@ -475,26 +469,25 @@ class UTWOQ_CompFp32 {
     benchmark_all<prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(1024, 4096, 4096, BTLA_DTYPE::F4_BNB);
   }
 
-  template <typename Core_T, typename LOG_T, template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  template <typename Core_T, typename LOG_T, template <class _T> class Wei, typename Scale_T>
   void benchmark(int m, int n, int k, int batch, int blocksize, float* A, float* B, float* C, float timems, int threads,
                  BTLA_DTYPE qtype, bool isasym) {
     LOG_T log;
     using Parallel = parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher = wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationBase, Wei,
+    using Launcher = wrapper::gemm::LauncherBase<Core_T, prologue_a::gemm::ActivationBase, Wei,
                                                  epilogue::gemm::AccumulatorWriteBackFp32>;
-    Launcher kernel;
+
     UT_Threading::set_threads(threads);
     auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
-    using WType = typename Wei<Core_T, Core_T::ISA>::StorageWeight;
+    using WType = typename Wei<Core_T>::StorageWeight;
     WType tmpB(0);
-    if constexpr (std::is_same_v<Wei<Core_T, Core_T::ISA>,
-                                 prologue_b::gemm::WeightKBlockNInteger<Core_T, Core_T::ISA>>) {
-      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, isasym);
+    if constexpr (std::is_same_v<Wei<Core_T>, prologue_b::gemm::WeightKBlockNInteger<Core_T>>) {
+      tmpB = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>,
+                                                isasym);
 
-    } else if constexpr (std::is_same_v<Wei<Core_T, Core_T::ISA>,
-                                        prologue_b::gemm::WeightKBlockNFloat<Core_T, Core_T::ISA>>) {
-      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
+    } else if constexpr (std::is_same_v<Wei<Core_T>, prologue_b::gemm::WeightKBlockNFloat<Core_T>>) {
+      tmpB = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
     }
     std::vector<WType> packBs(batch, 0);
     avector<int8_t> bufB(tmpB.mSize * batch);
@@ -502,7 +495,7 @@ class UTWOQ_CompFp32 {
       packBs[i] = tmpB;
       packBs[i].assign(bufB.data() + i * tmpB.mSize);
     }
-    kernel.mProB.packWeight(n, k, B, n, &packBs[0], UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, B, n, &packBs[0], UT_Threading::get());
     for (size_t i = 1; i < batch; i++) {
       memcpy(packBs[i].template WPtr<void>(), packBs[0].template WPtr<void>(), packBs[0].template WSize<char>());
       memcpy(packBs[i].template SPtr<void>(), packBs[0].template SPtr<void>(), packBs[0].CSize() * sizeof(Scale_T));
@@ -517,7 +510,7 @@ class UTWOQ_CompFp32 {
         log.start();
         GemmProblem gp(1, m, n, k, blocksize);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {&packBs[i]}, {C + i * m * n, n}};
-        parallel::GemmRun<Parallel>(kernel, args, UT_Threading::get());
+        parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
         log.stop();
         if (tm.stop() >= timems) {
           break;
@@ -532,7 +525,7 @@ class UTWOQ_CompFp32 {
            corestr, log.get_log_str(), flops, flops / cores, band);
   }
 
-  template <template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  template <template <class _T> class Wei, typename Scale_T>
   void benchmark_all(int m, int n, int k, BTLA_DTYPE qtype, bool isasym = false) {
     auto memsize = gemm_memsize(m, n, k, BTLA_DTYPE::F32, qtype, BTLA_DTYPE::F32);
     int batch = auto_batch(memsize);
@@ -595,26 +588,25 @@ class UTWOQ_CompBf16 {
     benchmark_all<prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2048, 4096, 4096, BTLA_DTYPE::F4_BNB);
   }
 
-  template <typename Core_T, typename LOG_T, template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  template <typename Core_T, typename LOG_T, template <class _T> class Wei, typename Scale_T>
   void benchmark(int m, int n, int k, int batch, int blocksize, float* A, float* B, float* C, float timems, int threads,
                  BTLA_DTYPE qtype) {
     LOG_T log;
     using Parallel = parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher = wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationConverterFp32, Wei,
+    using Launcher = wrapper::gemm::LauncherBase<Core_T, prologue_a::gemm::ActivationConverterFp32, Wei,
                                                  epilogue::gemm::AccumulatorWriteBackFp32>;
-    Launcher kernel;
+
     UT_Threading::set_threads(threads);
     auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
-    using WType = typename Wei<Core_T, Core_T::ISA>::StorageWeight;
+    using WType = typename Wei<Core_T>::StorageWeight;
     WType tmpB(0);
-    if constexpr (std::is_same_v<Wei<Core_T, Core_T::ISA>,
-                                 prologue_b::gemm::WeightKBlockNInteger<Core_T, Core_T::ISA>>) {
-      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
+    if constexpr (std::is_same_v<Wei<Core_T>, prologue_b::gemm::WeightKBlockNInteger<Core_T>>) {
+      tmpB =
+          Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
 
-    } else if constexpr (std::is_same_v<Wei<Core_T, Core_T::ISA>,
-                                        prologue_b::gemm::WeightKBlockNFloat<Core_T, Core_T::ISA>>) {
-      tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
+    } else if constexpr (std::is_same_v<Wei<Core_T>, prologue_b::gemm::WeightKBlockNFloat<Core_T>>) {
+      tmpB = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
     }
     std::vector<WType> packBs(batch, 0);
     avector<int8_t> bufB(tmpB.mSize * batch);
@@ -622,7 +614,7 @@ class UTWOQ_CompBf16 {
       packBs[i] = tmpB;
       packBs[i].assign(bufB.data() + i * tmpB.mSize);
     }
-    kernel.mProB.packWeight(n, k, B, n, &packBs[0], UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, B, n, &packBs[0], UT_Threading::get());
     for (size_t i = 1; i < batch; i++) {
       memcpy(packBs[i].template WPtr<void>(), packBs[0].template WPtr<void>(), packBs[0].template WSize<char>());
       memcpy(packBs[i].template SPtr<void>(), packBs[0].template SPtr<void>(), packBs[0].CSize() * sizeof(Scale_T));
@@ -637,7 +629,7 @@ class UTWOQ_CompBf16 {
         log.start();
         GemmProblem gp(1, m, n, k);
         typename Launcher::Param args{gp, {A + i * m * k, k}, {&packBs[i]}, {C + i * m * n, n}};
-        parallel::GemmRun<Parallel>(kernel, args, UT_Threading::get());
+        parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
         log.stop();
         if (tm.stop() >= timems) {
           break;
@@ -652,7 +644,7 @@ class UTWOQ_CompBf16 {
            corestr, log.get_log_str(), flops, flops / cores, band);
   }
 
-  template <template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  template <template <class _T> class Wei, typename Scale_T>
   void benchmark_all(int m, int n, int k, BTLA_DTYPE qtype) {
     auto memsize = gemm_memsize(m, n, k, BTLA_DTYPE::F32, qtype, BTLA_DTYPE::F32);
     int batch = auto_batch(memsize);
@@ -715,31 +707,32 @@ class UTWOQ_CompInt8 {
 
   using PcWriteBack = epilogue::gemm::PcKBlockCompInt8Epilogue<epilogue::gemm::AccumulatorWriteBackFp32>;
 
-  template <typename Core_T, typename LOG_T, template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  template <typename Core_T, typename LOG_T, template <class _T> class Wei, typename Scale_T>
   void benchmark_pc(int m, int n, int k, int batch, int blocksize, float* A, float* B, float* C, float timems,
                     int threads, BTLA_DTYPE qtype, bool isasym) {
     LOG_T log;
     using Parallel = parallel::gemm::SchedulerBase<Core_T>;
-    using Launcher = wrapper::gemm::LauncherBase<Core_T::ISA, Core_T, prologue_a::gemm::ActivationF32KBlockQuantize,
-                                                 Wei, PcWriteBack>;
-    Launcher kernel;
+    using Launcher =
+        wrapper::gemm::LauncherBase<Core_T, prologue_a::gemm::ActivationF32KBlockQuantize, Wei, PcWriteBack>;
+
     UT_Threading::set_threads(threads);
     auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
-    using WType = typename Wei<Core_T, Core_T::ISA>::StorageWeight;
-    WType tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, isasym);
+    using WType = typename Wei<Core_T>::StorageWeight;
+    WType tmpB =
+        Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, isasym);
     std::vector<WType> packBs(batch, 0);
     avector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
       packBs[i].assign(bufB.data() + i * tmpB.mSize);
     }
-    kernel.mProB.packWeight(n, k, B, n, &packBs[0], UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, B, n, &packBs[0], UT_Threading::get());
     for (size_t i = 1; i < batch; i++) {
       memcpy(packBs[i].template WPtr<void>(), packBs[0].template WPtr<void>(), packBs[0].template WSize<char>());
       memcpy(packBs[i].template SPtr<void>(), packBs[0].template SPtr<void>(), packBs[0].CSize() * sizeof(Scale_T));
     }
-    auto quanA = kernel.mProA.createStorage(m, k, blocksize, false);
+    auto quanA = Launcher::PrologueA::createStorage(m, k, blocksize, false);
     utils::avector<int8_t> bufferA(quanA.mSize);
     quanA.assign(bufferA.data());
     auto psize = (size_t)m * n * k * 2;
@@ -761,7 +754,7 @@ class UTWOQ_CompInt8 {
             {{packBs[i].template SPtr<char>(), packBs[i].SDtype(), quanA.template SPtr<float>(),
               quanA.template ZPtr<uint8_t>(), packBs[i].template RPtr<char>(), packBs[i].RDtype(), nullptr, nullptr, k},
              {C + i * m * n, n}}};
-        parallel::GemmRunWithA<Parallel>(kernel, args, UT_Threading::get());
+        parallel::GemmRunWithA<Parallel, Launcher>(args, UT_Threading::get());
         log.stop();
         if (tm.stop() >= timems) {
           break;
@@ -776,32 +769,32 @@ class UTWOQ_CompInt8 {
            corestr, log.get_log_str(), flops, flops / cores, band);
   }
 
-  template <typename Core_T, typename LOG_T, template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  template <typename Core_T, typename LOG_T, template <class _T> class Wei, typename Scale_T>
   void benchmark(int m, int n, int k, int batch, int blocksize, float* A, float* B, float* C, float timems, int threads,
                  BTLA_DTYPE qtype, bool isasym) {
     LOG_T log;
     using Parallel = parallel::gemm::SchedulerKBlockS<Core_T>;
-    using Launcher =
-        wrapper::gemm::LauncherIntKBlock<Core_T::ISA, Core_T, prologue_a::gemm::ActivationF32KBlockQuantize, Wei,
-                                         epilogue::gemm::AccumulatorWriteBackFp32>;
-    Launcher kernel;
+    using Launcher = wrapper::gemm::LauncherIntKBlock<Core_T, prologue_a::gemm::ActivationF32KBlockQuantize, Wei,
+                                                      epilogue::gemm::AccumulatorWriteBackFp32>;
+
     UT_Threading::set_threads(threads);
     auto corestr = gemm::CoreAttr::to_str(Core_T::ID);
     utils::timer<std::chrono::milliseconds> tm;
-    using WType = typename Wei<Core_T, Core_T::ISA>::StorageWeight;
-    WType tmpB = kernel.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, isasym);
+    using WType = typename Wei<Core_T>::StorageWeight;
+    WType tmpB =
+        Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, isasym);
     std::vector<WType> packBs(batch, 0);
     avector<int8_t> bufB(tmpB.mSize * batch);
     for (size_t i = 0; i < batch; i++) {
       packBs[i] = tmpB;
       packBs[i].assign(bufB.data() + i * tmpB.mSize);
     }
-    kernel.mProB.packWeight(n, k, B, n, &packBs[0], UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, B, n, &packBs[0], UT_Threading::get());
     for (size_t i = 1; i < batch; i++) {
       memcpy(packBs[i].template WPtr<void>(), packBs[0].template WPtr<void>(), packBs[0].template WSize<char>());
       memcpy(packBs[i].template SPtr<void>(), packBs[0].template SPtr<void>(), packBs[0].CSize() * sizeof(Scale_T));
     }
-    auto quanA = kernel.mProA.createStorage(m, k, blocksize, false);
+    auto quanA = Launcher::PrologueA::createStorage(m, k, blocksize, false);
     utils::avector<int8_t> bufferA(quanA.mSize);
     quanA.assign(bufferA.data());
     auto psize = (size_t)m * n * k * 2;
@@ -817,7 +810,7 @@ class UTWOQ_CompInt8 {
         log.start();
         GemmProblem gp(1, m, n, k, blocksize);
         typename Launcher::Param args{gp, {A + i * m * k, k, &quanA}, {&packBs[i]}, {C + i * m * n, n}};
-        parallel::GemmRunWithA<Parallel>(kernel, args, UT_Threading::get());
+        parallel::GemmRunWithA<Parallel, Launcher>(args, UT_Threading::get());
         log.stop();
         if (tm.stop() >= timems) {
           break;
@@ -831,7 +824,7 @@ class UTWOQ_CompInt8 {
            corestr, log.get_log_str(), flops, flops / threads, band);
   }
 
-  template <template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  template <template <class _T> class Wei, typename Scale_T>
   void benchmark_all(int m, int n, int k, BTLA_DTYPE qtype, bool isasym = false) {
     auto memsize = gemm_memsize(m, n, k, BTLA_DTYPE::F32, qtype, BTLA_DTYPE::F32);
     int batch = auto_batch(memsize);
diff --git a/bestla/bestla/ut/bestla_parallel.cpp b/bestla/bestla/ut/bestla_parallel.cpp
index 274b6c5ab..b92924fc5 100644
--- a/bestla/bestla/ut/bestla_parallel.cpp
+++ b/bestla/bestla/ut/bestla_parallel.cpp
@@ -144,11 +144,11 @@ class UT_SchedulerGemmKBlockNew {
     ut<gemm::ICoreRowNAmxint8SS<64, 16>>(1, 4096, 4096, 64, 24, 32 * 1024);
     ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 64, 24);
     ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 4096, 56);
-    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 32, 56);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 4096, 64, 56);
     ut<gemm::ICoreRowNAmxint8SS<64, 16>>(4, 4096, 4096, 128, 48);
-    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(4, 4096, 3072, 32, 48);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(4, 4096, 3072, 64, 48);
     ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 3072, 3072, 48);
-    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 3072, 32, 56);
+    ut<gemm::ICoreRowNAmxint8SS<64, 16>>(2048, 4096, 3072, 64, 56);
   }
 
   template <class GemmCore_T>
diff --git a/bestla/bestla/ut/bestla_prologue_a.cpp b/bestla/bestla/ut/bestla_prologue_a.cpp
index 3c79b5e8c..34fc9b32a 100644
--- a/bestla/bestla/ut/bestla_prologue_a.cpp
+++ b/bestla/bestla/ut/bestla_prologue_a.cpp
@@ -2,7 +2,6 @@
 #include "bestla_ut.h"
 #include "kernel_avx512f.h"
 
-#ifdef BTLA_UT_PROLOGUE_A
 namespace bestla {
 using namespace utils;
 namespace ut {
@@ -25,15 +24,16 @@ class UT_ActivationBase {
     for (int i = 0; i < src.size(); i++) {
       src[i] = static_cast<BType>(i);
     }
-    prologue_a::gemm::ActivationBase<_T, BTLA_ISA::NoSIMD> reorderref;
-    prologue_a::gemm::ActivationBase<_T, BTLA_ISA::AVX512F> reorderavx512;
+    using ProA = prologue_a::gemm::ActivationBase<_T>;
     auto dstrefptr = dstref.data();
     auto dstptr = dst.data();
     int dststride = 0;
-    reorderref.getActivation(&dstrefptr, &dststride, {src.data(), lda}, m, k, 0, 0, cache, CacheSize);
+    ProA::template getActivation<BTLA_ISA::NoSIMD>(&dstrefptr, &dststride, {src.data(), lda}, m, k, 0, 0, cache,
+                                                   CacheSize);
     GetCPUDevice();
     if (_cd->AVX512F()) {
-      reorderavx512.getActivation(&dstptr, &dststride, {src.data(), lda}, m, k, 0, 0, cache, CacheSize);
+      ProA::template getActivation<BTLA_ISA::AVX512F>(&dstptr, &dststride, {src.data(), lda}, m, k, 0, 0, cache,
+                                                      CacheSize);
       ut::buffer_error(dst.data(), dstref.data(), dst.size());
     }
   }
@@ -64,14 +64,15 @@ class UT_ActivationConverter {
     for (int i = 0; i < src.size(); i++) {
       src[i] = static_cast<SrcType>(float(i));
     }
-    prologue_a::gemm::ActivationConverter<_T, BTLA_ISA::NoSIMD, SRC_T> reorderref;
-    prologue_a::gemm::ActivationConverter<_T, BTLA_ISA::AVX512F, SRC_T> reorderavx512;
+    using ProA = prologue_a::gemm::ActivationConverter<_T, SRC_T>;
     auto dstptr = dstref.data();
     int dststride = 0;
-    auto ret = reorderref.getActivation(&dstptr, &dststride, {src.data(), lda}, m, k, 0, 0, cache, CacheSize);
+    auto ret = ProA::template getActivation<BTLA_ISA::NoSIMD>(&dstptr, &dststride, {src.data(), lda}, m, k, 0, 0, cache,
+                                                              CacheSize);
     assert(ret == BTLA_CODE::Success);
     dstptr = dst.data();
-    ret = reorderavx512.getActivation(&dstptr, &dststride, {src.data(), lda}, m, k, 0, 0, cache, CacheSize);
+    ret = ProA::template getActivation<BTLA_ISA::AVX512F>(&dstptr, &dststride, {src.data(), lda}, m, k, 0, 0, cache,
+                                                          CacheSize);
     assert(ret == BTLA_CODE::Success);
     ut::buffer_error(dst.data(), dstref.data(), dst.size(), AType{0});
     aligned_vector<SrcType> revert(dst.size());
@@ -127,11 +128,12 @@ class UT_ActivationU8KBlockQuantize {
 
     kernel::ref::quantize_fp_u8_colblock(m, k, raw.data(), lda, q.data(), lda, scales.data(), kcount, zp.data(), kblock,
                                          hasreduce ? reduce.data() : nullptr);
-    prologue_a::gemm::ActivationF32KBlockQuantize<_T, _T::ISA> actA;
-    auto quanAct = actA.createStorage(m, k, kblock, hasreduce);
+    using ProA = prologue_a::gemm::ActivationF32KBlockQuantize<_T>;
+    auto constexpr ISA = _T::ISA;
+    auto quanAct = ProA::createStorage(m, k, kblock, hasreduce);
     avector<int8_t> bufA(quanAct.mSize);
     quanAct.assign(bufA.data());
-    actA.quantize({raw.data(), lda, &quanAct}, m, k, UT_Threading::get());
+    ProA::quantize({raw.data(), lda, &quanAct}, m, k, UT_Threading::get());
 
     ut::buffer_error(q.data(), quanAct.template APtr<uint8_t>(), q.size(), uint8_t(1));
     ut::buffer_error(zp.data(), quanAct.template ZPtr<uint8_t>(), zp.size(), uint8_t(1));
@@ -182,11 +184,12 @@ class UT_ActivationS8KBlockQuantize {
     q.resize(m * lda);
     kernel::ref::quantize_fp_s8_colblock(m, k, raw.data(), k, q.data(), lda, scales.data(), kcount, kblock,
                                          hasreduce ? reduce.data() : nullptr);
-    prologue_a::gemm::ActivationF32KBlockQuantize<_T, BTLA_ISA::AVX512F> actA;
-    auto quanAct = actA.createStorage(m, k, kblock, hasreduce);
+    using ProA = prologue_a::gemm::ActivationF32KBlockQuantize<_T>;
+    auto quanAct = ProA::createStorage(m, k, kblock, hasreduce);
+    auto constexpr ISA = BTLA_ISA::AVX512F;
     avector<int8_t> bufA(quanAct.mSize);
     quanAct.assign(bufA.data());
-    actA.quantize({raw.data(), k, &quanAct}, m, k, UT_Threading::get());
+    ProA::quantize({raw.data(), k, &quanAct}, m, k, UT_Threading::get());
     ut::buffer_error(q.data(), quanAct.template APtr<int8_t>(), q.size(), int8_t(1));
     if (hasreduce) {
       avector<float> redref(reduce.size(), 0.f), redqref(reduce.size(), 0.f);
@@ -210,8 +213,10 @@ class UT_ShuffleActivationKblock {
  public:
   UT_ShuffleActivationKblock() {
     UT_START();
+    CheckISA(AVX2);
     ut<float, gemm::SCoreRowNAvx2<48, 2>>(15, 63);
     ut<bf16, gemm::SCoreRowNAvx2<48, 2>>(15, 63);
+    CheckISA(AMX_BF16);
     ut<float, gemm::HCoreRowNAmxbf16<64, 16>>(15, 63);
     ut<bf16, gemm::HCoreRowNAmxbf16<64, 16>>(15, 63);
     dynamic_ut(15, 63, 2, true);
@@ -228,17 +233,17 @@ class UT_ShuffleActivationKblock {
       indices[i] = i % 2 == 0 ? (i + 1) == indices.size() ? i : i + 1 : i - 1;
     }
     for (int i = 0; i < src.size(); i++) src[i] = static_cast<_SRC_T>(i);
-    prologue_a::gemm::ShuffleActivationKBlockBase<GC, BTLA_ISA::NoSIMD, _SRC_T> kernel;
+    using ProA = prologue_a::gemm::ShuffleActivationKBlockBase<GC, _SRC_T>;
     auto dstrefptr = dstref.data();
     auto dstptr = dst.data();
     int dststride = 0;
-    auto reordA = kernel.createReorderStorage(m, k, 32);
+    auto reordA = ProA::createReorderStorage(m, k, 32);
     avector<int8_t> bufA(reordA.mSize);
     reordA.assign(bufA.data());
-    kernel.preprocess({src.data(), k, nullptr, indices.data(), &reordA}, m, k, 32, UT_Threading::get());
+    ProA::preprocess({src.data(), k, nullptr, indices.data(), &reordA}, m, k, 32, UT_Threading::get());
 
-    kernel.getActivation(&dstptr, &dststride, {src.data(), k, nullptr, indices.data(), &reordA}, m, kpad, 0, 0, cache,
-                         CacheSize);
+    ProA::template getActivation<GC::ISA>(&dstptr, &dststride, {src.data(), k, nullptr, indices.data(), &reordA}, m,
+                                          kpad, 0, 0, cache, CacheSize);
     for (int i = 0; i < m; i++) {
       int j = 0;
       for (; j < k; j++) dstrefptr[i * kpad + j] = static_cast<BType>(src[i * k + indices[j]]);
@@ -266,13 +271,14 @@ class UT_ShuffleActivationKblock {
     kernel::ref::shuffle_activation(raw_cp.data(), raw.data(), m, k, 0, 0, indices.data(), k, k);
     kernel::ref::quantize_fp_s8_colblock(m, k, raw.data(), k, q.data(), lda, scales.data(), kcount, kblock,
                                          hasreduce ? reduce.data() : nullptr);
-    prologue_a::gemm::ShuffleActivationKBlockQuantize<GC, BTLA_ISA::NoSIMD, float> actA;
-    auto quanAct = actA.createQuantStorage(m, k, kblock, hasreduce);
-    auto reordAct = actA.createReorderStorage(m, k, kblock);
+    using ProA = prologue_a::gemm::ShuffleActivationKBlockQuantize<GC, float>;
+    auto constexpr RunISA = BTLA_ISA::NoSIMD;
+    auto quanAct = ProA::createQuantStorage(m, k, kblock, hasreduce);
+    auto reordAct = ProA::createReorderStorage(m, k, kblock);
     avector<int8_t> bufA(quanAct.mSize + reordAct.mSize);
     quanAct.assign(bufA.data());
     reordAct.assign(bufA.data() + quanAct.mSize);
-    actA.quantize({raw_cp.data(), k, &quanAct, indices.data(), &reordAct}, m, k, UT_Threading::get());
+    ProA::quantize({raw_cp.data(), k, &quanAct, indices.data(), &reordAct}, m, k, UT_Threading::get());
     ut::buffer_error(quanAct.template APtr<int8_t>(), q.data(), q.size(), int8_t(1));
     if (hasreduce) {
       avector<float> redref(reduce.size(), 0.f), redqref(reduce.size(), 0.f);
@@ -293,4 +299,3 @@ static UT_ShuffleActivationKblock sUT_ShuffleActivationKblock;
 #endif
 }  // namespace ut
 }  // namespace bestla
-#endif
diff --git a/bestla/bestla/ut/bestla_prologue_b.cpp b/bestla/bestla/ut/bestla_prologue_b.cpp
index 7f540f891..788026493 100644
--- a/bestla/bestla/ut/bestla_prologue_b.cpp
+++ b/bestla/bestla/ut/bestla_prologue_b.cpp
@@ -63,14 +63,14 @@ class UT_BlockQunatize_INT8 {
     }
 
     auto constexpr RuntimeISA = BTLA_ISA::AVX512F;
-    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
-    PrologueB kernel;
-    auto ptr = kernel.createStorage(n, k, blocksize, BTLA_DTYPE::S8, bestla_dtype<float>, bestla_dtype<float>, asym);
+    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<gemm::SCoreRowNAvx512f<48, 8>>;
+    auto ptr =
+        PrologueB::createStorage(n, k, blocksize, BTLA_DTYPE::S8, bestla_dtype<float>, bestla_dtype<float>, asym);
     avector<int8_t> buffer(ptr.mSize);
     ptr.assign(buffer.data());
-    kernel.packWeight(n, k, dequanRef.data(), ldb, &ptr, UT_Threading::get());
+    PrologueB::packWeight(n, k, dequanRef.data(), ldb, &ptr, UT_Threading::get());
     avector<float> dequant(n * k);
-    kernel.unpackWeight(n, k, &ptr, dequant.data(), n, UT_Threading::get());
+    PrologueB::unpackWeight(n, k, &ptr, dequant.data(), n, UT_Threading::get());
     ut::buffer_error(dequanRef.data(), dequant.data(), dequanRef.size(), 0.01f);
   }
 
@@ -110,15 +110,15 @@ class UT_BlockQunatize_INT8 {
     }
 
     auto constexpr RuntimeISA = BTLA_ISA::AVX512F;
-    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
-    PrologueB kernel;
-    auto ptr = kernel.createStorage(n, k, blocksize, BTLA_DTYPE::S8, bestla_dtype<float>, bestla_dtype<float>, asym);
+    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<gemm::SCoreRowNAvx512f<48, 8>>;
+    auto ptr =
+        PrologueB::createStorage(n, k, blocksize, BTLA_DTYPE::S8, bestla_dtype<float>, bestla_dtype<float>, asym);
     avector<int8_t> buffer(ptr.mSize);
     ptr.assign(buffer.data());
-    kernel.packTransposeWeight(n, k, dequanT.data(), k, &ptr, UT_Threading::get());
+    PrologueB::packTransposeWeight(n, k, dequanT.data(), k, &ptr, UT_Threading::get());
     avector<float> dequant(n * k), tardequanT(k * n);
-    kernel.unpackWeight(n, k, &ptr, dequant.data(), n, UT_Threading::get());
-    kernel.unpackTransposeWeight(n, k, &ptr, tardequanT.data(), k, UT_Threading::get());
+    PrologueB::unpackWeight(n, k, &ptr, dequant.data(), n, UT_Threading::get());
+    PrologueB::unpackTransposeWeight(n, k, &ptr, tardequanT.data(), k, UT_Threading::get());
     ut::buffer_error(dequanT.data(), tardequanT.data(), tardequanT.size(), 0.01f);
     ut::buffer_error(dequanRef.data(), dequant.data(), dequanRef.size(), 0.01f);
   }
@@ -127,45 +127,6 @@ class UT_BlockQunatize_INT8 {
 static UT_BlockQunatize_INT8 sUT_BlockQunatize_INT8;
 #endif
 
-class UT_BlockQunatize_F8 {
- public:
-  UT_BlockQunatize_F8() {
-    UT_START();
-    CheckISA(AVX512F);
-    ut(127, 1023, 32, BTLA_DTYPE::F8_E4M3);
-    ut(127, 1023, 32, BTLA_DTYPE::F8_E5M2);
-  }
-
-  void ut(int n, int k, int blocksize, BTLA_DTYPE QUANT_T) {
-    printf("%s: %d %d %d\n", __FUNCTION__, n, k, blocksize);
-    int ldb = n;
-    utils::aligned_vector<float> raw(n * k);
-    ut::fill_buffer_randn(raw.data(), raw.size(), -3.f, 3.f);
-
-    auto constexpr RuntimeISA = BTLA_ISA::AVX512F;
-    using PrologueB = prologue_b::gemm::WeightKBlockNFloat<gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
-    using refPorB = prologue_b::gemm::WeightKBlockNFloat<gemm::SCoreRowNAvx512f<48, 8>, BTLA_ISA::NoSIMD>;
-    PrologueB kernel;
-    refPorB ref_ker;
-    auto ptr = kernel.createStorage(n, k, blocksize, QUANT_T, BTLA_DTYPE::F8_E8M0);
-    auto ref_ptr = kernel.createStorage(n, k, blocksize, QUANT_T, BTLA_DTYPE::F8_E8M0);
-    avector<int8_t> buffer(ptr.mSize);
-    avector<int8_t> ref_buffer(ptr.mSize);
-    ptr.assign(buffer.data());
-    ref_ptr.assign(ref_buffer.data());
-    kernel.packWeight(n, k, raw.data(), ldb, &ptr, UT_Threading::get());
-    ref_ker.packWeight(n, k, raw.data(), ldb, &ref_ptr, UT_Threading::get());
-    avector<float> dequant(n * k, 0);
-    avector<float> ref_dequant(n * k, 0);
-    kernel.unpackWeight(n, k, &ptr, dequant.data(), n, UT_Threading::get());
-    ref_ker.unpackWeight(n, k, &ref_ptr, ref_dequant.data(), n, UT_Threading::get());
-    ut::buffer_error(ref_dequant.data(), dequant.data(), dequant.size(), 0.01f);
-  }
-};
-#ifdef BTLA_UT_PROLOGUE_B
-static UT_BlockQunatize_F8 sUT_BlockQunatize_F8;
-#endif
-
 class UT_BlockQunatize_SN {
  public:
   UT_BlockQunatize_SN() {
@@ -212,14 +173,13 @@ class UT_BlockQunatize_SN {
     int ldb = n;
     utils::aligned_vector<float> raw(n * k);
     ut::fill_buffer_randn(raw.data(), raw.size(), -0.5f, 0.5f);
-    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<GemmCore, RuntimeISA>;
-    PrologueB kernel;
-    auto ptr = kernel.createStorage(n, k, blocksize, QUANT_T, BTLA_DTYPE::F32, BTLA_DTYPE::F32, isAsym);
+    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<GemmCore>;
+    auto ptr = PrologueB::createStorage(n, k, blocksize, QUANT_T, BTLA_DTYPE::F32, BTLA_DTYPE::F32, isAsym);
     avector<int8_t> buffer(ptr.mSize);
     ptr.assign(buffer.data());
-    kernel.packWeight(n, k, raw.data(), ldb, &ptr, UT_Threading::get());
+    PrologueB::packWeight(n, k, raw.data(), ldb, &ptr, UT_Threading::get());
     avector<float> dequant(n * k, 0);
-    kernel.unpackWeight(n, k, &ptr, dequant.data(), n, UT_Threading::get());
+    PrologueB::unpackWeight(n, k, &ptr, dequant.data(), n, UT_Threading::get());
     ut::buffer_error(raw.data(), dequant.data(), dequant.size(), 0.01f);
   }
 };
@@ -303,17 +263,16 @@ class UT_TransposeBlockQuantize_F4 {
     }
 
     auto constexpr RuntimeISA = BTLA_ISA::AVX512F;
-    using PrologueB = prologue_b::gemm::WeightKBlockNFloat<gemm::SCoreRowNAvx512f<48, 8>, RuntimeISA>;
-    PrologueB kernel;
-    auto packedW = kernel.createStorage(n, k, blocksize, F4_T, SCA_T);
-    auto packedW1 = kernel.createStorage(n, k, blocksize, F4_T, SCA_T);
+    using PrologueB = prologue_b::gemm::WeightKBlockNFloat<gemm::SCoreRowNAvx512f<48, 8>>;
+    auto packedW = PrologueB::createStorage(n, k, blocksize, F4_T, SCA_T);
+    auto packedW1 = PrologueB::createStorage(n, k, blocksize, F4_T, SCA_T);
     avector<int8_t> buf(packedW.mSize), buf1(packedW1.mSize);
     packedW.assign(buf.data());
     packedW1.assign(buf1.data());
-    kernel.packTransposeWeight(n, k, dequanRef.data(), k, &packedW, UT_Threading::get());
-    kernel.packQWeight(n, k, quanW.data(), ldb, scales.data(), nullptr, &packedW1, UT_Threading::get());
+    PrologueB::packTransposeWeight(n, k, dequanRef.data(), k, &packedW, UT_Threading::get());
+    PrologueB::packQWeight(n, k, quanW.data(), ldb, scales.data(), nullptr, &packedW1, UT_Threading::get());
     avector<float> dequant(n * k);
-    kernel.unpackTransposeWeight(n, k, &packedW1, dequant.data(), k, UT_Threading::get());
+    PrologueB::unpackTransposeWeight(n, k, &packedW1, dequant.data(), k, UT_Threading::get());
     if (SCA_T != BTLA_DTYPE::DQ8_BNB) {
       ut::buffer_error(packedW.SPtr<float>(), packedW1.SPtr<float>(), packedW1.CSize());
       ut::buffer_error(dequanRef.data(), dequant.data(), dequant.size());
@@ -328,106 +287,6 @@ class UT_TransposeBlockQuantize_F4 {
 static UT_TransposeBlockQuantize_F4 sUT_TransposeBlockQuantize_F4;
 #endif
 
-class UT_BlockQuantize_INT4 {
- public:
-  UT_BlockQuantize_INT4() {
-    UT_START();
-    CheckISA(AVX2);
-    CheckISA(AVX512F);
-    ut_2(4096, 4096, 128, BTLA_DTYPE::S4_CLIP, false);
-    CheckISA(AVX512F);
-    ut_512vnni(4096, 4096, 128, BTLA_DTYPE::S4_CLIP, false);
-    ut_512vnni(4096, 4096, 128, BTLA_DTYPE::S4_CLIP, true);
-  }
-  void ut_2(int n, int k, int blocksize, BTLA_DTYPE qtype, bool asym = false) {
-    printf("Test Case: %d %d %d %s\n", n, k, blocksize, asym ? "asym" : "sym");
-    int ldb = n;
-    int kblk_num = utils::updiv(k, blocksize);
-    utils::aligned_vector<float> scales(kblk_num * n);
-    ut::fill_buffer_randn(scales.data(), scales.size(), 0.005f, 0.01f);
-    utils::aligned_vector<int8_t> zero_points(kblk_num * n);
-    ut::fill_buffer_randn(zero_points.data(), zero_points.size(), (int8_t)(-5), (int8_t)(5));
-    ut::UT_vector_s8 quanW;
-    quanW.resize(k * n);
-    quanW.fill_rand(-127, 127);
-    avector<float> dequant(quanW.size());
-    avector<float> reduce(scales.size(), 0.f);
-    for (int i = 0; i < k; i++) {
-      for (int j = 0; j < n; j++) {
-        quanW.data()[i * n + j] = quanW.data()[i * n + j] & 0xf0;
-        if (!asym) {
-          dequant[i * n + j] = quanW.data()[i * n + j] * scales[i / blocksize * n + j];
-        } else {
-          dequant[i * n + j] =
-              float(quanW.data()[i * n + j] - zero_points[i / blocksize * n + j]) * scales[i / blocksize * n + j];
-        }
-        reduce[i / blocksize * n + j] += dequant[i * n + j];
-      }
-    }
-
-    auto constexpr RuntimeISA = BTLA_ISA::AVX2;
-    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<gemm::SCoreRowNAvx2<48, 2>, BTLA_ISA::AVX2>;
-    using PrologueB512 = prologue_b::gemm::WeightKBlockNInteger<gemm::SCoreRowNAvx2<48, 2>, BTLA_ISA::AVX512F>;
-    PrologueB kernel;
-    PrologueB512 kernel512;
-    utils::aligned_vector<int8_t> retW(n * k);
-    auto packedW = kernel.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<float>, asym);
-    avector<int8_t> buffer(packedW.mSize);
-    packedW.assign(buffer.data());
-    kernel.packWeight(n, k, dequant.data(), ldb, &packedW, UT_Threading::get());
-    avector<float> unpackf32(dequant.size());
-    avector<float> unpack512f32(dequant.size());
-    kernel.unpackWeight(n, k, &packedW, unpackf32.data(), n, UT_Threading::get());
-    kernel512.unpackWeight(n, k, &packedW, unpack512f32.data(), n, UT_Threading::get());
-    ut::buffer_error(unpackf32.data(), unpack512f32.data(), unpackf32.size(), 0.01f);
-  }
-  void ut_512vnni(int n, int k, int blocksize, BTLA_DTYPE qtype, bool asym = false) {
-    printf("Test Case: %d %d %d %s\n", n, k, blocksize, asym ? "asym" : "sym");
-    int ldb = n;
-    int kblk_num = utils::updiv(k, blocksize);
-    utils::aligned_vector<float> scales(kblk_num * n);
-    ut::fill_buffer_randn(scales.data(), scales.size(), 0.005f, 0.01f);
-    utils::aligned_vector<int8_t> zero_points(kblk_num * n);
-    ut::fill_buffer_randn(zero_points.data(), zero_points.size(), (int8_t)(-5), (int8_t)(5));
-    ut::UT_vector_s8 quanW;
-    quanW.resize(k * n);
-    quanW.fill_rand(-127, 127);
-    avector<float> dequant(quanW.size());
-    avector<float> reduce(scales.size(), 0.f);
-    for (int i = 0; i < k; i++) {
-      for (int j = 0; j < n; j++) {
-        // quanW.data()[i * n + j] = quanW.data()[i * n + j] & 0xf0; //anyway there will be a float-rounding error
-        // about 1 LSB.
-        if (!asym) {
-          dequant[i * n + j] = quanW.data()[i * n + j] * scales[i / blocksize * n + j];
-        } else {
-          dequant[i * n + j] =
-              float(quanW.data()[i * n + j] - zero_points[i / blocksize * n + j]) * scales[i / blocksize * n + j];
-        }
-        reduce[i / blocksize * n + j] += dequant[i * n + j];
-      }
-    }
-
-    auto constexpr RuntimeISA = BTLA_ISA::AVX512_VNNI;
-    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<gemm::ICoreRowNAvx512vnni<48, 8>, RuntimeISA>;
-
-    PrologueB kernel;
-    utils::aligned_vector<int8_t> retW(n * k);
-    auto packedW = kernel.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<float>, asym);
-    avector<int8_t> buffer(packedW.mSize);
-    packedW.assign(buffer.data());
-    kernel.packWeight(n, k, dequant.data(), ldb, &packedW, UT_Threading::get());
-    avector<float> unpackf32(dequant.size());
-    kernel.unpackWeight(n, k, &packedW, unpackf32.data(), n, UT_Threading::get());
-    int lsb = 16;
-    float err_thres = lsb * 0.01f;  // lsb*max_scale
-    ut::buffer_error(dequant.data(), unpackf32.data(), dequant.size(), err_thres);
-  }
-};
-#ifdef BTLA_UT_PROLOGUE_B
-static UT_BlockQuantize_INT4 sUT_BlockQuantize_INT4;
-#endif
-
 class UT_StorageMemCheck {
  public:
   UT_StorageMemCheck() {
@@ -443,10 +302,10 @@ class UT_StorageMemCheck {
     int ldb = n;
     int kblk_num = utils::updiv(k, blocksize);
     using GemmCore = gemm::SCoreRowNAvx512f<48, 8>;
-    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<GemmCore, BTLA_ISA::AVX2>;
-    PrologueB ProWei;
+    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<GemmCore>;
 
-    auto packedW = ProWei.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<utils::bf16>, asym);
+    auto packedW =
+        PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<utils::bf16>, asym);
     avector<int8_t> buf0(packedW.mSize), buf1(packedW.mSize);
     packedW.assign(buf0.data());
     storage::gemm::StorageWeightKBlockNInteger tmp(GemmCore::ID);
@@ -460,10 +319,9 @@ class UT_StorageMemCheck {
     int ldb = n;
     int kblk_num = utils::updiv(k, blocksize);
     using GemmCore = gemm::HCoreRowNAmxbf16<64, 16>;
-    using PrologueB = prologue_b::gemm::WeightKBlockNFloat<GemmCore, BTLA_ISA::AMX_BF16>;
-    PrologueB ProWei;
+    using PrologueB = prologue_b::gemm::WeightKBlockNFloat<GemmCore>;
 
-    auto packedW = ProWei.createStorage(n, k, blocksize, qtype, bestla_dtype<float>);
+    auto packedW = PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<float>);
     avector<int8_t> buf0(packedW.mSize), buf1(packedW.mSize);
     packedW.assign(buf0.data());
     storage::gemm::StorageWeightKBlockNFloat tmp(GemmCore::ID);
@@ -490,10 +348,10 @@ class UT_ShuffleIndices {
     int ldb = n;
     int kblk_num = utils::updiv(k, blocksize);
     using GemmCore = gemm::SCoreRowNAvx2<24, 4>;
-    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<GemmCore, BTLA_ISA::AVX2>;
-    PrologueB ProWei;
-    auto packedW = ProWei.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<utils::bf16>, asym);
-    ProWei.enableShuffle(&packedW);
+    using PrologueB = prologue_b::gemm::WeightKBlockNInteger<GemmCore>;
+    auto packedW =
+        PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<utils::bf16>, asym);
+    PrologueB::enableShuffle(&packedW);
     avector<int> groupindices(k, 0);
     auto groupsize = utils::updiv(k, blocksize);
     avector<int> reflut(k, 0);
@@ -504,7 +362,7 @@ class UT_ShuffleIndices {
     }
     avector<int8_t> buf0(packedW.mSize), buf1(packedW.mSize);
     packedW.assign(buf0.data());
-    ProWei.setShuffleIndices(groupindices.data(), &packedW, UT_Threading::get());
+    PrologueB::setShuffleIndices(groupindices.data(), &packedW, UT_Threading::get());
     buffer_error(reflut.data(), packedW.ShfIndice(), reflut.size());
 
     storage::gemm::StorageWeightKBlockNInteger tmp(GemmCore::ID);
@@ -512,42 +370,6 @@ class UT_ShuffleIndices {
     tmp.serialize(buf1.data());
     buffer_error(buf0.data(), buf1.data(), buf0.size());
   }
-
-  void ut_file() {
-    int n = 14336;
-    int m = 8;
-    int k = 4096;
-    int blocksize = 32;
-    bool constexpr blauncher = true;
-    auto qtype = BTLA_DTYPE::S4_CLIP;
-    bool asym = true;
-    auto warray = ut::readFile2Buffer<int8_t>("src0_data.bin");
-    auto aarray = ut::readFile2Buffer<float>("src1_data.bin");
-    auto oarray = ut::readFile2Buffer<float>("tensor_data.bin");
-    auto refoarray = ut::readFile2Buffer<float>("tensor_data_ref.bin");
-    auto wptr = storage::gemm::PackedWeightParser::deserialBuffer(warray.data());
-    using GemmCore = gemm::SCoreRowNAvx512f<48, 8>;
-    auto wptr_ = reinterpret_cast<storage::gemm::StorageWeightKBlockNInteger*>(wptr);
-    utils::GemmProblem gp(1, m, n, k, blocksize);
-    avector<float> output(m * n);
-    if constexpr (blauncher) {
-      using Launcher =
-          wrapper::gemm::LauncherBase<GemmCore::ISA, GemmCore, prologue_a::gemm::ShuffleActivationKBlockBaseF32,
-                                      prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::AccumulatorWriteBackFp32>;
-      static Launcher kernel;
-      auto rordA = kernel.mProA.createReorderStorage(m, k, blocksize);
-      avector<int8_t> bufA(rordA.mSize);
-      rordA.assign(bufA.data());
-      typename Launcher::Param args{
-          gp, {aarray.data(), k, nullptr, wptr_->ShfIndice(), &rordA}, {wptr_}, {output.data(), n}};
-      parallel::GemmRunWithA<parallel::gemm::SchedulerBase<GemmCore>>(kernel, args, UT_Threading::get());
-    }
-
-    ut::buffer_error(output.data(), oarray.data(), output.size());
-    ut::buffer_error(output.data(), refoarray.data(), output.size());
-
-    delete wptr;
-  }
 };
 #ifdef BTLA_UT_PROLOGUE_B
 static UT_ShuffleIndices sUT_ShuffleIndices;
@@ -639,42 +461,42 @@ class UT_CompFp32 {
     ut<sAVX512F, prologue_b::gemm::WeightKBlockNFloat>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4, BTLA_DTYPE::BF16);
   }
 
-  template <class GemmCore_T, template <class _T, BTLA_ISA> class Wei>
+  template <class GemmCore_T, template <class _T> class Wei>
   void ut_int(int m, int n, int k, int blocksize, BTLA_DTYPE qtype, BTLA_DTYPE stype, bool isAsym) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s Asym:%d\n", __FUNCTION__, m, n, k, blocksize,
            bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), bestla_dtype_str(stype), isAsym);
     auto constexpr ISA = GemmCore_T::ISA;
     using Launcher =
-        wrapper::gemm::LauncherBase<ISA, GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32,
+        wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32,
                                     prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::AccumulatorWriteBackFp32>;
     using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-    Launcher launcher;
+
     blocksize = blocksize == -1 ? k : blocksize;
-    using WType = typename Wei<GemmCore_T, ISA>::StorageWeight;
+    using WType = typename Launcher::PrologueB::StorageWeight;
     WType packedw(0);
-    if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockNInteger<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, stype, bestla_dtype<float>, isAsym);
-    } else if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockNFloat<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, stype);
+    if constexpr (std::is_same_v<Wei<GemmCore_T>, prologue_b::gemm::WeightKBlockNInteger<GemmCore_T>>) {
+      packedw = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, stype, bestla_dtype<float>, isAsym);
+    } else if constexpr (std::is_same_v<Wei<GemmCore_T>, prologue_b::gemm::WeightKBlockNFloat<GemmCore_T>>) {
+      packedw = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, stype);
     }
 
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
-    auto reduceA = launcher.mProA.createStorage(m, k, blocksize);
+    auto reduceA = Launcher::PrologueA::createStorage(m, k, blocksize);
     utils::avector<int8_t> bufferA(packedw.mSize);
     reduceA.assign(bufferA.data());
     avector<float> matBf32(k * n), matAf32(m * k), matC(m * n), refC(m * n), refCupk(m * n);
     fill_buffer_randn(matBf32.data(), matBf32.size(), -0.5f, 0.5f);
     fill_buffer_randn(matAf32.data(), matAf32.size(), -0.5f, 0.5f);
-    launcher.mProB.packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refC.data(), k, n, n);
-    launcher.mProB.unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
+    Launcher::PrologueB::unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refCupk.data(), k, n, n);
 
-    launcher.mProA.reduce({matAf32.data(), k, &reduceA}, m, k, blocksize, UT_Threading::get());
+    Launcher::PrologueA::reduce({matAf32.data(), k, &reduceA}, m, k, blocksize, UT_Threading::get());
     utils::GemmProblem gp(1, m, n, k, blocksize);
     typename Launcher::Param args{gp, {matAf32.data(), k, &reduceA}, {&packedw}, {matC.data(), n}};
-    parallel::GemmRun<Parallel>(launcher, args, UT_Threading::get());
+    parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
     auto err = get_ut_err(qtype);
     auto dbits = bestla_dtype_bits(qtype);
     auto type = bestla_dtype_type(qtype);
@@ -683,31 +505,31 @@ class UT_CompFp32 {
     buffer_error(refCupk.data(), matC.data(), refCupk.size(), 0.001f);
   }
 
-  template <class GemmCore_T, template <class _T, BTLA_ISA> class Wei>
+  template <class GemmCore_T, template <class _T> class Wei>
   void ut(int m, int n, int k, int blocksize, BTLA_DTYPE qtype, BTLA_DTYPE stype) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s\n", __FUNCTION__, m, n, k, blocksize,
            bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), bestla_dtype_str(stype));
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = wrapper::gemm::LauncherBase<ISA, GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
+    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
                                                  epilogue::gemm::AccumulatorWriteBackFp32>;
     using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-    Launcher launcher;
+
     blocksize = blocksize == -1 ? k : blocksize;
-    using WType = typename Wei<GemmCore_T, ISA>::StorageWeight;
+    using WType = typename Wei<GemmCore_T>::StorageWeight;
     WType packedw(0);
-    packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, stype);
+    packedw = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, stype);
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
     avector<float> matBf32(k * n), matAf32(m * k), matC(m * n), refC(m * n), refCupk(m * n);
     fill_buffer_randn(matBf32.data(), matBf32.size(), -0.5f, 0.5f);
     fill_buffer_randn(matAf32.data(), matAf32.size(), -0.5f, 0.5f);
-    launcher.mProB.packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refC.data(), k, n, n);
-    launcher.mProB.unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
+    Launcher::PrologueB::unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refCupk.data(), k, n, n);
     GemmProblem gp(1, m, n, k, blocksize);
     typename Launcher::Param args{gp, {matAf32.data(), k}, {&packedw}, {matC.data(), n}};
-    parallel::GemmRun<Parallel>(launcher, args, UT_Threading::get());
+    parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
     auto err = get_ut_err(qtype);
     buffer_error(refC.data(), matC.data(), refC.size(), err);
     buffer_error(refCupk.data(), matC.data(), refCupk.size(), 0.001f);
@@ -770,12 +592,12 @@ class UT_CompInt8 {
       ut_newkblock_pc<gemm::ICoreRowNAvx2vnni<24, 4>>(1, 4096, 4096, 4096, qtype, BTLA_DTYPE::F32, true);
       ut_newkblock_pc<gemm::ICoreRowNAvx2vnni<24, 4>>(8, 4096, 4096, 4096, qtype, BTLA_DTYPE::F32, true);
 
-      ut_newkblock<gemm::ICoreRowNAvx2vnniKBlockSS<24, 2>>(1, 4096, 4096, 32, qtype, BTLA_DTYPE::F32, true);
-      ut_newkblock<gemm::ICoreRowNAvx2vnniKBlockSS<24, 2>>(4, 4096, 4096, 64, qtype, BTLA_DTYPE::BF16);
-      ut_newkblock<gemm::ICoreRowNAvx2vnniKBlockSS<24, 2>>(8, 4096, 4096, 128, qtype, BTLA_DTYPE::F32, true);
-      ut_newkblock<gemm::ICoreRowNAvx2vnniKBlockSS<24, 2>>(1, 4096, 4096, 32, qtype, BTLA_DTYPE::DQ8_BNB);
-      ut_newkblock_pc<gemm::ICoreRowNAvx2vnniSS<24, 2>>(1, 4096, 4096, 4096, qtype, BTLA_DTYPE::F32, true);
-      ut_newkblock_pc<gemm::ICoreRowNAvx2vnniSS<24, 2>>(8, 4096, 4096, 4096, qtype, BTLA_DTYPE::F32, true);
+      ut_newkblock<gemm::ICoreRowNAvx2vnniKBlockSS<24, 1>>(1, 4096, 4096, 32, qtype, BTLA_DTYPE::F32, true);
+      ut_newkblock<gemm::ICoreRowNAvx2vnniKBlockSS<24, 1>>(4, 4096, 4096, 64, qtype, BTLA_DTYPE::BF16);
+      ut_newkblock<gemm::ICoreRowNAvx2vnniKBlockSS<24, 1>>(8, 4096, 4096, 128, qtype, BTLA_DTYPE::F32, true);
+      ut_newkblock<gemm::ICoreRowNAvx2vnniKBlockSS<24, 1>>(1, 4096, 4096, 32, qtype, BTLA_DTYPE::DQ8_BNB);
+      ut_newkblock_pc<gemm::ICoreRowNAvx2vnniSS<24, 1>>(1, 4096, 4096, 4096, qtype, BTLA_DTYPE::F32, true);
+      ut_newkblock_pc<gemm::ICoreRowNAvx2vnniSS<24, 1>>(8, 4096, 4096, 4096, qtype, BTLA_DTYPE::F32, true);
     }
     if (_cd->AVX_VNNI()) {
       ut_newkblock<gemm::ICoreRowNAvxvnniKBlock<24, 2>>(1, 4096, 4096, 32, qtype, BTLA_DTYPE::F32, true);
@@ -835,15 +657,15 @@ class UT_CompInt8 {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s Asym:%d\n", __FUNCTION__, m, n, k, blocksize,
            bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), bestla_dtype_str(stype), isAsym);
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = wrapper::gemm::LauncherIntKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationF32KBlockQuantize,
+    using Launcher = wrapper::gemm::LauncherIntKBlock<GemmCore_T, prologue_a::gemm::ActivationF32KBlockQuantize,
                                                       prologue_b::gemm::WeightKBlockNInteger,
                                                       epilogue::gemm::AccumulatorWriteBackFp32>;
     using Parallel = parallel::gemm::SchedulerKBlockS<GemmCore_T>;
-    Launcher launcher;
+
     blocksize = blocksize == -1 ? k : blocksize;
     int kblks = updiv(k, blocksize);
     using WType = typename Launcher::PrologueB::StorageWeight;
-    WType packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, stype, bestla_dtype<float>, isAsym);
+    WType packedw = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, stype, bestla_dtype<float>, isAsym);
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
     avector<float> matBf32(k * n), matAf32(m * k), matC(m * n), refC(m * n), refCupk(m * n);
@@ -862,16 +684,16 @@ class UT_CompInt8 {
         reduceAf32[i * kblks + j / blocksize] += matAf32[i * k + j];
       }
     }
-    launcher.mProB.packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refC.data(), k, n, n);
-    launcher.mProB.unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
+    Launcher::PrologueB::unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refCupk.data(), k, n, n);
-    auto quanA = launcher.mProA.createStorage(m, k, blocksize, isAsym);
+    auto quanA = Launcher::PrologueA::createStorage(m, k, blocksize, isAsym);
     utils::avector<int8_t> bufferA(quanA.mSize);
     quanA.assign(bufferA.data());
     GemmProblem gp(1, m, n, k, blocksize);
     typename Launcher::Param args{gp, {matAf32.data(), k, &quanA}, {&packedw}, {matC.data(), n}};
-    parallel::GemmRunWithA<Parallel>(launcher, args, UT_Threading::get());
+    parallel::GemmRunWithA<Parallel, Launcher>(args, UT_Threading::get());
     auto err = get_ut_err(qtype);
     buffer_error(refC.data(), matC.data(), refC.size(), err);
     if (stype != BTLA_DTYPE::DQ8_BNB) {
@@ -889,14 +711,13 @@ class UT_CompInt8 {
            bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), bestla_dtype_str(stype), isAsym);
     auto constexpr ISA = GemmCore_T::ISA;
     using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-    using Launcher =
-        wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ActivationF32KBlockQuantize,
-                                    prologue_b::gemm::WeightKBlockNInteger, PcWriteBack>;
-    Launcher launcher;
+    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ActivationF32KBlockQuantize,
+                                                 prologue_b::gemm::WeightKBlockNInteger, PcWriteBack>;
+
     blocksize = blocksize == -1 ? k : blocksize;
     int kblks = updiv(k, blocksize);
     using WType = typename Launcher::PrologueB::StorageWeight;
-    WType packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, stype, bestla_dtype<float>, isAsym);
+    WType packedw = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, stype, bestla_dtype<float>, isAsym);
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
     avector<float> matBf32(k * n), matAf32(m * k), matC(m * n), refC(m * n), refCupk(m * n);
@@ -915,11 +736,11 @@ class UT_CompInt8 {
         reduceAf32[i * kblks + j / blocksize] += matAf32[i * k + j];
       }
     }
-    launcher.mProB.packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refC.data(), k, n, n);
-    launcher.mProB.unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
+    Launcher::PrologueB::unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refCupk.data(), k, n, n);
-    auto quanA = launcher.mProA.createStorage(m, k, blocksize, isAsym);
+    auto quanA = Launcher::PrologueA::createStorage(m, k, blocksize, isAsym);
     utils::avector<int8_t> bufferA(quanA.mSize);
     quanA.assign(bufferA.data());
     GemmProblem gp(1, m, n, k, blocksize);
@@ -930,7 +751,7 @@ class UT_CompInt8 {
         {{packedw.template SPtr<char>(), packedw.SDtype(), quanA.template SPtr<float>(), quanA.template ZPtr<uint8_t>(),
           packedw.template RPtr<char>(), packedw.RDtype(), nullptr, nullptr, k},
          {matC.data(), n}}};
-    parallel::GemmRunWithA<Parallel>(launcher, args, UT_Threading::get());
+    parallel::GemmRunWithA<Parallel, Launcher>(args, UT_Threading::get());
     auto err = get_ut_err(qtype);
     buffer_error(refC.data(), matC.data(), refC.size(), err);
 
@@ -992,23 +813,23 @@ class UT_CompBf16 {
     ut<sAMX_BF16, prologue_b::gemm::WeightKBlockNFloat, utils::bf16>(2, 4096, 4096, 32, BTLA_DTYPE::F4_NF4);
   }
 
-  template <class GemmCore_T, template <class _T, BTLA_ISA> class Wei, typename Scale_T>
+  template <class GemmCore_T, template <class _T> class Wei, typename Scale_T>
   void ut(int m, int n, int k, int blocksize, BTLA_DTYPE qtype) {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s\n", __FUNCTION__, m, n, k, blocksize,
            bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>);
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = wrapper::gemm::LauncherBase<ISA, GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
+    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
                                                  epilogue::gemm::AccumulatorWriteBackFp32>;
     using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
 
-    Launcher launcher;
     blocksize = blocksize == -1 ? k : blocksize;
-    using WType = typename Wei<GemmCore_T, ISA>::StorageWeight;
+    using WType = typename Wei<GemmCore_T>::StorageWeight;
     WType packedw(0);
-    if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockNInteger<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
-    } else if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockNFloat<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
+    if constexpr (std::is_same_v<Wei<GemmCore_T>, prologue_b::gemm::WeightKBlockNInteger<GemmCore_T>>) {
+      packedw =
+          Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
+    } else if constexpr (std::is_same_v<Wei<GemmCore_T>, prologue_b::gemm::WeightKBlockNFloat<GemmCore_T>>) {
+      packedw = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
     }
 
     utils::avector<int8_t> buffer(packedw.mSize);
@@ -1020,16 +841,16 @@ class UT_CompBf16 {
     for (size_t i = 0; i < matBf32.size(); i++) {
       matBf32[i] = matBbf16[i];
     }
-    launcher.mProB.packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
     gemmref_bf16bf16fp32(m, n, k, matAbf16.data(), matBbf16.data(), refC.data(), k, n, n);
-    launcher.mProB.unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
+    Launcher::PrologueB::unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
     for (size_t i = 0; i < matBf32.size(); i++) {
       matBbf16[i] = static_cast<utils::bf16>(matBf32[i]);
     }
     gemmref_bf16bf16fp32(m, n, k, matAbf16.data(), matBbf16.data(), refCupk.data(), k, n, n);
     GemmProblem gp(1, m, n, k, blocksize);
     typename Launcher::Param args{gp, {matAbf16.data(), k}, {&packedw}, {matC.data(), n}};
-    parallel::GemmRun<Parallel>(launcher, args, UT_Threading::get());
+    parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
     auto err = get_ut_err(qtype);
     buffer_error(refC.data(), matC.data(), refC.size(), err);
     buffer_error(refCupk.data(), matC.data(), refCupk.size(), 0.05f);
@@ -1069,15 +890,15 @@ class UT_ORT_NBits {
            bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), isasym);
     auto constexpr ISA = GemmCore_T::ISA;
     using Launcher =
-        wrapper::gemm::LauncherBase<ISA, GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32,
+        wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32,
                                     prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::AccumulatorWriteBackFp32>;
     using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-    Launcher launcher;
+
     blocksize = blocksize == -1 ? k : blocksize;
     using WType = storage::gemm::StorageWeightKBlockNInteger;
     WType packedw(0);
-    packedw =
-        launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<utils::bf16>, isasym);
+    packedw = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<utils::bf16>,
+                                                 isasym);
 
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
@@ -1097,7 +918,7 @@ class UT_ORT_NBits {
     fill_buffer_randn(scalesB.data(), scalesB.size(), 0.001f, 0.005f);
     avector<float> reduceA(m * blks, 0.f);
 
-    auto rA = launcher.mProA.createStorage(m, k, blocksize);
+    auto rA = Launcher::PrologueA::createStorage(m, k, blocksize);
     avector<int8_t> tmpA(rA.mSize);
     if (isasym) {
       for (size_t i = 0; i < m; i++) {
@@ -1106,7 +927,8 @@ class UT_ORT_NBits {
         }
       }
       rA.assign(tmpA.data());
-      launcher.mProA.reduce({matAf32.data(), k, &rA}, m, k, blocksize, UT_Threading::get());  // for reduce UT
+      Launcher::PrologueA::reduce({matAf32.data(), k, &rA}, m, k, blocksize,
+                                  UT_Threading::get());  // for reduce UT
       buffer_error(reduceA.data(), rA.template RPtr<float>(), reduceA.size(), FP32_ERR);
       memset(tmpA.data(), 0, tmpA.size());  // clear
     }
@@ -1123,20 +945,20 @@ class UT_ORT_NBits {
             zpBs8[i * blks + j / blocksize] | zpBs8[i * blks + j / blocksize + 1] << 4;
       }
     }
-    launcher.mProB.packNbitsWeightQ4(n, k, isasym, (uint8_t*)matBs4.data(), k, scalesB.data(), (uint8_t*)zpBs4.data(),
-                                     &packedw, UT_Threading::get());
-    launcher.mProB.reduceWeight(&packedw, UT_Threading::get());
+    Launcher::PrologueB::packNbitsWeightQ4(n, k, isasym, (uint8_t*)matBs4.data(), k, scalesB.data(),
+                                           (uint8_t*)zpBs4.data(), &packedw, UT_Threading::get());
+    Launcher::PrologueB::reduceWeight(&packedw, UT_Threading::get());
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refC.data(), k, n, n);
     avector<float> revB(matBf32.size());
-    launcher.mProB.unpackWeight(n, k, &packedw, revB.data(), n, UT_Threading::get());
+    Launcher::PrologueB::unpackWeight(n, k, &packedw, revB.data(), n, UT_Threading::get());
     buffer_error(matBf32.data(), revB.data(), revB.size(), FP32_ERR);
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), revB.data(), refCupk.data(), k, n, n);
     GemmProblem gp(1, m, n, k, blocksize);
     typename Launcher::Param args{gp, {matAf32.data(), k, &rA}, {&packedw}, {matC.data(), n}};
     if (isasym) {
-      parallel::GemmRunWithA<Parallel>(launcher, args, UT_Threading::get());
+      parallel::GemmRunWithA<Parallel, Launcher>(args, UT_Threading::get());
     } else {
-      parallel::GemmRun<Parallel>(launcher, args, UT_Threading::get());
+      parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
     }
     auto err = INT4_ERR;
     buffer_error(refC.data(), matC.data(), refC.size(), err);
@@ -1152,17 +974,17 @@ class UT_ORT_NBits {
            bestla_dtype_str(qtype), gemm::CoreAttr::to_str(GemmCore_T::ID), isasym);
     auto constexpr ISA = GemmCore_T::ISA;
     using Launcher =
-        wrapper::gemm::LauncherBase<ISA, GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32,
+        wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ActivationKBlockBaseF32,
                                     prologue_b::gemm::WeightKBlockNInteger, epilogue::gemm::AccumulatorWriteBackFp32>;
     using Parallel = parallel::gemm::SchedulerKBlockS<GemmCore_T>;
-    Launcher launcher;
+
     const char *qfile = "int_weight.bin", *sfile = "scales.bin", *zfile = "zeros.bin";
     auto qdata = ut::readFile2Buffer<int8_t>(qfile);
     auto sdata = readFile2Buffer<float>(sfile);
     auto zdata = readFile2Buffer<int8_t>(zfile);
     using WType = storage::gemm::StorageWeightKBlockNInteger;
-    WType packedw =
-        launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<float>, bestla_dtype<utils::bf16>, isasym);
+    WType packedw = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<float>,
+                                                       bestla_dtype<utils::bf16>, isasym);
 
     utils::avector<int8_t> buffer(packedw.mSize);
     packedw.assign(buffer.data());
@@ -1171,7 +993,7 @@ class UT_ORT_NBits {
     int blks = updiv(k, blocksize);
     avector<float> reduceA(m * blks, 0.f);
 
-    auto rA = launcher.mProA.createStorage(m, k, blocksize);
+    auto rA = Launcher::PrologueA::createStorage(m, k, blocksize);
     avector<int8_t> tmpA(rA.mSize);
     if (isasym) {
       for (size_t i = 0; i < m; i++) {
@@ -1180,7 +1002,8 @@ class UT_ORT_NBits {
         }
       }
       rA.assign(tmpA.data());
-      launcher.mProA.reduce({matAf32.data(), k, &rA}, m, k, blocksize, UT_Threading::get());  // for reduce UT
+      Launcher::PrologueA::template reduce<ISA>({matAf32.data(), k, &rA}, m, k, blocksize,
+                                                UT_Threading::get());  // for reduce UT
       buffer_error(reduceA.data(), rA.template RPtr<float>(), reduceA.size(), FP32_ERR);
       memset(tmpA.data(), 0, tmpA.size());  // clear
     }
@@ -1190,7 +1013,7 @@ class UT_ORT_NBits {
       }
     }
 
-    launcher.mProB.packQWeight(n, k, qdata.data(), n, sdata.data(), zdata.data(), &packedw, UT_Threading::get());
+    Launcher::PrologueB::packQWeight(n, k, qdata.data(), n, sdata.data(), zdata.data(), &packedw, UT_Threading::get());
 
     auto bfile = readFile2Buffer<int8_t>("bestla_w3.weight.bin");
     WType packedfile(0);
@@ -1200,15 +1023,15 @@ class UT_ORT_NBits {
     buffer_error(packedw.ZPtr<int8_t>(), packedfile.ZPtr<int8_t>(), packedw.CSize());
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refC.data(), k, n, n);
     avector<float> revB(matBf32.size());
-    launcher.mProB.unpackWeight(n, k, &packedw, revB.data(), n, UT_Threading::get());
+    Launcher::PrologueB::unpackWeight(n, k, &packedw, revB.data(), n, UT_Threading::get());
     buffer_error(matBf32.data(), revB.data(), revB.size(), FP32_ERR);
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), revB.data(), refCupk.data(), k, n, n);
     GemmProblem gp(1, m, n, k, blocksize);
     typename Launcher::Param args{gp, {matAf32.data(), k, &rA}, {&packedw}, {matC.data(), n}};
     if (isasym) {
-      parallel::GemmRunWithA<Parallel>(launcher, args, UT_Threading::get());
+      parallel::GemmRunWithA<Parallel, Launcher>(args, UT_Threading::get());
     } else {
-      parallel::GemmRun<Parallel>(launcher, args, UT_Threading::get());
+      parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
     }
     auto err = INT4_ERR;
     buffer_error(refC.data(), matC.data(), refC.size(), err);
@@ -1261,22 +1084,22 @@ class UT_CompFp16 {
     printf("Test Case %s: %d %d %d-%d type:%s core:%s scaletype:%s\n", __FUNCTION__, m, n, k, blocksize,
            bestla_dtype_str(qtype),gemm::CoreAttr::to_str(GemmCore_T::ID), type_str<Scale_T>);
     auto constexpr ISA = GemmCore_T::ISA;
-    using Launcher = wrapper::gemm::LauncherKBlock<ISA, GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
+    using Launcher = wrapper::gemm::LauncherKBlock<GemmCore_T, prologue_a::gemm::ActivationBase, Wei,
                                                           epilogue::gemm::CompFp32BlockEpilogue,
                                                           epilogue::gemm::AccumulatorWriteBackFp32>;
     using Parallel = parallel::gemm::SchedulerKBlock<GemmCore_T>;
-    Launcher launcher;
+    
     blocksize = blocksize == -1 ? k : blocksize;
     using WType = typename Wei<GemmCore_T, ISA>::StorageWeight;
     WType packedw(0);
     if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockS8<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
+      packedw = Launcher::PrologueB::createStorage(n, k, blocksize, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
     } else if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>,
                                         prologue_b::gemm::WeightKBlockS4<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
+      packedw = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>, bestla_dtype<float>, false);
     } else if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>,
                                         prologue_b::gemm::WeightKBlockF4<GemmCore_T, ISA>>) {
-      packedw = launcher.mProB.createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
+      packedw = Launcher::PrologueB::createStorage(n, k, blocksize, qtype, bestla_dtype<Scale_T>);
     }
 
     utils::avector<int8_t> buffer(packedw.mSize);
@@ -1288,9 +1111,9 @@ class UT_CompFp16 {
     for (size_t i = 0; i < matBf32.size(); i++) {
       matBf32[i] = matBbf16[i];
     }
-    launcher.mProB.packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, matBf32.data(), n, &packedw, UT_Threading::get());
     gemmref_bf16bf16fp32(m, n, k, matAbf16.data(), matBbf16.data(), refC.data(), k, n, n);
-    launcher.mProB.unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
+    Launcher::PrologueB::unpackWeight(n, k, &packedw, matBf32.data(), n, UT_Threading::get());
     for (size_t i = 0; i < matBf32.size(); i++) {
       matBbf16[i] = static_cast<utils::bf16>(matBf32[i]);
     }
@@ -1303,7 +1126,7 @@ class UT_CompFp16 {
                                   {&packedw},
                                   {packedw.template SPtr<int8_t>(), packedw.SDtype(), packedw.CStep()},
                                   {matC.data(), n}};
-    parallel::GemmRun<Parallel>(launcher, args);
+    parallel::GemmRun<Parallel,Launcher>(args);
     auto err = INT8_ERR;
     if constexpr (std::is_same_v<Wei<GemmCore_T, ISA>, prologue_b::gemm::WeightKBlockS4<GemmCore_T, ISA>>) {
       err = INT4_ERR;
diff --git a/bestla/bestla/ut/bestla_ut.h b/bestla/bestla/ut/bestla_ut.h
index 6f3ed40f4..99109a05f 100644
--- a/bestla/bestla/ut/bestla_ut.h
+++ b/bestla/bestla/ut/bestla_ut.h
@@ -70,7 +70,7 @@ static inline int auto_batch(size_t memsize) {
   auto L3 = _cd->getL3CacheSize();
   size_t constexpr Enlarge = 4;
   size_t constexpr TargetMem = 1LL << 30;
-  auto batch = std::max(L3 * Enlarge, TargetMem) / memsize;
+  auto batch = static_cast<int>(std::max(L3 * Enlarge, TargetMem) / memsize);
   return batch > 1 ? batch : 2;
 }
 
diff --git a/bestla/bestla/ut/bestla_wrapper.cpp b/bestla/bestla/ut/bestla_wrapper.cpp
index 0f57270a2..9f20b7ec8 100644
--- a/bestla/bestla/ut/bestla_wrapper.cpp
+++ b/bestla/bestla/ut/bestla_wrapper.cpp
@@ -33,18 +33,18 @@ class UT_Fp32Fp32 {
     fill_buffer_randn(matB.data(), matB.size(), -0.5f, 0.5f);
     gemmref_fp32fp32fp32(m, n, k, matA.data(), matB.data(), ref.data(), k, n, n);
     using Launcher =
-        wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
-                                    prologue_b::gemm::WeightPack, epilogue::gemm::AccumulatorWriteBackFp32>;
-    Launcher launcher;
+        wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                    epilogue::gemm::AccumulatorWriteBackFp32>;
+
     using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
 
-    auto packw = launcher.mProB.createStorage(n, k);
+    auto packw = Launcher::PrologueB::createStorage(n, k);
     avector<int8_t> buffer(packw.mSize);
     packw.assign(buffer.data());
-    launcher.mProB.packWeight(n, k, {matB.data(), n, &packw}, UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, {matB.data(), n, &packw}, UT_Threading::get());
     utils::GemmProblem gp(1, m, n, k);
     typename Launcher::Param args{gp, {matA.data(), k}, {matB.data(), n, &packw}, {matC.data(), n}};
-    parallel::GemmRun<Parallel>(launcher, args, UT_Threading::get());
+    parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
     ut::buffer_error(ref.data(), matC.data(), ref.size(), 0.001f);
   }
 };
@@ -119,22 +119,22 @@ class UT_U8S8S32 {
       }
     }
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refC.data(), k, n, n);
-    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
+    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ActivationBase,
                                                  prologue_b::gemm::WeightPack, epilogue::gemm::ZpDequantInt32ToFp32>;
-    Launcher launcher;
+
     using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
 
-    auto packw = launcher.mProB.createStorage(n, k);
+    auto packw = Launcher::PrologueB::createStorage(n, k);
     avector<int8_t> buffer(packw.mSize);
     packw.assign(buffer.data());
-    launcher.mProB.packWeight(n, k, {matBs8.data(), n, &packw}, UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, {matBs8.data(), n, &packw}, UT_Threading::get());
     utils::GemmProblem gp(1, m, n, k);
     typename Launcher::Param args{
         gp,
         {matAu8.data(), k},
         {matBs8.data(), n, &packw},
         {matC.data(), n, 1, scaleAf32.data(), scaleBf32.data(), zpAu8.data(), reduceB.data()}};
-    parallel::GemmRun<Parallel>(launcher, args, UT_Threading::get());
+    parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
     ut::buffer_error(refC.data(), matC.data(), refC.size(), 0.001f);
   }
 };
@@ -186,19 +186,19 @@ class UT_S8S8S32 {
       }
     }
     gemmref_fp32fp32fp32(m, n, k, matAf32.data(), matBf32.data(), refC.data(), k, n, n);
-    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
+    using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ActivationBase,
                                                  prologue_b::gemm::WeightPack, epilogue::gemm::DequantInt32ToFp32>;
-    Launcher launcher;
+
     using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
 
-    auto packw = launcher.mProB.createStorage(n, k);
+    auto packw = Launcher::PrologueB::createStorage(n, k);
     avector<int8_t> buffer(packw.mSize);
     packw.assign(buffer.data());
-    launcher.mProB.packWeight(n, k, {matBs8.data(), n, &packw}, UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, {matBs8.data(), n, &packw}, UT_Threading::get());
     utils::GemmProblem gp(1, m, n, k);
     typename Launcher::Param args{
         gp, {matAu8.data(), k}, {matBs8.data(), n, &packw}, {matC.data(), n, 1, scaleAf32.data(), scaleBf32.data()}};
-    parallel::GemmRun<Parallel>(launcher, args, UT_Threading::get());
+    parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
     ut::buffer_error(refC.data(), matC.data(), refC.size(), 0.001f);
   }
 };
@@ -223,22 +223,22 @@ class UT_Bf16Bf16Fp32 {
   void ut(int m, int n, int k) {
     printf("Test Case %s: %d %d %d core:%s\n", __FUNCTION__, m, n, k, gemm::CoreAttr::to_str(GemmCore_T::ID));
     using Launcher =
-        wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
-                                    prologue_b::gemm::WeightPack, epilogue::gemm::AccumulatorWriteBackFp32>;
-    Launcher launcher;
+        wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                    epilogue::gemm::AccumulatorWriteBackFp32>;
+
     using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-    auto packw = launcher.mProB.createStorage(n, k);
+    auto packw = Launcher::PrologueB::createStorage(n, k);
     avector<int8_t> buffer(packw.mSize);
     packw.assign(buffer.data());
     avector<utils::bf16> matAbf16(m * k), matBbf16(k * n);
     fill_buffer_randn(matAbf16.data(), matAbf16.size(), utils::bf16(-0.5f), utils::bf16(0.5f));
     fill_buffer_randn(matBbf16.data(), matBbf16.size(), utils::bf16(-0.5f), utils::bf16(0.5f));
     avector<float> matC(m * n), refC(m * n);
-    launcher.mProB.packWeight(n, k, {matBbf16.data(), n, &packw}, UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, {matBbf16.data(), n, &packw}, UT_Threading::get());
     gemmref_bf16bf16fp32(m, n, k, matAbf16.data(), matBbf16.data(), refC.data(), k, n, n);
     utils::GemmProblem gp(1, m, n, k);
     typename Launcher::Param args{gp, {matAbf16.data(), k}, {matBbf16.data(), n, &packw}, {matC.data(), n}};
-    parallel::GemmRun<Parallel>(launcher, args, UT_Threading::get());
+    parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
     buffer_error(refC.data(), matC.data(), refC.size(), 0.05f);
   }
 };
@@ -263,21 +263,21 @@ class UT_Fp16Fp16Fp16 {
   void ut(int m, int n, int k) {
     printf("Test Case %s: %d %d %d core:%s\n", __FUNCTION__, m, n, k, gemm::CoreAttr::to_str(GemmCore_T::ID));
     using Launcher =
-        wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ActivationBase,
-                                    prologue_b::gemm::WeightPack, epilogue::gemm::AccumulatorWriteBackFp16>;
-    Launcher launcher;
+        wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ActivationBase, prologue_b::gemm::WeightPack,
+                                    epilogue::gemm::AccumulatorWriteBackFp16>;
+
     using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-    auto packw = launcher.mProB.createStorage(n, k);
+    auto packw = Launcher::PrologueB::createStorage(n, k);
     avector<int8_t> buffer(packw.mSize);
     packw.assign(buffer.data());
     avector<utils::fp16> matAbf16(m * k), matBbf16(k * n), matC(m * n), refC(m * n);
     fill_buffer_randn(matAbf16.data(), matAbf16.size(), utils::fp16(-0.5f), utils::fp16(0.5f));
     fill_buffer_randn(matBbf16.data(), matBbf16.size(), utils::fp16(-0.5f), utils::fp16(0.5f));
-    launcher.mProB.packWeight(n, k, {matBbf16.data(), n, &packw}, UT_Threading::get());
+    Launcher::PrologueB::packWeight(n, k, {matBbf16.data(), n, &packw}, UT_Threading::get());
     gemmref_fp16fp16fp16(m, n, k, matAbf16.data(), matBbf16.data(), refC.data(), k, n, n);
     GemmProblem gp(1, m, n, k);
     typename Launcher::Param args{gp, {matAbf16.data(), k}, {matBbf16.data(), n, &packw}, {matC.data(), n}};
-    parallel::GemmRun<Parallel>(launcher, args, UT_Threading::get());
+    parallel::GemmRun<Parallel, Launcher>(args, UT_Threading::get());
     buffer_error(refC.data(), matC.data(), refC.size(), utils::fp16(0.0002f * k));
   }
 };
diff --git a/bestla/bestla/ut/kernel_wrapper.cpp b/bestla/bestla/ut/kernel_wrapper.cpp
index 65f5edfc6..f76286f37 100644
--- a/bestla/bestla/ut/kernel_wrapper.cpp
+++ b/bestla/bestla/ut/kernel_wrapper.cpp
@@ -106,9 +106,9 @@ class UT_PaddingInterleaveMN {
     aligned_vector<T_DST> dst(row_pad * col_pad), ref(row_pad * col_pad);
     for (size_t i = 0; i < src.size(); i++) src[i] = static_cast<T_SRC>(float(i));
 
-    kernel::wrapper::PaddingInterleaveMN<NTile, RowPack>::template forward<BTLA_ISA::NoSIMD>(
+    kernel::wrapper::PaddingInterleaveMN<NTile, RowPack, T_SRC, T_DST>::template forward<BTLA_ISA::NoSIMD>(
         src.data(), ref.data(), row, col, row_pad, col_pad, row_pad, col);
-    kernel::wrapper::PaddingInterleaveMN<NTile, RowPack>::template forward<BTLA_ISA::AVX512_FP16>(
+    kernel::wrapper::PaddingInterleaveMN<NTile, RowPack, T_SRC, T_DST>::template forward<BTLA_ISA::AVX512_FP16>(
         src.data(), dst.data(), row, col, row_pad, col_pad, col, row_pad);
     ut::buffer_error(dst.data(), ref.data(), dst.size(), T_DST(100));
   }
@@ -135,9 +135,9 @@ class UT_PaddingTransInterleaveMN {
     aligned_vector<T_DST> dst(col_pad * row_pad), ref(col_pad * row_pad);
     for (size_t i = 0; i < src.size(); i++) src[i] = static_cast<T_SRC>(float(i));
 
-    kernel::wrapper::PaddingTransInterleaveMN<MTile, ColPack>::template forward<BTLA_ISA::NoSIMD>(
+    kernel::wrapper::PaddingTransInterleaveMN<MTile, ColPack, T_SRC, T_DST>::template forward<BTLA_ISA::NoSIMD>(
         src.data(), ref.data(), row, col, row_pad, col_pad, row_pad, col);
-    kernel::wrapper::PaddingTransInterleaveMN<MTile, ColPack>::template forward<BTLA_ISA::AVX512_FP16>(
+    kernel::wrapper::PaddingTransInterleaveMN<MTile, ColPack, T_SRC, T_DST>::template forward<BTLA_ISA::AVX512_FP16>(
         src.data(), dst.data(), row, col, row_pad, col_pad, col, row_pad);
     ut::buffer_error(dst.data(), ref.data(), dst.size(), T_DST(100));
   }
@@ -164,9 +164,9 @@ class UT_RevertPaddingInterleaveMN {
       src[i] = static_cast<T>(i);
     }
     aligned_vector<T> reverted(row * col);
-    kernel::wrapper::PaddingInterleaveMN<NTile, PackRow>::template forward<BTLA_ISA::NoSIMD>(
+    kernel::wrapper::PaddingInterleaveMN<NTile, PackRow, T>::template forward<BTLA_ISA::NoSIMD>(
         src.data(), packed.data(), row, col, rowpad, colpad, col, rowpad);
-    kernel::wrapper::RevertPaddingInterleaveMN<NTile, PackRow>::template forward<BTLA_ISA::NoSIMD>(
+    kernel::wrapper::RevertPaddingInterleaveMN<NTile, PackRow, T>::template forward<BTLA_ISA::NoSIMD>(
         packed.data(), reverted.data(), row, col, rowpad, colpad, rowpad, col);
     ut::buffer_error(src.data(), reverted.data(), reverted.size());
   }
diff --git a/neural_speed/application/main_run.cpp b/neural_speed/application/main_run.cpp
index f9b7c5dce..745c3665a 100644
--- a/neural_speed/application/main_run.cpp
+++ b/neural_speed/application/main_run.cpp
@@ -353,8 +353,8 @@ int main(int argc, char** argv) {  // NOLINT
           params.repeat_last_n, params.repeat_penalty, params.presence_penalty, params.frequency_penalty, params.top_k,
           params.tfs_z, params.top_p, params.typical_p, params.temp, params.mirostat, params.mirostat_eta,
           params.mirostat_tau);
-  fprintf(stderr, "generate: n_ctx = %d, tokens_length = %ld, n_batch = %d, n_predict = %d, n_keep = %d\n", n_ctx,
-          embd_inp.size(), params.n_batch, params.n_predict, params.n_keep);
+  fprintf(stderr, "generate: n_ctx = %d, tokens_length = %d, n_batch = %d, n_predict = %d, n_keep = %d\n", n_ctx,
+          static_cast<int>(embd_inp.size()), params.n_batch, params.n_predict, params.n_keep);
   fprintf(stderr, "\n\n");
 
   // TODO(Bo): replace with ring-buffer
diff --git a/neural_speed/core/layers/bestla_defs.h b/neural_speed/core/layers/bestla_defs.h
index f24615921..392999989 100644
--- a/neural_speed/core/layers/bestla_defs.h
+++ b/neural_speed/core/layers/bestla_defs.h
@@ -17,22 +17,21 @@
 #include "bestla/bestla_wrapper.h"
 
 namespace bestla {
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
-using tLauncher_Fp_F32F32 =
-    wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockBaseF32, Wei_T,
-                                epilogue::gemm::AccumulatorWriteBackFp32>;
+template <class GemmCore_T, template <class> class Wei_T>
+using tLauncher_Fp_F32F32 = wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockBaseF32,
+                                                        Wei_T, epilogue::gemm::AccumulatorWriteBackFp32>;
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+template <class GemmCore_T, template <class> class Wei_T>
 using tLauncher_Int8_F32F32 =
-    wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32,
-                                     Wei_T, epilogue::gemm::AccumulatorWriteBackFp32>;
+    wrapper::gemm::LauncherIntKBlock<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
+                                     epilogue::gemm::AccumulatorWriteBackFp32>;
 
 using PcWriteBackF32 = epilogue::gemm::PcKBlockCompInt8Epilogue<epilogue::gemm::AccumulatorWriteBackFp32>;
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+template <class GemmCore_T, template <class> class Wei_T>
 using tLauncher_Int8Pc_F32F32 =
-    wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32,
-                                Wei_T, PcWriteBackF32>;
+    wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
+                                PcWriteBackF32>;
 
 using tAVX2 = gemm::SCoreRowNAvx2<24, 4>;
 using tAVX2_VNNI = gemm::ICoreRowNAvx2vnni<24, 4>;
@@ -53,13 +52,13 @@ using tAVX512_VNNI_KBlock = gemm::ICoreRowNAvx512vnniKBlock<48, 4>;
 using tAMX_INT8_US_KBlock = gemm::ICoreRowNAmxint8KBlock<64, 16>;
 using tAMX_INT8_SS_KBlock = gemm::ICoreRowNAmxint8SSKBlock<64, 16>;
 
-template <class GC_T, BTLA_ISA ISA_T>
-using tWeiNInt = prologue_b::gemm::WeightKBlockNInteger<GC_T, ISA_T>;
-template <class GC_T, BTLA_ISA ISA_T>
-using tWeiNFloat = prologue_b::gemm::WeightKBlockNFloat<GC_T, ISA_T>;
+template <class GC_T>
+using tWeiNInt = prologue_b::gemm::WeightKBlockNInteger<GC_T>;
+template <class GC_T>
+using tWeiNFloat = prologue_b::gemm::WeightKBlockNFloat<GC_T>;
 
-template <class GC_T, BTLA_ISA ISA_T>
-using tActKBaseF32 = prologue_a::gemm::ShuffleActivationKBlockBaseF32<GC_T, ISA_T>;
+template <class GC_T>
+using tActKBaseF32 = prologue_a::gemm::ShuffleActivationKBlockBaseF32<GC_T>;
 
 constexpr uint64_t Fp32Cores[] = {tAVX2::ID, tAVX512F::ID};
 constexpr uint64_t Bf16Cores[] = {tAMX_BF16::ID, tAVX512_BF16::ID};
diff --git a/neural_speed/core/layers/bestla_gemm.cpp b/neural_speed/core/layers/bestla_gemm.cpp
index dca8f4034..52be38994 100644
--- a/neural_speed/core/layers/bestla_gemm.cpp
+++ b/neural_speed/core/layers/bestla_gemm.cpp
@@ -31,43 +31,39 @@ Module Name:
 using namespace bestla;  // NOLINT
 
 namespace {
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+template <class GemmCore_T, template <class> class Wei_T>
 void BTLAGemmCompF32(const int M, const int N, const int K, const float* A, const int lda,
                      storage::gemm::IWeightBase* _B, float* C, const int ldc, int8_t* WorkSpace,
                      parallel::IThreading* th) {
   using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-  using Launcher =
-      wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockBaseF32, Wei_T,
-                                  epilogue::gemm::AccumulatorWriteBackFp32>;
-  static Launcher kernel;
+  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockBaseF32, Wei_T,
+                                               epilogue::gemm::AccumulatorWriteBackFp32>;
   auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
   utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
-  auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
+  auto reordA = Launcher::PrologueA::createReorderStorage(M, K, B->mBlockSize);
   typename Launcher::Param args{gp, {A, K, nullptr, B->ShfIndice(), &reordA}, {B}, {C, N}};
   if (B->ShfIndice()) {
     reordA.assign(WorkSpace);
-    parallel::GemmRunWithA<Parallel>(kernel, args, th);
+    parallel::GemmRunWithA<Parallel, Launcher>(args, th);
   } else {
-    parallel::GemmRun<Parallel>(kernel, args, th);
+    parallel::GemmRun<Parallel, Launcher>(args, th);
   }
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+template <class GemmCore_T, template <class> class Wei_T>
 void BTLAGemmCompInt8Pc(const int M, const int N, const int K, const float* A, const int lda,
                         storage::gemm::IWeightBase* _B, float* C, const int ldc, int8_t* WorkSpace,
                         parallel::IThreading* th) {
   using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-  using Launcher =
-      wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32,
-                                  Wei_T, PcWriteBackF32>;
+  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
+                                               PcWriteBackF32>;
   auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
   assert(B->mBlockSize >= K);
   utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
-  static Launcher kernel;
-  auto quanA = kernel.mProA.createQuantStorage(M, K, B->mBlockSize, B->IsAsym());
+  auto quanA = Launcher::PrologueA::createQuantStorage(M, K, B->mBlockSize, B->IsAsym());
   quanA.assign(WorkSpace);
   WorkSpace += quanA.mSize;
-  auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
+  auto reordA = Launcher::PrologueA::createReorderStorage(M, K, B->mBlockSize);
   typename Launcher::Param args{
       gp,
       {A, K, &quanA, B->ShfIndice(), &reordA},
@@ -77,14 +73,14 @@ void BTLAGemmCompInt8Pc(const int M, const int N, const int K, const float* A, c
        {C, N}}};
   if (B->ShfIndice()) {
     reordA.assign(WorkSpace);
-    kernel.mProA.quantize({A, K, &quanA, B->ShfIndice(), &reordA}, M, K, th);
-    parallel::GemmRun<Parallel>(kernel, args, th);
+    Launcher::PrologueA::quantize({A, K, &quanA, B->ShfIndice(), &reordA}, M, K, th);
+    parallel::GemmRun<Parallel, Launcher>(args, th);
   } else {
-    parallel::GemmRunWithA<Parallel>(kernel, args, th);
+    parallel::GemmRunWithA<Parallel, Launcher>(args, th);
   }
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+template <class GemmCore_T, template <class> class Wei_T>
 void BTLAGemmCompInt8(const int M, const int N, const int K, const float* A, const int lda,
                       storage::gemm::IWeightBase* _B, float* C, const int ldc, int8_t* WorkSpace,
                       parallel::IThreading* th) {
@@ -92,18 +88,17 @@ void BTLAGemmCompInt8(const int M, const int N, const int K, const float* A, con
   using Launcher = tLauncher_Int8_F32F32<GemmCore_T, Wei_T>;
   auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
   utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
-  static Launcher kernel;
-  auto quanA = kernel.mProA.createQuantStorage(M, K, B->mBlockSize, B->IsAsym());
+  auto quanA = Launcher::PrologueA::createQuantStorage(M, K, B->mBlockSize, B->IsAsym());
   quanA.assign(WorkSpace);
   WorkSpace += quanA.mSize;
-  auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
+  auto reordA = Launcher::PrologueA::createReorderStorage(M, K, B->mBlockSize);
   typename Launcher::Param args{gp, {A, K, &quanA, B->ShfIndice(), &reordA}, {B}, {C, N}};
   if (B->ShfIndice()) {
     reordA.assign(WorkSpace);
-    kernel.mProA.quantize({A, K, &quanA, B->ShfIndice(), &reordA}, M, K, th);
-    parallel::GemmRun<Parallel>(kernel, args, th);
+    Launcher::PrologueA::quantize({A, K, &quanA, B->ShfIndice(), &reordA}, M, K, th);
+    parallel::GemmRun<Parallel, Launcher>(args, th);
   } else {
-    parallel::GemmRunWithA<Parallel>(kernel, args, th);
+    parallel::GemmRunWithA<Parallel, Launcher>(args, th);
   }
 }
 
@@ -228,24 +223,22 @@ bool BTLAGemmBatchDriver(const size_t M, const size_t N, const size_t K, const s
 template <typename T>
 size_t BTLABuSize(int block_size, size_t N, size_t K, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym,
                   int* shuffle_indice) {
-  static T launcher;
   using WType = typename T::PrologueB::StorageWeight;
   WType stor(0);
-  if constexpr (std::is_same_v<typename T::PrologueB,
-                               prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore, T::ISA>>) {
-    stor = launcher.mProB.createStorage(N, K, block_size, QuantType, ScaleDtype, BTLA_DTYPE::BF16, isAsym);
+  if constexpr (std::is_same_v<typename T::PrologueB, prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore>>) {
+    stor = T::PrologueB::createStorage(N, K, block_size, QuantType, ScaleDtype, BTLA_DTYPE::BF16, isAsym);
     if (shuffle_indice != nullptr) {
-      launcher.mProB.enableShuffle(&stor);
+      T::PrologueB::enableShuffle(&stor);
     }
   } else {
-    stor = launcher.mProB.createStorage(N, K, block_size, QuantType, ScaleDtype);
+    stor = T::PrologueB::createStorage(N, K, block_size, QuantType, ScaleDtype);
     (void)(shuffle_indice);
   }
 
   // Reduce dtype set to bf16
   return stor.mSize;
 }
-template <template <class, BTLA_ISA> class Wei_T>
+template <template <class> class Wei_T>
 size_t BTLAGemmPackBSizeLocal(size_t N, size_t K, size_t BlkSize, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype,
                               bool isAsym, ne_comp_type CompType, int* shuffle_indice) {
   GetCPUDevice();
@@ -304,25 +297,23 @@ size_t BTLAGemmPackBSizeLocal(size_t N, size_t K, size_t BlkSize, BTLA_DTYPE Qua
 template <typename T>
 void BTLAGemmQuantPackB(void* PackedBuf, int BlkSize, const float* FpData, int N, int K, BTLA_DTYPE QuantType,
                         BTLA_DTYPE ScaleDtype, bool IsAsym, int ldb, bool IsTrans, void* ThreadPool) {
-  static T launcher;
   using WType = typename T::PrologueB::StorageWeight;
   WType stor(0);
-  if constexpr (std::is_same_v<typename T::PrologueB,
-                               prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore, T::ISA>>) {
-    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype, BTLA_DTYPE::BF16, IsAsym);
+  if constexpr (std::is_same_v<typename T::PrologueB, prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore>>) {
+    stor = T::PrologueB::createStorage(N, K, BlkSize, QuantType, ScaleDtype, BTLA_DTYPE::BF16, IsAsym);
   } else {
-    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype);
+    stor = T::PrologueB::createStorage(N, K, BlkSize, QuantType, ScaleDtype);
   }
   stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
   auto pth = reinterpret_cast<parallel::IThreading*>(ThreadPool);
   if (IsTrans) {
-    launcher.mProB.packTransposeWeight(N, K, FpData, ldb, &stor, pth);
+    T::PrologueB::packTransposeWeight(N, K, FpData, ldb, &stor, pth);
   } else {
-    launcher.mProB.packWeight(N, K, FpData, ldb, &stor, pth);
+    T::PrologueB::packWeight(N, K, FpData, ldb, &stor, pth);
   }
 }
 
-template <template <class, BTLA_ISA> class Wei_T>
+template <template <class> class Wei_T>
 bool BTLAGemmQuantPackBLocal(void* PackedBuf, const float* FpData, size_t N, size_t K, size_t ldb, size_t BlkSize,
                              BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym, ne_comp_type CompType,
                              bool isTrans, void* ThreadPool) {
@@ -398,29 +389,27 @@ template <typename T>
 void BTLAGemmPackBImpl(void* PackedBuf, int BlkSize, const int8_t* QData, const float* Scales, const int8_t* Zp, int N,
                        int K, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool IsAsym, int ldb, int* shuffle_indice,
                        void* ThreadPool) {
-  static T launcher;
   using WType = typename T::PrologueB::StorageWeight;
   auto pth = reinterpret_cast<parallel::IThreading*>(ThreadPool);
   WType stor(0);
-  if constexpr (std::is_same_v<typename T::PrologueB,
-                               prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore, T::ISA>>) {
-    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype, BTLA_DTYPE::BF16, IsAsym);
+  if constexpr (std::is_same_v<typename T::PrologueB, prologue_b::gemm::WeightKBlockNInteger<typename T::GemmCore>>) {
+    stor = T::PrologueB::createStorage(N, K, BlkSize, QuantType, ScaleDtype, BTLA_DTYPE::BF16, IsAsym);
     if (shuffle_indice != nullptr) {
-      launcher.mProB.enableShuffle(&stor);
+      T::PrologueB::enableShuffle(&stor);
       stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
-      launcher.mProB.setShuffleIndices(shuffle_indice, &stor, pth);
+      T::PrologueB::setShuffleIndices(shuffle_indice, &stor, pth);
     } else {
       stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
     }
   } else {
     (void)(shuffle_indice);
-    stor = launcher.mProB.createStorage(N, K, BlkSize, QuantType, ScaleDtype);
+    stor = T::PrologueB::createStorage(N, K, BlkSize, QuantType, ScaleDtype);
     stor.assign(reinterpret_cast<int8_t*>(PackedBuf));
   }
-  launcher.mProB.packQWeight(N, K, QData, ldb, Scales, IsAsym ? Zp : nullptr, &stor, pth);
+  T::PrologueB::packQWeight(N, K, QData, ldb, Scales, IsAsym ? Zp : nullptr, &stor, pth);
 }
 
-template <template <class, BTLA_ISA> class Wei_T>
+template <template <class> class Wei_T>
 bool BTLAGemmPackBLocal(void* PackedBuf, const int8_t* QData, const float* Scales, const int8_t* Zp, size_t N, size_t K,
                         size_t ldb, size_t BlkSize, BTLA_DTYPE QuantType, BTLA_DTYPE ScaleDtype, bool isAsym,
                         ne_comp_type CompType, int* shuffle_indice, void* ThreadPool) {
@@ -675,32 +664,32 @@ bool BTLAGemmUnPackB(float* FpData, const void* PackedBuf, size_t N, size_t K, s
       auto sptr = reinterpret_cast<storage::gemm::StorageWeightKBlockNInteger*>(ptr);
       if (btype == gemm::CompType::tFP32 && PackRow == 1) {
         if (NTile == tAVX512F::NTILE && _cd->AVX512F()) {
-          static prologue_b::gemm::WeightKBlockNInteger<tAVX512F, tAVX512F::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+          prologue_b::gemm::WeightKBlockNInteger<tAVX512F>::unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr,
+                                                                         FpData, static_cast<int>(ldb), pth);
         } else if (NTile == tAVX2::NTILE && _cd->AVX2()) {
-          static prologue_b::gemm::WeightKBlockNInteger<tAVX2, tAVX2::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+          prologue_b::gemm::WeightKBlockNInteger<tAVX2>::unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr,
+                                                                      FpData, static_cast<int>(ldb), pth);
         }
       }
       if (btype == gemm::CompType::tS8 && PackRow == 4) {
         if (NTile == tAMX_INT8_US_KBlock::NTILE && _cd->AMX_INT8()) {
-          static prologue_b::gemm::WeightKBlockNInteger<tAMX_INT8_US_KBlock, tAMX_INT8_US_KBlock::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+          prologue_b::gemm::WeightKBlockNInteger<tAMX_INT8_US_KBlock>::unpackWeight(
+              static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
         } else if (NTile == tAVX512_VNNI_KBlock::NTILE && _cd->AVX512_VNNI()) {
-          static prologue_b::gemm::WeightKBlockNInteger<tAVX512_VNNI_KBlock, tAVX512_VNNI_KBlock::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+          prologue_b::gemm::WeightKBlockNInteger<tAVX512_VNNI_KBlock>::unpackWeight(
+              static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
         } else if (NTile == tAVX512BW_KBlock::NTILE && _cd->AVX512BW()) {
-          static prologue_b::gemm::WeightKBlockNInteger<tAVX512BW_KBlock, tAVX512BW_KBlock::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+          prologue_b::gemm::WeightKBlockNInteger<tAVX512BW_KBlock>::unpackWeight(
+              static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
         } else if (NTile == tAVX_VNNI_KBlock::NTILE && _cd->AVX_VNNI()) {
-          static prologue_b::gemm::WeightKBlockNInteger<tAVX_VNNI_KBlock, tAVX_VNNI_KBlock::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+          prologue_b::gemm::WeightKBlockNInteger<tAVX_VNNI_KBlock>::unpackWeight(
+              static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
         }
       }
       if (btype == gemm::CompType::tBF16 && PackRow == 2) {
         if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16()) {
-          static prologue_b::gemm::WeightKBlockNInteger<tAMX_BF16, tAMX_BF16::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+          prologue_b::gemm::WeightKBlockNInteger<tAMX_BF16>::unpackWeight(static_cast<int>(N), static_cast<int>(K),
+                                                                          sptr, FpData, static_cast<int>(ldb), pth);
         }
       }
     }
@@ -708,17 +697,17 @@ bool BTLAGemmUnPackB(float* FpData, const void* PackedBuf, size_t N, size_t K, s
       auto sptr = reinterpret_cast<storage::gemm::StorageWeightKBlockNFloat*>(ptr);
       if (btype == gemm::CompType::tFP32 && PackRow == 1) {
         if (NTile == tAVX512F::NTILE && _cd->AVX512F()) {
-          static prologue_b::gemm::WeightKBlockNFloat<tAVX512F, tAVX512F::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+          prologue_b::gemm::WeightKBlockNFloat<tAVX512F>::unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr,
+                                                                       FpData, static_cast<int>(ldb), pth);
         } else if (NTile == tAVX2::NTILE && _cd->AVX2()) {
-          static prologue_b::gemm::WeightKBlockNFloat<tAVX2, tAVX2::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+          prologue_b::gemm::WeightKBlockNFloat<tAVX2>::unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr,
+                                                                    FpData, static_cast<int>(ldb), pth);
         }
       }
       if (btype == gemm::CompType::tBF16 && PackRow == 2) {
         if (NTile == tAMX_BF16::NTILE && _cd->AMX_BF16()) {
-          static prologue_b::gemm::WeightKBlockNFloat<tAMX_BF16, tAMX_BF16::ISA> proB;
-          proB.unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr, FpData, static_cast<int>(ldb), pth);
+          prologue_b::gemm::WeightKBlockNFloat<tAMX_BF16>::unpackWeight(static_cast<int>(N), static_cast<int>(K), sptr,
+                                                                        FpData, static_cast<int>(ldb), pth);
         }
       }
     }
diff --git a/neural_speed/core/layers/inner_product.cpp b/neural_speed/core/layers/inner_product.cpp
index 99c36619f..c5c27d88b 100644
--- a/neural_speed/core/layers/inner_product.cpp
+++ b/neural_speed/core/layers/inner_product.cpp
@@ -36,42 +36,39 @@ void bestla_f32f32_forward(float* activation, void* weiptr, float* output, int _
 }
 
 namespace ip_add {
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, template <class, BTLA_ISA> class Act_T>
+template <class GemmCore_T, template <class> class Wei_T, template <class> class Act_T>
 void BTLAGemmCompF32(const int M, const int N, const int K, const float* A, const int lda,
                      storage::gemm::IWeightBase* _B, float* C, const int ldc, float* bias, bool broadcast_bias,
                      int8_t* WorkSpace, parallel::IThreading* th) {
   using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, custom::epilogue::AddFp32>;
+  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, Act_T, Wei_T, custom::epilogue::AddFp32>;
   auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
   utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
-  static Launcher kernel;
-  auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
+  auto reordA = Launcher::PrologueA::createReorderStorage(M, K, B->mBlockSize);
   typename Launcher::Param args{
       gp, {A, lda, nullptr, B->ShfIndice(), &reordA}, {B}, {C, bias, ldc, broadcast_bias ? 0 : ldc}};
   if (B->ShfIndice()) {
     reordA.assign(WorkSpace);
-    parallel::GemmRunWithA<Parallel>(kernel, args, th);
+    parallel::GemmRunWithA<Parallel, Launcher>(args, th);
   } else {
-    parallel::GemmRun<Parallel>(kernel, args, th);
+    parallel::GemmRun<Parallel, Launcher>(args, th);
   }
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+template <class GemmCore_T, template <class> class Wei_T>
 void BTLAGemmCompInt8Pc(const int M, const int N, const int K, const float* A, const int lda,
                         storage::gemm::IWeightBase* _B, float* C, const int ldc, float* bias, bool broadcast_bias,
                         int8_t* WorkSpace, parallel::IThreading* th) {
   using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-  using Launcher =
-      wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32,
-                                  Wei_T, epilogue::gemm::PcKBlockCompInt8Epilogue<custom::epilogue::AddFp32>>;
+  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
+                                               epilogue::gemm::PcKBlockCompInt8Epilogue<custom::epilogue::AddFp32>>;
 
   auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
   utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
-  static Launcher kernel;
-  auto quanA = kernel.mProA.createQuantStorage(M, K, B->mBlockSize, B->IsAsym());
+  auto quanA = Launcher::PrologueA::createQuantStorage(M, K, B->mBlockSize, B->IsAsym());
   quanA.assign(WorkSpace);
   WorkSpace += quanA.mSize;
-  auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
+  auto reordA = Launcher::PrologueA::createReorderStorage(M, K, B->mBlockSize);
   typename Launcher::Param args{
       gp,
       {A, lda, &quanA, B->ShfIndice(), &reordA},
@@ -81,36 +78,34 @@ void BTLAGemmCompInt8Pc(const int M, const int N, const int K, const float* A, c
        {C, bias, ldc, broadcast_bias ? 0 : ldc}}};
   if (B->ShfIndice()) {
     reordA.assign(WorkSpace);
-    kernel.mProA.quantize({A, lda, &quanA, B->ShfIndice(), &reordA}, M, K, th);
-    parallel::GemmRun<Parallel>(kernel, args, th);
+    Launcher::PrologueA::quantize({A, lda, &quanA, B->ShfIndice(), &reordA}, M, K, th);
+    parallel::GemmRun<Parallel, Launcher>(args, th);
   } else {
-    parallel::GemmRunWithA<Parallel>(kernel, args, th);
+    parallel::GemmRunWithA<Parallel, Launcher>(args, th);
   }
 }
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+template <class GemmCore_T, template <class> class Wei_T>
 void BTLAGemmCompInt8(const int M, const int N, const int K, const float* A, const int lda,
                       storage::gemm::IWeightBase* _B, float* C, const int ldc, float* bias, bool broadcast_bias,
                       int8_t* WorkSpace, parallel::IThreading* th) {
   using Parallel = parallel::gemm::SchedulerKBlockS<GemmCore_T>;
-  using Launcher = wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
-                                                    prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
-                                                    custom::epilogue::AddFp32>;
+  using Launcher = wrapper::gemm::LauncherIntKBlock<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32,
+                                                    Wei_T, custom::epilogue::AddFp32>;
 
   auto B = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_B);
   utils::GemmProblem gp(1, M, N, K, B->mBlockSize);
-  static Launcher kernel;
-  auto quanA = kernel.mProA.createQuantStorage(M, K, B->mBlockSize, B->IsAsym());
+  auto quanA = Launcher::PrologueA::createQuantStorage(M, K, B->mBlockSize, B->IsAsym());
   quanA.assign(WorkSpace);
   WorkSpace += quanA.mSize;
-  auto reordA = kernel.mProA.createReorderStorage(M, K, B->mBlockSize);
+  auto reordA = Launcher::PrologueA::createReorderStorage(M, K, B->mBlockSize);
   typename Launcher::Param args{
       gp, {A, lda, &quanA, B->ShfIndice(), &reordA}, {B}, {C, bias, ldc, broadcast_bias ? 0 : ldc}};
   if (B->ShfIndice()) {
     reordA.assign(WorkSpace);
-    kernel.mProA.quantize({A, lda, &quanA, B->ShfIndice(), &reordA}, M, K, th);
-    parallel::GemmRun<Parallel>(kernel, args, th);
+    Launcher::PrologueA::quantize({A, lda, &quanA, B->ShfIndice(), &reordA}, M, K, th);
+    parallel::GemmRun<Parallel, Launcher>(args, th);
   } else {
-    parallel::GemmRunWithA<Parallel>(kernel, args, th);
+    parallel::GemmRunWithA<Parallel, Launcher>(args, th);
   }
 }
 }  // namespace ip_add
diff --git a/neural_speed/core/layers/ip_fusion_ffn.cpp b/neural_speed/core/layers/ip_fusion_ffn.cpp
index 8a1d20433..6d96fd3d1 100644
--- a/neural_speed/core/layers/ip_fusion_ffn.cpp
+++ b/neural_speed/core/layers/ip_fusion_ffn.cpp
@@ -29,14 +29,14 @@ unsigned long long bestla_fusion_FFN_f32f32_get_workspace_size(int seq, int fin,
 namespace ffn_2w {
 
 template <class Parallel_T, class Launch_T1, class Launch_T2>
-void GemmRunWithA_ffn(Launch_T1* launcher1, Launch_T2* launcher2, const typename Launch_T1::Param& args1,
-                      const typename Launch_T2::Param& args2, parallel::IThreading* th) {
+void GemmRunWithA_ffn(const typename Launch_T1::Param& args1, const typename Launch_T2::Param& args2,
+                      parallel::IThreading* th) {
   parallel::gemm::SchedulerDispatcher<Parallel_T> para1({th, args1.problem});
   parallel::gemm::SchedulerDispatcher<Parallel_T> para2({th, args2.problem});
   using AParall1 = typename Launch_T1::PrologueA::Parallel;
   using AParall2 = typename Launch_T2::PrologueA::Parallel;
-  auto apara1 = launcher1->mProA.createParallel(th->num_threads(), args1.problem);
-  auto apara2 = launcher2->mProA.createParallel(th->num_threads(), args2.problem);
+  auto apara1 = Launch_T1::PrologueA::createParallel(th->num_threads(), args1.problem);
+  auto apara2 = Launch_T2::PrologueA::createParallel(th->num_threads(), args2.problem);
   static bool flag = false;
   if (flag) {
     printf("%s\n", __FUNCTION__);
@@ -48,32 +48,32 @@ void GemmRunWithA_ffn(Launch_T1* launcher1, Launch_T2* launcher2, const typename
     typename AParall1::ThreadProblem thdpA1{tidx};
     apara1.getIndex(thdpA1);
     if (thdpA1.valid) {
-      launcher1->mProA.run(args1.paramA, thdpA1);
+      Launch_T1::PrologueA::run(args1.paramA, thdpA1);
     }
     th->sync(tidx, 0);
     typename Parallel_T::ThreadProblem thdp1{tidx};
     para1.getIndex(thdp1);
     if (thdp1.valid) {
-      launcher1->run(args1, thdp1);
+      Launch_T1::run(args1, thdp1);
     }
     th->sync(tidx, 1);
     typename AParall2::ThreadProblem thdpA2{tidx};
     apara2.getIndex(thdpA2);
     if (thdpA2.valid) {
-      launcher2->mProA.run(args2.paramA, thdpA2);
+      Launch_T2::PrologueA::run(args2.paramA, thdpA2);
     }
     th->sync(tidx, 2);
     typename Parallel_T::ThreadProblem thdp2{tidx};
     para2.getIndex(thdp2);
     if (thdp2.valid) {
-      launcher2->run(args2, thdp2);
+      Launch_T2::run(args2, thdp2);
     }
   });
 }
 
 template <class Parallel_T, class Launch_T1, class Launch_T2>
-void GemmRun_ffn(Launch_T1* launcher1, Launch_T2* launcher2, const typename Launch_T1::Param& args1,
-                 const typename Launch_T2::Param& args2, parallel::IThreading* th) {
+void GemmRun_ffn(const typename Launch_T1::Param& args1, const typename Launch_T2::Param& args2,
+                 parallel::IThreading* th) {
   parallel::gemm::SchedulerDispatcher<Parallel_T> para1({th, args1.problem});
   parallel::gemm::SchedulerDispatcher<Parallel_T> para2({th, args2.problem});
   static bool flag = false;
@@ -87,33 +87,30 @@ void GemmRun_ffn(Launch_T1* launcher1, Launch_T2* launcher2, const typename Laun
     typename Parallel_T::ThreadProblem thdp1{tidx};
     para1.getIndex(thdp1);
     if (thdp1.valid) {
-      launcher1->run(args1, thdp1);
+      Launch_T1::run(args1, thdp1);
     }
     th->sync(tidx);
     typename Parallel_T::ThreadProblem thdp2{tidx};
     para2.getIndex(thdp2);
     if (thdp2.valid) {
-      launcher2->run(args2, thdp2);
+      Launch_T2::run(args2, thdp2);
     }
   });
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, template <class, BTLA_ISA> class Act_T,
-          class Epi_T1, class Epi_T2>
+template <class GemmCore_T, template <class> class Wei_T, template <class> class Act_T, class Epi_T1, class Epi_T2>
 void BTLAGemmCompF32(float* activation, storage::gemm::IWeightBase* w1ptr, storage::gemm::IWeightBase* w2ptr,
                      float* tmp, float* output, int seq, int fin, int fmid, int fout, void* workspace,
                      parallel::IThreading* th, typename Epi_T1::Param epi_prama1, typename Epi_T2::Param epi_prama2) {
   using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-  using Launcher_epi = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T1>;
-  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T2>;
+  using Launcher_epi = wrapper::gemm::LauncherBase<GemmCore_T, Act_T, Wei_T, Epi_T1>;
+  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, Act_T, Wei_T, Epi_T2>;
   auto w1ptr_ = reinterpret_cast<typename Launcher_epi::PrologueB::StorageWeight*>(w1ptr);
   auto w2ptr_ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(w2ptr);
   utils::GemmProblem gp1(1, seq, fmid, fin, w1ptr_->mBlockSize);
   utils::GemmProblem gp2(1, seq, fout, fmid, w2ptr_->mBlockSize);
-  static Launcher_epi kernel_epi;
-  static Launcher kernel;
-  auto reordA1 = kernel_epi.mProA.createReorderStorage(seq, fin, w1ptr_->mBlockSize);
-  auto reordA2 = kernel_epi.mProA.createReorderStorage(seq, fin, w2ptr_->mBlockSize);
+  auto reordA1 = Launcher_epi::PrologueA::createReorderStorage(seq, fin, w1ptr_->mBlockSize);
+  auto reordA2 = Launcher::PrologueA::createReorderStorage(seq, fin, w2ptr_->mBlockSize);
   typename Launcher_epi::Param args1{
       gp1, {activation, fin, nullptr, w1ptr_->ShfIndice(), &reordA1}, {w1ptr_}, epi_prama1};
   typename Launcher::Param args2{gp2, {tmp, fmid, nullptr, w2ptr_->ShfIndice(), &reordA2}, {w2ptr_}, epi_prama2};
@@ -121,44 +118,41 @@ void BTLAGemmCompF32(float* activation, storage::gemm::IWeightBase* w1ptr, stora
   if (w1ptr_->ShfIndice()) {
     reordA1.assign(WS);
     reordA2.assign(WS);
-    GemmRunWithA_ffn<Parallel>(&kernel_epi, &kernel, args1, args2, th);
+    GemmRunWithA_ffn<Parallel, Launcher_epi, Launcher>(args1, args2, th);
   } else {
-    GemmRun_ffn<Parallel>(&kernel_epi, &kernel, args1, args2, th);
+    GemmRun_ffn<Parallel, Launcher_epi, Launcher>(args1, args2, th);
   }
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, class Epi_T1, class Epi_T2>
+template <class GemmCore_T, template <class> class Wei_T, class Epi_T1, class Epi_T2>
 void BTLAGemmCompInt8Pc(float* activation, storage::gemm::IWeightBase* w1ptr, storage::gemm::IWeightBase* w2ptr,
                         float* tmp, float* output, int seq, int fin, int fmid, int fout, void* workspace,
                         parallel::IThreading* th, typename Epi_T1::Fp32Param epi_prama1,
                         typename Epi_T2::Fp32Param epi_prama2) {
   using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-
-  using Launcher_epi = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T,
-                                                   prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
-  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T,
-                                               prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
+  using Launcher_epi =
+      wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
+  using Launcher =
+      wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
   auto w1ptr_ = reinterpret_cast<typename Launcher_epi::PrologueB::StorageWeight*>(w1ptr);
   auto w2ptr_ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(w2ptr);
   utils::GemmProblem gp1(1, seq, fmid, fin, w1ptr_->mBlockSize);
   utils::GemmProblem gp2(1, seq, fout, fmid, w2ptr_->mBlockSize);
   assert(w1ptr_->mBlockSize >= fin);
   assert(w2ptr_->mBlockSize >= fmid);
-  static Launcher_epi kernel_epi;
-  static Launcher kernel;
   auto WS = reinterpret_cast<int8_t*>(workspace);
-  auto quanA1 = kernel_epi.mProA.createStorage(seq, fin, w1ptr_->mBlockSize, w1ptr_->IsAsym());
+  auto quanA1 = Launcher_epi::PrologueA::createStorage(seq, fin, w1ptr_->mBlockSize, w1ptr_->IsAsym());
   quanA1.assign(WS);
   WS += quanA1.mSize;
-  auto reordA1 = kernel_epi.mProA.createReorderStorage(seq, fin, w1ptr_->mBlockSize);
+  auto reordA1 = Launcher_epi::PrologueA::createReorderStorage(seq, fin, w1ptr_->mBlockSize);
   if (w1ptr_->ShfIndice()) {
     reordA1.assign(WS);
   }
   WS = reinterpret_cast<int8_t*>(workspace);
-  auto quanA2 = kernel.mProA.createStorage(seq, fmid, w2ptr_->mBlockSize, w2ptr_->IsAsym());
+  auto quanA2 = Launcher::PrologueA::createStorage(seq, fmid, w2ptr_->mBlockSize, w2ptr_->IsAsym());
   quanA2.assign(WS);
   WS += quanA2.mSize;
-  auto reordA2 = kernel_epi.mProA.createReorderStorage(seq, fin, w2ptr_->mBlockSize);
+  auto reordA2 = Launcher::PrologueA::createReorderStorage(seq, fin, w2ptr_->mBlockSize);
   if (w2ptr_->ShfIndice()) {
     reordA2.assign(WS);
   }
@@ -176,46 +170,42 @@ void BTLAGemmCompInt8Pc(float* activation, storage::gemm::IWeightBase* w1ptr, st
       {{w2ptr_->template SPtr<char>(), w2ptr_->SDtype(), quanA2.template SPtr<float>(), quanA2.template ZPtr<uint8_t>(),
         w2ptr_->template RPtr<char>(), w2ptr_->RDtype(), nullptr, nullptr, fmid},
        epi_prama2}};
-  GemmRunWithA_ffn<Parallel>(&kernel_epi, &kernel, args1, args2, th);
+  GemmRunWithA_ffn<Parallel, Launcher_epi, Launcher>(args1, args2, th);
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, class Epi_T1, class Epi_T2>
+template <class GemmCore_T, template <class> class Wei_T, class Epi_T1, class Epi_T2>
 void BTLAGemmCompInt8(float* activation, storage::gemm::IWeightBase* w1ptr, storage::gemm::IWeightBase* w2ptr,
                       float* tmp, float* output, int seq, int fin, int fmid, int fout, void* workspace,
                       parallel::IThreading* th, typename Epi_T1::Param epi_prama1, typename Epi_T2::Param epi_prama2) {
   using Parallel = parallel::gemm::SchedulerKBlockS<GemmCore_T>;
   using Launcher_epi =
-      wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
-                                       prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
+      wrapper::gemm::LauncherIntKBlock<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
   using Launcher =
-      wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
-                                       prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
+      wrapper::gemm::LauncherIntKBlock<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
   auto w1ptr_ = reinterpret_cast<typename Launcher_epi::PrologueB::StorageWeight*>(w1ptr);
   auto w2ptr_ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(w2ptr);
   utils::GemmProblem gp1(1, seq, fmid, fin, w1ptr_->mBlockSize);
   utils::GemmProblem gp2(1, seq, fout, fmid, w2ptr_->mBlockSize);
-  static Launcher_epi kernel_epi;
-  static Launcher kernel;
   auto WS = reinterpret_cast<int8_t*>(workspace);
-  auto quanA1 = kernel_epi.mProA.createStorage(seq, fin, w1ptr_->mBlockSize, w1ptr_->IsAsym());
+  auto quanA1 = Launcher_epi::PrologueA::createStorage(seq, fin, w1ptr_->mBlockSize, w1ptr_->IsAsym());
   quanA1.assign(WS);
   WS += quanA1.mSize;
-  auto reordA1 = kernel_epi.mProA.createReorderStorage(seq, fin, w1ptr_->mBlockSize);
+  auto reordA1 = Launcher_epi::PrologueA::createReorderStorage(seq, fin, w1ptr_->mBlockSize);
   if (w1ptr_->ShfIndice()) {
     reordA1.assign(WS);
   }
   WS = reinterpret_cast<int8_t*>(workspace);
-  auto quanA2 = kernel.mProA.createStorage(seq, fmid, w2ptr_->mBlockSize, w2ptr_->IsAsym());
+  auto quanA2 = Launcher::PrologueA::createStorage(seq, fmid, w2ptr_->mBlockSize, w2ptr_->IsAsym());
   quanA2.assign(WS);
   WS += quanA2.mSize;
-  auto reordA2 = kernel_epi.mProA.createReorderStorage(seq, fin, w2ptr_->mBlockSize);
+  auto reordA2 = Launcher::PrologueA::createReorderStorage(seq, fin, w2ptr_->mBlockSize);
   if (w2ptr_->ShfIndice()) {
     reordA2.assign(WS);
   }
   typename Launcher_epi::Param args1{
       gp1, {activation, fin, &quanA1, w1ptr_->ShfIndice(), &reordA1}, {w1ptr_}, epi_prama1};
   typename Launcher::Param args2{gp2, {tmp, fmid, &quanA2, w2ptr_->ShfIndice(), &reordA2}, {w2ptr_}, epi_prama2};
-  GemmRunWithA_ffn<Parallel>(&kernel_epi, &kernel, args1, args2, th);
+  GemmRunWithA_ffn<Parallel, Launcher_epi, Launcher>(args1, args2, th);
 }
 
 bool bestla_fusion_ffn_f32f32_support(void* w1ptr, void* w2ptr, int seq, int fin, int fmid, int fout) {
@@ -371,15 +361,14 @@ void bestla_fusion_ffn_f32f32_forward(float* activation, void* w1ptr, void* w2pt
 namespace ffn_3w {
 
 template <class Parallel_T, class Launch_T1, class Launch_T2, class Launch_T3>
-void GemmRunWithA_ffn(Launch_T1* launcher1, Launch_T2* launcher2, Launch_T3* launcher3,
-                      const typename Launch_T1::Param& args1, const typename Launch_T2::Param& args2,
+void GemmRunWithA_ffn(const typename Launch_T1::Param& args1, const typename Launch_T2::Param& args2,
                       const typename Launch_T3::Param& args3, parallel::IThreading* th) {
   parallel::gemm::SchedulerDispatcher<Parallel_T> para1({th, args1.problem});
   parallel::gemm::SchedulerDispatcher<Parallel_T> para3({th, args3.problem});
   using AParall1 = typename Launch_T1::PrologueA::Parallel;
   using AParall3 = typename Launch_T3::PrologueA::Parallel;
-  auto apara1 = launcher1->mProA.createParallel(th->num_threads(), args1.problem);
-  auto apara3 = launcher3->mProA.createParallel(th->num_threads(), args3.problem);
+  auto apara1 = Launch_T1::PrologueA::createParallel(th->num_threads(), args1.problem);
+  auto apara3 = Launch_T3::PrologueA::createParallel(th->num_threads(), args3.problem);
   static bool flag = false;
   if (flag) {
     printf("%s\n", __FUNCTION__);
@@ -391,33 +380,32 @@ void GemmRunWithA_ffn(Launch_T1* launcher1, Launch_T2* launcher2, Launch_T3* lau
     typename AParall1::ThreadProblem thdpA1{tidx};
     apara1.getIndex(thdpA1);
     if (thdpA1.valid) {
-      launcher1->mProA.run(args1.paramA, thdpA1);
+      Launch_T1::PrologueA::run(args1.paramA, thdpA1);
     }
     th->sync(tidx, 0);
     typename Parallel_T::ThreadProblem thdp1{tidx};
     para1.getIndex(thdp1);
     if (thdp1.valid) {
-      launcher1->run(args1, thdp1);
-      launcher2->run(args2, thdp1);
+      Launch_T1::run(args1, thdp1);
+      Launch_T2::run(args2, thdp1);
     }
     th->sync(tidx, 1);
     typename AParall3::ThreadProblem thdpA3{tidx};
     apara3.getIndex(thdpA3);
     if (thdpA3.valid) {
-      launcher3->mProA.run(args3.paramA, thdpA3);
+      Launch_T3::PrologueA::run(args3.paramA, thdpA3);
     }
     th->sync(tidx, 2);
     typename Parallel_T::ThreadProblem thdp3{tidx};
     para3.getIndex(thdp3);
     if (thdp3.valid) {
-      launcher3->run(args3, thdp3);
+      Launch_T3::run(args3, thdp3);
     }
   });
 }
 
 template <class Parallel_T, class Launch_T1, class Launch_T2, class Launch_T3>
-void GemmRun_ffn(Launch_T1* launcher1, Launch_T2* launcher2, Launch_T3* launcher3,
-                 const typename Launch_T1::Param& args1, const typename Launch_T2::Param& args2,
+void GemmRun_ffn(const typename Launch_T1::Param& args1, const typename Launch_T2::Param& args2,
                  const typename Launch_T3::Param& args3, parallel::IThreading* th) {
   parallel::gemm::SchedulerDispatcher<Parallel_T> para1({th, args1.problem});
   parallel::gemm::SchedulerDispatcher<Parallel_T> para3({th, args3.problem});
@@ -432,29 +420,27 @@ void GemmRun_ffn(Launch_T1* launcher1, Launch_T2* launcher2, Launch_T3* launcher
     typename Parallel_T::ThreadProblem thdp1{tidx};
     para1.getIndex(thdp1);
     if (thdp1.valid) {
-      launcher1->run(args1, thdp1);
-      launcher2->run(args2, thdp1);
+      Launch_T1::run(args1, thdp1);
+      Launch_T2::run(args2, thdp1);
     }
     th->sync(tidx);
     typename Parallel_T::ThreadProblem thdp3{tidx};
     para3.getIndex(thdp3);
     if (thdp3.valid) {
-      launcher3->run(args3, thdp3);
+      Launch_T3::run(args3, thdp3);
     }
   });
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, template <class, BTLA_ISA> class Act_T,
-          class Epi_T1, class Epi_T2>
+template <class GemmCore_T, template <class> class Wei_T, template <class> class Act_T, class Epi_T1, class Epi_T2>
 void BTLAGemmCompF32(float* activation, storage::gemm::IWeightBase* w1ptr, storage::gemm::IWeightBase* w2ptr,
                      storage::gemm::IWeightBase* w3ptr, float* tmp1, float* tmp2, float* output, int seq, int fin,
                      int fmid, int fout, void* workspace, parallel::IThreading* th, typename Epi_T1::Param epi_prama1,
                      typename Epi_T2::Param epi_prama2) {
   using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-  using Launcher_epi = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T1>;
-  using Launcher_mul =
-      wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, custom::epilogue::MulFp32>;
-  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, Act_T, Wei_T, Epi_T2>;
+  using Launcher_epi = wrapper::gemm::LauncherBase<GemmCore_T, Act_T, Wei_T, Epi_T1>;
+  using Launcher_mul = wrapper::gemm::LauncherBase<GemmCore_T, Act_T, Wei_T, custom::epilogue::MulFp32>;
+  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, Act_T, Wei_T, Epi_T2>;
   auto w1ptr_ = reinterpret_cast<typename Launcher_epi::PrologueB::StorageWeight*>(w1ptr);
   auto w2ptr_ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(w2ptr);
   auto w3ptr_ = reinterpret_cast<typename Launcher_mul::PrologueB::StorageWeight*>(w3ptr);
@@ -464,42 +450,36 @@ void BTLAGemmCompF32(float* activation, storage::gemm::IWeightBase* w1ptr, stora
   utils::GemmProblem gp1(1, seq, fmid, fin, w1ptr_->mBlockSize);
   utils::GemmProblem gp2(1, seq, fout, fmid, w2ptr_->mBlockSize);
   utils::GemmProblem gp3(1, seq, fmid, fin, w3ptr_->mBlockSize);
-  static Launcher_epi kernel_epi;
-  static Launcher_mul kernel_mul;
-  static Launcher kernel;
   typename Launcher_epi::Param args1{gp1, {activation, fin, nullptr}, {w1ptr_}, epi_prama1};
   typename Launcher::Param args2{gp2, {tmp2, fmid, nullptr}, {w2ptr_}, epi_prama2};
   typename Launcher_mul::Param args3{gp3, {activation, fin, nullptr}, {w3ptr_}, {tmp2, tmp1, fmid, fmid}};
-  GemmRun_ffn<Parallel>(&kernel_epi, &kernel_mul, &kernel, args1, args3, args2, th);
+  GemmRun_ffn<Parallel, Launcher_epi, Launcher_mul, Launcher>(args1, args3, args2, th);
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, class Epi_T1, class Epi_T2>
+template <class GemmCore_T, template <class> class Wei_T, class Epi_T1, class Epi_T2>
 void BTLAGemmCompInt8Pc(float* activation, storage::gemm::IWeightBase* w1ptr, storage::gemm::IWeightBase* w2ptr,
                         storage::gemm::IWeightBase* w3ptr, float* tmp1, float* tmp2, float* output, int seq, int fin,
                         int fmid, int fout, void* workspace, parallel::IThreading* th,
                         typename Epi_T1::Fp32Param epi_prama1, typename Epi_T2::Fp32Param epi_prama2) {
   using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-  using Launcher_epi = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T,
-                                                   prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
+  using Launcher_epi =
+      wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
   using Launcher_mul =
-      wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32,
-                                  Wei_T, epilogue::gemm::PcKBlockCompInt8Epilogue<custom::epilogue::MulFp32>>;
-  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T,
-                                               prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
+      wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
+                                  epilogue::gemm::PcKBlockCompInt8Epilogue<custom::epilogue::MulFp32>>;
+  using Launcher =
+      wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
   auto w1ptr_ = reinterpret_cast<typename Launcher_epi::PrologueB::StorageWeight*>(w1ptr);
   auto w2ptr_ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(w2ptr);
   auto w3ptr_ = reinterpret_cast<typename Launcher_mul::PrologueB::StorageWeight*>(w3ptr);
   utils::GemmProblem gp1(1, seq, fmid, fin, w1ptr_->mBlockSize);
   utils::GemmProblem gp2(1, seq, fout, fmid, w2ptr_->mBlockSize);
   utils::GemmProblem gp3(1, seq, fmid, fin, w3ptr_->mBlockSize);
-  static Launcher_epi kernel_epi;
-  static Launcher_mul kernel_mul;
-  static Launcher kernel;
-  auto quanA1 = kernel_epi.mProA.createStorage(seq, fin, w1ptr_->mBlockSize, w1ptr_->IsAsym());
+  auto quanA1 = Launcher_epi::PrologueA::createStorage(seq, fin, w1ptr_->mBlockSize, w1ptr_->IsAsym());
   auto WS = reinterpret_cast<int8_t*>(workspace);
   quanA1.assign(WS);
 
-  auto quanA2 = kernel.mProA.createStorage(seq, fmid, w2ptr_->mBlockSize, w2ptr_->IsAsym());
+  auto quanA2 = Launcher::PrologueA::createStorage(seq, fmid, w2ptr_->mBlockSize, w2ptr_->IsAsym());
   WS = reinterpret_cast<int8_t*>(workspace);
   quanA2.assign(WS);
   assert(w1ptr_->ShfIndice() == nullptr);
@@ -526,38 +506,33 @@ void BTLAGemmCompInt8Pc(float* activation, storage::gemm::IWeightBase* w1ptr, st
       {{w3ptr_->template SPtr<char>(), w3ptr_->SDtype(), quanA1.template SPtr<float>(), quanA1.template ZPtr<uint8_t>(),
         w3ptr_->template RPtr<char>(), w3ptr_->RDtype(), nullptr, nullptr, fin},
        {tmp2, tmp1, fmid, fmid}}};
-  GemmRunWithA_ffn<Parallel>(&kernel_epi, &kernel_mul, &kernel, args1, args3, args2, th);
+  GemmRunWithA_ffn<Parallel, Launcher_epi, Launcher_mul, Launcher>(args1, args3, args2, th);
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T, class Epi_T1, class Epi_T2>
+template <class GemmCore_T, template <class> class Wei_T, class Epi_T1, class Epi_T2>
 void BTLAGemmCompInt8(float* activation, storage::gemm::IWeightBase* w1ptr, storage::gemm::IWeightBase* w2ptr,
                       storage::gemm::IWeightBase* w3ptr, float* tmp1, float* tmp2, float* output, int seq, int fin,
                       int fmid, int fout, void* workspace, parallel::IThreading* th, typename Epi_T1::Param epi_prama1,
                       typename Epi_T2::Param epi_prama2) {
   using Parallel = parallel::gemm::SchedulerKBlockS<GemmCore_T>;
   using Launcher_epi =
-      wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
-                                       prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
-  using Launcher_mul = wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
-                                                        prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
-                                                        custom::epilogue::MulFp32>;
+      wrapper::gemm::LauncherIntKBlock<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T1>;
+  using Launcher_mul =
+      wrapper::gemm::LauncherIntKBlock<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T,
+                                       custom::epilogue::MulFp32>;
   using Launcher =
-      wrapper::gemm::LauncherIntKBlock<GemmCore_T::ISA, GemmCore_T,
-                                       prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
+      wrapper::gemm::LauncherIntKBlock<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockQuantizeF32, Wei_T, Epi_T2>;
   auto w1ptr_ = reinterpret_cast<typename Launcher_epi::PrologueB::StorageWeight*>(w1ptr);
   auto w2ptr_ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(w2ptr);
   auto w3ptr_ = reinterpret_cast<typename Launcher_mul::PrologueB::StorageWeight*>(w3ptr);
   utils::GemmProblem gp1(1, seq, fmid, fin, w1ptr_->mBlockSize);
   utils::GemmProblem gp2(1, seq, fout, fmid, w2ptr_->mBlockSize);
   utils::GemmProblem gp3(1, seq, fmid, fin, w3ptr_->mBlockSize);
-  static Launcher_epi kernel_epi;
-  static Launcher_mul kernel_mul;
-  static Launcher kernel;
-  auto quanA1 = kernel_epi.mProA.createStorage(seq, fin, w1ptr_->mBlockSize, w1ptr_->IsAsym());
+  auto quanA1 = Launcher_epi::PrologueA::createStorage(seq, fin, w1ptr_->mBlockSize, w1ptr_->IsAsym());
   auto WS = reinterpret_cast<int8_t*>(workspace);
   quanA1.assign(WS);
 
-  auto quanA2 = kernel.mProA.createStorage(seq, fmid, w2ptr_->mBlockSize, w2ptr_->IsAsym());
+  auto quanA2 = Launcher::PrologueA::createStorage(seq, fmid, w2ptr_->mBlockSize, w2ptr_->IsAsym());
   WS = reinterpret_cast<int8_t*>(workspace);
   quanA2.assign(WS);
   assert(w1ptr_->ShfIndice() == nullptr);
@@ -566,7 +541,7 @@ void BTLAGemmCompInt8(float* activation, storage::gemm::IWeightBase* w1ptr, stor
   typename Launcher_epi::Param args1{gp1, {activation, fin, &quanA1}, {w1ptr_}, epi_prama1};
   typename Launcher::Param args2{gp2, {tmp2, fmid, &quanA2}, {w2ptr_}, epi_prama2};
   typename Launcher_mul::Param args3{gp3, {activation, fin, &quanA1}, {w3ptr_}, {tmp2, tmp1, fmid, fmid}};
-  GemmRunWithA_ffn<Parallel>(&kernel_epi, &kernel_mul, &kernel, args1, args3, args2, th);
+  GemmRunWithA_ffn<Parallel, Launcher_epi, Launcher_mul, Launcher>(args1, args3, args2, th);
 }
 
 bool bestla_fusion_ffn_f32f32_support(void* w1ptr, void* w2ptr, void* w3ptr, int seq, int fin, int fmid, int fout) {
diff --git a/neural_speed/core/layers/ip_fusion_qkv.cpp b/neural_speed/core/layers/ip_fusion_qkv.cpp
index 9667b3f1d..9831576b2 100644
--- a/neural_speed/core/layers/ip_fusion_qkv.cpp
+++ b/neural_speed/core/layers/ip_fusion_qkv.cpp
@@ -20,7 +20,7 @@ using namespace ne_bestla;  // NOLINT
 namespace ip_qkv {
 
 template <class Parallel_T, class Launch_T>
-void GemmRun_QKV(Launch_T* launcher, const typename Launch_T::Param* args, parallel::IThreading* th) {
+void GemmRun_QKV(const typename Launch_T::Param* args, parallel::IThreading* th) {
   parallel::gemm::SchedulerDispatcher<Parallel_T> para({th, args[0].problem});
   static bool flag = false;
   if (flag) {
@@ -33,17 +33,17 @@ void GemmRun_QKV(Launch_T* launcher, const typename Launch_T::Param* args, paral
     para.getIndex(thdp);
     if (thdp.valid) {
       for (size_t i = 0; i < 3; i++) {
-        launcher->run(args[i], thdp);
+        Launch_T::run(args[i], thdp);
       }
     }
   });
 }
 
 template <class Parallel_T, class Launch_T>
-void GemmRunWithA_QKV(Launch_T* launcher, const typename Launch_T::Param* args, parallel::IThreading* th) {
+void GemmRunWithA_QKV(const typename Launch_T::Param* args, parallel::IThreading* th) {
   parallel::gemm::SchedulerDispatcher<Parallel_T> para({th, args[0].problem});
   using AParall = typename Launch_T::PrologueA::Parallel;
-  auto apara = launcher->mProA.createParallel(th->num_threads(), args[0].problem);
+  auto apara = Launch_T::PrologueA::createParallel(th->num_threads(), args[0].problem);
   static bool flag = false;
   if (flag) {
     printf("%s\n", __FUNCTION__);
@@ -54,32 +54,30 @@ void GemmRunWithA_QKV(Launch_T* launcher, const typename Launch_T::Param* args,
     typename AParall::ThreadProblem thdpA{tidx};
     apara.getIndex(thdpA);
     if (thdpA.valid) {
-      launcher->mProA.run(args[0].paramA, thdpA);
+      Launch_T::PrologueA::run(args[0].paramA, thdpA);
     }
     th->sync(tidx);
     typename Parallel_T::ThreadProblem thdp{tidx};
     para.getIndex(thdp);
     if (thdp.valid) {
       for (size_t i = 0; i < 3; i++) {
-        launcher->run(args[i], thdp);
+        Launch_T::run(args[i], thdp);
       }
     }
   });
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+template <class GemmCore_T, template <class> class Wei_T>
 void BTLAGemmCompF32(const int M, const int N, const int K, const float* A, const int lda,
                      storage::gemm::IWeightBase* _BQ, storage::gemm::IWeightBase* _BK, storage::gemm::IWeightBase* _BV,
                      float* C, const int ldc, int8_t* WorkSpace, parallel::IThreading* th) {
   using Parallel = parallel::gemm::SchedulerBase<GemmCore_T>;
-  using Launcher =
-      wrapper::gemm::LauncherBase<GemmCore_T::ISA, GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockBaseF32, Wei_T,
-                                  epilogue::gemm::AccumulatorWriteBackFp32>;
-  static Launcher kernel;
+  using Launcher = wrapper::gemm::LauncherBase<GemmCore_T, prologue_a::gemm::ShuffleActivationKBlockBaseF32, Wei_T,
+                                               epilogue::gemm::AccumulatorWriteBackFp32>;
   auto BQ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BQ);
   auto BK = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BK);
   auto BV = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BV);
-  auto reordA = kernel.mProA.createReorderStorage(M, K, BQ->mBlockSize);
+  auto reordA = Launcher::PrologueA::createReorderStorage(M, K, BQ->mBlockSize);
   utils::GemmProblem gpq(1, M, N, K, BQ->mBlockSize);
   utils::GemmProblem gpk(1, M, N, K, BK->mBlockSize);
   utils::GemmProblem gpv(1, M, N, K, BV->mBlockSize);
@@ -88,13 +86,13 @@ void BTLAGemmCompF32(const int M, const int N, const int K, const float* A, cons
                                    {gpv, {A, K, nullptr, BV->ShfIndice(), &reordA}, {BV}, {C + M * ldc * 2, ldc}}};
   if (BQ->ShfIndice()) {
     reordA.assign(WorkSpace);
-    GemmRunWithA_QKV<Parallel>(&kernel, args, th);
+    GemmRunWithA_QKV<Parallel, Launcher>(args, th);
   } else {
-    GemmRun_QKV<Parallel>(&kernel, args, th);
+    GemmRun_QKV<Parallel, Launcher>(args, th);
   }
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+template <class GemmCore_T, template <class> class Wei_T>
 void BTLAGemmCompInt8Pc(const int M, const int N, const int K, const float* A, const int lda,
                         storage::gemm::IWeightBase* _BQ, storage::gemm::IWeightBase* _BK,
                         storage::gemm::IWeightBase* _BV, float* C, const int ldc, int8_t* WorkSpace,
@@ -104,11 +102,10 @@ void BTLAGemmCompInt8Pc(const int M, const int N, const int K, const float* A, c
   auto BQ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BQ);
   auto BK = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BK);
   auto BV = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BV);
-  static Launcher kernel;
-  auto quanA = kernel.mProA.createStorage(M, K, BQ->mBlockSize, BQ->IsAsym());
+  auto quanA = Launcher::PrologueA::createStorage(M, K, BQ->mBlockSize, BQ->IsAsym());
   quanA.assign(WorkSpace);
   WorkSpace += quanA.mSize;
-  auto reordA = kernel.mProA.createReorderStorage(M, K, BQ->mBlockSize);
+  auto reordA = Launcher::PrologueA::createReorderStorage(M, K, BQ->mBlockSize);
   utils::GemmProblem gp(1, M, N, K, BQ->mBlockSize);
   assert(BQ->mBlockSize == BK->mBlockSize);
   assert(BQ->mBlockSize == BV->mBlockSize);
@@ -131,10 +128,10 @@ void BTLAGemmCompInt8Pc(const int M, const int N, const int K, const float* A, c
        {{BV->template SPtr<char>(), BV->SDtype(), quanA.template SPtr<float>(), quanA.template ZPtr<uint8_t>(),
          BV->template RPtr<char>(), BV->RDtype(), nullptr, nullptr, K},
         {C + M * ldc * 2, N}}}};
-  GemmRunWithA_QKV<Parallel>(&kernel, args, th);
+  GemmRunWithA_QKV<Parallel, Launcher>(args, th);
 }
 
-template <class GemmCore_T, template <class, BTLA_ISA> class Wei_T>
+template <class GemmCore_T, template <class> class Wei_T>
 void BTLAGemmCompInt8(const int M, const int N, const int K, const float* A, const int lda,
                       storage::gemm::IWeightBase* _BQ, storage::gemm::IWeightBase* _BK, storage::gemm::IWeightBase* _BV,
                       float* C, const int ldc, int8_t* WorkSpace, parallel::IThreading* th) {
@@ -143,16 +140,15 @@ void BTLAGemmCompInt8(const int M, const int N, const int K, const float* A, con
   auto BQ = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BQ);
   auto BK = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BK);
   auto BV = reinterpret_cast<typename Launcher::PrologueB::StorageWeight*>(_BV);
-  static Launcher kernel;
-  auto quanA = kernel.mProA.createStorage(M, K, BQ->mBlockSize, BQ->IsAsym());
+  auto quanA = Launcher::PrologueA::createStorage(M, K, BQ->mBlockSize, BQ->IsAsym());
   quanA.assign(WorkSpace);
   WorkSpace += quanA.mSize;
-  auto reordA = kernel.mProA.createReorderStorage(M, K, BQ->mBlockSize);
+  auto reordA = Launcher::PrologueA::createReorderStorage(M, K, BQ->mBlockSize);
   utils::GemmProblem gp(1, M, N, K, BQ->mBlockSize);  // If mixed blocksize, change it to three instances.
   typename Launcher::Param args[3]{{gp, {A, K, &quanA, BQ->ShfIndice(), &reordA}, {BQ}, {C, N}},
                                    {gp, {A, K, &quanA, BK->ShfIndice(), &reordA}, {BK}, {C + M * ldc, N}},
                                    {gp, {A, K, &quanA, BV->ShfIndice(), &reordA}, {BV}, {C + M * ldc * 2, N}}};
-  GemmRunWithA_QKV<Parallel>(&kernel, args, th);
+  GemmRunWithA_QKV<Parallel, Launcher>(args, th);
 }
 }  // namespace ip_qkv
 
diff --git a/neural_speed/core/layers/mha_dense_wrapper.h b/neural_speed/core/layers/mha_dense_wrapper.h
index 6770a11bb..8a424b005 100644
--- a/neural_speed/core/layers/mha_dense_wrapper.h
+++ b/neural_speed/core/layers/mha_dense_wrapper.h
@@ -298,7 +298,7 @@ class storage_packed_weight_batch_t : public storage::gemm::IWeightBase {
  * @brief An weight Prologue that Packs transposed Bf16 weight; optimized for runtime packing. It is the base type of
  * that for transposed / non-transposed source
  */
-template <class GemmCore_T, BTLA_ISA ISA_T, bool IsTrans, typename T_SRC = typename GemmCore_T::BType>
+template <class GemmCore_T, bool IsTrans, typename T_SRC = typename GemmCore_T::BType>
 class weight_pack_batch_bf16_base_t {
  public:
   using WType = typename GemmCore_T::BType;           // weight type
@@ -311,10 +311,11 @@ class weight_pack_batch_bf16_base_t {
     const StorageType* packedW;
   };
 
-  BTLA_CODE getWeight(...) = delete;
+  TLACALL BTLA_CODE getWeight(...) = delete;
 
-  BTLA_CODE getWeight(WType** dstptr, int* dststep, int /* b_size */, int /* k_size */, int /* n_size */, int b_offset,
-                      int k_offset, int n_offset, const Param& param, void* /* tmpcache */, size_t /* cachesize */) {
+  TLACALL BTLA_CODE getWeight(WType** dstptr, int* dststep, int /* b_size */, int /* k_size */, int /* n_size */,
+                              int b_offset, int k_offset, int n_offset, const Param& param, void* /* tmpcache */,
+                              size_t /* cachesize */) {
     const auto wptr = param.packedW;
     if (!wptr) return BTLA_CODE::InvalidParam;
     assert(k_offset % GemmCore_T::KTILE == 0);
@@ -326,17 +327,17 @@ class weight_pack_batch_bf16_base_t {
     return BTLA_CODE::Success;
   }
 
-  BTLA_CODE getWeight(WType** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
-                      const Param& param, void* tmpcache, size_t cachesize) {
-    return getWeight(dstptr, dststep, 1, k_size, n_size, 0, k_offset, n_offset, param, tmpcache, cachesize);
+  TLACALL BTLA_CODE getWeight(WType** dstptr, int* dststep, int k_size, int n_size, int k_offset, int n_offset,
+                              const Param& param, void* tmpcache, size_t cachesize) {
+    return getWeight<ISA_T>(dstptr, dststep, 1, k_size, n_size, 0, k_offset, n_offset, param, tmpcache, cachesize);
   }
 
-  BTLA_CODE packWeight(...) = delete;
+  TLACALL BTLA_CODE packWeight(...) = delete;
 };
 
-template <class GemmCore_T, BTLA_ISA ISA_T, typename T_SRC = typename GemmCore_T::BType>
-class weight_pack_batch_bf16_trans_t : public weight_pack_batch_bf16_base_t<GemmCore_T, ISA_T, true, T_SRC> {
-  using Base = weight_pack_batch_bf16_base_t<GemmCore_T, ISA_T, true, T_SRC>;
+template <class GemmCore_T, typename T_SRC = typename GemmCore_T::BType>
+class weight_pack_batch_bf16_trans_t : public weight_pack_batch_bf16_base_t<GemmCore_T, true, T_SRC> {
+  using Base = weight_pack_batch_bf16_base_t<GemmCore_T, true, T_SRC>;
 
  public:
   using typename Base::Param;
@@ -345,7 +346,7 @@ class weight_pack_batch_bf16_trans_t : public weight_pack_batch_bf16_base_t<Gemm
   using typename Base::WType;
 
   /// Reorder job of a thread
-  void run(const Param& p, const parallel::ThreadProblem2D& thdp, const std::function<int(int)>& step_batch) {
+  AUTOCALL void run(const Param& p, const parallel::ThreadProblem2D& thdp, const std::function<int(int)>& step_batch) {
     if (!thdp.valid) return;
     const auto pw = dynamic_cast<const StorageType*>(p.packedW);
     assert(pw != nullptr);
@@ -362,23 +363,23 @@ class weight_pack_batch_bf16_trans_t : public weight_pack_batch_bf16_base_t<Gemm
     assert(padto(pw->mK, GemmCore_T::KTILE) == KPad);
 
     using KernInterleave = typename kernel::wrapper::PaddingTransInterleaveMN<  //
-        GemmCore_T::NTILE, GemmCore_T::PACK_ROW>;
+        GemmCore_T::NTILE, GemmCore_T::PACK_ROW, T_SRC, WType>;
 
     for (int ibat = y; ibat < y + ny; ++ibat) {
-      const auto forward_stat = KernInterleave::template forward<ISA_T, T_SRC, WType>(  //
-          p.B + step_batch(ibat) + x * p.ldb,                                           //
-          pw->template WPtr<WType>() + ibat * KPad * NPad + x * KPad,                   //
-          nx, pw->mK,                                                                   // size
-          nx_pad, KPad,                                                                 // padded size
-          p.ldb, KPad);                                                                 // step
+      const auto forward_stat = KernInterleave::forward_auto(          //
+          p.B + step_batch(ibat) + x * p.ldb,                          //
+          pw->template WPtr<WType>() + ibat * KPad * NPad + x * KPad,  //
+          nx, pw->mK,                                                  // size
+          nx_pad, KPad,                                                // padded size
+          p.ldb, KPad);                                                // step
       assert(forward_stat == BTLA_CODE::Success);
     }
   }
 };
 
-template <class GemmCore_T, BTLA_ISA ISA_T, typename T_SRC = typename GemmCore_T::BType>
-class weight_pack_batch_bf16_non_tr_t : public weight_pack_batch_bf16_base_t<GemmCore_T, ISA_T, false, T_SRC> {
-  using Base = weight_pack_batch_bf16_base_t<GemmCore_T, ISA_T, false, T_SRC>;
+template <class GemmCore_T, typename T_SRC = typename GemmCore_T::BType>
+class weight_pack_batch_bf16_non_tr_t : public weight_pack_batch_bf16_base_t<GemmCore_T, false, T_SRC> {
+  using Base = weight_pack_batch_bf16_base_t<GemmCore_T, false, T_SRC>;
 
  public:
   using typename Base::Param;
@@ -387,7 +388,7 @@ class weight_pack_batch_bf16_non_tr_t : public weight_pack_batch_bf16_base_t<Gem
   using typename Base::WType;
 
   /// Reorder job of a thread
-  void run(const Param& p, const parallel::ThreadProblem2D& thdp, const std::function<int(int)>& step_batch) {
+  AUTOCALL void run(const Param& p, const parallel::ThreadProblem2D& thdp, const std::function<int(int)>& step_batch) {
     if (!thdp.valid) return;
     const auto pw = dynamic_cast<const StorageType*>(p.packedW);
     assert(pw != nullptr);
@@ -402,21 +403,21 @@ class weight_pack_batch_bf16_non_tr_t : public weight_pack_batch_bf16_base_t<Gem
     const auto nx_pad = utils::padto(nx, GemmCore_T::KTILE);
 
     using KernInterleave = typename kernel::wrapper::PaddingInterleaveMN<  //
-        GemmCore_T::NTILE, GemmCore_T::PACK_ROW>;
+        GemmCore_T::NTILE, GemmCore_T::PACK_ROW, T_SRC, WType>;
 
     for (int ibat = y; ibat < y + ny; ++ibat) {
-      const auto forward_stat = KernInterleave::template forward<ISA_T, T_SRC, WType>(  //
-          p.B + step_batch(ibat) + x * p.ldb,                                           //
-          pw->template WPtr<WType>() + ibat * KPad * NPad + x * GemmCore_T::NTILE,      //
-          nx, pw->mN,                                                                   // size
-          nx_pad, NPad,                                                                 // padded size
-          p.ldb, KPad);                                                                 // stride
+      const auto forward_stat = KernInterleave::forward_auto(                       //
+          p.B + step_batch(ibat) + x * p.ldb,                                       //
+          pw->template WPtr<WType>() + ibat * KPad * NPad + x * GemmCore_T::NTILE,  //
+          nx, pw->mN,                                                               // size
+          nx_pad, NPad,                                                             // padded size
+          p.ldb, KPad);                                                             // stride
       assert(forward_stat == BTLA_CODE::Success);
     }
   }
 };
 
-template <class _GemmCore_T, BTLA_ISA ISA_T>
+template <class _GemmCore_T>
 class activation_identity_t {
  public:
   using AType = typename _GemmCore_T::AType;
@@ -426,8 +427,8 @@ class activation_identity_t {
   };
   activation_identity_t() = default;
 
-  BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size, int m_offset,
-                          int k_offset, void* /* tmpcache */, size_t /* cachesize */) {
+  TLACALL BTLA_CODE getActivation(AType** dstptr, int* dststep, const Param& _param, int m_size, int k_size,
+                                  int m_offset, int k_offset, void* /* tmpcache */, size_t /* cachesize */) {
     auto aptr = const_cast<AType*>(_param.A);
     *dstptr = aptr + m_offset * _param.lda + k_offset;
     *dststep = _param.lda;
@@ -438,13 +439,13 @@ class activation_identity_t {
 /**
  * @brief LauncherBase with addition input as packed weight offset
  */
-template <BTLA_ISA RT_ISA_, class _GemmCore_T, template <class, BTLA_ISA> class _PrologueA_T,
-          template <class, BTLA_ISA> class _PrologueB_T, class _Epilogue_T>
+template <class _GemmCore_T, template <class> class _PrologueA_T, template <class> class _PrologueB_T,
+          class _Epilogue_T>
 class launcher_base_off_t                  //
     : public wrapper::gemm::LauncherBase<  //
-          RT_ISA_, _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T> {
+          _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T> {
   using Base = wrapper::gemm::LauncherBase<  //
-      RT_ISA_, _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T>;
+      _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T>;
 
  public:
   using typename Base::GemmCore;
@@ -452,12 +453,12 @@ class launcher_base_off_t                  //
   using AType = typename Base::AType;
   using BType = typename Base::BType;
   using CType = typename Base::CType;
-  static constexpr auto RT_ISA = RT_ISA_;
+  static constexpr auto RT_ISA = Base::ISA;
 
-  void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config,
-           int w_offset /* weight offset for batching */) {
+  static void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config,
+                  int w_offset /* weight offset for batching */) {
     // TO(Yi) temporarily configure to max tiling size
-    this->mGemmCore.configure(16, 16, 16);  // Need 'this->' here; See：https://stackoverflow.com/questions/11405
+    Base::GemmCore::configure(16, 16, 16);  // Need 'this->' here; See：https://stackoverflow.com/questions/11405
     auto StackTmp = alloca(_config.stacksize);
     auto tmpB = reinterpret_cast<BType*>(StackTmp);
     tmpB = utils::cpu_pointer_align(tmpB);
@@ -478,9 +479,9 @@ class launcher_base_off_t                  //
   }
 
  protected:
-  void run_block(const Param& _param, const parallel::gemm::ThreadProblemBase& _config,
-                 int w_offset /* weight offset for batching */, int blk_m, int blk_n, int blk_msize, int blk_nsize,
-                 AType* tmpA, BType* /*tmpB*/, CType* tmpC, void* tmpcache) {
+  static void run_block(const Param& _param, const parallel::gemm::ThreadProblemBase& _config,
+                        int w_offset /* weight offset for batching */, int blk_m, int blk_n, int blk_msize,
+                        int blk_nsize, AType* tmpA, BType* /*tmpB*/, CType* tmpC, void* tmpcache) {
     int n_padded = padto(blk_nsize, GemmCore::NTILE);
     for (int iterk = 0; iterk < _param.problem.dims[3]; iterk += _config.block[2]) {
       int k_remain = utils::remainsize(iterk, _param.problem.dims[3], _config.block[2]);
@@ -488,10 +489,11 @@ class launcher_base_off_t                  //
       int k_paddedle = padto_le(k_remain, GemmCore::KTILE);
       BType* bptr_cache = nullptr;
       int bcache_step = 0;
-      this->mProB.getWeight(&bptr_cache, &bcache_step,      // See：https://stackoverflow.com/questions/11405
-                            k_padded, n_padded,             //
-                            iterk, _config.loc[1] + blk_n,  //
-                            _param.paramB, tmpcache, _config.tmpcachesize);
+      Base::PrologueB::template getWeight<Base::ISA>(&bptr_cache,
+                                                     &bcache_step,  // See：https://stackoverflow.com/questions/11405
+                                                     k_padded, n_padded,             //
+                                                     iterk, _config.loc[1] + blk_n,  //
+                                                     _param.paramB, tmpcache, _config.tmpcachesize);
       bptr_cache += w_offset;
       int bcache_stride = bcache_step * sizeof(BType);
       for (int i = 0; i < blk_msize; i += GemmCore::MTILE) {
@@ -502,18 +504,20 @@ class launcher_base_off_t                  //
         int acache_step = 0;
         if (k_paddedle) {
           AType* aptr_cache = tmpA;
-          this->mProA.getActivation(&aptr_cache, &acache_step, _param.paramA, m_remain, k_paddedle,
-                                    blk_m + i + _config.loc[0], iterk, tmpcache, _config.tmpcachesize);
-          this->mGemmCore.forward(aptr_cache, bptr_cache, cptr_cache, m_remain, n_padded, k_paddedle,
+          Base::PrologueA::template getActivation<Base::ISA>(&aptr_cache, &acache_step, _param.paramA, m_remain,
+                                                             k_paddedle, blk_m + i + _config.loc[0], iterk, tmpcache,
+                                                             _config.tmpcachesize);
+          Base::GemmCore::forward(aptr_cache, bptr_cache, cptr_cache, m_remain, n_padded, k_paddedle,
                                   acache_step * sizeof(AType), bcache_stride, ccache_stride, iterk, tmpcache,
                                   _config.tmpcachesize);
         }
         int k_tail = k_remain - k_paddedle;
         if (k_tail) {
           AType* aptr_cache = tmpA;
-          this->mProA.getActivation(&aptr_cache, &acache_step, _param.paramA, m_remain, k_tail,
-                                    blk_m + i + _config.loc[0], iterk + k_paddedle, tmpcache, _config.tmpcachesize);
-          this->mGemmCore.forward(aptr_cache, bptr_cache + k_paddedle * GemmCore::NTILE, cptr_cache, m_remain, n_padded,
+          Base::PrologueA::template getActivation<Base::ISA>(&aptr_cache, &acache_step, _param.paramA, m_remain, k_tail,
+                                                             blk_m + i + _config.loc[0], iterk + k_paddedle, tmpcache,
+                                                             _config.tmpcachesize);
+          Base::GemmCore::forward(aptr_cache, bptr_cache + k_paddedle * GemmCore::NTILE, cptr_cache, m_remain, n_padded,
                                   GemmCore::KTILE, acache_step * sizeof(AType), bcache_stride, ccache_stride,
                                   iterk + k_paddedle, tmpcache, _config.tmpcachesize);
         }
@@ -527,13 +531,13 @@ class launcher_base_off_t                  //
 /**
  * @brief LauncherBase with addition input as packed weight offset
  */
-template <BTLA_ISA RT_ISA_, class _GemmCore_T, template <class, BTLA_ISA> class _PrologueA_T,
-          template <class, BTLA_ISA> class _PrologueB_T, class _Epilogue_T>
+template <class _GemmCore_T, template <class> class _PrologueA_T, template <class> class _PrologueB_T,
+          class _Epilogue_T>
 class launcher_base_weight_t               //
     : public wrapper::gemm::LauncherBase<  //
-          RT_ISA_, _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T> {
+          _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T> {
   using Base = wrapper::gemm::LauncherBase<  //
-      RT_ISA_, _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T>;
+      _GemmCore_T, _PrologueA_T, _PrologueB_T, _Epilogue_T>;
 
  public:
   using typename Base::GemmCore;
@@ -541,10 +545,10 @@ class launcher_base_weight_t               //
   using AType = typename Base::AType;
   using BType = typename Base::BType;
   using CType = typename Base::CType;
-  static constexpr auto RT_ISA = RT_ISA_;
+  static constexpr auto RT_ISA = Base::ISA;
 
-  void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
-    this->mGemmCore.configure(16, 16, 16);  // Need 'this->' here; See：https://stackoverflow.com/questions/11405
+  static void run(const Param& _param, const parallel::gemm::ThreadProblemBase& _config) {
+    Base::GemmCore::configure(16, 16, 16);  // Need 'this->' here; See：https://stackoverflow.com/questions/11405
     auto StackTmp = alloca(_config.stacksize);
     auto tmpB = reinterpret_cast<BType*>(StackTmp);
     tmpB = utils::cpu_pointer_align(tmpB);
@@ -565,8 +569,8 @@ class launcher_base_weight_t               //
   }
 
  protected:
-  void run_block(const Param& _param, const parallel::gemm::ThreadProblemBase& _config, int blk_m, int blk_n,
-                 int blk_msize, int blk_nsize, AType* tmpA, BType* tmpB, CType* tmpC, void* tmpcache) {
+  static void run_block(const Param& _param, const parallel::gemm::ThreadProblemBase& _config, int blk_m, int blk_n,
+                        int blk_msize, int blk_nsize, AType* tmpA, BType* tmpB, CType* tmpC, void* tmpcache) {
     int n_padded = padto(blk_nsize, GemmCore::NTILE);
     for (int iterk = 0; iterk < _param.problem.dims[3]; iterk += _config.block[2]) {
       int k_remain = remainsize(iterk, _param.problem.dims[3], _config.block[2]);
@@ -575,8 +579,8 @@ class launcher_base_weight_t               //
       auto bptr_cache = tmpB;
       int bcache_step = 0;
 
-      this->mProB.getWeight(&bptr_cache, &bcache_step, _param.paramB, k_padded, blk_nsize, iterk,
-                            _config.loc[1] + blk_n, tmpcache, _config.tmpcachesize);
+      Base::PrologueB::template getWeight<Base::ISA>(&bptr_cache, &bcache_step, _param.paramB, k_padded, blk_nsize,
+                                                     iterk, _config.loc[1] + blk_n, tmpcache, _config.tmpcachesize);
       int bcache_stride = bcache_step * sizeof(BType);
       for (int i = 0; i < blk_msize; i += GemmCore::MTILE) {
         int m_remain = remainsize(i, blk_msize, GemmCore::MTILE);
@@ -586,18 +590,20 @@ class launcher_base_weight_t               //
         int acache_step = 0;
         if (k_paddedle) {
           AType* aptr_cache = tmpA;
-          this->mProA.getActivation(&aptr_cache, &acache_step, _param.paramA, m_remain, k_paddedle,
-                                    (blk_m + i + _config.loc[0]), iterk, tmpcache, _config.tmpcachesize);
-          this->mGemmCore.forward(aptr_cache, bptr_cache, cptr_cache, m_remain, n_padded, k_paddedle,
+          Base::PrologueA::template getActivation<Base::ISA>(&aptr_cache, &acache_step, _param.paramA, m_remain,
+                                                             k_paddedle, (blk_m + i + _config.loc[0]), iterk, tmpcache,
+                                                             _config.tmpcachesize);
+          Base::GemmCore::forward(aptr_cache, bptr_cache, cptr_cache, m_remain, n_padded, k_paddedle,
                                   acache_step * sizeof(AType), bcache_stride, ccache_stride, iterk, tmpcache,
                                   _config.tmpcachesize);
         }
         int k_tail = k_remain - k_paddedle;
         if (k_tail) {
           AType* aptr_cache = tmpA;
-          this->mProA.getActivation(&aptr_cache, &acache_step, _param.paramA, m_remain, k_tail,
-                                    (blk_m + i + _config.loc[0]), iterk + k_paddedle, tmpcache, _config.tmpcachesize);
-          this->mGemmCore.forward(aptr_cache, bptr_cache + k_paddedle * GemmCore::NTILE, cptr_cache, m_remain, n_padded,
+          Base::PrologueA::template getActivation<Base::ISA>(&aptr_cache, &acache_step, _param.paramA, m_remain, k_tail,
+                                                             (blk_m + i + _config.loc[0]), iterk + k_paddedle, tmpcache,
+                                                             _config.tmpcachesize);
+          Base::GemmCore::forward(aptr_cache, bptr_cache + k_paddedle * GemmCore::NTILE, cptr_cache, m_remain, n_padded,
                                   GemmCore::KTILE, acache_step * sizeof(AType), bcache_stride, ccache_stride,
                                   iterk + k_paddedle, tmpcache, _config.tmpcachesize);
         }
@@ -701,7 +707,7 @@ class mha_interface_t {
       {  // reorder K & V
         ThreadProblem2D thdpK{tid};
         schK.getIndex(thdpK);
-        l_expsum.mProB.run(  // pack K
+        PrologueK::run(  // pack K
             QKProKArgs{
                 /* .B = */ p.K,
                 /* .ldb = */ p.step_k_sl * p.step_k_head_size,  //  use the non-one step
@@ -711,7 +717,7 @@ class mha_interface_t {
 
         ThreadProblem2D thdpV{tid};
         schV.getIndex(thdpV);
-        l_scale.mProB.run(  // pack V
+        PrologueV::run(  // pack V
             PVProVArgs{
                 /* .B = */ p.V,
                 /* .ldb = */ p.step_v_sl,
@@ -761,7 +767,7 @@ class mha_interface_t {
               /* .tmpcachesize = */ _cd->getL2CacheSize(),
           };
           const auto bf16_tmp = reinterpret_cast<bf16*>(tmp);
-          l_expsum.run(  // QxK => S ==exp==> P
+          L_ExpSum::run(  // QxK => S ==exp==> P
               QKArgs{
                   utils::GemmProblem{
                       /* .batch */ 1,
@@ -791,7 +797,7 @@ class mha_interface_t {
               /* .stacksize = */ _cd->getL2CacheSize(),
               /* .tmpcachesize = */ _cd->getL2CacheSize(),
           };
-          l_scale.run(  // PxV => O
+          L_Scale::run(  // PxV => O
               PVArgs{
                   utils::GemmProblem{
                       /* .batch */ 1,
@@ -817,10 +823,6 @@ class mha_interface_t {
     utils::afree(bufferV);
     return BTLA_CODE::Success;
   }
-
- protected:
-  L_ExpSum l_expsum;
-  L_Scale l_scale;
 };
 
 /**
@@ -1126,7 +1128,7 @@ class scale_track_max_t<int32_t, float> {
 };
 using ScaleTrackMaxS32Fp32 = scale_track_max_t<int32_t, float>;
 
-template <class _GemmCore_T, BTLA_ISA ISA_T>
+template <class _GemmCore_T>
 class weight_base_t {
  public:
   using BType = typename _GemmCore_T::BType;
@@ -1137,8 +1139,8 @@ class weight_base_t {
     bool is_padded;
   };
   weight_base_t() = default;
-  BTLA_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size, int k_offset,
-                      int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
+  TLACALL BTLA_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size, int k_offset,
+                              int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
     if ((n_size % _GemmCore_T::NTILE == 0) && std::is_same<SType, BType>::value &&
         0) {  // TODO(Yi) : use a gemm core accept step for K or reorder at runtime
       *dst_ptr = const_cast<SType*>(p.B) + k_offset * p.ldb + n_offset;
@@ -1159,7 +1161,7 @@ class weight_base_t {
     }
   }
 };
-template <class _GemmCore_T, BTLA_ISA ISA_T>
+template <class _GemmCore_T>
 class weight_forward_n_tile48_t {
  public:
   using BType = typename _GemmCore_T::BType;
@@ -1170,8 +1172,8 @@ class weight_forward_n_tile48_t {
     bool is_padded;
   };
   weight_forward_n_tile48_t() = default;
-  BTLA_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size, int k_offset,
-                      int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
+  TLACALL BTLA_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size, int k_offset,
+                              int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
     assert(p.is_padded);
     *dst_ptr = const_cast<SType*>(p.B) + k_offset * 48 + n_offset * p.ldb;
     *dst_step = p.ldb;
@@ -1179,7 +1181,7 @@ class weight_forward_n_tile48_t {
   }
 };
 #if CompileAVX512F()
-template <class _GemmCore_T, BTLA_ISA ISA_T>
+template <class _GemmCore_T>
 class weight_cvt_bf16_ntile48_t {
  public:
   using BType = typename _GemmCore_T::BType;
@@ -1190,8 +1192,8 @@ class weight_cvt_bf16_ntile48_t {
     bool is_padded;
   };
   weight_cvt_bf16_ntile48_t() = default;
-  TARGET_512 BTLA_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size, int k_offset,
-                                 int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
+  TLACALL TARGET_512 BTLA_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size,
+                                         int k_offset, int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
     assert(p.is_padded);
     const auto src = const_cast<SType*>(p.B) + k_offset * 48 + n_offset * p.ldb;
     const auto dst = *dst_ptr;
@@ -1221,7 +1223,7 @@ class weight_cvt_bf16_ntile48_t {
 #endif
 
 #if CompileAVX2()
-template <class _GemmCore_T, BTLA_ISA ISA_T>
+template <class _GemmCore_T>
 class weight_cvt_f16_n_tile24_t {  // convert fp16 weight to fp32 using F16C
  public:
   using BType = typename _GemmCore_T::BType;
@@ -1232,8 +1234,8 @@ class weight_cvt_f16_n_tile24_t {  // convert fp16 weight to fp32 using F16C
     bool is_padded;
   };
   weight_cvt_f16_n_tile24_t() = default;
-  BTLA_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size, int k_offset,
-                      int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
+  TLACALL BTLA_CODE getWeight(BType** dst_ptr, int* dst_step, const Param& p, int k_size, int n_size, int k_offset,
+                              int n_offset, void* /* tmpcache */, size_t /* cachesize */) {
     assert(p.is_padded);
     const auto src = const_cast<SType*>(p.B) + k_offset * 24 + n_offset * p.ldb;
     const auto dst = *dst_ptr;
@@ -1807,20 +1809,18 @@ class mha_stable_interface_t {
 template <typename Q_T, typename K_T, typename V_T, typename DST_T>
 inline void bestla_fusion_attn_forward(const attn_fwd_args_t<Q_T, K_T, V_T, DST_T>& params) = delete;
 
-template <class GEMM_T, BTLA_ISA ISA_T>
-using WeightPackBatchBf16Bf16NonTr = weight_pack_batch_bf16_non_tr_t<GEMM_T, ISA_T, bf16>;
-template <class GEMM_T, BTLA_ISA ISA_T>
-using WeightPackBatchBf16Bf16Trans = weight_pack_batch_bf16_trans_t<GEMM_T, ISA_T, bf16>;
+template <class GEMM_T>
+using WeightPackBatchBf16Bf16NonTr = weight_pack_batch_bf16_non_tr_t<GEMM_T, bf16>;
+template <class GEMM_T>
+using WeightPackBatchBf16Bf16Trans = weight_pack_batch_bf16_trans_t<GEMM_T, bf16>;
 template <>
 inline void bestla_fusion_attn_forward<bf16, bf16, bf16, bf16>(const attn_fwd_args_t<bf16, bf16, bf16, bf16>& p) {
   using GemmKernelBF16ExpSum = mha::launcher_base_off_t<  //
-      BTLA_ISA::AMX_BF16,                                 //
       gemm::HCoreRowNAmxbf16<64, 16>,                     //
       prologue_a::gemm::ActivationBase,                   //
       WeightPackBatchBf16Bf16Trans,                       //
       mha::ScaleExpAccSumFp32Bf16>;                       //
   using GemmKernelBF16 = mha::launcher_base_off_t<        //
-      BTLA_ISA::AMX_BF16,                                 //
       gemm::HCoreRowNAmxbf16<64, 16>,                     //
       prologue_a::gemm::ActivationBase,                   //
       WeightPackBatchBf16Bf16NonTr,                       //
@@ -1831,10 +1831,10 @@ inline void bestla_fusion_attn_forward<bf16, bf16, bf16, bf16>(const attn_fwd_ar
   assert(ret == BTLA_CODE::Success);
 }
 
-template <class GEMM_T, BTLA_ISA ISA_T>
-using WeightPackBatchFp16Bf16NonTr = weight_pack_batch_bf16_non_tr_t<GEMM_T, ISA_T, fp16>;
-template <class GEMM_T, BTLA_ISA ISA_T>
-using WeightPackBatchFp16Bf16Trans = weight_pack_batch_bf16_trans_t<GEMM_T, ISA_T, fp16>;
+template <class GEMM_T>
+using WeightPackBatchFp16Bf16NonTr = weight_pack_batch_bf16_non_tr_t<GEMM_T, fp16>;
+template <class GEMM_T>
+using WeightPackBatchFp16Bf16Trans = weight_pack_batch_bf16_trans_t<GEMM_T, fp16>;
 template <>
 inline void bestla_fusion_attn_forward<float, fp16, fp16, float>(
     const attn_fwd_args_t<float, fp16, fp16, float>& params) {
@@ -1843,13 +1843,11 @@ inline void bestla_fusion_attn_forward<float, fp16, fp16, float>(
   if (MHA_PREFER_AVX512FP16 && _cd->AVX512_FP16() && params.step_k_sl == 1) {
 #if CompileAVX512F()
     using GemmKernelFP16TrackMax = mha::launcher_base_weight_t<  //
-        BTLA_ISA::AVX512_FP16,                                   //
         gemm::HCoreRowNAvx512fp16<64, 8>,                        //
         prologue_a::gemm::ActivationConverterFp32,               //
         mha::weight_base_t,                                      //
         mha::ScaleTrackMaxFp16Fp32>;                             //
     using GemmKernelFP16 = mha::launcher_base_weight_t<          //
-        BTLA_ISA::AVX512_FP16,                                   //
         gemm::HCoreRowNAvx512fp16<64, 8>,                        //
         prologue_a::gemm::ActivationBase,                        //
         mha::weight_base_t,                                      //
@@ -1866,13 +1864,11 @@ inline void bestla_fusion_attn_forward<float, fp16, fp16, float>(
 #if CompileBF16()
     if (params.step_k_head_size == 1) {
       using GemmKernelFP32FP16BF16ExpSum = mha::launcher_base_off_t<  //
-          BTLA_ISA::AMX_BF16,                                         //
           gemm::HCoreRowNAmxbf16<64, 16>,                             //
           prologue_a::gemm::ActivationConverterFp32,                  //
           WeightPackBatchFp16Bf16Trans,                               //
           mha::ScaleExpAccSumFp32Bf16>;                               //
       using GemmKernelBF16FP16FP32 = mha::launcher_base_off_t<        //
-          BTLA_ISA::AMX_BF16,                                         //
           gemm::HCoreRowNAmxbf16<64, 16>,                             //
           prologue_a::gemm::ActivationBase,                           //
           WeightPackBatchFp16Bf16NonTr,                               //
@@ -1882,13 +1878,11 @@ inline void bestla_fusion_attn_forward<float, fp16, fp16, float>(
       assert(ret == BTLA_CODE::Success);
     } else if (params.step_k_sl == 1) {
       using GemmKernelFP32FP16BF16ExpSum = mha::launcher_base_off_t<  //
-          BTLA_ISA::AMX_BF16,                                         //
           gemm::HCoreRowNAmxbf16<64, 16>,                             //
           prologue_a::gemm::ActivationConverterFp32,                  //
           WeightPackBatchFp16Bf16NonTr,                               //
           mha::ScaleExpAccSumFp32Bf16>;                               //
       using GemmKernelBF16FP16FP32 = mha::launcher_base_off_t<        //
-          BTLA_ISA::AMX_BF16,                                         //
           gemm::HCoreRowNAmxbf16<64, 16>,                             //
           prologue_a::gemm::ActivationBase,                           //
           WeightPackBatchFp16Bf16NonTr,                               //
@@ -1905,13 +1899,11 @@ inline void bestla_fusion_attn_forward<float, fp16, fp16, float>(
              params.V_layout == ATTN_FWD_LAYOUT_NTILE24_ROWPACK1) {
 #if CompileAVX2()
     using GemmKernelTrackMax = mha::launcher_base_weight_t<  //
-        BTLA_ISA::AVX2,                                      //
         gemm::SCoreRowNAvx2<24, 4>,                          //
         prologue_a::gemm::ActivationBase,                    //
         mha::weight_cvt_f16_n_tile24_t,                      //
         mha::ScaleTrackMaxFp32Fp32>;                         //
     using GemmKernelId = mha::launcher_base_weight_t<        //
-        BTLA_ISA::AVX2,                                      //
         gemm::SCoreRowNAvx2<24, 4>,                          //
         mha::activation_identity_t,                          // pretty sure we have enough paddings for P-matrix
         mha::weight_cvt_f16_n_tile24_t,                      //
@@ -1933,13 +1925,11 @@ inline void bestla_fusion_attn_forward<fp16, fp16, fp16, fp16>(const attn_fwd_ar
   const auto pth = ne_threading::get();
   if (_cd->AMX_BF16()) {
     using GemmKernelFP16TrackMax = mha::launcher_base_weight_t<  //
-        BTLA_ISA::AVX512_FP16,                                   //
         gemm::HCoreRowNAvx512fp16<64, 8>,                        //
         prologue_a::gemm::ActivationBase,                        //
         mha::weight_base_t,                                      //
         mha::ScaleTrackMaxFp16Fp32>;                             //
     using GemmKernelFP16 = mha::launcher_base_weight_t<          //
-        BTLA_ISA::AVX512_FP16,                                   //
         gemm::HCoreRowNAvx512fp16<64, 8>,                        //
         prologue_a::gemm::ActivationBase,                        //
         mha::weight_base_t,                                      //
@@ -1959,13 +1949,11 @@ inline void bestla_fusion_attn_forward<int8_t, int8_t, int8_t, int8_t>(
   const auto pth = ne_threading::get();
   if (/* params.sl_q > 4 &&  */ _cd->AMX_INT8()) {                // TODO(Yi): add vnni impl
     using GemmKernelInt32TrackMax = mha::launcher_base_weight_t<  //
-        BTLA_ISA::AMX_INT8,                                       //
         gemm::ICoreRowNAmxint8SS<48, 16>,                         //
         prologue_a::gemm::ActivationBase,                         //
         mha::weight_forward_n_tile48_t,                           //
         mha::ScaleTrackMaxS32Fp32>;                               //
     using GemmKernelInt32 = mha::launcher_base_weight_t<          //
-        BTLA_ISA::AMX_INT8,                                       //
         gemm::ICoreRowNAmxint8<48, 16>,                           //
         prologue_a::gemm::ActivationBase,                         //
         mha::weight_forward_n_tile48_t,                           //
@@ -2004,13 +1992,11 @@ inline void bestla_fusion_attn_forward<float, bf16, bf16, float>(
       ((_cd->AMX_BF16() && (params.attn_flags & NE_ATTN_FLAG_PREFER_FP32) != 0) || !_cd->AMX_BF16())) {
 #if CompileAVX512F()
     using GemmKernelBF16TrackMax = mha::launcher_base_weight_t<  //
-        BTLA_ISA::AVX512F,                                       //
         gemm::SCoreRowNAvx512f<48, 8>,                           //
         prologue_a::gemm::ActivationBase,                        //
         mha::weight_cvt_bf16_ntile48_t,                          //
         mha::ScaleTrackMaxFp32Fp32>;                             //
     using GemmKernelBF16 = mha::launcher_base_weight_t<          //
-        BTLA_ISA::AVX512F,                                       //
         gemm::SCoreRowNAvx512f<48, 8>,                           //
         mha::activation_identity_t,                              // pretty sure we have enough paddings for P-matrix
         mha::weight_cvt_bf16_ntile48_t,                          //
@@ -2024,13 +2010,11 @@ inline void bestla_fusion_attn_forward<float, bf16, bf16, float>(
   } else if (/* params.sl_q > 4 &&  */ _cd->AMX_BF16()) {  // TODO(Yi): add vdpbf16ps impl
 #if CompileBF16()
     using GemmKernelBF16TrackMax = mha::launcher_base_weight_t<  //
-        BTLA_ISA::AMX_BF16,                                      //
         gemm::HCoreRowNAmxbf16<48, 16>,                          //
         prologue_a::gemm::ActivationConverterFp32,               //
         mha::weight_forward_n_tile48_t,                          //
         mha::ScaleTrackMaxFp32Fp32>;                             //
     using GemmKernelBF16 = mha::launcher_base_weight_t<          //
-        BTLA_ISA::AMX_BF16,                                      //
         gemm::HCoreRowNAmxbf16<48, 16>,                          //
         mha::activation_identity_t,                              // pretty sure we have enough paddings for P-matrix
         mha::weight_forward_n_tile48_t,                          //
diff --git a/neural_speed/models/model_utils/scheduler.cpp b/neural_speed/models/model_utils/scheduler.cpp
index bd0ffd2e2..dc6c2459f 100644
--- a/neural_speed/models/model_utils/scheduler.cpp
+++ b/neural_speed/models/model_utils/scheduler.cpp
@@ -189,8 +189,8 @@ bool Cont_batch_gen_worker::update_seqs(std::vector<sequence>* seqs, const int&
     }
     if (!m_ctx->beam_search) {
       if (next_tokens.size() != n_input) {
-        fprintf(stderr, "%s: error: wrong next_tokens size %ld, which should be %d.\n", __func__, next_tokens.size(),
-                n_input);
+        fprintf(stderr, "%s: error: wrong next_tokens size %d, which should be %d.\n", __func__,
+                static_cast<int>(next_tokens.size()), n_input);
         return false;
       }
       seqs->at(ni).generated_ids.emplace_back(next_tokens[ni]);